msvcrt: Fix mingw compilation issues.

dlls/msvcrt/ctype.c

@@ -69,7 +69,7 @@ const unsigned short* CDECL MSVCRT___pctype_func(void)
 /*********************************************************************
  *		_isctype_l (MSVCRT.@)
  */
-int CDECL _isctype_l(int c, int type, MSVCRT__locale_t locale)
+int CDECL MSVCRT__isctype_l(int c, int type, MSVCRT__locale_t locale)
 {
   MSVCRT_pthreadlocinfo locinfo;
 
@@ -102,9 +102,9 @@ int CDECL _isctype_l(int c, int type, MSVCRT__locale_t locale)
 /*********************************************************************
  *              _isctype (MSVCRT.@)
  */
-int CDECL _isctype(int c, int type)
+int CDECL MSVCRT__isctype(int c, int type)
 {
-    return _isctype_l(c, type, NULL);
+    return MSVCRT__isctype_l(c, type, NULL);
 }
 
 /*********************************************************************
@@ -112,7 +112,7 @@ int CDECL _isctype(int c, int type)
  */
 int CDECL MSVCRT__isalnum_l(int c, MSVCRT__locale_t locale)
 {
-  return _isctype_l( c, MSVCRT__ALPHA | MSVCRT__DIGIT, locale );
+  return MSVCRT__isctype_l( c, MSVCRT__ALPHA | MSVCRT__DIGIT, locale );
 }
 
 /*********************************************************************
@@ -120,7 +120,7 @@ int CDECL MSVCRT__isalnum_l(int c, MSVCRT__locale_t locale)
  */
 int CDECL MSVCRT_isalnum(int c)
 {
-  return _isctype( c, MSVCRT__ALPHA | MSVCRT__DIGIT );
+  return MSVCRT__isctype( c, MSVCRT__ALPHA | MSVCRT__DIGIT );
 }
 
 /*********************************************************************
@@ -128,7 +128,7 @@ int CDECL MSVCRT_isalnum(int c)
  */
 int CDECL MSVCRT__isalpha_l(int c, MSVCRT__locale_t locale)
 {
-  return _isctype_l( c, MSVCRT__ALPHA, locale );
+  return MSVCRT__isctype_l( c, MSVCRT__ALPHA, locale );
 }
 
 /*********************************************************************
@@ -136,7 +136,7 @@ int CDECL MSVCRT__isalpha_l(int c, MSVCRT__locale_t locale)
  */
 int CDECL MSVCRT_isalpha(int c)
 {
-  return _isctype( c, MSVCRT__ALPHA );
+  return MSVCRT__isctype( c, MSVCRT__ALPHA );
 }
 
 /*********************************************************************
@@ -144,7 +144,7 @@ int CDECL MSVCRT_isalpha(int c)
  */
 int CDECL MSVCRT__iscntrl_l(int c, MSVCRT__locale_t locale)
 {
-  return _isctype_l( c, MSVCRT__CONTROL, locale );
+  return MSVCRT__isctype_l( c, MSVCRT__CONTROL, locale );
 }
 
 /*********************************************************************
@@ -152,7 +152,7 @@ int CDECL MSVCRT__iscntrl_l(int c, MSVCRT__locale_t locale)
  */
 int CDECL MSVCRT_iscntrl(int c)
 {
-  return _isctype( c, MSVCRT__CONTROL );
+  return MSVCRT__isctype( c, MSVCRT__CONTROL );
 }
 
 /*********************************************************************
@@ -160,7 +160,7 @@ int CDECL MSVCRT_iscntrl(int c)
  */
 int CDECL MSVCRT__isdigit_l(int c, MSVCRT__locale_t locale)
 {
-  return _isctype_l( c, MSVCRT__DIGIT, locale );
+  return MSVCRT__isctype_l( c, MSVCRT__DIGIT, locale );
 }
 
 /*********************************************************************
@@ -168,7 +168,7 @@ int CDECL MSVCRT__isdigit_l(int c, MSVCRT__locale_t locale)
  */
 int CDECL MSVCRT_isdigit(int c)
 {
-  return _isctype( c, MSVCRT__DIGIT );
+  return MSVCRT__isctype( c, MSVCRT__DIGIT );
 }
 
 /*********************************************************************
@@ -176,7 +176,7 @@ int CDECL MSVCRT_isdigit(int c)
  */
 int CDECL MSVCRT__isgraph_l(int c, MSVCRT__locale_t locale)
 {
-  return _isctype_l( c, MSVCRT__ALPHA | MSVCRT__DIGIT | MSVCRT__PUNCT, locale );
+  return MSVCRT__isctype_l( c, MSVCRT__ALPHA | MSVCRT__DIGIT | MSVCRT__PUNCT, locale );
 }
 
 /*********************************************************************
@@ -184,7 +184,7 @@ int CDECL MSVCRT__isgraph_l(int c, MSVCRT__locale_t locale)
  */
 int CDECL MSVCRT_isgraph(int c)
 {
-  return _isctype( c, MSVCRT__ALPHA | MSVCRT__DIGIT | MSVCRT__PUNCT );
+  return MSVCRT__isctype( c, MSVCRT__ALPHA | MSVCRT__DIGIT | MSVCRT__PUNCT );
 }
 
 /*********************************************************************
@@ -192,7 +192,7 @@ int CDECL MSVCRT_isgraph(int c)
  */
 int CDECL MSVCRT__isleadbyte_l(int c, MSVCRT__locale_t locale)
 {
-  return _isctype_l( c, MSVCRT__LEADBYTE, locale );
+  return MSVCRT__isctype_l( c, MSVCRT__LEADBYTE, locale );
 }
 
 /*********************************************************************
@@ -200,7 +200,7 @@ int CDECL MSVCRT__isleadbyte_l(int c, MSVCRT__locale_t locale)
  */
 int CDECL MSVCRT_isleadbyte(int c)
 {
-  return _isctype( c, MSVCRT__LEADBYTE );
+  return MSVCRT__isctype( c, MSVCRT__LEADBYTE );
 }
 
 /*********************************************************************
@@ -208,7 +208,7 @@ int CDECL MSVCRT_isleadbyte(int c)
  */
 int CDECL MSVCRT__islower_l(int c, MSVCRT__locale_t locale)
 {
-  return _isctype_l( c, MSVCRT__LOWER, locale );
+  return MSVCRT__isctype_l( c, MSVCRT__LOWER, locale );
 }
 
 /*********************************************************************
@@ -216,7 +216,7 @@ int CDECL MSVCRT__islower_l(int c, MSVCRT__locale_t locale)
  */
 int CDECL MSVCRT_islower(int c)
 {
-  return _isctype( c, MSVCRT__LOWER );
+  return MSVCRT__isctype( c, MSVCRT__LOWER );
 }
 
 /*********************************************************************
@@ -224,7 +224,7 @@ int CDECL MSVCRT_islower(int c)
  */
 int CDECL MSVCRT__isprint_l(int c, MSVCRT__locale_t locale)
 {
-  return _isctype_l( c, MSVCRT__ALPHA | MSVCRT__DIGIT | MSVCRT__BLANK | MSVCRT__PUNCT, locale );
+  return MSVCRT__isctype_l( c, MSVCRT__ALPHA | MSVCRT__DIGIT | MSVCRT__BLANK | MSVCRT__PUNCT, locale );
 }
 
 /*********************************************************************
@@ -232,7 +232,7 @@ int CDECL MSVCRT__isprint_l(int c, MSVCRT__locale_t locale)
  */
 int CDECL MSVCRT_isprint(int c)
 {
-  return _isctype( c, MSVCRT__ALPHA | MSVCRT__DIGIT | MSVCRT__BLANK | MSVCRT__PUNCT );
+  return MSVCRT__isctype( c, MSVCRT__ALPHA | MSVCRT__DIGIT | MSVCRT__BLANK | MSVCRT__PUNCT );
 }
 
 /*********************************************************************
@@ -240,7 +240,7 @@ int CDECL MSVCRT_isprint(int c)
  */
 int CDECL MSVCRT_ispunct(int c)
 {
-  return _isctype( c, MSVCRT__PUNCT );
+  return MSVCRT__isctype( c, MSVCRT__PUNCT );
 }
 
 /*********************************************************************
@@ -248,7 +248,7 @@ int CDECL MSVCRT_ispunct(int c)
  */
 int CDECL MSVCRT__isspace_l(int c, MSVCRT__locale_t locale)
 {
-  return _isctype_l( c, MSVCRT__SPACE, locale );
+  return MSVCRT__isctype_l( c, MSVCRT__SPACE, locale );
 }
 
 /*********************************************************************
@@ -256,7 +256,7 @@ int CDECL MSVCRT__isspace_l(int c, MSVCRT__locale_t locale)
  */
 int CDECL MSVCRT_isspace(int c)
 {
-  return _isctype( c, MSVCRT__SPACE );
+  return MSVCRT__isctype( c, MSVCRT__SPACE );
 }
 
 /*********************************************************************
@@ -264,7 +264,7 @@ int CDECL MSVCRT_isspace(int c)
  */
 int CDECL MSVCRT__isupper_l(int c, MSVCRT__locale_t locale)
 {
-  return _isctype_l( c, MSVCRT__UPPER, locale );
+  return MSVCRT__isctype_l( c, MSVCRT__UPPER, locale );
 }
 
 /*********************************************************************
@@ -272,7 +272,7 @@ int CDECL MSVCRT__isupper_l(int c, MSVCRT__locale_t locale)
  */
 int CDECL MSVCRT_isupper(int c)
 {
-  return _isctype( c, MSVCRT__UPPER );
+  return MSVCRT__isctype( c, MSVCRT__UPPER );
 }
 
 /*********************************************************************
@@ -280,7 +280,7 @@ int CDECL MSVCRT_isupper(int c)
  */
 int CDECL MSVCRT__isxdigit_l(int c, MSVCRT__locale_t locale)
 {
-  return _isctype_l( c, MSVCRT__HEX, locale );
+  return MSVCRT__isctype_l( c, MSVCRT__HEX, locale );
 }
 
 /*********************************************************************
@@ -288,7 +288,7 @@ int CDECL MSVCRT__isxdigit_l(int c, MSVCRT__locale_t locale)
  */
 int CDECL MSVCRT_isxdigit(int c)
 {
-  return _isctype( c, MSVCRT__HEX );
+  return MSVCRT__isctype( c, MSVCRT__HEX );
 }
 
 /*********************************************************************

dlls/msvcrt/data.c

@@ -203,7 +203,7 @@ MSVCRT_wchar_t*** CDECL __p___wargv(void) { return &MSVCRT___wargv; }
 /*********************************************************************
  *		__p__environ (MSVCRT.@)
  */
-char*** CDECL __p__environ(void)
+char*** CDECL MSVCRT___p__environ(void)
 {
   return &MSVCRT__environ;
 }
@@ -211,7 +211,7 @@ char*** CDECL __p__environ(void)
 /*********************************************************************
  *		__p__wenviron (MSVCRT.@)
  */
-MSVCRT_wchar_t*** CDECL __p__wenviron(void)
+MSVCRT_wchar_t*** CDECL MSVCRT___p__wenviron(void)
 {
   return &MSVCRT__wenviron;
 }
@@ -276,7 +276,7 @@ void msvcrt_init_args(void)
 {
   OSVERSIONINFOW osvi;
 
-  MSVCRT__acmdln = _strdup( GetCommandLineA() );
+  MSVCRT__acmdln = MSVCRT__strdup( GetCommandLineA() );
   MSVCRT__wcmdln = msvcrt_wstrdupa(MSVCRT__acmdln);
   MSVCRT___argc = __wine_main_argc;
   MSVCRT___argv = __wine_main_argv;

dlls/msvcrt/dir.c

@@ -246,7 +246,7 @@ int CDECL MSVCRT__chdir(const char * newdir)
  *
  * Unicode version of _chdir.
  */
-int CDECL _wchdir(const MSVCRT_wchar_t * newdir)
+int CDECL MSVCRT__wchdir(const MSVCRT_wchar_t * newdir)
 {
   if (!SetCurrentDirectoryW(newdir))
   {
@@ -271,7 +271,7 @@ int CDECL _wchdir(const MSVCRT_wchar_t * newdir)
  * NOTES
  *  See SetCurrentDirectoryA.
  */
-int CDECL _chdrive(int newdrive)
+int CDECL MSVCRT__chdrive(int newdrive)
 {
   WCHAR buffer[3] = {'A', ':', 0};
 
@@ -705,7 +705,7 @@ int CDECL MSVCRT__wfindnext64i32(MSVCRT_intptr_t hand, struct MSVCRT__wfinddata6
  *          Otherwise populates buf with the path and returns it.
  * Failure: NULL. errno indicates the error.
  */
-char* CDECL _getcwd(char * buf, int size)
+char* CDECL MSVCRT__getcwd(char * buf, int size)
 {
   char dir[MAX_PATH];
   int dir_len = GetCurrentDirectoryA(MAX_PATH,dir);
@@ -732,7 +732,7 @@ char* CDECL _getcwd(char * buf, int size)
  *
  * Unicode version of _getcwd.
  */
-MSVCRT_wchar_t* CDECL _wgetcwd(MSVCRT_wchar_t * buf, int size)
+MSVCRT_wchar_t* CDECL MSVCRT__wgetcwd(MSVCRT_wchar_t * buf, int size)
 {
   MSVCRT_wchar_t dir[MAX_PATH];
   int dir_len = GetCurrentDirectoryW(MAX_PATH,dir);
@@ -766,7 +766,7 @@ MSVCRT_wchar_t* CDECL _wgetcwd(MSVCRT_wchar_t * buf, int size)
  *  Success: The drive letter number from 1 to 26 ("A:" to "Z:").
  *  Failure: 0.
  */
-int CDECL _getdrive(void)
+int CDECL MSVCRT__getdrive(void)
 {
     WCHAR buffer[MAX_PATH];
     if (GetCurrentDirectoryW( MAX_PATH, buffer ) &&
@@ -790,14 +790,14 @@ int CDECL _getdrive(void)
  *           Otherwise populates drive with the path and returns it.
  *  Failure: NULL. errno indicates the error.
  */
-char* CDECL _getdcwd(int drive, char * buf, int size)
+char* CDECL MSVCRT__getdcwd(int drive, char * buf, int size)
 {
   static char* dummy;
 
   TRACE(":drive %d(%c), size %d\n",drive, drive + 'A' - 1, size);
 
-  if (!drive || drive == _getdrive())
+  if (!drive || drive == MSVCRT__getdrive())
-    return _getcwd(buf,size); /* current */
+    return MSVCRT__getcwd(buf,size); /* current */
   else
   {
     char dir[MAX_PATH];
@@ -820,7 +820,7 @@ char* CDECL _getdcwd(int drive, char * buf, int size)
 
     TRACE(":returning '%s'\n", dir);
     if (!buf)
-      return _strdup(dir); /* allocate */
+      return MSVCRT__strdup(dir); /* allocate */
 
     strcpy(buf,dir);
   }
@@ -832,14 +832,14 @@ char* CDECL _getdcwd(int drive, char * buf, int size)
  *
  * Unicode version of _wgetdcwd.
  */
-MSVCRT_wchar_t* CDECL _wgetdcwd(int drive, MSVCRT_wchar_t * buf, int size)
+MSVCRT_wchar_t* CDECL MSVCRT__wgetdcwd(int drive, MSVCRT_wchar_t * buf, int size)
 {
   static MSVCRT_wchar_t* dummy;
 
   TRACE(":drive %d(%c), size %d\n",drive, drive + 'A' - 1, size);
 
-  if (!drive || drive == _getdrive())
+  if (!drive || drive == MSVCRT__getdrive())
-    return _wgetcwd(buf,size); /* current */
+    return MSVCRT__wgetcwd(buf,size); /* current */
   else
   {
     MSVCRT_wchar_t dir[MAX_PATH];
@@ -862,7 +862,7 @@ MSVCRT_wchar_t* CDECL _wgetdcwd(int drive, MSVCRT_wchar_t * buf, int size)
 
     TRACE(":returning %s\n", debugstr_w(dir));
     if (!buf)
-      return _wcsdup(dir); /* allocate */
+      return MSVCRT__wcsdup(dir); /* allocate */
     strcpyW(buf,dir);
   }
   return buf;
@@ -936,7 +936,7 @@ int CDECL MSVCRT__mkdir(const char * newdir)
  *
  * Unicode version of _mkdir.
  */
-int CDECL _wmkdir(const MSVCRT_wchar_t* newdir)
+int CDECL MSVCRT__wmkdir(const MSVCRT_wchar_t* newdir)
 {
   if (CreateDirectoryW(newdir,NULL))
     return 0;
@@ -972,7 +972,7 @@ int CDECL MSVCRT__rmdir(const char * dir)
  *
  * Unicode version of _rmdir.
  */
-int CDECL _wrmdir(const MSVCRT_wchar_t * dir)
+int CDECL MSVCRT__wrmdir(const MSVCRT_wchar_t * dir)
 {
   if (RemoveDirectoryW(dir))
     return 0;
@@ -1177,7 +1177,7 @@ MSVCRT_wchar_t * CDECL _wfullpath(MSVCRT_wchar_t * absPath, const MSVCRT_wchar_t
   BOOL alloced = FALSE;
 
   if (!relPath || !*relPath)
-    return _wgetcwd(absPath, size);
+    return MSVCRT__wgetcwd(absPath, size);
 
   if (absPath == NULL)
   {
@@ -1231,7 +1231,7 @@ char * CDECL _fullpath(char * absPath, const char* relPath, unsigned int size)
   BOOL alloced = FALSE;
 
   if (!relPath || !*relPath)
-    return _getcwd(absPath, size);
+    return MSVCRT__getcwd(absPath, size);
 
   if (absPath == NULL)
   {
@@ -1589,7 +1589,7 @@ range:
  *  Nothing. If the file is not found, buf will contain an empty string
  *  and errno is set.
  */
-void CDECL _searchenv(const char* file, const char* env, char *buf)
+void CDECL MSVCRT__searchenv(const char* file, const char* env, char *buf)
 {
   char*envVal, *penv;
   char curPath[MAX_PATH];
@@ -1724,7 +1724,7 @@ int CDECL _searchenv_s(const char* file, const char* env, char *buf, MSVCRT_size
  *
  * Unicode version of _searchenv
  */
-void CDECL _wsearchenv(const MSVCRT_wchar_t* file, const MSVCRT_wchar_t* env, MSVCRT_wchar_t *buf)
+void CDECL MSVCRT__wsearchenv(const MSVCRT_wchar_t* file, const MSVCRT_wchar_t* env, MSVCRT_wchar_t *buf)
 {
   MSVCRT_wchar_t *envVal, *penv;
   MSVCRT_wchar_t curPath[MAX_PATH];
@@ -1741,7 +1741,7 @@ void CDECL _wsearchenv(const MSVCRT_wchar_t* file, const MSVCRT_wchar_t* env, MS
   }
 
   /* Search given environment variable */
-  envVal = _wgetenv(env);
+  envVal = MSVCRT__wgetenv(env);
   if (!envVal)
   {
     msvcrt_set_errno(ERROR_FILE_NOT_FOUND);
@@ -1808,7 +1808,7 @@ int CDECL _wsearchenv_s(const MSVCRT_wchar_t* file, const MSVCRT_wchar_t* env,
   }
 
   /* Search given environment variable */
-  envVal = _wgetenv(env);
+  envVal = MSVCRT__wgetenv(env);
   if (!envVal)
   {
     *MSVCRT__errno() = MSVCRT_ENOENT;

dlls/msvcrt/environ.c

@@ -50,7 +50,7 @@ char * CDECL MSVCRT_getenv(const char *name)
 /*********************************************************************
  *		_wgetenv (MSVCRT.@)
  */
-MSVCRT_wchar_t * CDECL _wgetenv(const MSVCRT_wchar_t *name)
+MSVCRT_wchar_t * CDECL MSVCRT__wgetenv(const MSVCRT_wchar_t *name)
 {
     MSVCRT_wchar_t **environ;
     unsigned int length=strlenW(name);
@@ -247,7 +247,7 @@ int CDECL _wdupenv_s(MSVCRT_wchar_t **buffer, MSVCRT_size_t *numberOfElements,
     MSVCRT_size_t       sz;
 
     if (!MSVCRT_CHECK_PMT(buffer != NULL) || !MSVCRT_CHECK_PMT(varname) ||
-        !(e = _wgetenv(varname)))
+        !(e = MSVCRT__wgetenv(varname)))
     {
         return *MSVCRT__errno() = MSVCRT_EINVAL;
     }
@@ -303,7 +303,7 @@ int CDECL _wgetenv_s(MSVCRT_size_t *pReturnValue, MSVCRT_wchar_t *buffer, MSVCRT
     {
         return *MSVCRT__errno() = MSVCRT_EINVAL;
     }
-    if (!(e = _wgetenv(varname)))
+    if (!(e = MSVCRT__wgetenv(varname)))
     {
         *pReturnValue = 0;
         return *MSVCRT__errno() = MSVCRT_EINVAL;

dlls/msvcrt/errno.c

@@ -291,7 +291,7 @@ int CDECL strerror_s(char *buffer, MSVCRT_size_t numberOfElements, int errnum)
 /**********************************************************************
  *		_strerror	(MSVCRT.@)
  */
-char* CDECL _strerror(const char* str)
+char* CDECL MSVCRT__strerror(const char* str)
 {
     thread_data_t *data = msvcrt_get_thread_data();
     int err;
@@ -345,7 +345,7 @@ int CDECL _wcserror_s(MSVCRT_wchar_t* buffer, MSVCRT_size_t nc, int err)
 /*********************************************************************
  *		_wcserror (MSVCRT.@)
  */
-MSVCRT_wchar_t* CDECL _wcserror(int err)
+MSVCRT_wchar_t* CDECL MSVCRT__wcserror(int err)
 {
     thread_data_t *data = msvcrt_get_thread_data();
 
@@ -392,7 +392,7 @@ int CDECL __wcserror_s(MSVCRT_wchar_t* buffer, MSVCRT_size_t nc, const MSVCRT_wc
 /**********************************************************************
  *		__wcserror	(MSVCRT.@)
  */
-MSVCRT_wchar_t* CDECL __wcserror(const MSVCRT_wchar_t* str)
+MSVCRT_wchar_t* CDECL MSVCRT___wcserror(const MSVCRT_wchar_t* str)
 {
     thread_data_t *data = msvcrt_get_thread_data();
     int err;

dlls/msvcrt/file.c

@@ -640,7 +640,7 @@ int CDECL _access_s(const char *filename, int mode)
 /*********************************************************************
  *		_waccess (MSVCRT.@)
  */
-int CDECL _waccess(const MSVCRT_wchar_t *filename, int mode)
+int CDECL MSVCRT__waccess(const MSVCRT_wchar_t *filename, int mode)
 {
   DWORD attr = GetFileAttributesW(filename);
 
@@ -671,7 +671,7 @@ int CDECL _waccess_s(const MSVCRT_wchar_t *filename, int mode)
      return -1;
   }
 
-  return _waccess(filename, mode);
+  return MSVCRT__waccess(filename, mode);
 }
 
 /*********************************************************************
@@ -696,7 +696,7 @@ int CDECL MSVCRT__chmod(const char *path, int flags)
 /*********************************************************************
  *		_wchmod (MSVCRT.@)
  */
-int CDECL _wchmod(const MSVCRT_wchar_t *path, int flags)
+int CDECL MSVCRT__wchmod(const MSVCRT_wchar_t *path, int flags)
 {
   DWORD oldFlags = GetFileAttributesW(path);
 
@@ -728,7 +728,7 @@ int CDECL MSVCRT__unlink(const char *path)
 /*********************************************************************
  *		_wunlink (MSVCRT.@)
  */
-int CDECL _wunlink(const MSVCRT_wchar_t *path)
+int CDECL MSVCRT__wunlink(const MSVCRT_wchar_t *path)
 {
   TRACE("(%s)\n",debugstr_w(path));
   if(DeleteFileW(path))
@@ -744,7 +744,7 @@ int CDECL MSVCRT_fflush(MSVCRT_FILE* file);
 /*********************************************************************
  *		_flushall (MSVCRT.@)
  */
-int CDECL _flushall(void)
+int CDECL MSVCRT__flushall(void)
 {
   int i, num_flushed = 0;
   MSVCRT_FILE *file;
@@ -773,7 +773,7 @@ int CDECL _flushall(void)
 int CDECL MSVCRT_fflush(MSVCRT_FILE* file)
 {
     if(!file) {
-        _flushall();
+        MSVCRT__flushall();
     } else if(file->_flag & MSVCRT__IOWRT) {
         int res;
 
@@ -818,7 +818,7 @@ int CDECL MSVCRT__close(int fd)
 /*********************************************************************
  *		_commit (MSVCRT.@)
  */
-int CDECL _commit(int fd)
+int CDECL MSVCRT__commit(int fd)
 {
   HANDLE hand = msvcrt_fdtoh(fd);
 
@@ -914,7 +914,7 @@ int CDECL MSVCRT__dup(int od)
 /*********************************************************************
  *		_eof (MSVCRT.@)
  */
-int CDECL _eof(int fd)
+int CDECL MSVCRT__eof(int fd)
 {
   DWORD curpos,endpos;
   LONG hcurpos,hendpos;
@@ -1501,7 +1501,7 @@ int CDECL _futime(int fd, struct MSVCRT___utimbuf32 *t)
 /*********************************************************************
  *		_get_osfhandle (MSVCRT.@)
  */
-MSVCRT_intptr_t CDECL _get_osfhandle(int fd)
+MSVCRT_intptr_t CDECL MSVCRT__get_osfhandle(int fd)
 {
   HANDLE hand = msvcrt_fdtoh(fd);
   TRACE(":fd (%d) handle (%p)\n",fd,hand);
@@ -1512,7 +1512,7 @@ MSVCRT_intptr_t CDECL _get_osfhandle(int fd)
 /*********************************************************************
  *		_isatty (MSVCRT.@)
  */
-int CDECL _isatty(int fd)
+int CDECL MSVCRT__isatty(int fd)
 {
   HANDLE hand = msvcrt_fdtoh(fd);
 
@@ -1526,7 +1526,7 @@ int CDECL _isatty(int fd)
 /*********************************************************************
  *		_mktemp (MSVCRT.@)
  */
-char * CDECL _mktemp(char *pattern)
+char * CDECL MSVCRT__mktemp(char *pattern)
 {
   int numX = 0;
   char *retVal = pattern;
@@ -1560,7 +1560,7 @@ char * CDECL _mktemp(char *pattern)
 /*********************************************************************
  *		_wmktemp (MSVCRT.@)
  */
-MSVCRT_wchar_t * CDECL _wmktemp(MSVCRT_wchar_t *pattern)
+MSVCRT_wchar_t * CDECL MSVCRT__wmktemp(MSVCRT_wchar_t *pattern)
 {
   int numX = 0;
   MSVCRT_wchar_t *retVal = pattern;
@@ -1932,7 +1932,7 @@ int CDECL MSVCRT__open( const char *path, int flags, ... )
 /*********************************************************************
  *              _wopen (MSVCRT.@)
  */
-int CDECL _wopen(const MSVCRT_wchar_t *path,int flags,...)
+int CDECL MSVCRT__wopen(const MSVCRT_wchar_t *path,int flags,...)
 {
   __ms_va_list ap;
 
@@ -1960,16 +1960,16 @@ int CDECL MSVCRT__creat(const char *path, int flags)
 /*********************************************************************
  *		_wcreat (MSVCRT.@)
  */
-int CDECL _wcreat(const MSVCRT_wchar_t *path, int flags)
+int CDECL MSVCRT__wcreat(const MSVCRT_wchar_t *path, int flags)
 {
   int usedFlags = (flags & MSVCRT__O_TEXT)| MSVCRT__O_CREAT| MSVCRT__O_WRONLY| MSVCRT__O_TRUNC;
-  return _wopen(path, usedFlags);
+  return MSVCRT__wopen(path, usedFlags);
 }
 
 /*********************************************************************
  *		_open_osfhandle (MSVCRT.@)
  */
-int CDECL _open_osfhandle(MSVCRT_intptr_t handle, int oflags)
+int CDECL MSVCRT__open_osfhandle(MSVCRT_intptr_t handle, int oflags)
 {
   int fd;
 
@@ -1990,7 +1990,7 @@ int CDECL _open_osfhandle(MSVCRT_intptr_t handle, int oflags)
 /*********************************************************************
  *		_rmtmp (MSVCRT.@)
  */
-int CDECL _rmtmp(void)
+int CDECL MSVCRT__rmtmp(void)
 {
   int num_removed = 0, i;
   MSVCRT_FILE *file;
@@ -2121,7 +2121,7 @@ int CDECL MSVCRT__read(int fd, void *buf, unsigned int count)
 /*********************************************************************
  *		_setmode (MSVCRT.@)
  */
-int CDECL _setmode(int fd,int mode)
+int CDECL MSVCRT__setmode(int fd,int mode)
 {
   int ret = msvcrt_get_ioinfo(fd)->wxflag & WX_TEXT ? MSVCRT__O_TEXT : MSVCRT__O_BINARY;
   if (mode & (~(MSVCRT__O_TEXT|MSVCRT__O_BINARY)))
@@ -2162,7 +2162,7 @@ int CDECL MSVCRT_stat64(const char* path, struct MSVCRT__stat64 * buf)
   if (isalpha(*path)&& (*(path+1)==':'))
     buf->st_dev = buf->st_rdev = toupper(*path) - 'A'; /* drive num */
   else
-    buf->st_dev = buf->st_rdev = _getdrive() - 1;
+    buf->st_dev = buf->st_rdev = MSVCRT__getdrive() - 1;
 
   plen = strlen(path);
 
@@ -2251,7 +2251,7 @@ int CDECL MSVCRT__wstat64(const MSVCRT_wchar_t* path, struct MSVCRT__stat64 * bu
   if (MSVCRT_iswalpha(*path))
     buf->st_dev = buf->st_rdev = toupperW(*path - 'A'); /* drive num */
   else
-    buf->st_dev = buf->st_rdev = _getdrive() - 1;
+    buf->st_dev = buf->st_rdev = MSVCRT__getdrive() - 1;
 
   plen = strlenW(path);
 
@@ -2334,7 +2334,7 @@ __int64 CDECL _telli64(int fd)
 /*********************************************************************
  *		_tempnam (MSVCRT.@)
  */
-char * CDECL _tempnam(const char *dir, const char *prefix)
+char * CDECL MSVCRT__tempnam(const char *dir, const char *prefix)
 {
   char tmpbuf[MAX_PATH];
   const char *tmp_dir = MSVCRT_getenv("TMP");
@@ -2346,7 +2346,7 @@ char * CDECL _tempnam(const char *dir, const char *prefix)
   {
     TRACE("got name (%s)\n",tmpbuf);
     DeleteFileA(tmpbuf);
-    return _strdup(tmpbuf);
+    return MSVCRT__strdup(tmpbuf);
   }
   TRACE("failed (%d)\n",GetLastError());
   return NULL;
@@ -2355,7 +2355,7 @@ char * CDECL _tempnam(const char *dir, const char *prefix)
 /*********************************************************************
  *		_wtempnam (MSVCRT.@)
  */
-MSVCRT_wchar_t * CDECL _wtempnam(const MSVCRT_wchar_t *dir, const MSVCRT_wchar_t *prefix)
+MSVCRT_wchar_t * CDECL MSVCRT__wtempnam(const MSVCRT_wchar_t *dir, const MSVCRT_wchar_t *prefix)
 {
   MSVCRT_wchar_t tmpbuf[MAX_PATH];
 
@@ -2364,7 +2364,7 @@ MSVCRT_wchar_t * CDECL _wtempnam(const MSVCRT_wchar_t *dir, const MSVCRT_wchar_t
   {
     TRACE("got name (%s)\n",debugstr_w(tmpbuf));
     DeleteFileW(tmpbuf);
-    return _wcsdup(tmpbuf);
+    return MSVCRT__wcsdup(tmpbuf);
   }
   TRACE("failed (%d)\n",GetLastError());
   return NULL;
@@ -2428,7 +2428,7 @@ int CDECL _utime(const char* path, struct MSVCRT___utimbuf32 *t)
  */
 int CDECL _wutime64(const MSVCRT_wchar_t* path, struct MSVCRT___utimbuf64 *t)
 {
-  int fd = _wopen(path, MSVCRT__O_WRONLY | MSVCRT__O_BINARY);
+  int fd = MSVCRT__wopen(path, MSVCRT__O_WRONLY | MSVCRT__O_BINARY);
 
   if (fd > 0)
   {
@@ -2707,7 +2707,7 @@ int CDECL MSVCRT_fgetc(MSVCRT_FILE* file)
 /*********************************************************************
  *		_fgetchar (MSVCRT.@)
  */
-int CDECL _fgetchar(void)
+int CDECL MSVCRT__fgetchar(void)
 {
   return MSVCRT_fgetc(MSVCRT_stdin);
 }
@@ -2838,7 +2838,7 @@ MSVCRT_wint_t CDECL MSVCRT_getwc(MSVCRT_FILE* file)
 /*********************************************************************
  *		_fgetwchar (MSVCRT.@)
  */
-MSVCRT_wint_t CDECL _fgetwchar(void)
+MSVCRT_wint_t CDECL MSVCRT__fgetwchar(void)
 {
   return MSVCRT_fgetwc(MSVCRT_stdin);
 }
@@ -2848,7 +2848,7 @@ MSVCRT_wint_t CDECL _fgetwchar(void)
  */
 MSVCRT_wint_t CDECL MSVCRT_getwchar(void)
 {
-  return _fgetwchar();
+  return MSVCRT__fgetwchar();
 }
 
 /*********************************************************************
@@ -2942,7 +2942,7 @@ MSVCRT_wint_t CDECL MSVCRT_fputwc(MSVCRT_wint_t wc, MSVCRT_FILE* file)
 /*********************************************************************
  *		_fputwchar (MSVCRT.@)
  */
-MSVCRT_wint_t CDECL _fputwchar(MSVCRT_wint_t wc)
+MSVCRT_wint_t CDECL MSVCRT__fputwchar(MSVCRT_wint_t wc)
 {
   return MSVCRT_fputwc(wc, MSVCRT_stdout);
 }
@@ -3138,7 +3138,7 @@ int CDECL MSVCRT__flsbuf(int c, MSVCRT_FILE* file)
 /*********************************************************************
  *		_fputchar (MSVCRT.@)
  */
-int CDECL _fputchar(int c)
+int CDECL MSVCRT__fputchar(int c)
 {
   return MSVCRT_fputc(c, MSVCRT_stdout);
 }
@@ -3242,7 +3242,7 @@ MSVCRT_FILE* CDECL MSVCRT__wfreopen(const MSVCRT_wchar_t *path, const MSVCRT_wch
       file = NULL;
     else
     {
-      fd = _wopen(path, open_flags, MSVCRT__S_IREAD | MSVCRT__S_IWRITE);
+      fd = MSVCRT__wopen(path, open_flags, MSVCRT__S_IREAD | MSVCRT__S_IWRITE);
       if (fd < 0)
         file = NULL;
       else if (msvcrt_init_fp(file, fd, stream_flags) == -1)
@@ -3543,7 +3543,7 @@ int CDECL MSVCRT_puts(const char *s)
 /*********************************************************************
  *		_putws (MSVCRT.@)
  */
-int CDECL _putws(const MSVCRT_wchar_t *s)
+int CDECL MSVCRT__putws(const MSVCRT_wchar_t *s)
 {
     static const MSVCRT_wchar_t nl = '\n';
     MSVCRT_size_t len = strlenW(s);
@@ -3576,7 +3576,7 @@ int CDECL MSVCRT_remove(const char *path)
 /*********************************************************************
  *		_wremove (MSVCRT.@)
  */
-int CDECL _wremove(const MSVCRT_wchar_t *path)
+int CDECL MSVCRT__wremove(const MSVCRT_wchar_t *path)
 {
   TRACE("(%s)\n",debugstr_w(path));
   if (DeleteFileW(path))
@@ -3602,7 +3602,7 @@ int CDECL MSVCRT_rename(const char *oldpath,const char *newpath)
 /*********************************************************************
  *		_wrename (MSVCRT.@)
  */
-int CDECL _wrename(const MSVCRT_wchar_t *oldpath,const MSVCRT_wchar_t *newpath)
+int CDECL MSVCRT__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))
@@ -3724,7 +3724,7 @@ MSVCRT_FILE* CDECL MSVCRT_tmpfile(void)
         file->_flag = 0;
         file = NULL;
     }
-    else file->_tmpfname = _strdup(filename);
+    else file->_tmpfname = MSVCRT__strdup(filename);
   }
   UNLOCK_FILES();
   return file;
@@ -3992,7 +3992,7 @@ int CDECL MSVCRT_wprintf_s(const MSVCRT_wchar_t *format, ...)
 /*********************************************************************
  *		_getmaxstdio (MSVCRT.@)
  */
-int CDECL _getmaxstdio(void)
+int CDECL MSVCRT__getmaxstdio(void)
 {
     return MSVCRT_max_streams;
 }
@@ -4000,7 +4000,7 @@ int CDECL _getmaxstdio(void)
 /*********************************************************************
  *		_setmaxstdio (MSVCRT.@)
  */
-int CDECL _setmaxstdio(int newmax)
+int CDECL MSVCRT__setmaxstdio(int newmax)
 {
     TRACE("%d\n", newmax);
 

dlls/msvcrt/locale.c

@@ -769,7 +769,7 @@ MSVCRT__locale_t MSVCRT__create_locale(int category, const char *locale)
             return NULL;
         }
     } else
-        loc->locinfo->lc_category[MSVCRT_LC_COLLATE].locale = _strdup("C");
+        loc->locinfo->lc_category[MSVCRT_LC_COLLATE].locale = MSVCRT__strdup("C");
 
     if(lcid[MSVCRT_LC_CTYPE] && (category==MSVCRT_LC_ALL || category==MSVCRT_LC_CTYPE)) {
         CPINFO cp;
@@ -815,7 +815,7 @@ MSVCRT__locale_t MSVCRT__create_locale(int category, const char *locale)
         loc->locinfo->lc_clike = 1;
         loc->locinfo->mb_cur_max = 1;
         loc->locinfo->pctype = MSVCRT__ctype+1;
-        loc->locinfo->lc_category[MSVCRT_LC_CTYPE].locale = _strdup("C");
+        loc->locinfo->lc_category[MSVCRT_LC_CTYPE].locale = MSVCRT__strdup("C");
     }
 
     for(i=0; i<256; i++) {
@@ -1025,7 +1025,7 @@ MSVCRT__locale_t MSVCRT__create_locale(int category, const char *locale)
         loc->locinfo->lconv->p_sign_posn = 127;
         loc->locinfo->lconv->n_sign_posn = 127;
 
-        loc->locinfo->lc_category[MSVCRT_LC_MONETARY].locale = _strdup("C");
+        loc->locinfo->lc_category[MSVCRT_LC_MONETARY].locale = MSVCRT__strdup("C");
     }
 
     if(lcid[MSVCRT_LC_NUMERIC] && (category==MSVCRT_LC_ALL || category==MSVCRT_LC_NUMERIC)) {
@@ -1092,7 +1092,7 @@ MSVCRT__locale_t MSVCRT__create_locale(int category, const char *locale)
         loc->locinfo->lconv->thousands_sep[0] = '\0';
         loc->locinfo->lconv->grouping[0] = '\0';
 
-        loc->locinfo->lc_category[MSVCRT_LC_NUMERIC].locale = _strdup("C");
+        loc->locinfo->lc_category[MSVCRT_LC_NUMERIC].locale = MSVCRT__strdup("C");
     }
 
     if(lcid[MSVCRT_LC_TIME] && (category==MSVCRT_LC_ALL || category==MSVCRT_LC_TIME)) {
@@ -1101,7 +1101,7 @@ MSVCRT__locale_t MSVCRT__create_locale(int category, const char *locale)
             return NULL;
         }
     } else
-        loc->locinfo->lc_category[MSVCRT_LC_TIME].locale = _strdup("C");
+        loc->locinfo->lc_category[MSVCRT_LC_TIME].locale = MSVCRT__strdup("C");
 
     return loc;
 }

dlls/msvcrt/math.c

@@ -577,7 +577,7 @@ double CDECL _CItanh(void)
 /*********************************************************************
  *		_fpclass (MSVCRT.@)
  */
-int CDECL _fpclass(double num)
+int CDECL MSVCRT__fpclass(double num)
 {
 #if defined(HAVE_FPCLASS) || defined(fpclass)
   switch (fpclass( num ))
@@ -711,7 +711,7 @@ __int64 CDECL _abs64( __int64 n )
 /*********************************************************************
  *		_logb (MSVCRT.@)
  */
-double CDECL _logb(double num)
+double CDECL MSVCRT__logb(double num)
 {
   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
   return logb(num);
@@ -738,7 +738,7 @@ double CDECL _hypot(double x, double y)
 /*********************************************************************
  *      _hypotf (MSVCRT.@)
  */
-float CDECL _hypotf(float x, float y)
+float CDECL MSVCRT__hypotf(float x, float y)
 {
   /* FIXME: errno handling */
   return hypotf( x, y );
@@ -940,7 +940,7 @@ double CDECL MSVCRT__cabs(struct MSVCRT__complex num)
 /*********************************************************************
  *		_chgsign (MSVCRT.@)
  */
-double CDECL _chgsign(double num)
+double CDECL MSVCRT__chgsign(double num)
 {
   /* FIXME: +-infinity,Nan not tested */
   return -num;
@@ -1140,7 +1140,7 @@ int CDECL _controlfp_s(unsigned int *cur, unsigned int newval, unsigned int mask
 /*********************************************************************
  *		_copysign (MSVCRT.@)
  */
-double CDECL _copysign(double num, double sign)
+double CDECL MSVCRT__copysign(double num, double sign)
 {
   /* FIXME: Behaviour for Nan/Inf? */
   if (sign < 0.0)
@@ -1151,7 +1151,7 @@ double CDECL _copysign(double num, double sign)
 /*********************************************************************
  *		_finite (MSVCRT.@)
  */
-int CDECL _finite(double num)
+int CDECL MSVCRT__finite(double num)
 {
   return (finite(num)?1:0); /* See comment for _isnan() */
 }
@@ -1177,7 +1177,7 @@ void CDECL _fpreset(void)
 /*********************************************************************
  *		_isnan (MSVCRT.@)
  */
-INT CDECL _isnan(double num)
+INT CDECL MSVCRT__isnan(double num)
 {
   /* Some implementations return -1 for true(glibc), msvcrt/crtdll return 1.
    * Do the same, as the result may be used in calculations
@@ -1188,7 +1188,7 @@ INT CDECL _isnan(double num)
 /*********************************************************************
  *		_j0 (MSVCRT.@)
  */
-double CDECL _j0(double num)
+double CDECL MSVCRT__j0(double num)
 {
   /* FIXME: errno handling */
   return j0(num);
@@ -1197,16 +1197,16 @@ double CDECL _j0(double num)
 /*********************************************************************
  *		_j1 (MSVCRT.@)
  */
-double CDECL _j1(double num)
+double CDECL MSVCRT__j1(double num)
 {
   /* FIXME: errno handling */
   return j1(num);
 }
 
 /*********************************************************************
- *		jn (MSVCRT.@)
+ *		_jn (MSVCRT.@)
  */
-double CDECL _jn(int n, double num)
+double CDECL MSVCRT__jn(int n, double num)
 {
   /* FIXME: errno handling */
   return jn(n, num);
@@ -1215,12 +1215,12 @@ double CDECL _jn(int n, double num)
 /*********************************************************************
  *		_y0 (MSVCRT.@)
  */
-double CDECL _y0(double num)
+double CDECL MSVCRT__y0(double num)
 {
   double retval;
   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
   retval  = y0(num);
-  if (_fpclass(retval) == MSVCRT__FPCLASS_NINF)
+  if (MSVCRT__fpclass(retval) == MSVCRT__FPCLASS_NINF)
   {
     *MSVCRT__errno() = MSVCRT_EDOM;
     retval = sqrt(-1);
@@ -1231,12 +1231,12 @@ double CDECL _y0(double num)
 /*********************************************************************
  *		_y1 (MSVCRT.@)
  */
-double CDECL _y1(double num)
+double CDECL MSVCRT__y1(double num)
 {
   double retval;
   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
   retval  = y1(num);
-  if (_fpclass(retval) == MSVCRT__FPCLASS_NINF)
+  if (MSVCRT__fpclass(retval) == MSVCRT__FPCLASS_NINF)
   {
     *MSVCRT__errno() = MSVCRT_EDOM;
     retval = sqrt(-1);
@@ -1247,12 +1247,12 @@ double CDECL _y1(double num)
 /*********************************************************************
  *		_yn (MSVCRT.@)
  */
-double CDECL _yn(int order, double num)
+double CDECL MSVCRT__yn(int order, double num)
 {
   double retval;
   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
   retval  = yn(order,num);
-  if (_fpclass(retval) == MSVCRT__FPCLASS_NINF)
+  if (MSVCRT__fpclass(retval) == MSVCRT__FPCLASS_NINF)
   {
     *MSVCRT__errno() = MSVCRT_EDOM;
     retval = sqrt(-1);
@@ -1263,7 +1263,7 @@ double CDECL _yn(int order, double num)
 /*********************************************************************
  *		_nextafter (MSVCRT.@)
  */
-double CDECL _nextafter(double num, double next)
+double CDECL MSVCRT__nextafter(double num, double next)
 {
   double retval;
   if (!finite(num) || !finite(next)) *MSVCRT__errno() = MSVCRT_EDOM;

dlls/msvcrt/misc.c

@@ -33,7 +33,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
 /*********************************************************************
  *		_beep (MSVCRT.@)
  */
-void CDECL _beep( unsigned int freq, unsigned int duration)
+void CDECL MSVCRT__beep( unsigned int freq, unsigned int duration)
 {
     TRACE(":Freq %d, Duration %d\n",freq,duration);
     Beep(freq, duration);
@@ -265,7 +265,7 @@ unsigned int CDECL _get_output_format(void)
 /*********************************************************************
  * _resetstkoflw (MSVCRT.@)
  */
-int CDECL _resetstkoflw(void)
+int CDECL MSVCRT__resetstkoflw(void)
 {
     int stack_addr;
 

dlls/msvcrt/msvcrt.h

@@ -895,31 +895,31 @@ int            __cdecl _ismbstrail(const unsigned char* start, const unsigned ch
 MSVCRT_size_t  __cdecl MSVCRT_mbstowcs(MSVCRT_wchar_t*,const char*,MSVCRT_size_t);
 MSVCRT_intptr_t __cdecl MSVCRT__spawnve(int,const char*,const char* const *,const char* const *);
 MSVCRT_intptr_t __cdecl MSVRT__spawnvpe(int,const char*,const char* const *,const char* const *);
-MSVCRT_intptr_t __cdecl _wspawnve(int,const MSVCRT_wchar_t*,const MSVCRT_wchar_t* const *,const MSVCRT_wchar_t* const *);
+MSVCRT_intptr_t __cdecl MSVCRT__wspawnve(int,const MSVCRT_wchar_t*,const MSVCRT_wchar_t* const *,const MSVCRT_wchar_t* const *);
-MSVCRT_intptr_t __cdecl _wspawnvpe(int,const MSVCRT_wchar_t*,const MSVCRT_wchar_t* const *,const MSVCRT_wchar_t* const *);
+MSVCRT_intptr_t __cdecl MSVCRT__wspawnvpe(int,const MSVCRT_wchar_t*,const MSVCRT_wchar_t* const *,const MSVCRT_wchar_t* const *);
-void __cdecl     _searchenv(const char*,const char*,char*);
+void __cdecl     MSVCRT__searchenv(const char*,const char*,char*);
-int __cdecl      _getdrive(void);
+int __cdecl      MSVCRT__getdrive(void);
-char* __cdecl    _strdup(const char*);
+char* __cdecl    MSVCRT__strdup(const char*);
 char* __cdecl    MSVCRT__strnset(char*,int,MSVCRT_size_t);
 char* __cdecl    _strset(char*,int);
 int __cdecl      _ungetch(int);
 int __cdecl      _cputs(const char*);
 int __cdecl      _cprintf(const char*,...);
 int __cdecl      _cwprintf(const MSVCRT_wchar_t*,...);
-char*** __cdecl  __p__environ(void);
+char*** __cdecl  MSVCRT___p__environ(void);
 int*    __cdecl  __p___mb_cur_max(void);
 unsigned int*  __cdecl __p__fmode(void);
-MSVCRT_wchar_t* __cdecl _wcsdup(const MSVCRT_wchar_t*);
+MSVCRT_wchar_t* __cdecl MSVCRT__wcsdup(const MSVCRT_wchar_t*);
-MSVCRT_wchar_t*** __cdecl __p__wenviron(void);
+MSVCRT_wchar_t*** __cdecl MSVCRT___p__wenviron(void);
-char*   __cdecl _strdate(char* date);
+char*   __cdecl MSVCRT__strdate(char* date);
-char*   __cdecl _strtime(char* date);
+char*   __cdecl MSVCRT__strtime(char* date);
 int     __cdecl _setmbcp(int);
 int     __cdecl MSVCRT__close(int);
 int     __cdecl MSVCRT__dup(int);
 int     __cdecl MSVCRT__dup2(int, int);
 int     __cdecl MSVCRT__pipe(int *, unsigned int, int);
-MSVCRT_wchar_t* __cdecl _wgetenv(const MSVCRT_wchar_t*);
+MSVCRT_wchar_t* __cdecl MSVCRT__wgetenv(const MSVCRT_wchar_t*);
-void __cdecl    _wsearchenv(const MSVCRT_wchar_t*, const MSVCRT_wchar_t*, MSVCRT_wchar_t*);
+void __cdecl    MSVCRT__wsearchenv(const MSVCRT_wchar_t*, const MSVCRT_wchar_t*, MSVCRT_wchar_t*);
 MSVCRT_intptr_t __cdecl MSVCRT__spawnvpe(int, const char*, const char* const*, const char* const*);
 void __cdecl MSVCRT__invalid_parameter(const MSVCRT_wchar_t *expr, const MSVCRT_wchar_t *func,
                                        const MSVCRT_wchar_t *file, unsigned int line, MSVCRT_uintptr_t arg);

dlls/msvcrt/msvcrt.spec

@@ -229,7 +229,7 @@
 @ cdecl __p__commode()
 @ cdecl __p__daylight() MSVCRT___p__daylight
 @ cdecl __p__dstbias()
-@ cdecl __p__environ()
+@ cdecl __p__environ() MSVCRT___p__environ
 @ stub __p__fileinfo()
 @ cdecl __p__fmode()
 @ cdecl __p__iob() MSVCRT___iob_func
@@ -242,7 +242,7 @@
 @ cdecl __p__timezone() MSVCRT___p__timezone
 @ cdecl __p__tzname()
 @ cdecl __p__wcmdln()
-@ cdecl __p__wenviron()
+@ cdecl __p__wenviron() MSVCRT___p__wenviron
 @ cdecl __p__winmajor()
 @ cdecl __p__winminor()
 @ cdecl __p__winver()
@@ -263,7 +263,7 @@
 @ cdecl __unDNameEx(ptr str long ptr ptr ptr long)
 @ extern __unguarded_readlc_active MSVCRT___unguarded_readlc_active
 @ extern __wargv MSVCRT___wargv
-@ cdecl __wcserror(wstr)
+@ cdecl __wcserror(wstr) MSVCRT___wcserror
 @ cdecl __wcserror_s(ptr long wstr)
 # stub __wcsncnt(wstr long)
 @ cdecl __wgetmainargs(ptr ptr ptr long ptr)
@@ -310,7 +310,7 @@
 # stub _atol_l(str ptr)
 @ cdecl _atoldbl(ptr str) MSVCRT__atoldbl
 # stub _atoldbl_l(ptr str ptr)
-@ cdecl _beep(long long)
+@ cdecl _beep(long long) MSVCRT__beep
 @ cdecl _beginthread (ptr long ptr)
 @ cdecl _beginthreadex (ptr long ptr ptr long ptr)
 @ cdecl _c_exit() MSVCRT__c_exit
@@ -323,8 +323,8 @@
 # stub _cgetws(ptr)
 # stub _cgetws_s(ptr long ptr)
 @ cdecl _chdir(str) MSVCRT__chdir
-@ cdecl _chdrive(long)
+@ cdecl _chdrive(long) MSVCRT__chdrive
-@ cdecl _chgsign( double )
+@ cdecl _chgsign(double) MSVCRT__chgsign
 # stub -arch=win64 _chgsignf(float)
 @ cdecl -i386 -norelay _chkesp()
 @ cdecl _chmod(str long) MSVCRT__chmod
@@ -334,12 +334,12 @@
 # stub _chvalidator_l(ptr long long)
 @ cdecl _clearfp()
 @ cdecl _close(long) MSVCRT__close
-@ cdecl _commit(long)
+@ cdecl MSVCRT__commit(long)
 @ extern _commode MSVCRT__commode
 @ cdecl _control87(long long)
 @ cdecl _controlfp(long long)
 @ cdecl _controlfp_s(ptr long long)
-@ cdecl _copysign( double double )
+@ cdecl _copysign(double double) MSVCRT__copysign
 # stub -arch=win64 _copysignf(float float)
 @ varargs _cprintf(str)
 # stub _cprintf_l(str ptr)
@@ -384,7 +384,7 @@
 @ cdecl _endthread ()
 @ cdecl _endthreadex(long)
 @ extern _environ MSVCRT__environ
-@ cdecl _eof(long)
+@ cdecl _eof(long) MSVCRT__eof
 @ cdecl _errno() MSVCRT__errno
 @ cdecl -i386 _except_handler2(ptr ptr ptr ptr)
 @ cdecl -i386 _except_handler3(ptr ptr ptr ptr)
@@ -404,8 +404,8 @@
 @ cdecl _fcvt(double long ptr ptr)
 @ cdecl _fcvt_s(ptr long double long ptr ptr)
 @ cdecl _fdopen(long str) MSVCRT__fdopen
-@ cdecl _fgetchar()
+@ cdecl _fgetchar() MSVCRT__fgetchar
-@ cdecl _fgetwchar()
+@ cdecl _fgetwchar() MSVCRT__fgetwchar
 @ cdecl _filbuf(ptr) MSVCRT__filbuf
 # extern _fileinfo
 @ cdecl _filelength(long) MSVCRT__filelength
@@ -422,12 +422,12 @@
 @ cdecl _findnext64(long ptr) MSVCRT__findnext64
 @ cdecl _findnext64i32(long ptr) MSVCRT__findnext64i32
 @ cdecl _findnexti64(long ptr) MSVCRT__findnexti64
-@ cdecl _finite( double )
+@ cdecl _finite(double) MSVCRT__finite
 # stub -arch=win64 _finitef(float)
 @ cdecl _flsbuf(long ptr) MSVCRT__flsbuf
-@ cdecl _flushall()
+@ cdecl _flushall() MSVCRT__flushall
 @ extern _fmode MSVCRT__fmode
-@ cdecl _fpclass(double)
+@ cdecl _fpclass(double) MSVCRT__fpclass
 # stub -arch=win64 _fpclassf(float)
 @ stub _fpieee_flt(long ptr ptr)
 @ cdecl _fpreset()
@@ -435,8 +435,8 @@
 # stub _fprintf_p(ptr str)
 # stub _fprintf_p_l(ptr str ptr)
 # stub _fprintf_s_l(ptr str ptr)
-@ cdecl _fputchar(long)
+@ cdecl _fputchar(long) MSVCRT__fputchar
-@ cdecl _fputwchar(long)
+@ cdecl _fputwchar(long) MSVCRT__fputwchar
 # stub _free_dbg(ptr long)
 # stub _freea(ptr)
 # stub _freea_s
@@ -476,7 +476,7 @@
 # stub _get_fileinfo(ptr)
 # stub _get_fmode(ptr)
 @ cdecl _get_heap_handle()
-@ cdecl _get_osfhandle(long)
+@ cdecl _get_osfhandle(long) MSVCRT__get_osfhandle
 @ cdecl _get_osplatform(ptr) MSVCRT__get_osplatform
 # stub _get_osver(ptr)
 @ cdecl _get_output_format()
@@ -492,13 +492,13 @@
 @ cdecl _get_unexpected() MSVCRT__get_unexpected
 @ cdecl _getch()
 @ cdecl _getche()
-@ cdecl _getcwd(str long)
+@ cdecl _getcwd(str long) MSVCRT__getcwd
-@ cdecl _getdcwd(long str long)
+@ cdecl _getdcwd(long str long) MSVCRT__getdcwd
 @ cdecl _getdiskfree(long ptr) MSVCRT__getdiskfree
 @ cdecl _getdllprocaddr(long str long)
-@ cdecl _getdrive()
+@ cdecl _getdrive() MSVCRT__getdrive
 @ cdecl _getdrives() kernel32.GetLogicalDrives
-@ cdecl _getmaxstdio()
+@ cdecl _getmaxstdio() MSVCRT__getmaxstdio
 @ cdecl _getmbcp()
 @ cdecl _getpid() kernel32.GetCurrentProcessId
 @ stub _getsystime(ptr)
@@ -518,7 +518,7 @@
 @ stub _heapused(ptr ptr)
 @ cdecl _heapwalk(ptr)
 @ cdecl _hypot(double double)
-@ cdecl _hypotf(float float)
+@ cdecl _hypotf(float float) MSVCRT__hypotf
 @ cdecl _i64toa(int64 ptr long) ntdll._i64toa
 @ cdecl _i64toa_s(int64 ptr long long) _i64toa_s
 @ cdecl _i64tow(int64 ptr long) ntdll._i64tow
@@ -532,10 +532,10 @@
 @ extern _iob MSVCRT__iob
 @ cdecl _isalnum_l(long ptr) MSVCRT__isalnum_l
 @ cdecl _isalpha_l(long ptr) MSVCRT__isalpha_l
-@ cdecl _isatty(long)
+@ cdecl _isatty(long) MSVCRT__isatty
 @ cdecl _iscntrl_l(long ptr) MSVCRT__iscntrl_l
-@ cdecl _isctype(long long)
+@ cdecl _isctype(long long) MSVCRT__isctype
-@ cdecl _isctype_l(long long ptr)
+@ cdecl _isctype_l(long long ptr) MSVCRT__isctype_l
 @ cdecl _isdigit_l(long ptr) MSVCRT__isdigit_l
 @ cdecl _isgraph_l(long ptr) MSVCRT__isgraph_l
 @ cdecl _isleadbyte_l(long ptr) MSVCRT__isleadbyte_l
@@ -598,7 +598,7 @@
 # stub _ismbslead_l(long ptr)
 @ cdecl _ismbstrail(ptr ptr)
 # stub _ismbstrail_l(long ptr)
-@ cdecl _isnan( double )
+@ cdecl _isnan(double) MSVCRT__isnan
 # stub -arch=win64 _isnanf(float)
 @ cdecl _isprint_l(long ptr) MSVCRT__isprint_l
 @ cdecl _isspace_l(long ptr) MSVCRT__isspace_l
@@ -620,9 +620,9 @@
 @ cdecl _itoa_s(long ptr long long)
 @ cdecl _itow(long ptr long) ntdll._itow
 @ cdecl _itow_s(long ptr long long)
-@ cdecl _j0(double)
+@ cdecl _j0(double) MSVCRT__j0
-@ cdecl _j1(double)
+@ cdecl _j1(double) MSVCRT__j1
-@ cdecl _jn(long double)
+@ cdecl _jn(long double) MSVCRT__jn
 @ cdecl _kbhit()
 @ cdecl _lfind(ptr ptr ptr long ptr)
 # stub _lfind_s(ptr ptr ptr long ptr ptr)
@@ -637,7 +637,7 @@
 @ cdecl _lock(long)
 @ cdecl _lock_file(ptr) MSVCRT__lock_file
 @ cdecl _locking(long long long) MSVCRT__locking
-@ cdecl _logb(double)
+@ cdecl _logb(double) MSVCRT__logb
 # stub _logbf(float)
 @ cdecl -i386 _longjmpex(ptr long) MSVCRT_longjmp
 @ cdecl _lrotl(long long) MSVCRT__lrotl
@@ -698,7 +698,7 @@
 # stub _mbscspn_l(str str ptr)
 @ cdecl _mbsdec(ptr ptr)
 # stub _mbsdec_l(ptr ptr ptr)
-@ cdecl _mbsdup(str) _strdup
+@ cdecl _mbsdup(str) MSVCRT__strdup
 # stub _strdup_dbg(str long str long)
 @ cdecl _mbsicmp(str str)
 # stub _mbsicmp_l(str str ptr)
@@ -800,18 +800,18 @@
 @ cdecl _mkgmtime(ptr) MSVCRT__mkgmtime
 @ cdecl _mkgmtime32(ptr) MSVCRT__mkgmtime32
 @ cdecl _mkgmtime64(ptr) MSVCRT__mkgmtime64
-@ cdecl _mktemp(str)
+@ cdecl _mktemp(str) MSVCRT__mktemp
 # stub _mktemp_s(str long)
 @ cdecl _mktime32(ptr) MSVCRT__mktime32
 @ cdecl _mktime64(ptr) MSVCRT__mktime64
 @ cdecl _msize(ptr)
 # stub -arch=win32 _msize_debug(ptr long)
 # stub -arch=win64 _msize_dbg(ptr long)
-@ cdecl _nextafter(double double)
+@ cdecl _nextafter(double double) MSVCRT__nextafter
 # stub -arch=win64 _nextafterf(float float)
 @ cdecl _onexit(ptr) MSVCRT__onexit
 @ varargs _open(str long) MSVCRT__open
-@ cdecl _open_osfhandle(long long)
+@ cdecl _open_osfhandle(long long) MSVCRT__open_osfhandle
 @ extern _osplatform MSVCRT__osplatform
 @ extern _osver MSVCRT__osver
 @ stub -arch=i386 _outp(long long)
@@ -832,13 +832,13 @@
 @ cdecl _putenv_s(str str)
 @ cdecl _putw(long ptr) MSVCRT__putw
 @ cdecl _putwch(long) MSVCRT__putwch
-@ cdecl _putws(wstr)
+@ cdecl _putws(wstr) MSVCRT__putws
 # extern _pwctype
 @ cdecl _read(long ptr long) MSVCRT__read
 # stub _realloc_dbg(ptr long long str long)
-@ cdecl _resetstkoflw()
+@ cdecl _resetstkoflw() MSVCRT__resetstkoflw
 @ cdecl _rmdir(str) MSVCRT__rmdir
-@ cdecl _rmtmp()
+@ cdecl _rmtmp() MSVCRT__rmtmp
 @ cdecl _rotl(long long)
 @ cdecl -ret64 _rotl64(int64 long)
 @ cdecl _rotr(long long)
@@ -857,7 +857,7 @@
 @ varargs _scwprintf(wstr) MSVCRT__scwprintf
 # stub _scwprintf_l(wstr ptr)
 # stub _scwprintf_p_l(wstr ptr)
-@ cdecl _searchenv(str str ptr)
+@ cdecl _searchenv(str str ptr) MSVCRT__searchenv
 @ cdecl _searchenv_s(str str ptr long)
 @ stdcall -i386 _seh_longjmp_unwind4(ptr)
 @ stdcall -i386 _seh_longjmp_unwind(ptr)
@@ -874,9 +874,9 @@
 @ cdecl -arch=i386,x86_64 -norelay _setjmp(ptr) MSVCRT__setjmp
 @ cdecl -arch=i386 -norelay _setjmp3(ptr long) MSVCRT__setjmp3
 @ cdecl -arch=x86_64 -norelay _setjmpex(ptr ptr) MSVCRT__setjmpex
-@ cdecl _setmaxstdio(long)
+@ cdecl _setmaxstdio(long) MSVCRT__setmaxstdio
 @ cdecl _setmbcp(long)
-@ cdecl _setmode(long long)
+@ cdecl _setmode(long long) MSVCRT__setmode
 @ stub _setsystime(ptr long)
 @ cdecl _sleep(long) MSVCRT__sleep
 @ varargs _snprintf(ptr long str) MSVCRT__snprintf
@@ -920,17 +920,17 @@
 @ cdecl _statusfp()
 @ cdecl _strcmpi(str str) ntdll._strcmpi
 @ cdecl _strcoll_l(str str ptr) MSVCRT_strcoll_l
-@ cdecl _strdate(ptr)
+@ cdecl _strdate(ptr) MSVCRT__strdate
 @ cdecl _strdate_s(ptr long)
-@ cdecl _strdup(str)
+@ cdecl _strdup(str) MSVCRT__strdup
 # stub _strdup_dbg(str long str long)
-@ cdecl _strerror(long)
+@ cdecl _strerror(long) MSVCRT__strerror
 # stub _strerror_s(ptr long long)
 @ cdecl _stricmp(str str) ntdll._stricmp
 # stub _stricmp_l(str str ptr)
 @ cdecl _stricoll(str str) MSVCRT__stricoll
 @ cdecl _stricoll_l(str str ptr) MSVCRT__stricoll_l
-@ cdecl _strlwr(str)
+@ cdecl _strlwr(str) MSVCRT__strlwr
 @ cdecl _strlwr_l(str ptr)
 @ cdecl _strlwr_s(ptr long)
 @ cdecl _strlwr_s_l(ptr long ptr)
@@ -942,10 +942,10 @@
 @ cdecl _strnicoll_l(str str long ptr) MSVCRT__strnicoll_l
 @ cdecl _strnset(str long long) MSVCRT__strnset
 # stub _strnset_s(str long long long)
-@ cdecl _strrev(str)
+@ cdecl _strrev(str) MSVCRT__strrev
 @ cdecl _strset(str long)
 # stub _strset_s(str long long)
-@ cdecl _strtime(ptr)
+@ cdecl _strtime(ptr) MSVCRT__strtime
 @ cdecl _strtime_s(ptr long)
 @ cdecl _strtod_l(str ptr ptr) MSVCRT_strtod_l
 @ cdecl -ret64 _strtoi64(str ptr long) MSVCRT_strtoi64
@@ -954,8 +954,8 @@
 @ cdecl -ret64 _strtoui64(str ptr long) MSVCRT_strtoui64
 @ cdecl -ret64 _strtoui64_l(str ptr long ptr) MSVCRT_strtoui64_l
 # stub _strtoul_l(str ptr long ptr)
-@ cdecl _strupr(str)
+@ cdecl _strupr(str) MSVCRT__strupr
-@ cdecl _strupr_l(str ptr)
+@ cdecl _strupr_l(str ptr) MSVCRT__strupr_l
 @ cdecl _strupr_s(str long)
 @ cdecl _strupr_s_l(str long ptr)
 # stub _strxfrm_l(ptr str long ptr)
@@ -971,7 +971,7 @@
 @ extern _sys_nerr MSVCRT__sys_nerr
 @ cdecl _tell(long) MSVCRT__tell
 @ cdecl -ret64 _telli64(long)
-@ cdecl _tempnam(str str)
+@ cdecl _tempnam(str str) MSVCRT__tempnam
 # stub _tempnam_dbg(str str long str long)
 @ cdecl _time32(ptr) MSVCRT__time32
 @ cdecl _time64(ptr) MSVCRT__time64
@@ -1027,10 +1027,10 @@
 # stub _vprintf_p_l(str ptr ptr)
 # stub _vprintf_s_l(str ptr ptr)
 @ cdecl _utime(str ptr)
-@ cdecl _vscprintf(str ptr)
+@ cdecl _vscprintf(str ptr) MSVCRT__vscprintf
 # stub _vscprintf_l(str ptr ptr)
 # stub _vscprintf_p_l(str ptr ptr)
-@ cdecl _vscwprintf(wstr ptr)
+@ cdecl _vscwprintf(wstr ptr) MSVCRT__vscwprintf
 # stub _vscwprintf_l(wstr ptr ptr)
 # stub _vscwprintf_p_l(wstr ptr ptr)
 @ cdecl _vsnprintf(ptr long str ptr) MSVCRT_vsnprintf
@@ -1057,24 +1057,24 @@
 # stub _vwprintf_p(wstr ptr)
 # stub _vwprintf_p_l(wstr ptr ptr)
 # stub _vwprintf_s_l(wstr ptr ptr)
-@ cdecl _waccess(wstr long)
+@ cdecl _waccess(wstr long) MSVCRT__waccess
 @ cdecl _waccess_s(wstr long)
 @ cdecl _wasctime(ptr) MSVCRT__wasctime
 # stub _wasctime_s(ptr long ptr)
 @ cdecl _wassert(wstr wstr long) MSVCRT__wassert
-@ cdecl _wchdir(wstr)
+@ cdecl _wchdir(wstr) MSVCRT__wchdir
-@ cdecl _wchmod(wstr long)
+@ cdecl _wchmod(wstr long) MSVCRT__wchmod
 @ extern _wcmdln MSVCRT__wcmdln
-@ cdecl _wcreat(wstr long)
+@ cdecl _wcreat(wstr long) MSVCRT__wcreat
 # stub _wcscoll_l(wstr wstr ptr)
-@ cdecl _wcsdup(wstr)
+@ cdecl _wcsdup(wstr) MSVCRT__wcsdup
 # stub _wcsdup_dbg(wstr long str long)
-@ cdecl _wcserror(long)
+@ cdecl _wcserror(long) MSVCRT__wcserror
 @ cdecl _wcserror_s(ptr long long)
 # stub _wcsftime_l(ptr long wstr ptr ptr)
 @ cdecl _wcsicmp(wstr wstr) ntdll._wcsicmp
 # stub _wcsicmp_l(wstr wstr ptr)
-@ cdecl _wcsicoll(wstr wstr)
+@ cdecl _wcsicoll(wstr wstr) MSVCRT__wcsicoll
 # stub _wcsicoll_l(wstr wstr ptr)
 @ cdecl _wcslwr(wstr) ntdll._wcslwr
 # stub _wcslwr_l(wstr ptr)
@@ -1084,12 +1084,12 @@
 # stub _wcsncoll_l(wstr wstr long ptr)
 @ cdecl _wcsnicmp(wstr wstr long) ntdll._wcsnicmp
 # stub _wcsnicmp_l(wstr wstr long ptr)
-@ cdecl _wcsnicoll(wstr wstr long)
+@ cdecl _wcsnicoll(wstr wstr long) MSVCRT__wcsnicoll
 # stub _wcsnicoll_l(wstr wstr long ptr)
 @ cdecl _wcsnset(wstr long long) MSVCRT__wcsnset
 # stub _wcsnset_s(wstr long long)
-@ cdecl _wcsrev(wstr)
+@ cdecl _wcsrev(wstr) MSVCRT__wcsrev
-@ cdecl _wcsset(wstr long)
+@ cdecl _wcsset(wstr long) MSVCRT__wcsset
 # stub _wcsset_s(wstr long)
 @ cdecl -ret64 _wcstoi64(wstr ptr long) MSVCRT__wcstoi64
 @ cdecl -ret64 _wcstoi64_l(wstr ptr long ptr) MSVCRT__wcstoi64_l
@@ -1137,9 +1137,9 @@
 @ cdecl _wfsopen(wstr wstr long) MSVCRT__wfsopen
 @ cdecl _wfullpath(ptr wstr long)
 # stub _wfullpath_dbg(ptr wstr long long str long)
-@ cdecl _wgetcwd(wstr long)
+@ cdecl _wgetcwd(wstr long) MSVCRT__wgetcwd
-@ cdecl _wgetdcwd(long wstr long)
+@ cdecl _wgetdcwd(long wstr long) MSVCRT__wgetdcwd
-@ cdecl _wgetenv(wstr)
+@ cdecl _wgetenv(wstr) MSVCRT__wgetenv
 @ cdecl _wgetenv_s(ptr ptr long wstr)
 @ extern _winmajor MSVCRT__winmajor
 @ extern _winminor MSVCRT__winminor
@@ -1147,10 +1147,10 @@
 @ extern _winver MSVCRT__winver
 @ cdecl _wmakepath(ptr wstr wstr wstr wstr)
 @ cdecl _wmakepath_s(ptr long wstr wstr wstr wstr)
-@ cdecl _wmkdir(wstr)
+@ cdecl _wmkdir(wstr) MSVCRT__wmkdir
-@ cdecl _wmktemp(wstr)
+@ cdecl _wmktemp(wstr) MSVCRT__wmktemp
 # stub _wmktemp_s(wstr long)
-@ varargs _wopen(wstr long)
+@ varargs _wopen(wstr long) MSVCRT__wopen
 # stub _woutput_s
 @ stub _wperror(wstr)
 @ extern _wpgmptr MSVCRT__wpgmptr
@@ -1161,13 +1161,13 @@
 # stub _wprintf_s_l(wstr ptr)
 @ cdecl _wputenv(wstr)
 @ cdecl _wputenv_s(wstr wstr)
-@ cdecl _wremove(wstr)
+@ cdecl _wremove(wstr) MSVCRT__wremove
-@ cdecl _wrename(wstr wstr)
+@ cdecl _wrename(wstr wstr) MSVCRT__wrename
 @ cdecl _write(long ptr long) MSVCRT__write
-@ cdecl _wrmdir(wstr)
+@ cdecl _wrmdir(wstr) MSVCRT__wrmdir
 @ varargs _wscanf_l(wstr ptr) MSVCRT__wscanf_l
 @ varargs _wscanf_s_l(wstr ptr) MSVCRT__wscanf_s_l
-@ cdecl _wsearchenv(wstr wstr ptr)
+@ cdecl MSVCRT__wsearchenv(wstr wstr ptr)
 @ cdecl _wsearchenv_s(wstr wstr ptr long)
 @ cdecl _wsetlocale(long wstr) MSVCRT__wsetlocale
 @ varargs _wsopen(wstr long long) MSVCRT__wsopen
@@ -1177,20 +1177,20 @@
 @ varargs _wspawnlp(long wstr wstr)
 @ varargs _wspawnlpe(long wstr wstr)
 @ cdecl _wspawnv(long wstr ptr)
-@ cdecl _wspawnve(long wstr ptr ptr)
+@ cdecl MSVCRT__wspawnve(long wstr ptr ptr)
 @ cdecl _wspawnvp(long wstr ptr)
-@ cdecl _wspawnvpe(long wstr ptr ptr)
+@ cdecl _wspawnvpe(long wstr ptr ptr) MSVCRT__wspawnvpe
 @ cdecl _wsplitpath(wstr ptr ptr ptr ptr)
 @ cdecl _wsplitpath_s(wstr ptr long ptr long ptr long ptr long) _wsplitpath_s
 @ cdecl _wstat(wstr ptr) MSVCRT__wstat
 @ cdecl _wstati64(wstr ptr) MSVCRT__wstati64
 @ cdecl _wstat64(wstr ptr) MSVCRT__wstat64
-@ cdecl _wstrdate(ptr)
+@ cdecl _wstrdate(ptr) MSVCRT__wstrdate
 @ cdecl _wstrdate_s(ptr long)
-@ cdecl _wstrtime(ptr)
+@ cdecl _wstrtime(ptr) MSVCRT__wstrtime
 @ cdecl _wstrtime_s(ptr long)
 @ cdecl _wsystem(wstr)
-@ cdecl _wtempnam(wstr wstr)
+@ cdecl _wtempnam(wstr wstr) MSVCRT__wtempnam
 # stub _wtempnam_dbg(wstr wstr long str long)
 @ cdecl _wtmpnam(ptr) MSVCRT_wtmpnam
 # stub _wtmpnam_s(ptr long)
@@ -1202,13 +1202,13 @@
 # stub _wtoi_l(wstr ptr)
 @ cdecl _wtol(wstr) ntdll._wtol
 # stub _wtol_l(wstr ptr)
-@ cdecl _wunlink(wstr)
+@ cdecl _wunlink(wstr) MSVCRT__wunlink
 @ cdecl _wutime(wstr ptr)
 @ cdecl _wutime32(wstr ptr)
 @ cdecl _wutime64(wstr ptr)
-@ cdecl _y0(double)
+@ cdecl _y0(double) MSVCRT__y0
-@ cdecl _y1(double)
+@ cdecl _y1(double) MSVCRT__y1
-@ cdecl _yn(long double )
+@ cdecl _yn(long double) MSVCRT__yn
 @ cdecl abort() MSVCRT_abort
 @ cdecl abs(long) MSVCRT_abs
 @ cdecl acos(double) MSVCRT_acos
@@ -1317,7 +1317,7 @@
 @ cdecl iswxdigit(long) MSVCRT_iswxdigit
 @ cdecl isxdigit(long) MSVCRT_isxdigit
 @ cdecl labs(long) MSVCRT_labs
-@ cdecl ldexp( double long) MSVCRT_ldexp
+@ cdecl ldexp(double long) MSVCRT_ldexp
 @ cdecl ldiv(long long) MSVCRT_ldiv
 @ cdecl localeconv() MSVCRT_localeconv
 @ cdecl localtime(ptr) MSVCRT_localtime
@@ -1355,7 +1355,7 @@
 @ cdecl putchar(long) MSVCRT_putchar
 @ cdecl puts(str) MSVCRT_puts
 @ cdecl putwc(long ptr) MSVCRT_fputwc
-@ cdecl putwchar(long) _fputwchar
+@ cdecl putwchar(long) MSVCRT__fputwchar
 @ cdecl qsort(ptr long long ptr) ntdll.qsort
 @ cdecl qsort_s(ptr long long ptr ptr) MSVCRT_qsort_s
 @ cdecl raise(long) MSVCRT_raise
@@ -1500,6 +1500,6 @@
 @ cdecl -arch=i386 _statusfp2(ptr ptr)
 @ cdecl _wcstod_l(wstr ptr) MSVCRT__wcstod_l
 @ cdecl _wdupenv_s(ptr ptr wstr)
-@ cdecl _get_printf_count_output()
+@ cdecl _get_printf_count_output() MSVCRT__get_printf_count_output
-@ cdecl _set_printf_count_output(long)
+@ cdecl _set_printf_count_output(long) MSVCRT__set_printf_count_output
 @ cdecl _getptd()

dlls/msvcrt/process.c

@@ -83,7 +83,7 @@ static void msvcrt_search_executable(const MSVCRT_wchar_t *name, MSVCRT_wchar_t
     extension = 0;
   }
 
-  if (!use_path || !(env = _wgetenv(path))) return;
+  if (!use_path || !(env = MSVCRT__wgetenv(path))) return;
 
   /* now try search path */
   do
@@ -601,7 +601,7 @@ MSVCRT_intptr_t CDECL _execlpe(const char* name, const char* arg0, ...)
  */
 MSVCRT_intptr_t CDECL _wexecv(const MSVCRT_wchar_t* name, MSVCRT_wchar_t* const* argv)
 {
-  return _wspawnve(MSVCRT__P_OVERLAY, name, (const MSVCRT_wchar_t* const*) argv, NULL);
+  return MSVCRT__wspawnve(MSVCRT__P_OVERLAY, name, (const MSVCRT_wchar_t* const*) argv, NULL);
 }
 
 /*********************************************************************
@@ -622,7 +622,7 @@ MSVCRT_intptr_t CDECL _execv(const char* name, char* const* argv)
  */
 MSVCRT_intptr_t CDECL _wexecve(const MSVCRT_wchar_t* name, MSVCRT_wchar_t* const* argv, const MSVCRT_wchar_t* const* envv)
 {
-  return _wspawnve(MSVCRT__P_OVERLAY, name, (const MSVCRT_wchar_t* const*) argv, envv);
+  return MSVCRT__wspawnve(MSVCRT__P_OVERLAY, name, (const MSVCRT_wchar_t* const*) argv, envv);
 }
 
 /*********************************************************************
@@ -643,7 +643,7 @@ MSVCRT_intptr_t CDECL MSVCRT__execve(const char* name, char* const* argv, const
  */
 MSVCRT_intptr_t CDECL _wexecvpe(const MSVCRT_wchar_t* name, MSVCRT_wchar_t* const* argv, const MSVCRT_wchar_t* const* envv)
 {
-  return _wspawnvpe(MSVCRT__P_OVERLAY, name, (const MSVCRT_wchar_t* const*) argv, envv);
+  return MSVCRT__wspawnvpe(MSVCRT__P_OVERLAY, name, (const MSVCRT_wchar_t* const*) argv, envv);
 }
 
 /*********************************************************************
@@ -918,7 +918,7 @@ MSVCRT_intptr_t CDECL MSVCRT__spawnve(int flags, const char* name, const char* c
  *
  * Unicode version of _spawnve
  */
-MSVCRT_intptr_t CDECL _wspawnve(int flags, const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* const* argv,
+MSVCRT_intptr_t CDECL MSVCRT__wspawnve(int flags, const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* const* argv,
                                 const MSVCRT_wchar_t* const* envv)
 {
   MSVCRT_wchar_t *args, *envs;
@@ -952,7 +952,7 @@ MSVCRT_intptr_t CDECL _spawnv(int flags, const char* name, const char* const* ar
  */
 MSVCRT_intptr_t CDECL _wspawnv(int flags, const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* const* argv)
 {
-  return _wspawnve(flags, name, argv, NULL);
+  return MSVCRT__wspawnve(flags, name, argv, NULL);
 }
 
 /*********************************************************************
@@ -985,7 +985,7 @@ MSVCRT_intptr_t CDECL MSVCRT__spawnvpe(int flags, const char* name, const char*
  *
  * Unicode version of _spawnvpe
  */
-MSVCRT_intptr_t CDECL _wspawnvpe(int flags, const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* const* argv,
+MSVCRT_intptr_t CDECL MSVCRT__wspawnvpe(int flags, const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* const* argv,
                                  const MSVCRT_wchar_t* const* envv)
 {
   MSVCRT_wchar_t *args, *envs;
@@ -1019,7 +1019,7 @@ MSVCRT_intptr_t CDECL _spawnvp(int flags, const char* name, const char* const* a
  */
 MSVCRT_intptr_t CDECL _wspawnvp(int flags, const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* const* argv)
 {
-  return _wspawnvpe(flags, name, argv, NULL);
+  return MSVCRT__wspawnvpe(flags, name, argv, NULL);
 }
 
 /*********************************************************************

dlls/msvcrt/string.c

@@ -40,7 +40,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  *		_mbsdup (MSVCRT.@)
  *		_strdup (MSVCRT.@)
  */
-char* CDECL _strdup(const char* str)
+char* CDECL MSVCRT__strdup(const char* str)
 {
     if(str)
     {
@@ -106,7 +106,7 @@ char* CDECL _strlwr_l(char *str, MSVCRT__locale_t locale)
 /*********************************************************************
  *		_strlwr (MSVCRT.@)
  */
-char* CDECL _strlwr(char *str)
+char* CDECL MSVCRT__strlwr(char *str)
 {
     _strlwr_s_l(str, -1, NULL);
     return str;
@@ -158,7 +158,7 @@ int CDECL _strupr_s(char *str, MSVCRT_size_t len)
 /*********************************************************************
  *              _strupr_l (MSVCRT.@)
  */
-char* CDECL _strupr_l(char *str, MSVCRT__locale_t locale)
+char* CDECL MSVCRT__strupr_l(char *str, MSVCRT__locale_t locale)
 {
     _strupr_s_l(str, -1, locale);
     return str;
@@ -167,7 +167,7 @@ char* CDECL _strupr_l(char *str, MSVCRT__locale_t locale)
 /*********************************************************************
  *              _strupr (MSVCRT.@)
  */
-char* CDECL _strupr(char *str)
+char* CDECL MSVCRT__strupr(char *str)
 {
     _strupr_s_l(str, -1, NULL);
     return str;
@@ -187,7 +187,7 @@ char* CDECL MSVCRT__strnset(char* str, int value, MSVCRT_size_t len)
 /*********************************************************************
  *		_strrev (MSVCRT.@)
  */
-char* CDECL _strrev(char* str)
+char* CDECL MSVCRT__strrev(char* str)
 {
   char * p1;
   char * p2;

dlls/msvcrt/time.c

@@ -401,7 +401,7 @@ struct MSVCRT_tm* CDECL MSVCRT_gmtime(const MSVCRT___time32_t* secs)
 /**********************************************************************
  *		_strdate (MSVCRT.@)
  */
-char* CDECL _strdate(char* date)
+char* CDECL MSVCRT__strdate(char* date)
 {
   static const char format[] = "MM'/'dd'/'yy";
 
@@ -428,14 +428,14 @@ int CDECL _strdate_s(char* date, MSVCRT_size_t size)
         return MSVCRT_ERANGE;
     }
 
-    _strdate(date);
+    MSVCRT__strdate(date);
     return 0;
 }
 
 /**********************************************************************
  *		_wstrdate (MSVCRT.@)
  */
-MSVCRT_wchar_t* CDECL _wstrdate(MSVCRT_wchar_t* date)
+MSVCRT_wchar_t* CDECL MSVCRT__wstrdate(MSVCRT_wchar_t* date)
 {
   static const WCHAR format[] = { 'M','M','\'','/','\'','d','d','\'','/','\'','y','y',0 };
 
@@ -462,14 +462,14 @@ int CDECL _wstrdate_s(MSVCRT_wchar_t* date, MSVCRT_size_t size)
         return MSVCRT_ERANGE;
     }
 
-    _wstrdate(date);
+    MSVCRT__wstrdate(date);
     return 0;
 }
 
 /*********************************************************************
  *		_strtime (MSVCRT.@)
  */
-char* CDECL _strtime(char* time)
+char* CDECL MSVCRT__strtime(char* time)
 {
   static const char format[] = "HH':'mm':'ss";
 
@@ -496,14 +496,14 @@ int CDECL _strtime_s(char* time, MSVCRT_size_t size)
         return MSVCRT_ERANGE;
     }
 
-    _strtime(time);
+    MSVCRT__strtime(time);
     return 0;
 }
 
 /*********************************************************************
  *		_wstrtime (MSVCRT.@)
  */
-MSVCRT_wchar_t* CDECL _wstrtime(MSVCRT_wchar_t* time)
+MSVCRT_wchar_t* CDECL MSVCRT__wstrtime(MSVCRT_wchar_t* time)
 {
   static const WCHAR format[] = { 'H','H','\'',':','\'','m','m','\'',':','\'','s','s',0 };
 
@@ -530,7 +530,7 @@ int CDECL _wstrtime_s(MSVCRT_wchar_t* time, MSVCRT_size_t size)
         return MSVCRT_ERANGE;
     }
 
-    _wstrtime(time);
+    MSVCRT__wstrtime(time);
     return 0;
 }
 

dlls/msvcrt/wcs.c

@@ -41,13 +41,13 @@ static BOOL n_format_enabled = TRUE;
 #undef PRINTF_WIDE
 
 /* _get_printf_count_output - not exported in native msvcrt */
-int CDECL _get_printf_count_output( void )
+int CDECL MSVCRT__get_printf_count_output( void )
 {
     return n_format_enabled ? 1 : 0;
 }
 
 /* _set_printf_count_output - not exported in native msvcrt */
-int CDECL _set_printf_count_output( int enable )
+int CDECL MSVCRT__set_printf_count_output( int enable )
 {
     BOOL old = n_format_enabled;
     n_format_enabled = (enable ? TRUE : FALSE);
@@ -57,7 +57,7 @@ int CDECL _set_printf_count_output( int enable )
 /*********************************************************************
  *		_wcsdup (MSVCRT.@)
  */
-MSVCRT_wchar_t* CDECL _wcsdup( const MSVCRT_wchar_t* str )
+MSVCRT_wchar_t* CDECL MSVCRT__wcsdup( const MSVCRT_wchar_t* str )
 {
   MSVCRT_wchar_t* ret = NULL;
   if (str)
@@ -72,7 +72,7 @@ MSVCRT_wchar_t* CDECL _wcsdup( const MSVCRT_wchar_t* str )
 /*********************************************************************
  *		_wcsicoll (MSVCRT.@)
  */
-INT CDECL _wcsicoll( const MSVCRT_wchar_t* str1, const MSVCRT_wchar_t* str2 )
+INT CDECL MSVCRT__wcsicoll( const MSVCRT_wchar_t* str1, const MSVCRT_wchar_t* str2 )
 {
   /* FIXME: handle collates */
   return strcmpiW( str1, str2 );
@@ -81,7 +81,7 @@ INT CDECL _wcsicoll( const MSVCRT_wchar_t* str1, const MSVCRT_wchar_t* str2 )
 /*********************************************************************
  *		_wcsnicoll (MSVCRT.@)
  */
-INT CDECL _wcsnicoll( const MSVCRT_wchar_t* str1, const MSVCRT_wchar_t* str2, MSVCRT_size_t count )
+INT CDECL MSVCRT__wcsnicoll( const MSVCRT_wchar_t* str1, const MSVCRT_wchar_t* str2, MSVCRT_size_t count )
 {
   /* FIXME: handle collates */
   return strncmpiW( str1, str2, count );
@@ -100,7 +100,7 @@ MSVCRT_wchar_t* CDECL MSVCRT__wcsnset( MSVCRT_wchar_t* str, MSVCRT_wchar_t c, MS
 /*********************************************************************
  *		_wcsrev (MSVCRT.@)
  */
-MSVCRT_wchar_t* CDECL _wcsrev( MSVCRT_wchar_t* str )
+MSVCRT_wchar_t* CDECL MSVCRT__wcsrev( MSVCRT_wchar_t* str )
 {
   MSVCRT_wchar_t* ret = str;
   MSVCRT_wchar_t* end = str + strlenW(str) - 1;
@@ -116,7 +116,7 @@ MSVCRT_wchar_t* CDECL _wcsrev( MSVCRT_wchar_t* str )
 /*********************************************************************
  *		_wcsset (MSVCRT.@)
  */
-MSVCRT_wchar_t* CDECL _wcsset( MSVCRT_wchar_t* str, MSVCRT_wchar_t c )
+MSVCRT_wchar_t* CDECL MSVCRT__wcsset( MSVCRT_wchar_t* str, MSVCRT_wchar_t c )
 {
   MSVCRT_wchar_t* ret = str;
   while (*str) *str++ = c;
@@ -609,7 +609,7 @@ int CDECL MSVCRT_vsprintf_s( char *str, MSVCRT_size_t num, const char *format, _
 /*********************************************************************
  *		_vscprintf (MSVCRT.@)
  */
-int CDECL _vscprintf( const char *format, __ms_va_list valist )
+int CDECL MSVCRT__vscprintf( const char *format, __ms_va_list valist )
 {
     return MSVCRT_vsnprintf( NULL, INT_MAX, format, valist );
 }
@@ -649,7 +649,7 @@ int CDECL MSVCRT__scprintf(const char *format, ...)
     int retval;
     __ms_va_list valist;
     __ms_va_start(valist, format);
-    retval = _vscprintf(format, valist);
+    retval = MSVCRT__vscprintf(format, valist);
     __ms_va_end(valist);
     return retval;
 }
@@ -842,7 +842,7 @@ int CDECL MSVCRT_vswprintf( MSVCRT_wchar_t* str, const MSVCRT_wchar_t* format, _
 /*********************************************************************
  *		_vscwprintf (MSVCRT.@)
  */
-int CDECL _vscwprintf( const MSVCRT_wchar_t *format, __ms_va_list args )
+int CDECL MSVCRT__vscwprintf( const MSVCRT_wchar_t *format, __ms_va_list args )
 {
     return MSVCRT_vsnwprintf( NULL, INT_MAX, format, args );
 }