Use MSVCRT_wchar_t instead of WCHAR so that the implementation matches

dlls/msvcrt/ctype.c

@@ -218,7 +218,7 @@ int MSVCRT___toascii(int c)
  *		iswascii (MSVCRT.@)
  *
  */
-int MSVCRT_iswascii(WCHAR c)
+int MSVCRT_iswascii(MSVCRT_wchar_t c)
 {
   return ((unsigned)c < 0x80);
 }

dlls/msvcrt/data.c

@@ -53,13 +53,13 @@ unsigned int MSVCRT___setlc_active;
 unsigned int MSVCRT___unguarded_readlc_active;
 double MSVCRT__HUGE;
 char **MSVCRT___argv;
-WCHAR **MSVCRT___wargv;
+MSVCRT_wchar_t **MSVCRT___wargv;
 char *MSVCRT__acmdln;
-WCHAR *MSVCRT__wcmdln;
+MSVCRT_wchar_t *MSVCRT__wcmdln;
 char **MSVCRT__environ = 0;
-WCHAR **MSVCRT__wenviron = 0;
+MSVCRT_wchar_t **MSVCRT__wenviron = 0;
 char **MSVCRT___initenv = 0;
-WCHAR **MSVCRT___winitenv = 0;
+MSVCRT_wchar_t **MSVCRT___winitenv = 0;
 int MSVCRT_timezone;
 int MSVCRT_app_type;
 
@@ -104,11 +104,11 @@ char ** msvcrt_SnapshotOfEnvironmentA(char **blk)
   return blk;
 }
 
-WCHAR ** msvcrt_SnapshotOfEnvironmentW(WCHAR **wblk)
+MSVCRT_wchar_t ** msvcrt_SnapshotOfEnvironmentW(MSVCRT_wchar_t **wblk)
 {
-  WCHAR* wenviron_strings = GetEnvironmentStringsW();
+  MSVCRT_wchar_t* wenviron_strings = GetEnvironmentStringsW();
   int count = 1, len = 1, i = 0; /* keep space for the trailing NULLS */
-  WCHAR *wptr;
+  MSVCRT_wchar_t *wptr;
 
   for (wptr = wenviron_strings; *wptr; wptr += strlenW(wptr) + 1)
   {
@@ -116,15 +116,15 @@ WCHAR ** msvcrt_SnapshotOfEnvironmentW(WCHAR **wblk)
     len += strlenW(wptr) + 1;
   }
   if (wblk)
-      wblk = HeapReAlloc( GetProcessHeap(), 0, wblk, count* sizeof(WCHAR*) + len * sizeof(WCHAR));
+      wblk = HeapReAlloc( GetProcessHeap(), 0, wblk, count* sizeof(MSVCRT_wchar_t*) + len * sizeof(MSVCRT_wchar_t));
   else
-    wblk = HeapAlloc(GetProcessHeap(), 0, count* sizeof(WCHAR*) + len * sizeof(WCHAR));
+    wblk = HeapAlloc(GetProcessHeap(), 0, count* sizeof(MSVCRT_wchar_t*) + len * sizeof(MSVCRT_wchar_t));
   if (wblk)
     {
       if (count)
 	{
-	  memcpy(&wblk[count],wenviron_strings,len * sizeof(WCHAR));
-	  for (wptr = (WCHAR*)&wblk[count]; *wptr; wptr += strlenW(wptr) + 1)
+	  memcpy(&wblk[count],wenviron_strings,len * sizeof(MSVCRT_wchar_t));
+	  for (wptr = (MSVCRT_wchar_t*)&wblk[count]; *wptr; wptr += strlenW(wptr) + 1)
 	    {
 	      wblk[i++] = wptr;
 	    }
@@ -180,7 +180,7 @@ char** __p__acmdln(void) { return &MSVCRT__acmdln; }
 /*********************************************************************
  *		__p__wcmdln (MSVCRT.@)
  */
-WCHAR** __p__wcmdln(void) { return &MSVCRT__wcmdln; }
+MSVCRT_wchar_t** __p__wcmdln(void) { return &MSVCRT__wcmdln; }
 
 /*********************************************************************
  *		__p___argv (MSVCRT.@)
@@ -190,7 +190,7 @@ char*** __p___argv(void) { return &MSVCRT___argv; }
 /*********************************************************************
  *		__p___wargv (MSVCRT.@)
  */
-WCHAR*** __p___wargv(void) { return &MSVCRT___wargv; }
+MSVCRT_wchar_t*** __p___wargv(void) { return &MSVCRT___wargv; }
 
 /*********************************************************************
  *		__p__environ (MSVCRT.@)
@@ -205,7 +205,7 @@ char*** __p__environ(void)
 /*********************************************************************
  *		__p__wenviron (MSVCRT.@)
  */
-WCHAR*** __p__wenviron(void)
+MSVCRT_wchar_t*** __p__wenviron(void)
 {
   if (!MSVCRT__wenviron)
     MSVCRT__wenviron = msvcrt_SnapshotOfEnvironmentW(NULL);
@@ -220,7 +220,7 @@ char*** __p___initenv(void) { return &MSVCRT___initenv; }
 /*********************************************************************
  *		__p___winitenv (MSVCRT.@)
  */
-WCHAR*** __p___winitenv(void) { return &MSVCRT___winitenv; }
+MSVCRT_wchar_t*** __p___winitenv(void) { return &MSVCRT___winitenv; }
 
 /*********************************************************************
  *		__p__timezone (MSVCRT.@)
@@ -228,13 +228,13 @@ WCHAR*** __p___winitenv(void) { return &MSVCRT___winitenv; }
 int* __p__timezone(void) { return &MSVCRT_timezone; }
 
 /* INTERNAL: Create a wide string from an ascii string */
-static WCHAR *wstrdupa(const char *str)
+static MSVCRT_wchar_t *wstrdupa(const char *str)
 {
   const size_t len = strlen(str) + 1 ;
-  WCHAR *wstr = MSVCRT_malloc(len* sizeof (WCHAR));
+  MSVCRT_wchar_t *wstr = MSVCRT_malloc(len* sizeof (MSVCRT_wchar_t));
   if (!wstr)
     return NULL;
-   MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED,str,len*sizeof(char),wstr,len* sizeof (WCHAR));
+   MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED,str,len,wstr,len);
   return wstr;
 }
 
@@ -308,8 +308,8 @@ void __getmainargs(int *argc, char** *argv, char** *envp,
 /*********************************************************************
  *		__wgetmainargs (MSVCRT.@)
  */
-void __wgetmainargs(int *argc, WCHAR** *wargv, WCHAR** *wenvp,
-                                   int expand_wildcards, int *new_mode)
+void __wgetmainargs(int *argc, MSVCRT_wchar_t** *wargv, MSVCRT_wchar_t** *wenvp,
+                    int expand_wildcards, int *new_mode)
 {
   TRACE("(%p,%p,%p,%d,%p).\n", argc, wargv, wenvp, expand_wildcards, new_mode);
   *argc = MSVCRT___argc;

dlls/msvcrt/dir.c

@@ -97,7 +97,7 @@ int _chdir(const char * newdir)
 /*********************************************************************
  *		_wchdir (MSVCRT.@)
  */
-int _wchdir(const WCHAR * newdir)
+int _wchdir(const MSVCRT_wchar_t * newdir)
 {
   if (!SetCurrentDirectoryW(newdir))
   {
@@ -160,7 +160,7 @@ long _findfirst(const char * fspec, struct _finddata_t* ft)
 /*********************************************************************
  *		_wfindfirst (MSVCRT.@)
  */
-long _wfindfirst(const WCHAR * fspec, struct _wfinddata_t* ft)
+long _wfindfirst(const MSVCRT_wchar_t * fspec, struct _wfinddata_t* ft)
 {
   WIN32_FIND_DATAW find_data;
   HANDLE hfind;
@@ -239,9 +239,9 @@ char* _getcwd(char * buf, int size)
 /*********************************************************************
  *		_wgetcwd (MSVCRT.@)
  */
-WCHAR* _wgetcwd(WCHAR * buf, int size)
+MSVCRT_wchar_t* _wgetcwd(MSVCRT_wchar_t * buf, int size)
 {
-  WCHAR dir[MAX_PATH];
+  MSVCRT_wchar_t dir[MAX_PATH];
   int dir_len = GetCurrentDirectoryW(MAX_PATH,dir);
 
   if (dir_len < 1)
@@ -316,9 +316,9 @@ char* _getdcwd(int drive, char * buf, int size)
 /*********************************************************************
  *		_wgetdcwd (MSVCRT.@)
  */
-WCHAR* _wgetdcwd(int drive, WCHAR * buf, int size)
+MSVCRT_wchar_t* _wgetdcwd(int drive, MSVCRT_wchar_t * buf, int size)
 {
-  static WCHAR* dummy;
+  static MSVCRT_wchar_t* dummy;
 
   TRACE(":drive %d(%c), size %d\n",drive, drive + 'A' - 1, size);
 
@@ -326,8 +326,8 @@ WCHAR* _wgetdcwd(int drive, WCHAR * buf, int size)
     return _wgetcwd(buf,size); /* current */
   else
   {
-    WCHAR dir[MAX_PATH];
-    WCHAR drivespec[4] = {'A', ':', '\\', 0};
+    MSVCRT_wchar_t dir[MAX_PATH];
+    MSVCRT_wchar_t drivespec[4] = {'A', ':', '\\', 0};
     int dir_len;
 
     drivespec[0] += drive - 1;
@@ -393,7 +393,7 @@ int _mkdir(const char * newdir)
 /*********************************************************************
  *		_wmkdir (MSVCRT.@)
  */
-int _wmkdir(const WCHAR* newdir)
+int _wmkdir(const MSVCRT_wchar_t* newdir)
 {
   if (CreateDirectoryW(newdir,NULL))
     return 0;
@@ -415,7 +415,7 @@ int _rmdir(const char * dir)
 /*********************************************************************
  *		_wrmdir (MSVCRT.@)
  */
-int _wrmdir(const WCHAR * dir)
+int _wrmdir(const MSVCRT_wchar_t * dir)
 {
   if (RemoveDirectoryW(dir))
     return 0;
@@ -426,45 +426,45 @@ int _wrmdir(const WCHAR * dir)
 /*********************************************************************
  *		_wsplitpath (MSVCRT.@)
  */
-void _wsplitpath(const WCHAR *inpath, WCHAR *drv, WCHAR *dir,
-                                WCHAR *fname, WCHAR *ext )
+void _wsplitpath(const MSVCRT_wchar_t *inpath, MSVCRT_wchar_t *drv, MSVCRT_wchar_t *dir,
+                 MSVCRT_wchar_t *fname, MSVCRT_wchar_t *ext )
 {
   /* Modified PD code from 'snippets' collection. */
-  WCHAR ch, *ptr, *p;
-  WCHAR pathbuff[MAX_PATH],*path=pathbuff;
+  MSVCRT_wchar_t ch, *ptr, *p;
+  MSVCRT_wchar_t pathbuff[MAX_PATH],*path=pathbuff;
 
   TRACE(":splitting path %s\n",debugstr_w(path));
   /* FIXME: Should be an strncpyW or something */
   strcpyW(pathbuff, inpath);
 
   /* convert slashes to backslashes for searching */
-  for (ptr = (WCHAR*)path; *ptr; ++ptr)
-    if (*ptr == (WCHAR)L'/')
-      *ptr = (WCHAR)L'\\';
+  for (ptr = (MSVCRT_wchar_t*)path; *ptr; ++ptr)
+    if (*ptr == '/')
+      *ptr = '\\';
 
   /* look for drive spec */
-  if ((ptr = strchrW(path, (WCHAR)L':')) != (WCHAR)L'\0')
+  if ((ptr = strchrW(path, ':')) != 0)
   {
     ++ptr;
     if (drv)
     {
       strncpyW(drv, path, ptr - path);
-      drv[ptr - path] = (WCHAR)L'\0';
+      drv[ptr - path] = 0;
     }
     path = ptr;
   }
   else if (drv)
-    *drv = (WCHAR)L'\0';
+    *drv = 0;
 
   /* find rightmost backslash or leftmost colon */
-  if ((ptr = strrchrW(path, (WCHAR)L'\\')) == NULL)
-    ptr = (strchrW(path, (WCHAR)L':'));
+  if ((ptr = strrchrW(path, '\\')) == NULL)
+    ptr = (strchrW(path, ':'));
 
   if (!ptr)
   {
-    ptr = (WCHAR *)path; /* no path */
+    ptr = (MSVCRT_wchar_t *)path; /* no path */
     if (dir)
-      *dir = (WCHAR)L'\0';
+      *dir = 0;
   }
   else
   {
@@ -472,25 +472,25 @@ void _wsplitpath(const WCHAR *inpath, WCHAR *drv, WCHAR *dir,
     if (dir)
     {
       ch = *ptr;
-      *ptr = (WCHAR)L'\0';
+      *ptr = 0;
       strcpyW(dir, path);
       *ptr = ch;
     }
   }
 
-  if ((p = strrchrW(ptr, (WCHAR)L'.')) == NULL)
+  if ((p = strrchrW(ptr, '.')) == NULL)
   {
     if (fname)
       strcpyW(fname, ptr);
     if (ext)
-      *ext = (WCHAR)L'\0';
+      *ext = 0;
   }
   else
   {
-    *p = (WCHAR)L'\0';
+    *p = 0;
     if (fname)
       strcpyW(fname, ptr);
-    *p = (WCHAR)L'.';
+    *p = '.';
     if (ext)
       strcpyW(ext, p);
   }
@@ -498,13 +498,13 @@ void _wsplitpath(const WCHAR *inpath, WCHAR *drv, WCHAR *dir,
   /* Fix pathological case - Win returns ':' as part of the
    * directory when no drive letter is given.
    */
-  if (drv && drv[0] == (WCHAR)L':')
+  if (drv && drv[0] == ':')
   {
-    *drv = (WCHAR)L'\0';
+    *drv = 0;
     if (dir)
     {
-      pathbuff[0] = (WCHAR)L':';
-      pathbuff[1] = (WCHAR)L'\0';
+      pathbuff[0] = ':';
+      pathbuff[1] = 0;
       strcatW(pathbuff,dir);
       strcpyW(dir, pathbuff);
     }
@@ -714,10 +714,10 @@ VOID _makepath(char * path, const char * drive,
 /*********************************************************************
  *		_wmakepath (MSVCRT.@)
  */
-VOID _wmakepath(WCHAR *path, const WCHAR *drive, const WCHAR *directory,
-		const WCHAR *filename, const WCHAR *extension)
+VOID _wmakepath(MSVCRT_wchar_t *path, const MSVCRT_wchar_t *drive, const MSVCRT_wchar_t *directory,
+		const MSVCRT_wchar_t *filename, const MSVCRT_wchar_t *extension)
 {
-    WCHAR ch;
+    MSVCRT_wchar_t ch;
     TRACE("%s %s %s %s\n", debugstr_w(drive), debugstr_w(directory),
 	  debugstr_w(filename), debugstr_w(extension));
 
@@ -737,7 +737,7 @@ VOID _wmakepath(WCHAR *path, const WCHAR *drive, const WCHAR *directory,
         ch = path[strlenW(path) - 1];
         if (ch != '/' && ch != '\\')
 	{
-	    static const WCHAR backslashW[] = {'\\',0};
+	    static const MSVCRT_wchar_t backslashW[] = {'\\',0};
             strcatW(path, backslashW);
 	}
     }
@@ -748,7 +748,7 @@ VOID _wmakepath(WCHAR *path, const WCHAR *drive, const WCHAR *directory,
         {
             if ( extension[0] != '.' )
 	    {
-		static const WCHAR dotW[] = {'.',0};
+		static const MSVCRT_wchar_t dotW[] = {'.',0};
                 strcatW(path, dotW);
 	    }
             strcatW(path, extension);

dlls/msvcrt/environ.c

@@ -61,10 +61,10 @@ char *MSVCRT_getenv(const char *name)
 /*********************************************************************
  *		_wgetenv (MSVCRT.@)
  */
-WCHAR *_wgetenv(const WCHAR *name)
+MSVCRT_wchar_t *_wgetenv(const MSVCRT_wchar_t *name)
 {
-  WCHAR* environ = GetEnvironmentStringsW();
-  WCHAR* pp,*pos = NULL;
+  MSVCRT_wchar_t* environ = GetEnvironmentStringsW();
+  MSVCRT_wchar_t* pp,*pos = NULL;
   unsigned int length=strlenW(name);
 
   for (pp = environ; (*pp); pp = pp + strlenW(pp) + 1)
@@ -122,25 +122,25 @@ int _putenv(const char *str)
 /*********************************************************************
  *		_wputenv (MSVCRT.@)
  */
-int _wputenv(const WCHAR *str)
+int _wputenv(const MSVCRT_wchar_t *str)
 {
- WCHAR name[256], value[512];
- WCHAR *dst = name;
+ MSVCRT_wchar_t name[256], value[512];
+ MSVCRT_wchar_t *dst = name;
  int ret;
 
  TRACE("%s\n", debugstr_w(str));
 
  if (!str)
    return -1;
- while (*str && *str != (WCHAR)L'=')
+ while (*str && *str != '=')
   *dst++ = *str++;
  if (!*str++)
    return -1;
- *dst = (WCHAR)L'\0';
+ *dst = 0;
  dst = value;
  while (*str)
   *dst++ = *str++;
- *dst = (WCHAR)L'\0';
+ *dst = 0;
 
  ret = !SetEnvironmentVariableW(name, value[0] ? value : NULL);
  /* Update the __p__environ array only when already initialized */

dlls/msvcrt/file.c

@@ -87,7 +87,7 @@ static const unsigned int BAT = 'b' << 16 | 'a' << 8 | 't';
 static const unsigned int CMD = 'c' << 16 | 'm' << 8 | 'd';
 static const unsigned int COM = 'c' << 16 | 'o' << 8 | 'm';
 
-#define TOUL(x) (ULONGLONG)((WCHAR)L##x)
+#define TOUL(x) (ULONGLONG)(x)
 static const ULONGLONG WCEXE = TOUL('e') << 32 | TOUL('x') << 16 | TOUL('e');
 static const ULONGLONG WCBAT = TOUL('b') << 32 | TOUL('a') << 16 | TOUL('t');
 static const ULONGLONG WCCMD = TOUL('c') << 32 | TOUL('m') << 16 | TOUL('d');
@@ -291,7 +291,7 @@ int _access(const char *filename, int mode)
 /*********************************************************************
  *		_waccess (MSVCRT.@)
  */
-int _waccess(const WCHAR *filename, int mode)
+int _waccess(const MSVCRT_wchar_t *filename, int mode)
 {
   DWORD attr = GetFileAttributesW(filename);
 
@@ -332,7 +332,7 @@ int _chmod(const char *path, int flags)
 /*********************************************************************
  *		_wchmod (MSVCRT.@)
  */
-int _wchmod(const WCHAR *path, int flags)
+int _wchmod(const MSVCRT_wchar_t *path, int flags)
 {
   DWORD oldFlags = GetFileAttributesW(path);
 
@@ -364,7 +364,7 @@ int _unlink(const char *path)
 /*********************************************************************
  *		_wunlink (MSVCRT.@)
  */
-int _wunlink(const WCHAR *path)
+int _wunlink(const MSVCRT_wchar_t *path)
 {
   TRACE("(%s)\n",debugstr_w(path));
   if(DeleteFileW(path))
@@ -628,7 +628,7 @@ MSVCRT_FILE* _fdopen(int fd, const char *mode)
 /*********************************************************************
  *		_wfdopen (MSVCRT.@)
  */
-MSVCRT_FILE* _wfdopen(int fd, const WCHAR *mode)
+MSVCRT_FILE* _wfdopen(int fd, const MSVCRT_wchar_t *mode)
 {
   MSVCRT_FILE* file = msvcrt_alloc_fp(fd);
 
@@ -853,15 +853,15 @@ char *_mktemp(char *pattern)
 /*********************************************************************
  *		_wmktemp (MSVCRT.@)
  */
-WCHAR *_wmktemp(WCHAR *pattern)
+MSVCRT_wchar_t *_wmktemp(MSVCRT_wchar_t *pattern)
 {
   int numX = 0;
-  WCHAR *retVal = pattern;
+  MSVCRT_wchar_t *retVal = pattern;
   int id;
-  WCHAR letter = (WCHAR)L'a';
+  MSVCRT_wchar_t letter = 'a';
 
   while(*pattern)
-    numX = (*pattern++ == (WCHAR)L'X')? numX + 1 : 0;
+    numX = (*pattern++ == 'X')? numX + 1 : 0;
   if (numX < 5)
     return NULL;
   pattern--;
@@ -870,7 +870,7 @@ WCHAR *_wmktemp(WCHAR *pattern)
   while(numX--)
   {
     int tempNum = id / 10;
-    *pattern-- = id - (tempNum * 10) + (WCHAR)L'0';
+    *pattern-- = id - (tempNum * 10) + '0';
     id = tempNum;
   }
   pattern++;
@@ -880,7 +880,7 @@ WCHAR *_wmktemp(WCHAR *pattern)
         GetLastError() == ERROR_FILE_NOT_FOUND)
       return retVal;
     *pattern = letter++;
-  } while(letter != (WCHAR)L'|');
+  } while(letter != '|');
   return NULL;
 }
 
@@ -1007,7 +1007,7 @@ int MSVCRT__sopen( const char *path, int oflags, int shflags, ... )
 /*********************************************************************
  *              _wsopen (MSVCRT.@)
  */
-int MSVCRT__wsopen( const WCHAR* path, int oflags, int shflags, ... )
+int MSVCRT__wsopen( const MSVCRT_wchar_t* path, int oflags, int shflags, ... )
 {
   const unsigned int len = strlenW(path);
   char *patha = MSVCRT_calloc(len + 1,1);
@@ -1047,7 +1047,7 @@ int _open( const char *path, int flags, ... )
 /*********************************************************************
  *              _wopen (MSVCRT.@)
  */
-int _wopen(const WCHAR *path,int flags,...)
+int _wopen(const MSVCRT_wchar_t *path,int flags,...)
 {
   const unsigned int len = strlenW(path);
   char *patha = MSVCRT_calloc(len + 1,1);
@@ -1081,7 +1081,7 @@ int _creat(const char *path, int flags)
 /*********************************************************************
  *		_wcreat (MSVCRT.@)
  */
-int _wcreat(const WCHAR *path, int flags)
+int _wcreat(const MSVCRT_wchar_t *path, int flags)
 {
   int usedFlags = (flags & _O_TEXT)| _O_CREAT| _O_WRONLY| _O_TRUNC;
   return _wopen(path, usedFlags);
@@ -1253,7 +1253,7 @@ int MSVCRT__stat(const char* path, struct _stat * buf)
 /*********************************************************************
  *		_wstat (MSVCRT.@)
  */
-int _wstat(const WCHAR* path, struct _stat * buf)
+int _wstat(const MSVCRT_wchar_t* path, struct _stat * buf)
 {
   DWORD dw;
   WIN32_FILE_ATTRIBUTE_DATA hfi;
@@ -1273,7 +1273,7 @@ int _wstat(const WCHAR* path, struct _stat * buf)
 
   /* FIXME: rdev isn't drive num, despite what the docs says-what is it? */
   if (MSVCRT_iswalpha(*path))
-    buf->st_dev = buf->st_rdev = toupperW(*path - (WCHAR)L'A'); /* drive num */
+    buf->st_dev = buf->st_rdev = toupperW(*path - 'A'); /* drive num */
   else
     buf->st_dev = buf->st_rdev = _getdrive() - 1;
 
@@ -1281,13 +1281,13 @@ int _wstat(const WCHAR* path, struct _stat * buf)
 
   /* Dir, or regular file? */
   if ((hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ||
-      (path[plen-1] == (WCHAR)L'\\'))
+      (path[plen-1] == '\\'))
     mode |= (_S_IFDIR | MSVCRT_S_IEXEC);
   else
   {
     mode |= _S_IFREG;
     /* executable? */
-    if (plen > 6 && path[plen-4] == (WCHAR)L'.')  /* shortest exe: "\x.exe" */
+    if (plen > 6 && path[plen-4] == '.')  /* shortest exe: "\x.exe" */
     {
       ULONGLONG ext = tolowerW(path[plen-1]) | (tolowerW(path[plen-2]) << 16) |
                                ((ULONGLONG)tolowerW(path[plen-3]) << 32);
@@ -1339,9 +1339,9 @@ char *_tempnam(const char *dir, const char *prefix)
 /*********************************************************************
  *		_wtempnam (MSVCRT.@)
  */
-WCHAR *_wtempnam(const WCHAR *dir, const WCHAR *prefix)
+MSVCRT_wchar_t *_wtempnam(const MSVCRT_wchar_t *dir, const MSVCRT_wchar_t *prefix)
 {
-  WCHAR tmpbuf[MAX_PATH];
+  MSVCRT_wchar_t tmpbuf[MAX_PATH];
 
   TRACE("dir (%s) prefix (%s)\n",debugstr_w(dir),debugstr_w(prefix));
   if (GetTempFileNameW(dir,prefix,0,tmpbuf))
@@ -1383,7 +1383,7 @@ int _utime(const char* path, struct _utimbuf *t)
 /*********************************************************************
  *		_wutime (MSVCRT.@)
  */
-int _wutime(const WCHAR* path, struct _utimbuf *t)
+int _wutime(const MSVCRT_wchar_t* path, struct _utimbuf *t)
 {
   int fd = _wopen(path, _O_WRONLY | _O_BINARY);
 
@@ -1587,7 +1587,7 @@ char *MSVCRT_fgets(char *s, int size, MSVCRT_FILE* file)
  */
 MSVCRT_wint_t MSVCRT_fgetwc(MSVCRT_FILE* file)
 {
-  WCHAR wc;
+  MSVCRT_wchar_t wc;
   if (_read(file->_file, &wc, sizeof(wc)) != sizeof(wc))
     return MSVCRT_WEOF;
   return wc;
@@ -1620,10 +1620,10 @@ MSVCRT_wint_t MSVCRT_getwchar(void)
 /*********************************************************************
  *              fgetws (MSVCRT.@)
  */
-WCHAR *MSVCRT_fgetws(WCHAR *s, int size, MSVCRT_FILE* file)
+MSVCRT_wchar_t *MSVCRT_fgetws(MSVCRT_wchar_t *s, int size, MSVCRT_FILE* file)
 {
   int    cc;
-  WCHAR * buf_start = s;
+  MSVCRT_wchar_t * buf_start = s;
 
   TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
         file,file->_file,s,size);
@@ -1654,7 +1654,7 @@ WCHAR *MSVCRT_fgetws(WCHAR *s, int size, MSVCRT_FILE* file)
  */
 MSVCRT_wint_t MSVCRT_fputwc(MSVCRT_wint_t wc, MSVCRT_FILE* file)
 {
-  WCHAR mwc=wc;
+  MSVCRT_wchar_t mwc=wc;
   if (MSVCRT_fwrite( &mwc, sizeof(mwc), 1, file) != 1)
     return MSVCRT_WEOF;
   return wc;
@@ -1732,7 +1732,7 @@ MSVCRT_FILE* MSVCRT_fopen(const char *path, const char *mode)
 /*********************************************************************
  *		_wfopen (MSVCRT.@)
  */
-MSVCRT_FILE *_wfopen(const WCHAR *path, const WCHAR *mode)
+MSVCRT_FILE *_wfopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode)
 {
   const unsigned int plen = strlenW(path), mlen = strlenW(mode);
   char *patha = MSVCRT_calloc(plen + 1, 1);
@@ -1766,7 +1766,7 @@ MSVCRT_FILE*  _fsopen(const char *path, const char *mode, int share)
 /*********************************************************************
  *		_wfsopen (MSVCRT.@)
  */
-MSVCRT_FILE*  _wfsopen(const WCHAR *path, const WCHAR *mode, int share)
+MSVCRT_FILE*  _wfsopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode, int share)
 {
   FIXME(":(%s,%s,%d),ignoring share mode!\n",
         debugstr_w(path),debugstr_w(mode),share);
@@ -2001,7 +2001,7 @@ int MSVCRT_fputs(const char *s, MSVCRT_FILE* file)
 /*********************************************************************
  *		fputws (MSVCRT.@)
  */
-int MSVCRT_fputws(const WCHAR *s, MSVCRT_FILE* file)
+int MSVCRT_fputws(const MSVCRT_wchar_t *s, MSVCRT_FILE* file)
 {
     size_t len = strlenW(s);
     return MSVCRT_fwrite(s,sizeof(*s),len,file) == len ? 0 : MSVCRT_EOF;
@@ -2044,16 +2044,16 @@ char *MSVCRT_gets(char *buf)
 /*********************************************************************
  *		_getws (MSVCRT.@)
  */
-WCHAR* MSVCRT__getws(WCHAR* buf)
+MSVCRT_wchar_t* MSVCRT__getws(MSVCRT_wchar_t* buf)
 {
     MSVCRT_wint_t cc;
-    WCHAR* ws = buf;
+    MSVCRT_wchar_t* ws = buf;
 
     for (cc = MSVCRT_fgetwc(MSVCRT_stdin); cc != MSVCRT_WEOF && cc != '\n';
          cc = MSVCRT_fgetwc(MSVCRT_stdin))
     {
         if (cc != '\r')
-            *buf++ = (WCHAR)cc;
+            *buf++ = (MSVCRT_wchar_t)cc;
     }
     *buf = '\0';
 
@@ -2090,9 +2090,9 @@ int MSVCRT_puts(const char *s)
 /*********************************************************************
  *		_putws (MSVCRT.@)
  */
-int _putws(const WCHAR *s)
+int _putws(const MSVCRT_wchar_t *s)
 {
-    static const WCHAR nl = '\n';
+    static const MSVCRT_wchar_t nl = '\n';
     size_t len = strlenW(s);
     if (MSVCRT_fwrite(s,sizeof(*s),len,MSVCRT_stdout) != len) return MSVCRT_EOF;
     return MSVCRT_fwrite(&nl,sizeof(nl),1,MSVCRT_stdout) == 1 ? 0 : MSVCRT_EOF;
@@ -2114,7 +2114,7 @@ int MSVCRT_remove(const char *path)
 /*********************************************************************
  *		_wremove (MSVCRT.@)
  */
-int _wremove(const WCHAR *path)
+int _wremove(const MSVCRT_wchar_t *path)
 {
   TRACE("(%s)\n",debugstr_w(path));
   if (DeleteFileW(path))
@@ -2141,7 +2141,7 @@ int MSVCRT_scanf(const char *format, ...)
 /*********************************************************************
  *		wscanf (MSVCRT.@)
  */
-int MSVCRT_wscanf(const WCHAR *format, ...)
+int MSVCRT_wscanf(const MSVCRT_wchar_t *format, ...)
 {
   va_list valist;
   int res;
@@ -2168,7 +2168,7 @@ int MSVCRT_rename(const char *oldpath,const char *newpath)
 /*********************************************************************
  *		_wrename (MSVCRT.@)
  */
-int _wrename(const WCHAR *oldpath,const WCHAR *newpath)
+int _wrename(const MSVCRT_wchar_t *oldpath,const MSVCRT_wchar_t *newpath)
 {
   TRACE(":from %s to %s\n",debugstr_w(oldpath),debugstr_w(newpath));
   if (MoveFileExW(oldpath, newpath, MOVEFILE_COPY_ALLOWED))
@@ -2273,18 +2273,18 @@ int MSVCRT_vfprintf(MSVCRT_FILE* file, const char *format, va_list valist)
  * Is final char included in written (then resize is too big) or not
  * (then we must test for equality too)?
  */
-int MSVCRT_vfwprintf(MSVCRT_FILE* file, const WCHAR *format, va_list valist)
+int MSVCRT_vfwprintf(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, va_list valist)
 {
-  WCHAR buf[2048], *mem = buf;
-  int written, resize = sizeof(buf) / sizeof(WCHAR), retval;
+  MSVCRT_wchar_t buf[2048], *mem = buf;
+  int written, resize = sizeof(buf) / sizeof(MSVCRT_wchar_t), retval;
   /* See vfprintf comments */
   while ((written = _vsnwprintf(mem, resize, format, valist)) == -1 ||
           written > resize)
   {
-    resize = (written == -1 ? resize * 2 : written + sizeof(WCHAR));
+    resize = (written == -1 ? resize * 2 : written + sizeof(MSVCRT_wchar_t));
     if (mem != buf)
       MSVCRT_free (mem);
-    if (!(mem = (WCHAR *)MSVCRT_malloc(resize*sizeof(*mem))))
+    if (!(mem = (MSVCRT_wchar_t *)MSVCRT_malloc(resize*sizeof(*mem))))
       return MSVCRT_EOF;
   }
   retval = MSVCRT_fwrite(mem, sizeof(*mem), written, file);
@@ -2304,7 +2304,7 @@ int MSVCRT_vprintf(const char *format, va_list valist)
 /*********************************************************************
  *		vwprintf (MSVCRT.@)
  */
-int MSVCRT_vwprintf(const WCHAR *format, va_list valist)
+int MSVCRT_vwprintf(const MSVCRT_wchar_t *format, va_list valist)
 {
   return MSVCRT_vfwprintf(MSVCRT_stdout,format,valist);
 }
@@ -2325,7 +2325,7 @@ int MSVCRT_fprintf(MSVCRT_FILE* file, const char *format, ...)
 /*********************************************************************
  *		fwprintf (MSVCRT.@)
  */
-int MSVCRT_fwprintf(MSVCRT_FILE* file, const WCHAR *format, ...)
+int MSVCRT_fwprintf(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, ...)
 {
     va_list valist;
     int res;
@@ -2371,10 +2371,10 @@ int MSVCRT_ungetc(int c, MSVCRT_FILE * file)
  */
 MSVCRT_wint_t MSVCRT_ungetwc(MSVCRT_wint_t wc, MSVCRT_FILE * file)
 {
-	WCHAR mwc = wc;
+	MSVCRT_wchar_t mwc = wc;
 	char * pp = (char *)&mwc;
 	int i;
-	for(i=sizeof(WCHAR)-1;i>=0;i--) {
+	for(i=sizeof(MSVCRT_wchar_t)-1;i>=0;i--) {
 		if(pp[i] != MSVCRT_ungetc(pp[i],file))
 			return MSVCRT_WEOF;
 	}
@@ -2384,7 +2384,7 @@ MSVCRT_wint_t MSVCRT_ungetwc(MSVCRT_wint_t wc, MSVCRT_FILE * file)
 /*********************************************************************
  *		wprintf (MSVCRT.@)
  */
-int MSVCRT_wprintf(const WCHAR *format, ...)
+int MSVCRT_wprintf(const MSVCRT_wchar_t *format, ...)
 {
     va_list valist;
     int res;

dlls/msvcrt/mbcs.c

@@ -39,9 +39,9 @@ WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
 unsigned char MSVCRT_mbctype[257];
 int MSVCRT___mb_cur_max = 1;
 
-static WCHAR msvcrt_mbc_to_wc(unsigned int ch)
+static MSVCRT_wchar_t msvcrt_mbc_to_wc(unsigned int ch)
 {
-  WCHAR chW;
+  MSVCRT_wchar_t chW;
   char mbch[2];
   int n_chars;
 
@@ -527,7 +527,7 @@ unsigned char* _mbsrchr(const unsigned char* s, unsigned int x)
 /*********************************************************************
  *		mbtowc(MSVCRT.@)
  */
-int MSVCRT_mbtowc(WCHAR *dst, const char* str, MSVCRT_size_t n)
+int MSVCRT_mbtowc(MSVCRT_wchar_t *dst, const char* str, MSVCRT_size_t n)
 {
   if(n <= 0 || !str)
     return 0;
@@ -575,7 +575,7 @@ int _ismbbkana(unsigned int c)
  */
 int _ismbcdigit(unsigned int ch)
 {
-    WCHAR wch = msvcrt_mbc_to_wc( ch );
+    MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
     return (get_char_typeW( wch ) & C1_DIGIT);
 }
 
@@ -584,7 +584,7 @@ int _ismbcdigit(unsigned int ch)
  */
 int _ismbcgraph(unsigned int ch)
 {
-    WCHAR wch = msvcrt_mbc_to_wc( ch );
+    MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
     return (get_char_typeW( wch ) & (C1_UPPER | C1_LOWER | C1_DIGIT | C1_PUNCT | C1_ALPHA));
 }
 
@@ -593,7 +593,7 @@ int _ismbcgraph(unsigned int ch)
  */
 int _ismbcalpha(unsigned int ch)
 {
-    WCHAR wch = msvcrt_mbc_to_wc( ch );
+    MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
     return (get_char_typeW( wch ) & C1_ALPHA);
 }
 
@@ -602,7 +602,7 @@ int _ismbcalpha(unsigned int ch)
  */
 int _ismbclower(unsigned int ch)
 {
-    WCHAR wch = msvcrt_mbc_to_wc( ch );
+    MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
     return (get_char_typeW( wch ) & C1_UPPER);
 }
 
@@ -611,7 +611,7 @@ int _ismbclower(unsigned int ch)
  */
 int _ismbcupper(unsigned int ch)
 {
-    WCHAR wch = msvcrt_mbc_to_wc( ch );
+    MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
     return (get_char_typeW( wch ) & C1_LOWER);
 }
 
@@ -620,7 +620,7 @@ int _ismbcupper(unsigned int ch)
  */
 int _ismbcsymbol(unsigned int ch)
 {
-    WCHAR wch = msvcrt_mbc_to_wc( ch );
+    MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
     WORD ctype;
     if (!GetStringTypeW(CT_CTYPE3, &wch, 1, &ctype))
     {
@@ -635,7 +635,7 @@ int _ismbcsymbol(unsigned int ch)
  */
 int _ismbcalnum(unsigned int ch)
 {
-    WCHAR wch = msvcrt_mbc_to_wc( ch );
+    MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
     return (get_char_typeW( wch ) & (C1_ALPHA | C1_DIGIT));
 }
 
@@ -644,7 +644,7 @@ int _ismbcalnum(unsigned int ch)
  */
 int _ismbcspace(unsigned int ch)
 {
-    WCHAR wch = msvcrt_mbc_to_wc( ch );
+    MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
     return (get_char_typeW( wch ) & C1_SPACE);
 }
 
@@ -653,7 +653,7 @@ int _ismbcspace(unsigned int ch)
  */
 int _ismbcprint(unsigned int ch)
 {
-    WCHAR wch = msvcrt_mbc_to_wc( ch );
+    MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
     return (get_char_typeW( wch ) & (C1_UPPER | C1_LOWER | C1_DIGIT | C1_PUNCT | C1_ALPHA | C1_SPACE));
 }
 
@@ -662,7 +662,7 @@ int _ismbcprint(unsigned int ch)
  */
 int _ismbcpunct(unsigned int ch)
 {
-    WCHAR wch = msvcrt_mbc_to_wc( ch );
+    MSVCRT_wchar_t wch = msvcrt_mbc_to_wc( ch );
     return (get_char_typeW( wch ) & C1_PUNCT);
 }
 

dlls/msvcrt/msvcrt.h

@@ -28,6 +28,7 @@
 #include "winerror.h"
 #include "winnls.h"
 
+#include "msvcrt/string.h"
 #include "msvcrt/eh.h"
 
 /* TLS data */
@@ -50,15 +51,15 @@ extern int MSVCRT_current_lc_all_cp;
 void _purecall(void);
 void   MSVCRT__set_errno(int);
 char*  msvcrt_strndup(const char*,unsigned int);
-LPWSTR msvcrt_wstrndup(LPCWSTR, unsigned int);
+MSVCRT_wchar_t *msvcrt_wstrndup(const MSVCRT_wchar_t*, unsigned int);
 
 void MSVCRT__amsg_exit(int errnum);
 
 extern char **MSVCRT__environ;
-extern WCHAR **MSVCRT__wenviron;
+extern MSVCRT_wchar_t **MSVCRT__wenviron;
 
 extern char ** msvcrt_SnapshotOfEnvironmentA(char **);
-extern WCHAR ** msvcrt_SnapshotOfEnvironmentW(WCHAR **);
+extern MSVCRT_wchar_t ** msvcrt_SnapshotOfEnvironmentW(MSVCRT_wchar_t **);
 
 /* FIXME: This should be declared in new.h but it's not an extern "C" so
  * it would not be much use anyway. Even for Winelib applications.

dlls/msvcrt/scanf.c

@@ -48,7 +48,7 @@ static int char2digit(char c, int base) {
 /* helper function for *wscanf.  Returns the value of character c in the
  * given base, or -1 if the given character is not a digit of the base.
  */
-static int wchar2digit(WCHAR c, int base) {
+static int wchar2digit(MSVCRT_wchar_t c, int base) {
     if ((c>=L'0') && (c<=L'9') && (c<=L'0'+base-1)) return (c-L'0');
     if (base<=10) return -1;
     if ((c>=L'A') && (c<=L'Z') && (c<=L'A'+base-11)) return (c-L'A'+10);

dlls/msvcrt/scanf.h

@@ -25,7 +25,7 @@
 
 #ifdef WIDE_SCANF
 #define _L_(x) L##x
-#define _CHAR_ WCHAR
+#define _CHAR_ MSVCRT_wchar_t
 #define _EOF_ MSVCRT_WEOF
 #define _ISSPACE_(c) MSVCRT_iswspace(c)
 #define _ISDIGIT_(c) MSVCRT_iswdigit(c)
@@ -52,7 +52,7 @@
 #define _GETC_(file) *file++
 #define _UNGETC_(nch, file) file--
 #ifdef WIDE_SCANF
-#define _FUNCTION_ MSVCRT_swscanf(const WCHAR *file, const WCHAR *format, ...)
+#define _FUNCTION_ MSVCRT_swscanf(const MSVCRT_wchar_t *file, const MSVCRT_wchar_t *format, ...)
 #else /* WIDE_SCANF */
 #define _FUNCTION_ MSVCRT_sscanf(const char *file, const char *format, ...)
 #endif /* WIDE_SCANF */
@@ -60,7 +60,7 @@
 #ifdef WIDE_SCANF
 #define _GETC_(file) MSVCRT_fgetwc(file)
 #define _UNGETC_(nch, file) MSVCRT_ungetwc(nch, file)
-#define _FUNCTION_ MSVCRT_fwscanf(MSVCRT_FILE* file, const WCHAR *format, ...)
+#define _FUNCTION_ MSVCRT_fwscanf(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, ...)
 #else /* WIDE_SCANF */
 #define _GETC_(file) MSVCRT_fgetc(file)
 #define _UNGETC_(nch, file) MSVCRT_ungetc(nch, file)
@@ -369,10 +369,10 @@ int _FUNCTION_ {
                     if (!suppress) *sptr = 0;
                 }
                 break;
-	    widecharstring: { /* read a word into a WCHAR * */
-		    WCHAR*str =
-			suppress ? NULL : va_arg(ap, WCHAR*);
-                    WCHAR*sptr = str;
+	    widecharstring: { /* read a word into a wchar_t* */
+		    MSVCRT_wchar_t*str =
+			suppress ? NULL : va_arg(ap, MSVCRT_wchar_t*);
+                    MSVCRT_wchar_t*sptr = str;
                     /* skip initial whitespace */
                     while ((nch!=_EOF_) && _ISSPACE_(nch))
                         nch = _GETC_(file);
@@ -423,8 +423,8 @@ int _FUNCTION_ {
 	        }
 		break;
 	  widecharacter: {
-		    if (!suppress) { /* read single character into WCHAR */
-			WCHAR*c = va_arg(ap, WCHAR*);
+		    if (!suppress) { /* read single character into a wchar_t */
+			MSVCRT_wchar_t*c = va_arg(ap, MSVCRT_wchar_t*);
 #ifdef WIDE_SCANF
 			*c = nch;
 #else /* WIDE_SCANF */

dlls/msvcrt/wcs.c

@@ -35,17 +35,17 @@ WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
 
 
 /* INTERNAL: MSVCRT_malloc() based wstrndup */
-WCHAR* msvcrt_wstrndup(LPCWSTR buf, unsigned int size)
+MSVCRT_wchar_t* msvcrt_wstrndup(const MSVCRT_wchar_t *buf, unsigned int size)
 {
-  WCHAR* ret;
+  MSVCRT_wchar_t* ret;
   unsigned int len = strlenW(buf), max_len;
 
   max_len = size <= len? size : len + 1;
 
-  ret = MSVCRT_malloc(max_len * sizeof (WCHAR));
+  ret = MSVCRT_malloc(max_len * sizeof (MSVCRT_wchar_t));
   if (ret)
   {
-    memcpy(ret,buf,max_len * sizeof (WCHAR));
+    memcpy(ret,buf,max_len * sizeof (MSVCRT_wchar_t));
     ret[max_len] = 0;
   }
   return ret;
@@ -54,12 +54,12 @@ WCHAR* msvcrt_wstrndup(LPCWSTR buf, unsigned int size)
 /*********************************************************************
  *		_wcsdup (MSVCRT.@)
  */
-WCHAR* _wcsdup( const WCHAR* str )
+MSVCRT_wchar_t* _wcsdup( const MSVCRT_wchar_t* str )
 {
-  WCHAR* ret = NULL;
+  MSVCRT_wchar_t* ret = NULL;
   if (str)
   {
-    int size = (strlenW(str) + 1) * sizeof(WCHAR);
+    int size = (strlenW(str) + 1) * sizeof(MSVCRT_wchar_t);
     ret = MSVCRT_malloc( size );
     if (ret) memcpy( ret, str, size );
   }
@@ -69,7 +69,7 @@ WCHAR* _wcsdup( const WCHAR* str )
 /*********************************************************************
  *		_wcsicoll (MSVCRT.@)
  */
-INT _wcsicoll( const WCHAR* str1, const WCHAR* str2 )
+INT _wcsicoll( const MSVCRT_wchar_t* str1, const MSVCRT_wchar_t* str2 )
 {
   /* FIXME: handle collates */
   return strcmpiW( str1, str2 );
@@ -78,9 +78,9 @@ INT _wcsicoll( const WCHAR* str1, const WCHAR* str2 )
 /*********************************************************************
  *		_wcsnset (MSVCRT.@)
  */
-WCHAR* _wcsnset( WCHAR* str, WCHAR c, MSVCRT_size_t n )
+MSVCRT_wchar_t* _wcsnset( MSVCRT_wchar_t* str, MSVCRT_wchar_t c, MSVCRT_size_t n )
 {
-  WCHAR* ret = str;
+  MSVCRT_wchar_t* ret = str;
   while ((n-- > 0) && *str) *str++ = c;
   return ret;
 }
@@ -88,13 +88,13 @@ WCHAR* _wcsnset( WCHAR* str, WCHAR c, MSVCRT_size_t n )
 /*********************************************************************
  *		_wcsrev (MSVCRT.@)
  */
-WCHAR* _wcsrev( WCHAR* str )
+MSVCRT_wchar_t* _wcsrev( MSVCRT_wchar_t* str )
 {
-  WCHAR* ret = str;
-  WCHAR* end = str + strlenW(str) - 1;
+  MSVCRT_wchar_t* ret = str;
+  MSVCRT_wchar_t* end = str + strlenW(str) - 1;
   while (end > str)
   {
-    WCHAR t = *end;
+    MSVCRT_wchar_t t = *end;
     *end--  = *str;
     *str++  = t;
   }
@@ -104,9 +104,9 @@ WCHAR* _wcsrev( WCHAR* str )
 /*********************************************************************
  *		_wcsset (MSVCRT.@)
  */
-WCHAR* _wcsset( WCHAR* str, WCHAR c )
+MSVCRT_wchar_t* _wcsset( MSVCRT_wchar_t* str, MSVCRT_wchar_t c )
 {
-  WCHAR* ret = str;
+  MSVCRT_wchar_t* ret = str;
   while (*str) *str++ = c;
   return ret;
 }
@@ -114,37 +114,37 @@ WCHAR* _wcsset( WCHAR* str, WCHAR c )
 /*********************************************************************
  *		_vsnwprintf (MSVCRT.@)
  */
-int _vsnwprintf(WCHAR *str, unsigned int len,
-                              const WCHAR *format, va_list valist)
+int _vsnwprintf(MSVCRT_wchar_t *str, unsigned int len,
+                const MSVCRT_wchar_t *format, va_list valist)
 {
 /* If you fix a bug in this function, fix it in ntdll/wcstring.c also! */
   unsigned int written = 0;
-  const WCHAR *iter = format;
+  const MSVCRT_wchar_t *iter = format;
   char bufa[256], fmtbufa[64], *fmta;
 
   TRACE("(%d,%s)\n",len,debugstr_w(format));
 
   while (*iter)
   {
-    while (*iter && *iter != (WCHAR)L'%')
+    while (*iter && *iter != '%')
     {
      if (written++ >= len)
        return -1;
      *str++ = *iter++;
     }
-    if (*iter == (WCHAR)L'%')
+    if (*iter == '%')
     {
       fmta = fmtbufa;
       *fmta++ = *iter++;
-      while (*iter == (WCHAR)L'0' ||
-             *iter == (WCHAR)L'+' ||
-             *iter == (WCHAR)L'-' ||
-             *iter == (WCHAR)L' ' ||
-             *iter == (WCHAR)L'0' ||
-             *iter == (WCHAR)L'*' ||
-             *iter == (WCHAR)L'#')
+      while (*iter == '0' ||
+             *iter == '+' ||
+             *iter == '-' ||
+             *iter == ' ' ||
+             *iter == '0' ||
+             *iter == '*' ||
+             *iter == '#')
       {
-        if (*iter == (WCHAR)L'*')
+        if (*iter == '*')
         {
           char *buffiter = bufa;
           int fieldlen = va_arg(valist, int);
@@ -160,10 +160,10 @@ int _vsnwprintf(WCHAR *str, unsigned int len,
       while (isdigit(*iter))
         *fmta++ = *iter++;
 
-      if (*iter == (WCHAR)L'.')
+      if (*iter == '.')
       {
         *fmta++ = *iter++;
-        if (*iter == (WCHAR)L'*')
+        if (*iter == '*')
         {
           char *buffiter = bufa;
           int fieldlen = va_arg(valist, int);
@@ -175,17 +175,17 @@ int _vsnwprintf(WCHAR *str, unsigned int len,
           while (isdigit(*iter))
             *fmta++ = *iter++;
       }
-      if (*iter == (WCHAR)L'h' ||
-          *iter == (WCHAR)L'l')
+      if (*iter == 'h' ||
+          *iter == 'l')
           *fmta++ = *iter++;
 
       switch (*iter)
       {
-      case (WCHAR)L's':
+      case 's':
         {
-          static const WCHAR none[] = { '(', 'n', 'u', 'l', 'l', ')', 0 };
-          const WCHAR *wstr = va_arg(valist, const WCHAR *);
-          const WCHAR *striter = wstr ? wstr : none;
+          static const MSVCRT_wchar_t none[] = { '(', 'n', 'u', 'l', 'l', ')', 0 };
+          const MSVCRT_wchar_t *wstr = va_arg(valist, const MSVCRT_wchar_t *);
+          const MSVCRT_wchar_t *striter = wstr ? wstr : none;
           while (*striter)
           {
             if (written++ >= len)
@@ -196,10 +196,10 @@ int _vsnwprintf(WCHAR *str, unsigned int len,
           break;
         }
 
-      case (WCHAR)L'c':
+      case 'c':
         if (written++ >= len)
           return -1;
-        *str++ = (WCHAR)va_arg(valist, int);
+        *str++ = (MSVCRT_wchar_t)va_arg(valist, int);
         iter++;
         break;
 
@@ -208,13 +208,13 @@ int _vsnwprintf(WCHAR *str, unsigned int len,
           /* For non wc types, use system sprintf and append to wide char output */
           /* FIXME: for unrecognised types, should ignore % when printing */
           char *bufaiter = bufa;
-          if (*iter == (WCHAR)L'p')
+          if (*iter == 'p')
             sprintf(bufaiter, "%08lX", va_arg(valist, long));
           else
           {
             *fmta++ = *iter;
             *fmta = '\0';
-            if (*iter == (WCHAR)L'f')
+            if (*iter == 'f')
               sprintf(bufaiter, fmtbufa, va_arg(valist, double));
             else
               sprintf(bufaiter, fmtbufa, va_arg(valist, void *));
@@ -233,14 +233,14 @@ int _vsnwprintf(WCHAR *str, unsigned int len,
   }
   if (written >= len)
     return -1;
-  *str++ = (WCHAR)L'\0';
+  *str++ = 0;
   return (int)written;
 }
 
 /*********************************************************************
  *		vswprintf (MSVCRT.@)
  */
-int MSVCRT_vswprintf( WCHAR* str, const WCHAR* format, va_list args )
+int MSVCRT_vswprintf( MSVCRT_wchar_t* str, const MSVCRT_wchar_t* format, va_list args )
 {
   return _vsnwprintf( str, INT_MAX, format, args );
 }
@@ -248,7 +248,7 @@ int MSVCRT_vswprintf( WCHAR* str, const WCHAR* format, va_list args )
 /*********************************************************************
  *		wcscoll (MSVCRT.@)
  */
-int MSVCRT_wcscoll( const WCHAR* str1, const WCHAR* str2 )
+int MSVCRT_wcscoll( const MSVCRT_wchar_t* str1, const MSVCRT_wchar_t* str2 )
 {
   /* FIXME: handle collates */
   return strcmpW( str1, str2 );
@@ -257,12 +257,12 @@ int MSVCRT_wcscoll( const WCHAR* str1, const WCHAR* str2 )
 /*********************************************************************
  *		wcspbrk (MSVCRT.@)
  */
-WCHAR* MSVCRT_wcspbrk( const WCHAR* str, const WCHAR* accept )
+MSVCRT_wchar_t* MSVCRT_wcspbrk( const MSVCRT_wchar_t* str, const MSVCRT_wchar_t* accept )
 {
-  const WCHAR* p;
+  const MSVCRT_wchar_t* p;
   while (*str)
   {
-    for (p = accept; *p; p++) if (*p == *str) return (WCHAR*)str;
+    for (p = accept; *p; p++) if (*p == *str) return (MSVCRT_wchar_t*)str;
       str++;
   }
   return NULL;
@@ -271,7 +271,7 @@ WCHAR* MSVCRT_wcspbrk( const WCHAR* str, const WCHAR* accept )
 /*********************************************************************
  *		wctomb (MSVCRT.@)
  */
-INT MSVCRT_wctomb( char *dst, WCHAR ch )
+INT MSVCRT_wctomb( char *dst, MSVCRT_wchar_t ch )
 {
   return WideCharToMultiByte( CP_ACP, 0, &ch, 1, dst, 6, NULL, NULL );
 }
@@ -279,7 +279,7 @@ INT MSVCRT_wctomb( char *dst, WCHAR ch )
 /*********************************************************************
  *		iswalnum (MSVCRT.@)
  */
-INT MSVCRT_iswalnum( WCHAR wc )
+INT MSVCRT_iswalnum( MSVCRT_wchar_t wc )
 {
     return isalnumW( wc );
 }
@@ -287,7 +287,7 @@ INT MSVCRT_iswalnum( WCHAR wc )
 /*********************************************************************
  *		iswalpha (MSVCRT.@)
  */
-INT MSVCRT_iswalpha( WCHAR wc )
+INT MSVCRT_iswalpha( MSVCRT_wchar_t wc )
 {
     return isalphaW( wc );
 }
@@ -295,7 +295,7 @@ INT MSVCRT_iswalpha( WCHAR wc )
 /*********************************************************************
  *		iswcntrl (MSVCRT.@)
  */
-INT MSVCRT_iswcntrl( WCHAR wc )
+INT MSVCRT_iswcntrl( MSVCRT_wchar_t wc )
 {
     return iscntrlW( wc );
 }
@@ -303,7 +303,7 @@ INT MSVCRT_iswcntrl( WCHAR wc )
 /*********************************************************************
  *		iswdigit (MSVCRT.@)
  */
-INT MSVCRT_iswdigit( WCHAR wc )
+INT MSVCRT_iswdigit( MSVCRT_wchar_t wc )
 {
     return isdigitW( wc );
 }
@@ -311,7 +311,7 @@ INT MSVCRT_iswdigit( WCHAR wc )
 /*********************************************************************
  *		iswgraph (MSVCRT.@)
  */
-INT MSVCRT_iswgraph( WCHAR wc )
+INT MSVCRT_iswgraph( MSVCRT_wchar_t wc )
 {
     return isgraphW( wc );
 }
@@ -319,7 +319,7 @@ INT MSVCRT_iswgraph( WCHAR wc )
 /*********************************************************************
  *		iswlower (MSVCRT.@)
  */
-INT MSVCRT_iswlower( WCHAR wc )
+INT MSVCRT_iswlower( MSVCRT_wchar_t wc )
 {
     return islowerW( wc );
 }
@@ -327,7 +327,7 @@ INT MSVCRT_iswlower( WCHAR wc )
 /*********************************************************************
  *		iswprint (MSVCRT.@)
  */
-INT MSVCRT_iswprint( WCHAR wc )
+INT MSVCRT_iswprint( MSVCRT_wchar_t wc )
 {
     return isprintW( wc );
 }
@@ -335,7 +335,7 @@ INT MSVCRT_iswprint( WCHAR wc )
 /*********************************************************************
  *		iswpunct (MSVCRT.@)
  */
-INT MSVCRT_iswpunct( WCHAR wc )
+INT MSVCRT_iswpunct( MSVCRT_wchar_t wc )
 {
     return ispunctW( wc );
 }
@@ -343,7 +343,7 @@ INT MSVCRT_iswpunct( WCHAR wc )
 /*********************************************************************
  *		iswspace (MSVCRT.@)
  */
-INT MSVCRT_iswspace( WCHAR wc )
+INT MSVCRT_iswspace( MSVCRT_wchar_t wc )
 {
     return isspaceW( wc );
 }
@@ -351,7 +351,7 @@ INT MSVCRT_iswspace( WCHAR wc )
 /*********************************************************************
  *		iswupper (MSVCRT.@)
  */
-INT MSVCRT_iswupper( WCHAR wc )
+INT MSVCRT_iswupper( MSVCRT_wchar_t wc )
 {
     return isupperW( wc );
 }
@@ -359,7 +359,7 @@ INT MSVCRT_iswupper( WCHAR wc )
 /*********************************************************************
  *		iswxdigit (MSVCRT.@)
  */
-INT MSVCRT_iswxdigit( WCHAR wc )
+INT MSVCRT_iswxdigit( MSVCRT_wchar_t wc )
 {
     return isxdigitW( wc );
 }
@@ -367,7 +367,7 @@ INT MSVCRT_iswxdigit( WCHAR wc )
 /*********************************************************************
  *		_itow (MSVCRT.@)
  */
-WCHAR* _itow(int value,WCHAR* out,int base)
+MSVCRT_wchar_t* _itow(int value,MSVCRT_wchar_t* out,int base)
 {
   char buf[64];
   _itoa(value, buf, base);
@@ -378,11 +378,10 @@ WCHAR* _itow(int value,WCHAR* out,int base)
 /*********************************************************************
  *		_ltow (MSVCRT.@)
  */
-WCHAR* _ltow(long value,WCHAR* out,int base)
+MSVCRT_wchar_t* _ltow(long value,MSVCRT_wchar_t* out,int base)
 {
   char buf[128];
   _ltoa(value, buf, base);
   MultiByteToWideChar (CP_ACP, MB_PRECOMPOSED, buf, -1, out, 128);
   return out;
 }
-