diff --git a/dlls/msvcrt/console.c b/dlls/msvcrt/console.c
index cd30dea..aa02a60 100644
--- a/dlls/msvcrt/console.c
+++ b/dlls/msvcrt/console.c
@@ -21,7 +21,7 @@
 static int __MSVCRT_console_buffer = MSVCRT_EOF;
 
 /* INTERNAL: Initialise console handles */
-void MSVCRT_init_console(void)
+void msvcrt_init_console(void)
 {
   TRACE(":Opening console handles\n");
 
@@ -41,7 +41,7 @@
 }
 
 /* INTERNAL: Free console handles */
-void MSVCRT_free_console(void)
+void msvcrt_free_console(void)
 {
   TRACE(":Closing console handles\n");
   CloseHandle(MSVCRT_console_in);
@@ -51,7 +51,7 @@
 /*********************************************************************
  *		_cputs (MSVCRT.@)
  */
-int __cdecl MSVCRT__cputs(const char * str)
+int _cputs(const char* str)
 {
   DWORD count;
   int retval = MSVCRT_EOF;
@@ -67,7 +67,7 @@
 /*********************************************************************
  *		_getch (MSVCRT.@)
  */
-int __cdecl MSVCRT__getch(void)
+int _getch(void)
 {
   int retval = MSVCRT_EOF;
 
@@ -112,7 +112,7 @@
 /*********************************************************************
  *		_putch (MSVCRT.@)
  */
-int __cdecl MSVCRT__putch(int c)
+int _putch(int c)
 {
   int retval = MSVCRT_EOF;
   DWORD count;
@@ -126,13 +126,13 @@
 /*********************************************************************
  *		_getche (MSVCRT.@)
  */
-int __cdecl MSVCRT__getche(void)
+int _getche(void)
 {
   int retval;
   LOCK_CONSOLE;
-  retval = MSVCRT__getch();
+  retval = _getch();
   if (retval != MSVCRT_EOF)
-    retval = MSVCRT__putch(retval);
+    retval = _putch(retval);
   UNLOCK_CONSOLE;
   return retval;
 }
@@ -140,7 +140,7 @@
 /*********************************************************************
  *		_cgets (MSVCRT.@)
  */
-char *__cdecl MSVCRT__cgets(char *str)
+char* _cgets(char* str)
 {
   char *buf = str + 2;
   int c;
@@ -149,7 +149,7 @@
   LOCK_CONSOLE;
   do
   {
-    if (str[1] >= str[0] || (str[1]++, c = MSVCRT__getche()) == MSVCRT_EOF || c == '\n')
+    if (str[1] >= str[0] || (str[1]++, c = _getche()) == MSVCRT_EOF || c == '\n')
       break;
     *buf++ = c & 0xff;
   } while (1);
@@ -161,7 +161,7 @@
 /*********************************************************************
  *		_ungetch (MSVCRT.@)
  */
-int __cdecl MSVCRT__ungetch(int c)
+int _ungetch(int c)
 {
   int retval = MSVCRT_EOF;
   LOCK_CONSOLE;
@@ -174,7 +174,7 @@
 /*********************************************************************
  *		_cscanf (MSVCRT.@)
  */
-int __cdecl MSVCRT__cscanf( const char * format, ... )
+int _cscanf(const char* format, ...)
 {
     /* NOTE: If you extend this function, extend MSVCRT_fscanf in file.c too */
     int rd = 0;
@@ -184,12 +184,12 @@
     WARN("\"%s\": semi-stub\n", format);
     va_start(ap, format);
   LOCK_CONSOLE;
-    nch = MSVCRT__getch();
+    nch = _getch();
     while (*format) {
         if (*format == ' ') {
             /* skip whitespace */
             while ((nch!=MSVCRT_EOF) && isspace(nch))
-                nch = MSVCRT__getch();
+                nch = _getch();
         }
         else if (*format == '%') {
             int st = 0;
@@ -200,10 +200,10 @@
                     int cur = 0;
                     /* skip initial whitespace */
                     while ((nch!=MSVCRT_EOF) && isspace(nch))
-                        nch = MSVCRT__getch();
+                        nch = _getch();
                     /* get sign and first digit */
                     if (nch == '-') {
-                        nch = MSVCRT__getch();
+                        nch = _getch();
                         if (isdigit(nch))
                             cur = -(nch - '0');
                         else break;
@@ -212,11 +212,11 @@
                             cur = nch - '0';
                         else break;
                     }
-                    nch = MSVCRT__getch();
+                    nch = _getch();
                     /* read until no more digits */
                     while ((nch!=MSVCRT_EOF) && isdigit(nch)) {
                         cur = cur*10 + (nch - '0');
-                        nch = MSVCRT__getch();
+                        nch = _getch();
                     }
                     st = 1;
                     *val = cur;
@@ -227,10 +227,10 @@
                     float cur = 0;
                     /* skip initial whitespace */
                     while ((nch!=MSVCRT_EOF) && isspace(nch))
-                        nch = MSVCRT__getch();
+                        nch = _getch();
                     /* get sign and first digit */
                     if (nch == '-') {
-                        nch = MSVCRT__getch();
+                        nch = _getch();
                         if (isdigit(nch))
                             cur = -(nch - '0');
                         else break;
@@ -242,16 +242,16 @@
                     /* read until no more digits */
                     while ((nch!=MSVCRT_EOF) && isdigit(nch)) {
                         cur = cur*10 + (nch - '0');
-                        nch = MSVCRT__getch();
+                        nch = _getch();
                     }
                     if (nch == '.') {
                         /* handle decimals */
                         float dec = 1;
-                        nch = MSVCRT__getch();
+                        nch = _getch();
                         while ((nch!=MSVCRT_EOF) && isdigit(nch)) {
                             dec /= 10;
                             cur += dec * (nch - '0');
-                            nch = MSVCRT__getch();
+                            nch = _getch();
                         }
                     }
                     st = 1;
@@ -263,11 +263,11 @@
                     char*sptr = str;
                     /* skip initial whitespace */
                     while ((nch!=MSVCRT_EOF) && isspace(nch))
-                        nch = MSVCRT__getch();
+                        nch = _getch();
                     /* read until whitespace */
                     while ((nch!=MSVCRT_EOF) && !isspace(nch)) {
                         *sptr++ = nch; st++;
-                        nch = MSVCRT__getch();
+                        nch = _getch();
                     }
                     /* terminate */
                     *sptr = 0;
@@ -282,13 +282,13 @@
         else {
             /* check for character match */
             if (nch == *format)
-               nch = MSVCRT__getch();
+               nch = _getch();
             else break;
         }
         format++;
     }
     if (nch != MSVCRT_EOF)
-      MSVCRT__ungetch(nch);
+      _ungetch(nch);
     UNLOCK_CONSOLE;
     va_end(ap);
     TRACE("returning %d\n", rd);
@@ -298,7 +298,7 @@
 /*********************************************************************
  *		_kbhit (MSVCRT.@)
  */
-int __cdecl MSVCRT__kbhit(void)
+int _kbhit(void)
 {
   int retval = 0;
 
@@ -338,7 +338,7 @@
 /*********************************************************************
  *		_cprintf (MSVCRT.@)
  */
-int __cdecl MSVCRT__cprintf( const char * format, ... )
+int _cprintf(const char* format, ...)
 {
   char buf[2048], *mem = buf;
   int written, resize = sizeof(buf), retval;
@@ -362,7 +362,7 @@
   }
   va_end(valist);
   LOCK_CONSOLE;
-  retval = MSVCRT__cputs( mem );
+  retval = _cputs( mem );
   UNLOCK_CONSOLE;
   if (mem != buf)
     MSVCRT_free (mem);
diff --git a/dlls/msvcrt/cpp.c b/dlls/msvcrt/cpp.c
index bf80ba2..4d8117c 100644
--- a/dlls/msvcrt/cpp.c
+++ b/dlls/msvcrt/cpp.c
@@ -8,9 +8,9 @@
 DEFAULT_DEBUG_CHANNEL(msvcrt);
 
 
-void __cdecl MSVCRT__purecall(void);
+void _purecall(void);
 
-typedef void (__cdecl *v_table_ptr)();
+typedef void (*v_table_ptr)();
 
 static v_table_ptr exception_vtable[2];
 static v_table_ptr bad_typeid_vtable[3];
@@ -50,7 +50,7 @@
 /******************************************************************
  *		exception_ctor (MSVCRT.@)
  */
-void __cdecl MSVCRT_exception_ctor(exception * _this, const char ** name)
+void MSVCRT_exception_ctor(exception * _this, const char ** name)
 {
   TRACE("(%p %s)\n",_this,*name);
   _this->vtable = exception_vtable;
@@ -62,7 +62,7 @@
 /******************************************************************
  *		exception_copy_ctor (MSVCRT.@)
  */
-void __cdecl MSVCRT_exception_copy_ctor(exception * _this, const exception * rhs)
+void MSVCRT_exception_copy_ctor(exception * _this, const exception * rhs)
 {
   TRACE("(%p %p)\n",_this,rhs);
   if (_this != rhs)
@@ -73,7 +73,7 @@
 /******************************************************************
  *		exception_default_ctor (MSVCRT.@)
  */
-void __cdecl MSVCRT_exception_default_ctor(exception * _this)
+void MSVCRT_exception_default_ctor(exception * _this)
 {
   TRACE("(%p)\n",_this);
   _this->vtable = exception_vtable;
@@ -84,7 +84,7 @@
 /******************************************************************
  *		exception_dtor (MSVCRT.@)
  */
-void __cdecl MSVCRT_exception_dtor(exception * _this)
+void MSVCRT_exception_dtor(exception * _this)
 {
   TRACE("(%p)\n",_this);
 }
@@ -92,7 +92,7 @@
 /******************************************************************
  *		exception_opequals (MSVCRT.@)
  */
-exception * __cdecl MSVCRT_exception_opequals(exception * _this, const exception * rhs)
+exception * MSVCRT_exception_opequals(exception * _this, const exception * rhs)
 {
   TRACE("(%p %p)\n",_this,rhs);
   memcpy (_this, rhs, sizeof (*_this));
@@ -103,20 +103,20 @@
 /******************************************************************
  *		exception__unknown_E (MSVCRT.@)
  */
-void * __cdecl MSVCRT_exception__unknown_E(exception * _this, unsigned int arg1)
+void * MSVCRT_exception__unknown_E(exception * _this, unsigned int arg1)
 {
   TRACE("(%p %d)\n",_this,arg1);
-  MSVCRT__purecall();
+  _purecall();
   return NULL;
 }
 
 /******************************************************************
  *		exception__unknown_G (MSVCRT.@)
  */
-void * __cdecl MSVCRT_exception__unknown_G(exception * _this, unsigned int arg1)
+void * MSVCRT_exception__unknown_G(exception * _this, unsigned int arg1)
 {
   TRACE("(%p %d)\n",_this,arg1);
-  MSVCRT__purecall();
+  _purecall();
   return NULL;
 }
 
@@ -133,7 +133,7 @@
 /******************************************************************
  *		bad_typeid_copy_ctor (MSVCRT.@)
  */
-void __cdecl MSVCRT_bad_typeid_copy_ctor(bad_typeid * _this, const bad_typeid * rhs)
+void MSVCRT_bad_typeid_copy_ctor(bad_typeid * _this, const bad_typeid * rhs)
 {
   TRACE("(%p %p)\n",_this,rhs);
   MSVCRT_exception_copy_ctor(&_this->base,&rhs->base);
@@ -142,7 +142,7 @@
 /******************************************************************
  *		bad_typeid_ctor (MSVCRT.@)
  */
-void __cdecl MSVCRT_bad_typeid_ctor(bad_typeid * _this, const char * name)
+void MSVCRT_bad_typeid_ctor(bad_typeid * _this, const char * name)
 {
   TRACE("(%p %s)\n",_this,name);
   MSVCRT_exception_ctor(&_this->base, &name);
@@ -152,7 +152,7 @@
 /******************************************************************
  *		bad_typeid_dtor (MSVCRT.@)
  */
-void __cdecl MSVCRT_bad_typeid_dtor(bad_typeid * _this)
+void MSVCRT_bad_typeid_dtor(bad_typeid * _this)
 {
   TRACE("(%p)\n",_this);
   MSVCRT_exception_dtor(&_this->base);
@@ -161,7 +161,7 @@
 /******************************************************************
  *		bad_typeid_opequals (MSVCRT.@)
  */
-bad_typeid * __cdecl MSVCRT_bad_typeid_opequals(bad_typeid * _this, const bad_typeid * rhs)
+bad_typeid * MSVCRT_bad_typeid_opequals(bad_typeid * _this, const bad_typeid * rhs)
 {
   TRACE("(%p %p)\n",_this,rhs);
   MSVCRT_exception_copy_ctor(&_this->base,&rhs->base);
@@ -171,7 +171,7 @@
 /******************************************************************
  *		__non_rtti_object_copy_ctor (MSVCRT.@)
  */
-void __cdecl MSVCRT___non_rtti_object_copy_ctor(__non_rtti_object * _this,
+void MSVCRT___non_rtti_object_copy_ctor(__non_rtti_object * _this,
                                                 const __non_rtti_object * rhs)
 {
   TRACE("(%p %p)\n",_this,rhs);
@@ -181,7 +181,7 @@
 /******************************************************************
  *		__non_rtti_object_ctor (MSVCRT.@)
  */
-void __cdecl MSVCRT___non_rtti_object_ctor(__non_rtti_object * _this,
+void MSVCRT___non_rtti_object_ctor(__non_rtti_object * _this,
                                            const char * name)
 {
   TRACE("(%p %s)\n",_this,name);
@@ -192,7 +192,7 @@
 /******************************************************************
  *		__non_rtti_object_dtor (MSVCRT.@)
  */
-void __cdecl MSVCRT___non_rtti_object_dtor(__non_rtti_object * _this)
+void MSVCRT___non_rtti_object_dtor(__non_rtti_object * _this)
 {
   TRACE("(%p)\n",_this);
   MSVCRT_bad_typeid_dtor(&_this->base);
@@ -201,7 +201,7 @@
 /******************************************************************
  *		__non_rtti_object_opequals (MSVCRT.@)
  */
-__non_rtti_object * __cdecl MSVCRT___non_rtti_object_opequals(__non_rtti_object * _this,
+__non_rtti_object * MSVCRT___non_rtti_object_opequals(__non_rtti_object * _this,
                                                               const __non_rtti_object *rhs)
 {
   TRACE("(%p %p)\n",_this,rhs);
@@ -213,27 +213,27 @@
 /******************************************************************
  *		__non_rtti_object__unknown_E (MSVCRT.@)
  */
-void * __cdecl MSVCRT___non_rtti_object__unknown_E(__non_rtti_object * _this, unsigned int arg1)
+void * MSVCRT___non_rtti_object__unknown_E(__non_rtti_object * _this, unsigned int arg1)
 {
   TRACE("(%p %d)\n",_this,arg1);
-  MSVCRT__purecall();
+  _purecall();
   return NULL;
 }
 
 /******************************************************************
  *		__non_rtti_object__unknown_G (MSVCRT.@)
  */
-void * __cdecl MSVCRT___non_rtti_object__unknown_G(__non_rtti_object * _this, unsigned int arg1)
+void * MSVCRT___non_rtti_object__unknown_G(__non_rtti_object * _this, unsigned int arg1)
 {
   TRACE("(%p %d)\n",_this,arg1);
-  MSVCRT__purecall();
+  _purecall();
   return NULL;
 }
 
 /******************************************************************
  *		bad_cast_ctor (MSVCRT.@)
  */
-void __cdecl MSVCRT_bad_cast_ctor(bad_cast * _this, const char ** name)
+void MSVCRT_bad_cast_ctor(bad_cast * _this, const char ** name)
 {
   TRACE("(%p %s)\n",_this,*name);
   MSVCRT_exception_ctor(&_this->base, name);
@@ -243,7 +243,7 @@
 /******************************************************************
  *		bad_cast_copy_ctor (MSVCRT.@)
  */
-void __cdecl MSVCRT_bad_cast_copy_ctor(bad_cast * _this, const bad_cast * rhs)
+void MSVCRT_bad_cast_copy_ctor(bad_cast * _this, const bad_cast * rhs)
 {
   TRACE("(%p %p)\n",_this,rhs);
   MSVCRT_exception_copy_ctor(&_this->base,&rhs->base);
@@ -252,7 +252,7 @@
 /******************************************************************
  *		bad_cast_dtor (MSVCRT.@)
  */
-void __cdecl MSVCRT_bad_cast_dtor(bad_cast * _this)
+void MSVCRT_bad_cast_dtor(bad_cast * _this)
 {
   TRACE("(%p)\n",_this);
   MSVCRT_exception_dtor(&_this->base);
@@ -261,7 +261,7 @@
 /******************************************************************
  *		bad_cast_opequals (MSVCRT.@)
  */
-bad_cast * __cdecl MSVCRT_bad_cast_opequals(bad_cast * _this, const bad_cast * rhs)
+bad_cast * MSVCRT_bad_cast_opequals(bad_cast * _this, const bad_cast * rhs)
 {
   TRACE("(%p %p)\n",_this,rhs);
   MSVCRT_exception_copy_ctor(&_this->base,&rhs->base);
@@ -289,7 +289,7 @@
 /******************************************************************
  *		type_info_dtor (MSVCRT.@)
  */
-void __cdecl MSVCRT_type_info_dtor(type_info * _this)
+void MSVCRT_type_info_dtor(type_info * _this)
 {
   TRACE("(%p)\n",_this);
   if (_this->data)
@@ -318,14 +318,14 @@
 /* INTERNAL: Set up vtables
  * FIXME:should be static, cope with versions?
  */
-void MSVCRT_init_vtables(void)
+void msvcrt_init_vtables(void)
 {
   exception_vtable[0] = MSVCRT_exception_dtor;
   exception_vtable[1] = (void*)MSVCRT_exception_what;
 
   bad_typeid_vtable[0] = MSVCRT_bad_typeid_dtor;
   bad_typeid_vtable[1] = exception_vtable[1];
-  bad_typeid_vtable[2] = MSVCRT__purecall; /* FIXME */
+  bad_typeid_vtable[2] = _purecall; /* FIXME */
 
   __non_rtti_object_vtable[0] = MSVCRT___non_rtti_object_dtor;
   __non_rtti_object_vtable[1] = bad_typeid_vtable[1];
@@ -333,7 +333,7 @@
 
   bad_cast_vtable[0] = MSVCRT_bad_cast_dtor;
   bad_cast_vtable[1] = exception_vtable[1];
-  bad_cast_vtable[2] = MSVCRT__purecall; /* FIXME */
+  bad_cast_vtable[2] = _purecall; /* FIXME */
 
   type_info_vtable[0] = MSVCRT_type_info_dtor;
 
diff --git a/dlls/msvcrt/ctype.c b/dlls/msvcrt/ctype.c
index c1273ec..07f4b98 100644
--- a/dlls/msvcrt/ctype.c
+++ b/dlls/msvcrt/ctype.c
@@ -8,29 +8,29 @@
 DEFAULT_DEBUG_CHANNEL(msvcrt);
 
 /* ASCII char classification table - binary compatible */
-#define MSVCRT_UPPER		C1_UPPER
-#define MSVCRT_LOWER		C1_LOWER
-#define MSVCRT_DIGIT		C1_DIGIT
-#define MSVCRT_SPACE		C1_SPACE
-#define MSVCRT_PUNCT		C1_PUNCT
-#define MSVCRT_CONTROL		C1_CNTRL
-#define MSVCRT_BLANK		C1_BLANK
-#define MSVCRT_HEX		C1_XDIGIT
-#define MSVCRT_LEADBYTE  0x8000
-#define MSVCRT_ALPHA    (C1_ALPHA|MSVCRT_UPPER|MSVCRT_LOWER)
+#define _UPPER        C1_UPPER
+#define _LOWER        C1_LOWER
+#define _DIGIT        C1_DIGIT
+#define _SPACE        C1_SPACE
+#define _PUNCT        C1_PUNCT
+#define _CONTROL      C1_CNTRL
+#define _BLANK        C1_BLANK
+#define _HEX          C1_XDIGIT
+#define _LEADBYTE     0x8000
+#define _ALPHA       (C1_ALPHA|_UPPER|_LOWER)
 
-#define _C_ MSVCRT_CONTROL
-#define _S_ MSVCRT_SPACE
-#define _P_ MSVCRT_PUNCT
-#define _D_ MSVCRT_DIGIT
-#define _H_ MSVCRT_HEX
-#define _U_ MSVCRT_UPPER
-#define _L_ MSVCRT_LOWER
+#define _C_ _CONTROL
+#define _S_ _SPACE
+#define _P_ _PUNCT
+#define _D_ _DIGIT
+#define _H_ _HEX
+#define _U_ _UPPER
+#define _L_ _LOWER
 
 WORD MSVCRT__ctype [257] = {
   0, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _S_|_C_, _S_|_C_,
   _S_|_C_, _S_|_C_, _S_|_C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_,
-  _C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _S_|MSVCRT_BLANK,
+  _C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _S_|_BLANK,
   _P_, _P_, _P_, _P_, _P_, _P_, _P_, _P_, _P_, _P_, _P_, _P_, _P_, _P_,
   _P_, _D_|_H_, _D_|_H_, _D_|_H_, _D_|_H_, _D_|_H_, _D_|_H_, _D_|_H_,
   _D_|_H_, _D_|_H_, _D_|_H_, _P_, _P_, _P_, _P_, _P_, _P_, _P_, _U_|_H_,
@@ -62,9 +62,9 @@
 extern LCID MSVCRT_current_lc_all_lcid;
 
 /*********************************************************************
- *		MSVCRT___p__pctype (MSVCRT.@)
+ *		__p__pctype (MSVCRT.@)
  */
-WORD** MSVCRT___p__pctype(void)
+WORD** __p__pctype(void)
 {
   return &MSVCRT__pctype;
 }
@@ -72,7 +72,7 @@
 /*********************************************************************
  *		_isctype (MSVCRT.@)
  */
-int __cdecl MSVCRT__isctype(int c, int type)
+int _isctype(int c, int type)
 {
   if (c >= -1 && c <= 255)
     return MSVCRT__pctype[c] & type;
@@ -83,7 +83,7 @@
     WORD typeInfo;
     char convert[3], *pconv = convert;
 
-    if (MSVCRT__pctype[(UINT)c >> 8] & MSVCRT_LEADBYTE)
+    if (MSVCRT__pctype[(UINT)c >> 8] & _LEADBYTE)
       *pconv++ = (UINT)c >> 8;
     *pconv++ = c & 0xff;
     *pconv = 0;
@@ -98,104 +98,103 @@
 /*********************************************************************
  *		isalnum (MSVCRT.@)
  */
-int __cdecl MSVCRT_isalnum(int c)
+int MSVCRT_isalnum(int c)
 {
-  return MSVCRT__isctype( c,MSVCRT_ALPHA | MSVCRT_DIGIT );
+  return _isctype( c, _ALPHA | _DIGIT );
 }
 
 /*********************************************************************
  *		isalpha (MSVCRT.@)
  */
-int __cdecl MSVCRT_isalpha(int c)
+int MSVCRT_isalpha(int c)
 {
-  return MSVCRT__isctype( c, MSVCRT_ALPHA );
+  return _isctype( c, _ALPHA );
 }
 
 /*********************************************************************
  *		iscntrl (MSVCRT.@)
  */
-int __cdecl MSVCRT_iscntrl(int c)
+int MSVCRT_iscntrl(int c)
 {
-  return MSVCRT__isctype( c, MSVCRT_CONTROL );
+  return _isctype( c, _CONTROL );
 }
 
 /*********************************************************************
  *		isdigit (MSVCRT.@)
  */
-int __cdecl MSVCRT_isdigit(int c)
+int MSVCRT_isdigit(int c)
 {
-  return MSVCRT__isctype( c, MSVCRT_DIGIT );
+  return _isctype( c, _DIGIT );
 }
 
 /*********************************************************************
  *		isgraph (MSVCRT.@)
  */
-int __cdecl MSVCRT_isgraph(int c)
+int MSVCRT_isgraph(int c)
 {
-  return MSVCRT__isctype( c, MSVCRT_ALPHA | MSVCRT_DIGIT | MSVCRT_PUNCT );
+  return _isctype( c, _ALPHA | _DIGIT | _PUNCT );
 }
 
 /*********************************************************************
  *		isleadbyte (MSVCRT.@)
  */
-int __cdecl MSVCRT_isleadbyte(int c)
+int MSVCRT_isleadbyte(int c)
 {
-  return MSVCRT__isctype( c, MSVCRT_LEADBYTE );
+  return _isctype( c, _LEADBYTE );
 }
 
 /*********************************************************************
  *		islower (MSVCRT.@)
  */
-int __cdecl MSVCRT_islower(int c)
+int MSVCRT_islower(int c)
 {
-  return MSVCRT__isctype( c, MSVCRT_LOWER );
+  return _isctype( c, _LOWER );
 }
 
 /*********************************************************************
  *		isprint (MSVCRT.@)
  */
-int __cdecl MSVCRT_isprint(int c)
+int MSVCRT_isprint(int c)
 {
-  return MSVCRT__isctype( c, MSVCRT_ALPHA | MSVCRT_DIGIT |
-			  MSVCRT_BLANK | MSVCRT_PUNCT );
+  return _isctype( c, _ALPHA | _DIGIT | _BLANK | _PUNCT );
 }
 
 /*********************************************************************
  *		ispunct (MSVCRT.@)
  */
-int __cdecl MSVCRT_ispunct(int c)
+int MSVCRT_ispunct(int c)
 {
-  return MSVCRT__isctype( c, MSVCRT_PUNCT );
+  return _isctype( c, _PUNCT );
 }
 
 /*********************************************************************
  *		isspace (MSVCRT.@)
  */
-int __cdecl MSVCRT_isspace(int c)
+int MSVCRT_isspace(int c)
 {
-  return MSVCRT__isctype( c, MSVCRT_SPACE );
+  return _isctype( c, _SPACE );
 }
 
 /*********************************************************************
  *		isupper (MSVCRT.@)
  */
-int __cdecl MSVCRT_isupper(int c)
+int MSVCRT_isupper(int c)
 {
-  return MSVCRT__isctype( c, MSVCRT_UPPER );
+  return _isctype( c, _UPPER );
 }
 
 /*********************************************************************
  *		isxdigit (MSVCRT.@)
  */
-int __cdecl MSVCRT_isxdigit(int c)
+int MSVCRT_isxdigit(int c)
 {
-  return MSVCRT__isctype( c, MSVCRT_HEX );
+  return _isctype( c, _HEX );
 }
 
 /*********************************************************************
  *		__isascii (MSVCRT.@)
  */
-int __cdecl MSVCRT___isascii(int c)
+int MSVCRT___isascii(int c)
 {
   return isascii((unsigned)c);
 }
@@ -203,7 +202,7 @@
 /*********************************************************************
  *		__toascii (MSVCRT.@)
  */
-int __cdecl MSVCRT___toascii(int c)
+int MSVCRT___toascii(int c)
 {
   return (unsigned)c & 0x7f;
 }
@@ -212,7 +211,7 @@
  *		iswascii (MSVCRT.@)
  *
  */
-int __cdecl MSVCRT_iswascii(WCHAR c)
+int MSVCRT_iswascii(WCHAR c)
 {
   return ((unsigned)c < 0x80);
 }
@@ -220,7 +219,7 @@
 /*********************************************************************
  *		__iscsym (MSVCRT.@)
  */
-int __cdecl MSVCRT___iscsym(int c)
+int MSVCRT___iscsym(int c)
 {
   return (c < 127 && (isalnum(c) || c == '_'));
 }
@@ -228,7 +227,7 @@
 /*********************************************************************
  *		__iscsymf (MSVCRT.@)
  */
-int __cdecl MSVCRT___iscsymf(int c)
+int MSVCRT___iscsymf(int c)
 {
   return (c < 127 && (isalpha(c) || c == '_'));
 }
@@ -236,7 +235,7 @@
 /*********************************************************************
  *		_toupper (MSVCRT.@)
  */
-int __cdecl MSVCRT__toupper(int c)
+int MSVCRT__toupper(int c)
 {
     return c - 0x20;  /* sic */
 }
@@ -244,7 +243,7 @@
 /*********************************************************************
  *		_tolower (MSVCRT.@)
  */
-int __cdecl MSVCRT__tolower(int c)
+int MSVCRT__tolower(int c)
 {
     return c + 0x20;  /* sic */
 }
diff --git a/dlls/msvcrt/data.c b/dlls/msvcrt/data.c
index e6c641e..f710308 100644
--- a/dlls/msvcrt/data.c
+++ b/dlls/msvcrt/data.c
@@ -37,87 +37,87 @@
 int MSVCRT_timezone;
 int MSVCRT_app_type;
 
-typedef void (__cdecl *MSVCRT__INITTERMFUN)(void);
+typedef void (*_INITTERMFUN)(void);
 
 /***********************************************************************
  *		__p___argc (MSVCRT.@)
  */
-unsigned int *__cdecl MSVCRT___p___argc(void) { return &MSVCRT___argc; }
+unsigned int* __p___argc(void) { return &MSVCRT___argc; }
 
 /***********************************************************************
  *		__p__commode (MSVCRT.@)
  */
-unsigned int *__cdecl MSVCRT___p__commode(void) { return &MSVCRT__commode; }
+unsigned int* __p__commode(void) { return &MSVCRT__commode; }
 
 /***********************************************************************
  *		__p__fmode (MSVCRT.@)
  */
-unsigned int *__cdecl MSVCRT___p__fmode(void) { return &MSVCRT__fmode; }
+unsigned int* __p__fmode(void) { return &MSVCRT__fmode; }
 
 /***********************************************************************
  *		__p__osver (MSVCRT.@)
  */
-unsigned int *__cdecl MSVCRT___p__osver(void) { return &MSVCRT__osver; }
+unsigned int* __p__osver(void) { return &MSVCRT__osver; }
 
 /***********************************************************************
  *		__p__winmajor (MSVCRT.@)
  */
-unsigned int *__cdecl MSVCRT___p__winmajor(void) { return &MSVCRT__winmajor; }
+unsigned int* __p__winmajor(void) { return &MSVCRT__winmajor; }
 
 /***********************************************************************
  *		__p__winminor (MSVCRT.@)
  */
-unsigned int *__cdecl MSVCRT___p__winminor(void) { return &MSVCRT__winminor; }
+unsigned int* __p__winminor(void) { return &MSVCRT__winminor; }
 
 /***********************************************************************
  *		__p__winver (MSVCRT.@)
  */
-unsigned int *__cdecl MSVCRT___p__winver(void) { return &MSVCRT__winver; }
+unsigned int* __p__winver(void) { return &MSVCRT__winver; }
 
 /*********************************************************************
  *		__p__acmdln (MSVCRT.@)
  */
-char **__cdecl MSVCRT___p__acmdln(void) { return &MSVCRT__acmdln; }
+char** __p__acmdln(void) { return &MSVCRT__acmdln; }
 
 /*********************************************************************
  *		__p__wcmdln (MSVCRT.@)
  */
-WCHAR **__cdecl MSVCRT___p__wcmdln(void) { return &MSVCRT__wcmdln; }
+WCHAR** __p__wcmdln(void) { return &MSVCRT__wcmdln; }
 
 /*********************************************************************
  *		__p___argv (MSVCRT.@)
  */
-char ***__cdecl MSVCRT___p___argv(void) { return &MSVCRT___argv; }
+char*** __p___argv(void) { return &MSVCRT___argv; }
 
 /*********************************************************************
  *		__p___wargv (MSVCRT.@)
  */
-WCHAR ***__cdecl MSVCRT___p___wargv(void) { return &MSVCRT___wargv; }
+WCHAR*** __p___wargv(void) { return &MSVCRT___wargv; }
 
 /*********************************************************************
  *		__p__environ (MSVCRT.@)
  */
-char **__cdecl MSVCRT___p__environ(void) { return &MSVCRT__environ; }
+char** __p__environ(void) { return &MSVCRT__environ; }
 
 /*********************************************************************
  *		__p__wenviron (MSVCRT.@)
  */
-WCHAR **__cdecl MSVCRT___p__wenviron(void) { return &MSVCRT__wenviron; }
+WCHAR** __p__wenviron(void) { return &MSVCRT__wenviron; }
 
 /*********************************************************************
  *		__p___initenv (MSVCRT.@)
  */
-char ***__cdecl MSVCRT___p___initenv(void) { return &MSVCRT___initenv; }
+char*** __p___initenv(void) { return &MSVCRT___initenv; }
 
 /*********************************************************************
  *		__p___winitenv (MSVCRT.@)
  */
-WCHAR ***__cdecl MSVCRT___p___winitenv(void) { return &MSVCRT___winitenv; }
+WCHAR*** __p___winitenv(void) { return &MSVCRT___winitenv; }
 
 /*********************************************************************
  *		__p__timezone (MSVCRT.@)
  */
-int *__cdecl MSVCRT___p__timezone(void) { return &MSVCRT_timezone; }
+int* __p__timezone(void) { return &MSVCRT_timezone; }
 
 /* INTERNAL: Create a wide string from an ascii string */
 static WCHAR *wstrdupa(const char *str)
@@ -135,19 +135,19 @@
  * program we simply return the data we've already initialised. This also means
  * you can call multiple times without leaking
  */
-void MSVCRT_init_args(void)
+void msvcrt_init_args(void)
 {
   char *cmdline, **xargv = NULL;
   WCHAR *wcmdline, **wxargv = NULL;
   int xargc,end,last_arg,afterlastspace;
   DWORD version;
 
-  MSVCRT__acmdln = MSVCRT__strdup( GetCommandLineA() );
+  MSVCRT__acmdln = _strdup( GetCommandLineA() );
   MSVCRT__wcmdln = wcmdline = wstrdupa(MSVCRT__acmdln);
 
   /* Make a copy of MSVCRT__acmdln to be able modify it.
      We will free it at the end of processing. */
-  cmdline = MSVCRT__strdup(MSVCRT__acmdln);
+  cmdline = _strdup(MSVCRT__acmdln);
 
   TRACE("got '%s', wide = '%s'\n", cmdline, debugstr_w(wcmdline));
 
@@ -187,7 +187,7 @@
 
       if (strlen(cmdline+afterlastspace))
       {
-        xargv[xargc] = MSVCRT__strdup(cmdline+afterlastspace);
+        xargv[xargc] = _strdup(cmdline+afterlastspace);
         wxargv[xargc] = wstrdupa(xargv[xargc]);
         xargc++;
         if (!last_arg) /* need to seek to the next arg ? */
@@ -224,7 +224,7 @@
 
 
 /* INTERNAL: free memory used by args */
-void MSVCRT_free_args(void)
+void msvcrt_free_args(void)
 {
   /* FIXME */
 }
@@ -232,7 +232,7 @@
 /*********************************************************************
  *		__getmainargs (MSVCRT.@)
  */
-void __cdecl MSVCRT___getmainargs(int *argc, char ***argv, char **environ,
+void __getmainargs(int *argc, char ***argv, char **environ,
                                   int expand_wildcards, int *new_mode)
 {
   TRACE("(%p,%p,%p,%d,%p).\n", argc, argv, environ, expand_wildcards, new_mode);
@@ -245,7 +245,7 @@
 /*********************************************************************
  *		__wgetmainargs (MSVCRT.@)
  */
-void __cdecl MSVCRT___wgetmainargs(int *argc, WCHAR ***wargv, WCHAR **wenviron,
+void __wgetmainargs(int *argc, WCHAR ***wargv, WCHAR **wenviron,
                                    int expand_wildcards, int *new_mode)
 {
   TRACE("(%p,%p,%p,%d,%p).\n", argc, wargv, wenviron, expand_wildcards, new_mode);
@@ -258,9 +258,9 @@
 /*********************************************************************
  *		_initterm (MSVCRT.@)
  */
-unsigned int __cdecl MSVCRT__initterm(MSVCRT__INITTERMFUN *start,MSVCRT__INITTERMFUN *end)
+unsigned int _initterm(_INITTERMFUN *start,_INITTERMFUN *end)
 {
-  MSVCRT__INITTERMFUN*current = start;
+  _INITTERMFUN* current = start;
 
   TRACE("(%p,%p)\n",start,end);
   while (current<end)
@@ -279,7 +279,7 @@
 /*********************************************************************
  *		__set_app_type (MSVCRT.@)
  */
-void __cdecl MSVCRT___set_app_type(int app_type)
+void MSVCRT___set_app_type(int app_type)
 {
   TRACE("(%d) %s application\n", app_type, app_type == 2 ? "Gui" : "Console");
   MSVCRT_app_type = app_type;
diff --git a/dlls/msvcrt/dir.c b/dlls/msvcrt/dir.c
index 2493e36..ca95f9a 100644
--- a/dlls/msvcrt/dir.c
+++ b/dlls/msvcrt/dir.c
@@ -35,7 +35,7 @@
   WCHAR          name[MAX_PATH];
 } MSVCRT_wfinddata_t;
 
-typedef struct __MSVCRT_diskfree_t {
+typedef struct msvcrt_diskfree_t {
   unsigned num_clusters;
   unsigned available;
   unsigned cluster_sectors;
@@ -43,7 +43,7 @@
 } MSVCRT_diskfree_t;
 
 /* INTERNAL: Translate finddata_t to PWIN32_FIND_DATAA */
-static void MSVCRT__fttofd(LPWIN32_FIND_DATAA fd, MSVCRT_finddata_t* ft)
+static void msvcrt_fttofd(LPWIN32_FIND_DATAA fd, MSVCRT_finddata_t* ft)
 {
   DWORD dw;
 
@@ -63,7 +63,7 @@
 }
 
 /* INTERNAL: Translate wfinddata_t to PWIN32_FIND_DATAA */
-static void MSVCRT__wfttofd(LPWIN32_FIND_DATAW fd, MSVCRT_wfinddata_t* ft)
+static void msvcrt_wfttofd(LPWIN32_FIND_DATAW fd, MSVCRT_wfinddata_t* ft)
 {
   DWORD dw;
 
@@ -82,21 +82,21 @@
   strcpyW(ft->name, fd->cFileName);
 }
 
-char * MSVCRT__strndup(const char *, unsigned int);
-LPWSTR __cdecl MSVCRT__wcsdup( LPCWSTR );
-LPWSTR __cdecl MSVCRT__wstrndup( LPCWSTR , unsigned int );
-char *__cdecl  MSVCRT_getenv(const char *);
-WCHAR *__cdecl wcscpy(WCHAR *,const WCHAR *);
-WCHAR *__cdecl wcsncpy(WCHAR *,const WCHAR *,unsigned int);
-WCHAR *__cdecl wcscat(WCHAR *,const WCHAR *);
-WCHAR *__cdecl wcschr(WCHAR *,WCHAR);
-WCHAR *__cdecl wcsrchr(WCHAR *,WCHAR);
-void __cdecl _splitpath(const char *,char *, char *,char *,char *);
+char* msvcrt_strndup(const char*, unsigned int);
+LPWSTR _wcsdup( LPCWSTR );
+LPWSTR msvcrt_wstrndup( LPCWSTR , unsigned int );
+char * MSVCRT_getenv(const char *);
+WCHAR *wcscpy(WCHAR *,const WCHAR *);
+WCHAR *wcsncpy(WCHAR *,const WCHAR *,unsigned int);
+WCHAR *wcscat(WCHAR *,const WCHAR *);
+WCHAR *wcschr(WCHAR *,WCHAR);
+WCHAR *wcsrchr(WCHAR *,WCHAR);
+void _splitpath(const char *,char *, char *,char *,char *);
 
 /*********************************************************************
  *		_chdir (MSVCRT.@)
  */
-int __cdecl MSVCRT__chdir(const char * newdir)
+int _chdir(const char * newdir)
 {
   if (!SetCurrentDirectoryA(newdir))
   {
@@ -109,7 +109,7 @@
 /*********************************************************************
  *		_wchdir (MSVCRT.@)
  */
-int __cdecl MSVCRT__wchdir(const WCHAR * newdir)
+int _wchdir(const WCHAR * newdir)
 {
   if (!SetCurrentDirectoryW(newdir))
   {
@@ -122,7 +122,7 @@
 /*********************************************************************
  *		_chdrive (MSVCRT.@)
  */
-int __cdecl MSVCRT__chdrive(int newdrive)
+int _chdrive(int newdrive)
 {
   char buffer[3] = "A:";
   buffer[0] += newdrive - 1;
@@ -139,7 +139,7 @@
 /*********************************************************************
  *		_findclose (MSVCRT.@)
  */
-int __cdecl MSVCRT__findclose(DWORD hand)
+int _findclose(DWORD hand)
 {
   TRACE(":handle %ld\n",hand);
   if (!FindClose((HANDLE)hand))
@@ -153,7 +153,7 @@
 /*********************************************************************
  *		_findfirst (MSVCRT.@)
  */
-DWORD __cdecl MSVCRT__findfirst(const char * fspec, MSVCRT_finddata_t* ft)
+DWORD _findfirst(const char * fspec, MSVCRT_finddata_t* ft)
 {
   WIN32_FIND_DATAA find_data;
   HANDLE hfind;
@@ -164,7 +164,7 @@
     MSVCRT__set_errno(GetLastError());
     return -1;
   }
-  MSVCRT__fttofd(&find_data,ft);
+  msvcrt_fttofd(&find_data,ft);
   TRACE(":got handle %d\n",hfind);
   return hfind;
 }
@@ -172,7 +172,7 @@
 /*********************************************************************
  *		_wfindfirst (MSVCRT.@)
  */
-DWORD __cdecl MSVCRT__wfindfirst(const WCHAR * fspec, MSVCRT_wfinddata_t* ft)
+DWORD _wfindfirst(const WCHAR * fspec, MSVCRT_wfinddata_t* ft)
 {
   WIN32_FIND_DATAW find_data;
   HANDLE hfind;
@@ -183,7 +183,7 @@
     MSVCRT__set_errno(GetLastError());
     return -1;
   }
-  MSVCRT__wfttofd(&find_data,ft);
+  msvcrt_wfttofd(&find_data,ft);
   TRACE(":got handle %d\n",hfind);
   return hfind;
 }
@@ -191,7 +191,7 @@
 /*********************************************************************
  *		_findnext (MSVCRT.@)
  */
-int __cdecl MSVCRT__findnext(DWORD hand, MSVCRT_finddata_t * ft)
+int _findnext(DWORD hand, MSVCRT_finddata_t * ft)
 {
   WIN32_FIND_DATAA find_data;
 
@@ -201,14 +201,14 @@
     return -1;
   }
 
-  MSVCRT__fttofd(&find_data,ft);
+  msvcrt_fttofd(&find_data,ft);
   return 0;
 }
 
 /*********************************************************************
  *		_wfindnext (MSVCRT.@)
  */
-int __cdecl MSVCRT__wfindnext(DWORD hand, MSVCRT_wfinddata_t * ft)
+int _wfindnext(DWORD hand, MSVCRT_wfinddata_t * ft)
 {
   WIN32_FIND_DATAW find_data;
 
@@ -218,14 +218,14 @@
     return -1;
   }
 
-  MSVCRT__wfttofd(&find_data,ft);
+  msvcrt_wfttofd(&find_data,ft);
   return 0;
 }
 
 /*********************************************************************
  *		_getcwd (MSVCRT.@)
  */
-char* __cdecl MSVCRT__getcwd(char * buf, int size)
+char* _getcwd(char * buf, int size)
 {
   char dir[_MAX_PATH];
   int dir_len = GetCurrentDirectoryA(MAX_PATH,dir);
@@ -236,8 +236,8 @@
   if (!buf)
   {
     if (size < 0)
-      return MSVCRT__strdup(dir);
-    return MSVCRT__strndup(dir,size);
+      return _strdup(dir);
+    return msvcrt_strndup(dir,size);
   }
   if (dir_len >= size)
   {
@@ -251,7 +251,7 @@
 /*********************************************************************
  *		_wgetcwd (MSVCRT.@)
  */
-WCHAR* __cdecl MSVCRT__wgetcwd(WCHAR * buf, int size)
+WCHAR* _wgetcwd(WCHAR * buf, int size)
 {
   WCHAR dir[_MAX_PATH];
   int dir_len = GetCurrentDirectoryW(MAX_PATH,dir);
@@ -262,8 +262,8 @@
   if (!buf)
   {
     if (size < 0)
-      return MSVCRT__wcsdup(dir);
-    return MSVCRT__wstrndup(dir,size);
+      return _wcsdup(dir);
+    return msvcrt_wstrndup(dir,size);
   }
   if (dir_len >= size)
   {
@@ -277,7 +277,7 @@
 /*********************************************************************
  *		_getdrive (MSVCRT.@)
  */
-int __cdecl MSVCRT__getdrive(void)
+int _getdrive(void)
 {
     char buffer[MAX_PATH];
     if (!GetCurrentDirectoryA( sizeof(buffer), buffer )) return 0;
@@ -288,14 +288,14 @@
 /*********************************************************************
  *		_getdcwd (MSVCRT.@)
  */
-char* __cdecl MSVCRT__getdcwd(int drive, char * buf, int size)
+char* _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 == MSVCRT__getdrive())
-    return MSVCRT__getcwd(buf,size); /* current */
+  if (!drive || drive == _getdrive())
+    return _getcwd(buf,size); /* current */
   else
   {
     char dir[_MAX_PATH];
@@ -318,7 +318,7 @@
 
     TRACE(":returning '%s'\n", dir);
     if (!buf)
-      return MSVCRT__strdup(dir); /* allocate */
+      return _strdup(dir); /* allocate */
 
     strcpy(buf,dir);
   }
@@ -328,14 +328,14 @@
 /*********************************************************************
  *		_wgetdcwd (MSVCRT.@)
  */
-WCHAR* __cdecl MSVCRT__wgetdcwd(int drive, WCHAR * buf, int size)
+WCHAR* _wgetdcwd(int drive, WCHAR * buf, int size)
 {
   static WCHAR* dummy;
 
   TRACE(":drive %d(%c), size %d\n",drive, drive + 'A' - 1, size);
 
-  if (!drive || drive == MSVCRT__getdrive())
-    return MSVCRT__wgetcwd(buf,size); /* current */
+  if (!drive || drive == _getdrive())
+    return _wgetcwd(buf,size); /* current */
   else
   {
     WCHAR dir[_MAX_PATH];
@@ -358,7 +358,7 @@
 
     TRACE(":returning '%s'\n", debugstr_w(dir));
     if (!buf)
-      return MSVCRT__wcsdup(dir); /* allocate */
+      return _wcsdup(dir); /* allocate */
     strcpyW(buf,dir);
   }
   return buf;
@@ -367,7 +367,7 @@
 /*********************************************************************
  *		_getdiskfree (MSVCRT.@)
  */
-unsigned int __cdecl MSVCRT__getdiskfree(unsigned int disk, MSVCRT_diskfree_t* d)
+unsigned int _getdiskfree(unsigned int disk, MSVCRT_diskfree_t* d)
 {
   char drivespec[4] = {'@', ':', '\\', 0};
   DWORD ret[4];
@@ -394,7 +394,7 @@
 /*********************************************************************
  *		_mkdir (MSVCRT.@)
  */
-int __cdecl MSVCRT__mkdir(const char * newdir)
+int _mkdir(const char * newdir)
 {
   if (CreateDirectoryA(newdir,NULL))
     return 0;
@@ -405,7 +405,7 @@
 /*********************************************************************
  *		_wmkdir (MSVCRT.@)
  */
-int __cdecl MSVCRT__wmkdir(const WCHAR* newdir)
+int _wmkdir(const WCHAR* newdir)
 {
   if (CreateDirectoryW(newdir,NULL))
     return 0;
@@ -416,7 +416,7 @@
 /*********************************************************************
  *		_rmdir (MSVCRT.@)
  */
-int __cdecl MSVCRT__rmdir(const char * dir)
+int _rmdir(const char * dir)
 {
   if (RemoveDirectoryA(dir))
     return 0;
@@ -427,7 +427,7 @@
 /*********************************************************************
  *		_wrmdir (MSVCRT.@)
  */
-int __cdecl MSVCRT__wrmdir(const WCHAR * dir)
+int _wrmdir(const WCHAR * dir)
 {
   if (RemoveDirectoryW(dir))
     return 0;
@@ -438,7 +438,7 @@
 /*********************************************************************
  *		_wsplitpath (MSVCRT.@)
  */
-void __cdecl MSVCRT__wsplitpath(const WCHAR *inpath, WCHAR *drv, WCHAR *dir,
+void _wsplitpath(const WCHAR *inpath, WCHAR *drv, WCHAR *dir,
                                 WCHAR *fname, WCHAR *ext )
 {
   /* Modified PD code from 'snippets' collection. */
@@ -523,7 +523,7 @@
 }
 
 /* INTERNAL: Helper for _fullpath. Modified PD code from 'snippets'. */
-static void fln_fix(char *path)
+static void msvcrt_fln_fix(char *path)
 {
   int dir_flag = 0, root_flag = 0;
   char *r, *p, *q, *s;
@@ -627,7 +627,7 @@
 /*********************************************************************
  *		_fullpath (MSVCRT.@)
  */
-char *__cdecl MSVCRT__fullpath(char * absPath, const char* relPath, unsigned int size)
+char *_fullpath(char * absPath, const char* relPath, unsigned int size)
 {
   char drive[5],dir[MAX_PATH],file[MAX_PATH],ext[MAX_PATH];
   char res[MAX_PATH];
@@ -636,7 +636,7 @@
   res[0] = '\0';
 
   if (!relPath || !*relPath)
-    return MSVCRT__getcwd(absPath, size);
+    return _getcwd(absPath, size);
 
   if (size < 4)
   {
@@ -652,7 +652,7 @@
   if (!dir[0] || (dir[0] != '/' && dir[0] != '\\'))
   {
     /* Relative or no directory given */
-    MSVCRT__getdcwd(drive[0] ? toupper(drive[0]) - 'A' + 1 :  0, res, MAX_PATH);
+    _getdcwd(drive[0] ? toupper(drive[0]) - 'A' + 1 :  0, res, MAX_PATH);
     strcat(res,"\\");
     if (dir[0])
       strcat(res,dir);
@@ -668,14 +668,14 @@
   strcat(res,"\\");
   strcat(res, file);
   strcat(res, ext);
-  fln_fix(res);
+  msvcrt_fln_fix(res);
 
   len = strlen(res);
   if (len >= MAX_PATH || len >= (size_t)size)
     return NULL; /* FIXME: errno? */
 
   if (!absPath)
-    return MSVCRT__strdup(res);
+    return _strdup(res);
   strcpy(absPath,res);
   return absPath;
 }
@@ -683,12 +683,12 @@
 /*********************************************************************
  *		_makepath (MSVCRT.@)
  */
-VOID __cdecl MSVCRT__makepath(char * path, const char * drive,
+VOID _makepath(char * path, const char * drive,
                               const char *directory, const char * filename,
                               const char * extension )
 {
     char ch;
-    TRACE("MSVCRT__makepath got %s %s %s %s\n", drive, directory,
+    TRACE("_makepath got %s %s %s %s\n", drive, directory,
           filename, extension);
 
     if ( !path )
@@ -719,14 +719,14 @@
         }
     }
 
-    TRACE("MSVCRT__makepath returns %s\n",path);
+    TRACE("_makepath returns %s\n",path);
 }
 
 
 /*********************************************************************
  *		_searchenv (MSVCRT.@)
  */
-void __cdecl MSVCRT__searchenv(const char* file, const char* env, char *buf)
+void _searchenv(const char* file, const char* env, char *buf)
 {
   char*envVal, *penv;
   char curPath[MAX_PATH];
diff --git a/dlls/msvcrt/environ.c b/dlls/msvcrt/environ.c
index 03990d1..c1c5e8e 100644
--- a/dlls/msvcrt/environ.c
+++ b/dlls/msvcrt/environ.c
@@ -11,12 +11,12 @@
 
 DEFAULT_DEBUG_CHANNEL(msvcrt);
 
-LPWSTR __cdecl wcsrchr( LPWSTR str, WCHAR ch );
+LPWSTR wcsrchr( LPWSTR str, WCHAR ch );
 
 /*********************************************************************
  *		getenv (MSVCRT.@)
  */
-char *__cdecl MSVCRT_getenv(const char *name)
+char *MSVCRT_getenv(const char *name)
 {
   char *environ = GetEnvironmentStringsA();
   char *pp,*pos = NULL;
@@ -43,7 +43,7 @@
 /*********************************************************************
  *		_wgetenv (MSVCRT.@)
  */
-WCHAR *__cdecl MSVCRT__wgetenv(const WCHAR *name)
+WCHAR *_wgetenv(const WCHAR *name)
 {
   WCHAR* environ = GetEnvironmentStringsW();
   WCHAR* pp,*pos = NULL;
@@ -70,7 +70,7 @@
 /*********************************************************************
  *		_putenv (MSVCRT.@)
  */
-int __cdecl MSVCRT__putenv(const char *str)
+int _putenv(const char *str)
 {
  char name[256], value[512];
  char *dst = name;
@@ -95,7 +95,7 @@
 /*********************************************************************
  *		_wputenv (MSVCRT.@)
  */
-int __cdecl MSVCRT__wputenv(const WCHAR *str)
+int _wputenv(const WCHAR *str)
 {
  WCHAR name[256], value[512];
  WCHAR *dst = name;
diff --git a/dlls/msvcrt/errno.c b/dlls/msvcrt/errno.c
index 7ba487c..31682c6 100644
--- a/dlls/msvcrt/errno.c
+++ b/dlls/msvcrt/errno.c
@@ -73,7 +73,7 @@
 /*********************************************************************
  *		_errno (MSVCRT.@)
  */
-int *__cdecl MSVCRT__errno(void)
+int* MSVCRT__errno(void)
 {
   return GET_THREAD_VAR_PTR(errno);
 }
@@ -81,7 +81,7 @@
 /*********************************************************************
  *		__doserrno (MSVCRT.@)
  */
-int *__cdecl MSVCRT___doserrno(void)
+int* __doserrno(void)
 {
   return GET_THREAD_VAR_PTR(doserrno);
 }
@@ -91,7 +91,7 @@
 /*********************************************************************
  *		strerror (MSVCRT.@)
  */
-char * __cdecl MSVCRT_strerror (int err)
+char* MSVCRT_strerror(int err)
 {
   return strerror(err); /* FIXME */
 }
@@ -101,19 +101,19 @@
  */
 extern int sprintf(char *str, const char *format, ...);
 
-const char *__cdecl MSVCRT__strerror (const char *err)
+const char* _strerror(const char* err)
 {
   static char strerrbuff[256]; /* FIXME: Per thread, nprintf */
   sprintf(strerrbuff,"%s: %s\n",err,MSVCRT_strerror(GET_THREAD_VAR(errno)));
   return strerrbuff;
 }
 
-int __cdecl MSVCRT__cprintf( const char * format, ... );
+int _cprintf( const char * format, ... );
 
 /*********************************************************************
  *		perror (MSVCRT.@)
  */
-void __cdecl MSVCRT_perror (const char *str)
+void MSVCRT_perror(const char *str)
 {
-  MSVCRT__cprintf("%s: %s\n",str,MSVCRT_strerror(GET_THREAD_VAR(errno)));
+  _cprintf("%s: %s\n",str,MSVCRT_strerror(GET_THREAD_VAR(errno)));
 }
diff --git a/dlls/msvcrt/except.c b/dlls/msvcrt/except.c
index ba26117..d13c604 100644
--- a/dlls/msvcrt/except.c
+++ b/dlls/msvcrt/except.c
@@ -21,8 +21,8 @@
 typedef struct _SCOPETABLE
 {
   DWORD previousTryLevel;
-  int (__cdecl *lpfnFilter)(PEXCEPTION_POINTERS);
-  int (__cdecl *lpfnHandler)(void);
+  int (*lpfnFilter)(PEXCEPTION_POINTERS);
+  int (*lpfnHandler)(void);
 } SCOPETABLE, *PSCOPETABLE;
 
 typedef struct _MSVCRT_EXCEPTION_FRAME
@@ -44,10 +44,10 @@
   __asm__ __volatile__ ("movl %0,%%eax; movl %1,%%ebp; call *%%eax" \
                         : : "g" (code_block), "g" (base_ptr))
 
-static DWORD __cdecl MSVCRT_nested_handler(PEXCEPTION_RECORD rec,
-                                           struct __EXCEPTION_FRAME *frame,
-                                           PCONTEXT context WINE_UNUSED,
-                                           struct __EXCEPTION_FRAME **dispatch)
+static DWORD MSVCRT_nested_handler(PEXCEPTION_RECORD rec,
+                                   struct __EXCEPTION_FRAME* frame,
+                                   PCONTEXT context WINE_UNUSED,
+                                   struct __EXCEPTION_FRAME** dispatch)
 {
   if (rec->ExceptionFlags & 0x6)
     return ExceptionContinueSearch;
@@ -60,7 +60,7 @@
 /*********************************************************************
  *		_XcptFilter (MSVCRT.@)
  */
-int __cdecl MSVCRT__XcptFilter(int ex, PEXCEPTION_POINTERS ptr)
+int _XcptFilter(int ex, PEXCEPTION_POINTERS ptr)
 {
   FIXME("(%d,%p)semi-stub\n", ex, ptr);
   return UnhandledExceptionFilter(ptr);
@@ -71,7 +71,7 @@
  */
 #ifdef __i386__
 /* Provided for VC++ binary compatability only */
-__ASM_GLOBAL_FUNC(MSVCRT__EH_prolog,
+__ASM_GLOBAL_FUNC(_EH_prolog,
                   "pushl $0xff\n\t"
                   "pushl %eax\n\t"
                   "pushl %fs:0\n\t"
@@ -86,7 +86,7 @@
 /*******************************************************************
  *		_global_unwind2 (MSVCRT.@)
  */
-void __cdecl MSVCRT__global_unwind2(PEXCEPTION_FRAME frame)
+void _global_unwind2(PEXCEPTION_FRAME frame)
 {
     TRACE("(%p)\n",frame);
     RtlUnwind( frame, 0, 0, 0 );
@@ -95,8 +95,8 @@
 /*******************************************************************
  *		_local_unwind2 (MSVCRT.@)
  */
-void __cdecl MSVCRT__local_unwind2(MSVCRT_EXCEPTION_FRAME *frame,
-                                   DWORD trylevel)
+void _local_unwind2(MSVCRT_EXCEPTION_FRAME* frame,
+                    DWORD trylevel)
 {
   MSVCRT_EXCEPTION_FRAME *curframe = frame;
   DWORD curtrylevel = 0xfe;
@@ -129,10 +129,10 @@
 /*********************************************************************
  *		_except_handler2 (MSVCRT.@)
  */
-int __cdecl MSVCRT__except_handler2(PEXCEPTION_RECORD rec,
-                                    PEXCEPTION_FRAME frame,
-                                    PCONTEXT context,
-                                    PEXCEPTION_FRAME *dispatcher)
+int _except_handler2(PEXCEPTION_RECORD rec,
+                     PEXCEPTION_FRAME frame,
+                     PCONTEXT context,
+                     PEXCEPTION_FRAME* dispatcher)
 {
   FIXME("exception %lx flags=%lx at %p handler=%p %p %p stub\n",
         rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress,
@@ -143,9 +143,9 @@
 /*********************************************************************
  *		_except_handler3 (MSVCRT.@)
  */
-int __cdecl MSVCRT__except_handler3(PEXCEPTION_RECORD rec,
-                                    MSVCRT_EXCEPTION_FRAME *frame,
-                                    PCONTEXT context,void *dispatcher)
+int _except_handler3(PEXCEPTION_RECORD rec,
+                     MSVCRT_EXCEPTION_FRAME* frame,
+                     PCONTEXT context, void* dispatcher)
 {
 #if defined(__GNUC__) && defined(__i386__)
   long retval, trylevel;
@@ -161,7 +161,7 @@
   if (rec->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND))
   {
     /* Unwinding the current frame */
-     MSVCRT__local_unwind2(frame, TRYLEVEL_END);
+     _local_unwind2(frame, TRYLEVEL_END);
     return ExceptionContinueSearch;
   }
   else
@@ -191,8 +191,8 @@
         if (retval == EXCEPTION_EXECUTE_HANDLER)
         {
           /* Unwind all higher frames, this one will handle the exception */
-          MSVCRT__global_unwind2((PEXCEPTION_FRAME)frame);
-          MSVCRT__local_unwind2(frame, trylevel);
+          _global_unwind2((PEXCEPTION_FRAME)frame);
+          _local_unwind2(frame, trylevel);
 
           /* Set our trylevel to the enclosing block, and call the __finally
            * code, which won't return
@@ -217,7 +217,7 @@
 /*********************************************************************
  *		_abnormal_termination (MSVCRT.@)
  */
-int __cdecl MSVCRT__abnormal_termination(void)
+int _abnormal_termination(void)
 {
   FIXME("(void)stub\n");
   return 0;
@@ -226,7 +226,7 @@
 /*******************************************************************
  *		_setjmp (MSVCRT.@)
  */
-int __cdecl MSVCRT__setjmp(LPDWORD *jmpbuf)
+int MSVCRT__setjmp(LPDWORD* jmpbuf)
 {
   FIXME(":(%p): stub\n",jmpbuf);
   return 0;
@@ -244,7 +244,7 @@
 /*********************************************************************
  *		longjmp (MSVCRT.@)
  */
-void __cdecl MSVCRT_longjmp(jmp_buf env, int val)
+void MSVCRT_longjmp(jmp_buf env, int val)
 {
   FIXME("MSVCRT_longjmp semistub, expect crash\n");
   longjmp(env, val);
@@ -253,7 +253,7 @@
 /*********************************************************************
  *		signal (MSVCRT.@)
  */
-void * __cdecl MSVCRT_signal(int sig, MSVCRT_sig_handler_func func)
+void* MSVCRT_signal(int sig, MSVCRT_sig_handler_func func)
 {
   FIXME("(%d %p):stub\n", sig, func);
   return (void*)-1;
diff --git a/dlls/msvcrt/exit.c b/dlls/msvcrt/exit.c
index 1c5c194..0311117 100644
--- a/dlls/msvcrt/exit.c
+++ b/dlls/msvcrt/exit.c
@@ -12,14 +12,14 @@
 #define LOCK_EXIT      EnterCriticalSection(&MSVCRT_exit_cs)
 #define UNLOCK_EXIT    LeaveCriticalSection(&MSVCRT_exit_cs)
 
-typedef void (__cdecl *MSVCRT_atexit_func)(void);
+typedef void (*MSVCRT_atexit_func)(void);
 
 static MSVCRT_atexit_func *MSVCRT_atexit_table = NULL;
 static int MSVCRT_atexit_table_size = 0;
 static int MSVCRT_atexit_registered = 0; /* Points to free slot */
 
 extern int MSVCRT_app_type;
-void *__cdecl MSVCRT_realloc(void *ptr, unsigned int size);
+void *MSVCRT_realloc(void *ptr, unsigned int size);
 
 /* INTERNAL: call atexit functions */
 void __MSVCRT__call_atexit(void)
@@ -40,7 +40,7 @@
 /*********************************************************************
  *		__dllonexit (MSVCRT.@)
  */
-MSVCRT_atexit_func __cdecl MSVCRT___dllonexit(MSVCRT_atexit_func func,
+MSVCRT_atexit_func __dllonexit(MSVCRT_atexit_func func,
                                               MSVCRT_atexit_func **start,
                                               MSVCRT_atexit_func **end)
 {
@@ -75,7 +75,7 @@
 /*********************************************************************
  *		_exit (MSVCRT.@)
  */
-void __cdecl MSVCRT__exit(int exitcode)
+void MSVCRT__exit(int exitcode)
 {
   TRACE("(%d)\n", exitcode);
   ExitProcess(exitcode);
@@ -84,7 +84,7 @@
 /*********************************************************************
  *		_amsg_exit (MSVCRT.@)
  */
-void __cdecl MSVCRT__amsg_exit(int errnum)
+void MSVCRT__amsg_exit(int errnum)
 {
   TRACE("(%d)\n", errnum);
   /* FIXME: text for the error number. */
@@ -92,42 +92,42 @@
   {
     /* FIXME: MsgBox */
   }
-  MSVCRT__cprintf("\nruntime error R60%d\n",errnum);
+  _cprintf("\nruntime error R60%d\n",errnum);
   MSVCRT__exit(255);
 }
 
 /*********************************************************************
  *		abort (MSVCRT.@)
  */
-void __cdecl MSVCRT_abort(void)
+void MSVCRT_abort(void)
 {
   TRACE("(void)\n");
   if (MSVCRT_app_type == 2)
   {
     /* FIXME: MsgBox */
   }
-  MSVCRT__cputs("\nabnormal program termination\n");
+  _cputs("\nabnormal program termination\n");
   MSVCRT__exit(3);
 }
 
 /*********************************************************************
  *		_assert (MSVCRT.@)
  */
-void __cdecl MSVCRT__assert(const char* str, const char* file, unsigned int line)
+void MSVCRT__assert(const char* str, const char* file, unsigned int line)
 {
   TRACE("(%s,%s,%d)\n",str,file,line);
   if (MSVCRT_app_type == 2)
   {
     /* FIXME: MsgBox */
   }
-  MSVCRT__cprintf("Assertion failed: %s, file %s, line %d\n\n",str,file, line);
+  _cprintf("Assertion failed: %s, file %s, line %d\n\n",str,file, line);
   MSVCRT_abort();
 }
 
 /*********************************************************************
  *		_c_exit (MSVCRT.@)
  */
-void __cdecl MSVCRT__c_exit(void)
+void MSVCRT__c_exit(void)
 {
   TRACE("(void)\n");
   /* All cleanup is done on DLL detach; Return to caller */
@@ -136,7 +136,7 @@
 /*********************************************************************
  *		_cexit (MSVCRT.@)
  */
-void __cdecl MSVCRT__cexit(void)
+void MSVCRT__cexit(void)
 {
   TRACE("(void)\n");
   /* All cleanup is done on DLL detach; Return to caller */
@@ -145,7 +145,7 @@
 /*********************************************************************
  *		_onexit (MSVCRT.@)
  */
- MSVCRT_atexit_func __cdecl MSVCRT__onexit(MSVCRT_atexit_func func)
+ MSVCRT_atexit_func _onexit(MSVCRT_atexit_func func)
 {
   TRACE("(%p)\n",func);
 
@@ -179,7 +179,7 @@
 /*********************************************************************
  *		exit (MSVCRT.@)
  */
-void __cdecl MSVCRT_exit(int exitcode)
+void MSVCRT_exit(int exitcode)
 {
   TRACE("(%d)\n",exitcode);
   LOCK_EXIT;
@@ -191,16 +191,16 @@
 /*********************************************************************
  *		atexit (MSVCRT.@)
  */
-int __cdecl MSVCRT_atexit(MSVCRT_atexit_func func)
+int MSVCRT_atexit(MSVCRT_atexit_func func)
 {
   TRACE("(%p)\n", func);
-  return MSVCRT__onexit(func) == func ? 0 : -1;
+  return _onexit(func) == func ? 0 : -1;
 }
 
 /*********************************************************************
  *		_purecall (MSVCRT.@)
  */
-void __cdecl MSVCRT__purecall(void)
+void _purecall(void)
 {
   TRACE("(void)\n");
   MSVCRT__amsg_exit( 25 );
diff --git a/dlls/msvcrt/file.c b/dlls/msvcrt/file.c
index 13c3073..e00f126 100644
--- a/dlls/msvcrt/file.c
+++ b/dlls/msvcrt/file.c
@@ -134,17 +134,17 @@
 #define LOCK_FILES     EnterCriticalSection(&MSVCRT_file_cs)
 #define UNLOCK_FILES   LeaveCriticalSection(&MSVCRT_file_cs)
 
-time_t __cdecl MSVCRT_time(time_t *);
-int __cdecl MSVCRT__getdrive(void);
-WCHAR *__cdecl MSVCRT__wcsdup(const WCHAR *);
-unsigned int __cdecl wcslen(const WCHAR*);
-int __cdecl iswalpha(WCHAR);
-int __cdecl towupper(WCHAR);
-int __cdecl towlower(WCHAR);
-int __cdecl MSVCRT__vsnwprintf(WCHAR *,unsigned int,const WCHAR *,va_list);
+time_t MSVCRT_time(time_t *);
+int _getdrive(void);
+WCHAR *_wcsdup(const WCHAR *);
+unsigned int wcslen(const WCHAR*);
+int iswalpha(WCHAR);
+int towupper(WCHAR);
+int towlower(WCHAR);
+int _vsnwprintf(WCHAR *,unsigned int,const WCHAR *,va_list);
 
 /* INTERNAL: Get the HANDLE for a fd */
-static HANDLE MSVCRT__fdtoh(int fd)
+static HANDLE msvcrt_fdtoh(int fd)
 {
   if (fd < 0 || fd >= MSVCRT_fdend ||
       MSVCRT_handles[fd] == INVALID_HANDLE_VALUE)
@@ -158,7 +158,7 @@
 }
 
 /* INTERNAL: free a file entry fd */
-static void MSVCRT__free_fd(int fd)
+static void msvcrt_free_fd(int fd)
 {
   MSVCRT_handles[fd] = INVALID_HANDLE_VALUE;
   MSVCRT_files[fd] = 0;
@@ -173,7 +173,7 @@
 }
 
 /* INTERNAL: Allocate an fd slot from a Win32 HANDLE */
-static int MSVCRT__alloc_fd(HANDLE hand, int flag)
+static int msvcrt_alloc_fd(HANDLE hand, int flag)
 {
   int fd = MSVCRT_fdstart;
 
@@ -201,7 +201,7 @@
  * This is done lazily to avoid memory wastage for low level open/write
  * usage when a FILE* is not requested (but may be later).
  */
-static MSVCRT_FILE* MSVCRT__alloc_fp(int fd)
+static MSVCRT_FILE* msvcrt_alloc_fp(int fd)
 {
   TRACE(":fd (%d) allocating FILE*\n",fd);
   if (fd < 0 || fd >= MSVCRT_fdend ||
@@ -227,7 +227,7 @@
 
 
 /* INTERNAL: Set up stdin, stderr and stdout */
-void MSVCRT_init_io(void)
+void msvcrt_init_io(void)
 {
   int i;
   memset(MSVCRT__iob,0,3*sizeof(MSVCRT_FILE));
@@ -253,7 +253,7 @@
 /*********************************************************************
  *		__p__iob(MSVCRT.@)
  */
-MSVCRT_FILE *MSVCRT___p__iob(void)
+MSVCRT_FILE *__p__iob(void)
 {
  return &MSVCRT__iob[0];
 }
@@ -261,7 +261,7 @@
 /*********************************************************************
  *		_access (MSVCRT.@)
  */
-int __cdecl MSVCRT__access(const char *filename, int mode)
+int _access(const char *filename, int mode)
 {
   DWORD attr = GetFileAttributesA(filename);
 
@@ -283,7 +283,7 @@
 /*********************************************************************
  *		_waccess (MSVCRT.@)
  */
-int __cdecl MSVCRT__waccess(const WCHAR *filename, int mode)
+int _waccess(const WCHAR *filename, int mode)
 {
   DWORD attr = GetFileAttributesW(filename);
 
@@ -305,7 +305,7 @@
 /*********************************************************************
  *		_chmod (MSVCRT.@)
  */
-int __cdecl MSVCRT__chmod(const char *path, int flags)
+int _chmod(const char *path, int flags)
 {
   DWORD oldFlags = GetFileAttributesA(path);
 
@@ -324,7 +324,7 @@
 /*********************************************************************
  *		_wchmod (MSVCRT.@)
  */
-int __cdecl MSVCRT__wchmod(const WCHAR *path, int flags)
+int _wchmod(const WCHAR *path, int flags)
 {
   DWORD oldFlags = GetFileAttributesW(path);
 
@@ -343,7 +343,7 @@
 /*********************************************************************
  *		_unlink (MSVCRT.@)
  */
-int __cdecl MSVCRT__unlink(const char *path)
+int _unlink(const char *path)
 {
   TRACE("(%s)\n",path);
   if(DeleteFileA(path))
@@ -356,7 +356,7 @@
 /*********************************************************************
  *		_wunlink (MSVCRT.@)
  */
-int __cdecl MSVCRT__wunlink(const WCHAR *path)
+int _wunlink(const WCHAR *path)
 {
   TRACE("(%s)\n",debugstr_w(path));
   if(DeleteFileW(path))
@@ -369,9 +369,9 @@
 /*********************************************************************
  *		_close (MSVCRT.@)
  */
-int __cdecl MSVCRT__close(int fd)
+int _close(int fd)
 {
-  HANDLE hand = MSVCRT__fdtoh(fd);
+  HANDLE hand = msvcrt_fdtoh(fd);
 
   TRACE(":fd (%d) handle (%d)\n",fd,hand);
   if (hand == INVALID_HANDLE_VALUE)
@@ -381,7 +381,7 @@
   if (fd > 2 && MSVCRT_files[fd])
     MSVCRT_free(MSVCRT_files[fd]);
 
-  MSVCRT__free_fd(fd);
+  msvcrt_free_fd(fd);
 
   if (!CloseHandle(hand))
   {
@@ -392,7 +392,7 @@
   if (MSVCRT_tempfiles[fd])
   {
     TRACE("deleting temporary file '%s'\n",MSVCRT_tempfiles[fd]);
-    MSVCRT__unlink(MSVCRT_tempfiles[fd]);
+    _unlink(MSVCRT_tempfiles[fd]);
     MSVCRT_free(MSVCRT_tempfiles[fd]);
     MSVCRT_tempfiles[fd] = NULL;
   }
@@ -404,9 +404,9 @@
 /*********************************************************************
  *		_commit (MSVCRT.@)
  */
-int __cdecl MSVCRT__commit(int fd)
+int _commit(int fd)
 {
-  HANDLE hand = MSVCRT__fdtoh(fd);
+  HANDLE hand = msvcrt_fdtoh(fd);
 
   TRACE(":fd (%d) handle (%d)\n",fd,hand);
   if (hand == INVALID_HANDLE_VALUE)
@@ -432,10 +432,10 @@
 /*********************************************************************
  *		_eof (MSVCRT.@)
  */
-int __cdecl MSVCRT__eof(int fd)
+int _eof(int fd)
 {
   DWORD curpos,endpos;
-  HANDLE hand = MSVCRT__fdtoh(fd);
+  HANDLE hand = msvcrt_fdtoh(fd);
 
   TRACE(":fd (%d) handle (%d)\n",fd,hand);
 
@@ -462,14 +462,14 @@
 /*********************************************************************
  *		_fcloseall (MSVCRT.@)
  */
-int __cdecl MSVCRT__fcloseall(void)
+int _fcloseall(void)
 {
   int num_closed = 0, i;
 
   for (i = 3; i < MSVCRT_fdend; i++)
     if (MSVCRT_handles[i] != INVALID_HANDLE_VALUE)
     {
-      MSVCRT__close(i);
+      _close(i);
       num_closed++;
     }
 
@@ -480,10 +480,10 @@
 /*********************************************************************
  *		_lseek (MSVCRT.@)
  */
-LONG __cdecl MSVCRT__lseek(int fd, LONG offset, int whence)
+LONG _lseek(int fd, LONG offset, int whence)
 {
   DWORD ret;
-  HANDLE hand = MSVCRT__fdtoh(fd);
+  HANDLE hand = msvcrt_fdtoh(fd);
 
   TRACE(":fd (%d) handle (%d)\n",fd,hand);
   if (hand == INVALID_HANDLE_VALUE)
@@ -525,19 +525,19 @@
 /*********************************************************************
  *		rewind (MSVCRT.@)
  */
-void __cdecl MSVCRT_rewind(MSVCRT_FILE* file)
+void MSVCRT_rewind(MSVCRT_FILE* file)
 {
   TRACE(":file (%p) fd (%d)\n",file,file->_file);
-  MSVCRT__lseek(file->_file,0,SEEK_SET);
+  _lseek(file->_file,0,SEEK_SET);
   file->_flag &= ~(_IOEOF | _IOERR);
 }
 
 /*********************************************************************
  *		_fdopen (MSVCRT.@)
  */
-MSVCRT_FILE* __cdecl MSVCRT__fdopen(int fd, const char *mode)
+MSVCRT_FILE* _fdopen(int fd, const char *mode)
 {
-  MSVCRT_FILE* file = MSVCRT__alloc_fp(fd);
+  MSVCRT_FILE* file = msvcrt_alloc_fp(fd);
 
   TRACE(":fd (%d) mode (%s) FILE* (%p)\n",fd,mode,file);
   if (file)
@@ -549,9 +549,9 @@
 /*********************************************************************
  *		_wfdopen (MSVCRT.@)
  */
-MSVCRT_FILE* __cdecl MSVCRT__wfdopen(int fd, const WCHAR *mode)
+MSVCRT_FILE* _wfdopen(int fd, const WCHAR *mode)
 {
-  MSVCRT_FILE* file = MSVCRT__alloc_fp(fd);
+  MSVCRT_FILE* file = msvcrt_alloc_fp(fd);
 
   TRACE(":fd (%d) mode (%s) FILE* (%p)\n",fd,debugstr_w(mode),file);
   if (file)
@@ -563,16 +563,16 @@
 /*********************************************************************
  *		_filelength (MSVCRT.@)
  */
-LONG __cdecl MSVCRT__filelength(int fd)
+LONG _filelength(int fd)
 {
-  LONG curPos = MSVCRT__lseek(fd, 0, SEEK_CUR);
+  LONG curPos = _lseek(fd, 0, SEEK_CUR);
   if (curPos != -1)
   {
-    LONG endPos = MSVCRT__lseek(fd, 0, SEEK_END);
+    LONG endPos = _lseek(fd, 0, SEEK_END);
     if (endPos != -1)
     {
       if (endPos != curPos)
-        MSVCRT__lseek(fd, curPos, SEEK_SET);
+        _lseek(fd, curPos, SEEK_SET);
       return endPos;
     }
   }
@@ -582,7 +582,7 @@
 /*********************************************************************
  *		_fileno (MSVCRT.@)
  */
-int __cdecl MSVCRT__fileno(MSVCRT_FILE* file)
+int _fileno(MSVCRT_FILE* file)
 {
   TRACE(":FILE* (%p) fd (%d)\n",file,file->_file);
   return file->_file;
@@ -591,14 +591,14 @@
 /*********************************************************************
  *		_flushall (MSVCRT.@)
  */
-int __cdecl MSVCRT__flushall(void)
+int _flushall(void)
 {
   int num_flushed = 0, i = 3;
 
   while(i < MSVCRT_fdend)
     if (MSVCRT_handles[i] != INVALID_HANDLE_VALUE)
     {
-      if (MSVCRT__commit(i) == -1)
+      if (_commit(i) == -1)
 	if (MSVCRT_files[i])
 	  MSVCRT_files[i]->_flag |= _IOERR;
       num_flushed++;
@@ -611,11 +611,11 @@
 /*********************************************************************
  *		_fstat (MSVCRT.@)
  */
-int __cdecl MSVCRT__fstat(int fd, struct _stat* buf)
+int _fstat(int fd, struct _stat* buf)
 {
   DWORD dw;
   BY_HANDLE_FILE_INFORMATION hfi;
-  HANDLE hand = MSVCRT__fdtoh(fd);
+  HANDLE hand = msvcrt_fdtoh(fd);
 
   TRACE(":fd (%d) stat (%p)\n",fd,buf);
   if (hand == INVALID_HANDLE_VALUE)
@@ -649,9 +649,9 @@
 /*********************************************************************
  *		_futime (MSVCRT.@)
  */
-int __cdecl MSVCRT__futime(int fd, struct _utimbuf *t)
+int _futime(int fd, struct _utimbuf *t)
 {
-  HANDLE hand = MSVCRT__fdtoh(fd);
+  HANDLE hand = msvcrt_fdtoh(fd);
   FILETIME at, wt;
 
   if (!t)
@@ -681,9 +681,9 @@
 /*********************************************************************
  *		_get_osfhandle (MSVCRT.@)
  */
-HANDLE MSVCRT__get_osfhandle(int fd)
+HANDLE _get_osfhandle(int fd)
 {
-  HANDLE hand = MSVCRT__fdtoh(fd);
+  HANDLE hand = msvcrt_fdtoh(fd);
   HANDLE newhand = hand;
   TRACE(":fd (%d) handle (%d)\n",fd,hand);
 
@@ -707,9 +707,9 @@
 /*********************************************************************
  *		_isatty (MSVCRT.@)
  */
-int __cdecl MSVCRT__isatty(int fd)
+int _isatty(int fd)
 {
-  HANDLE hand = MSVCRT__fdtoh(fd);
+  HANDLE hand = msvcrt_fdtoh(fd);
 
   TRACE(":fd (%d) handle (%d)\n",fd,hand);
   if (hand == INVALID_HANDLE_VALUE)
@@ -721,7 +721,7 @@
 /*********************************************************************
  *		_mktemp (MSVCRT.@)
  */
-char *__cdecl MSVCRT__mktemp(char *pattern)
+char *_mktemp(char *pattern)
 {
   int numX = 0;
   char *retVal = pattern;
@@ -755,7 +755,7 @@
 /*********************************************************************
  *		_wmktemp (MSVCRT.@)
  */
-WCHAR *__cdecl MSVCRT__wmktemp(WCHAR *pattern)
+WCHAR *_wmktemp(WCHAR *pattern)
 {
   int numX = 0;
   WCHAR *retVal = pattern;
@@ -789,7 +789,7 @@
 /*********************************************************************
  *		_open (MSVCRT.@)
  */
-int __cdecl MSVCRT__open(const char *path,int flags)
+int _open(const char *path,int flags)
 {
   DWORD access = 0, creation = 0;
   int ioflag = 0, fd;
@@ -857,16 +857,16 @@
     return -1;
   }
 
-  fd = MSVCRT__alloc_fd(hand, ioflag);
+  fd = msvcrt_alloc_fd(hand, ioflag);
 
   TRACE(":fd (%d) handle (%d)\n",fd, hand);
 
   if (fd > 0)
   {
     if (flags & _O_TEMPORARY)
-      MSVCRT_tempfiles[fd] = MSVCRT__strdup(path);
+      MSVCRT_tempfiles[fd] = _strdup(path);
     if (ioflag & _IOAPPEND)
-      MSVCRT__lseek(fd, 0, FILE_END);
+      _lseek(fd, 0, FILE_END);
   }
 
   return fd;
@@ -875,13 +875,13 @@
 /*********************************************************************
  *		_wopen (MSVCRT.@)
  */
-int __cdecl MSVCRT__wopen(const WCHAR *path,int flags)
+int _wopen(const WCHAR *path,int flags)
 {
   const unsigned int len = wcslen(path);
   char *patha = MSVCRT_calloc(len + 1,1);
   if (patha && WideCharToMultiByte(CP_ACP,0,path,len,patha,len,NULL,NULL))
   {
-    int retval = MSVCRT__open(patha,flags);
+    int retval = _open(patha,flags);
     MSVCRT_free(patha);
     return retval;
   }
@@ -893,35 +893,35 @@
 /*********************************************************************
  *		_sopen (MSVCRT.@)
  */
-int __cdecl MSVCRT__sopen(const char *path,int oflags,int shflags)
+int MSVCRT__sopen(const char *path,int oflags,int shflags)
 {
-  return MSVCRT__open(path, oflags | shflags);
+  return _open(path, oflags | shflags);
 }
 
 /*********************************************************************
  *		_creat (MSVCRT.@)
  */
-int __cdecl MSVCRT__creat(const char *path, int flags)
+int _creat(const char *path, int flags)
 {
   int usedFlags = (flags & _O_TEXT)| _O_CREAT| _O_WRONLY| _O_TRUNC;
-  return MSVCRT__open(path, usedFlags);
+  return _open(path, usedFlags);
 }
 
 /*********************************************************************
  *		_wcreat (MSVCRT.@)
  */
-int __cdecl MSVCRT__wcreat(const WCHAR *path, int flags)
+int _wcreat(const WCHAR *path, int flags)
 {
   int usedFlags = (flags & _O_TEXT)| _O_CREAT| _O_WRONLY| _O_TRUNC;
-  return MSVCRT__wopen(path, usedFlags);
+  return _wopen(path, usedFlags);
 }
 
 /*********************************************************************
  *		_open_osfhandle (MSVCRT.@)
  */
-int __cdecl MSVCRT__open_osfhandle(HANDLE hand, int flags)
+int _open_osfhandle(HANDLE hand, int flags)
 {
-  int fd = MSVCRT__alloc_fd(hand,flags);
+  int fd = msvcrt_alloc_fd(hand,flags);
   TRACE(":handle (%d) fd (%d)\n",hand,fd);
   return fd;
 }
@@ -929,14 +929,14 @@
 /*********************************************************************
  *		_rmtmp (MSVCRT.@)
  */
-int __cdecl MSVCRT__rmtmp(void)
+int _rmtmp(void)
 {
   int num_removed = 0, i;
 
   for (i = 3; i < MSVCRT_fdend; i++)
     if (MSVCRT_tempfiles[i])
     {
-      MSVCRT__close(i);
+      _close(i);
       num_removed++;
     }
 
@@ -948,10 +948,10 @@
 /*********************************************************************
  *		_read (MSVCRT.@)
  */
-int __cdecl MSVCRT__read(int fd, void *buf, unsigned int count)
+int _read(int fd, void *buf, unsigned int count)
 {
   DWORD num_read;
-  HANDLE hand = MSVCRT__fdtoh(fd);
+  HANDLE hand = msvcrt_fdtoh(fd);
 
   /* Dont trace small reads, it gets *very* annoying */
   if (count > 4)
@@ -983,10 +983,10 @@
 /*********************************************************************
  *		_getw (MSVCRT.@)
  */
-int __cdecl MSVCRT__getw(MSVCRT_FILE* file)
+int _getw(MSVCRT_FILE* file)
 {
   int i;
-  if (MSVCRT__read(file->_file, &i, sizeof(int)) != 1)
+  if (_read(file->_file, &i, sizeof(int)) != 1)
     return MSVCRT_EOF;
   return i;
 }
@@ -994,7 +994,7 @@
 /*********************************************************************
  *		_setmode (MSVCRT.@)
  */
-int __cdecl MSVCRT__setmode(int fd,int mode)
+int _setmode(int fd,int mode)
 {
   if (mode & _O_TEXT)
     FIXME("fd (%d) mode (%d) TEXT not implemented\n",fd,mode);
@@ -1004,7 +1004,7 @@
 /*********************************************************************
  *		_stat (MSVCRT.@)
  */
-int __cdecl MSVCRT__stat(const char* path, struct _stat * buf)
+int _stat(const char* path, struct _stat * buf)
 {
   DWORD dw;
   WIN32_FILE_ATTRIBUTE_DATA hfi;
@@ -1026,7 +1026,7 @@
   if (isalpha(*path))
     buf->st_dev = buf->st_rdev = toupper(*path - 'A'); /* drive num */
   else
-    buf->st_dev = buf->st_rdev = MSVCRT__getdrive() - 1;
+    buf->st_dev = buf->st_rdev = _getdrive() - 1;
 
   plen = strlen(path);
 
@@ -1065,7 +1065,7 @@
 /*********************************************************************
  *		_wstat (MSVCRT.@)
  */
-int __cdecl MSVCRT__wstat(const WCHAR* path, struct _stat * buf)
+int _wstat(const WCHAR* path, struct _stat * buf)
 {
   DWORD dw;
   WIN32_FILE_ATTRIBUTE_DATA hfi;
@@ -1087,7 +1087,7 @@
   if (iswalpha(*path))
     buf->st_dev = buf->st_rdev = towupper(*path - (WCHAR)L'A'); /* drive num */
   else
-    buf->st_dev = buf->st_rdev = MSVCRT__getdrive() - 1;
+    buf->st_dev = buf->st_rdev = _getdrive() - 1;
 
   plen = wcslen(path);
 
@@ -1126,15 +1126,15 @@
 /*********************************************************************
  *		_tell (MSVCRT.@)
  */
-LONG __cdecl MSVCRT__tell(int fd)
+LONG _tell(int fd)
 {
-  return MSVCRT__lseek(fd, 0, SEEK_CUR);
+  return _lseek(fd, 0, SEEK_CUR);
 }
 
 /*********************************************************************
  *		_tempnam (MSVCRT.@)
  */
-char *__cdecl MSVCRT__tempnam(const char *dir, const char *prefix)
+char *_tempnam(const char *dir, const char *prefix)
 {
   char tmpbuf[MAX_PATH];
 
@@ -1142,7 +1142,7 @@
   if (GetTempFileNameA(dir,prefix,0,tmpbuf))
   {
     TRACE("got name (%s)\n",tmpbuf);
-    return MSVCRT__strdup(tmpbuf);
+    return _strdup(tmpbuf);
   }
   TRACE("failed (%ld)\n",GetLastError());
   return NULL;
@@ -1151,7 +1151,7 @@
 /*********************************************************************
  *		_wtempnam (MSVCRT.@)
  */
-WCHAR *__cdecl MSVCRT__wtempnam(const WCHAR *dir, const WCHAR *prefix)
+WCHAR *_wtempnam(const WCHAR *dir, const WCHAR *prefix)
 {
   WCHAR tmpbuf[MAX_PATH];
 
@@ -1159,7 +1159,7 @@
   if (GetTempFileNameW(dir,prefix,0,tmpbuf))
   {
     TRACE("got name (%s)\n",debugstr_w(tmpbuf));
-    return MSVCRT__wcsdup(tmpbuf);
+    return _wcsdup(tmpbuf);
   }
   TRACE("failed (%ld)\n",GetLastError());
   return NULL;
@@ -1168,7 +1168,7 @@
 /*********************************************************************
  *		_umask (MSVCRT.@)
  */
-int __cdecl MSVCRT__umask(int umask)
+int _umask(int umask)
 {
   int old_umask = MSVCRT_umask;
   TRACE("(%d)\n",umask);
@@ -1179,14 +1179,14 @@
 /*********************************************************************
  *		_utime (MSVCRT.@)
  */
-int __cdecl MSVCRT__utime(const char *path, struct _utimbuf *t)
+int _utime(const char* path, struct _utimbuf *t)
 {
-  int fd = MSVCRT__open(path, _O_WRONLY | _O_BINARY);
+  int fd = _open(path, _O_WRONLY | _O_BINARY);
 
   if (fd > 0)
   {
-    int retVal = MSVCRT__futime(fd, t);
-    MSVCRT__close(fd);
+    int retVal = _futime(fd, t);
+    _close(fd);
     return retVal;
   }
   return -1;
@@ -1195,14 +1195,14 @@
 /*********************************************************************
  *		_wutime (MSVCRT.@)
  */
-int __cdecl MSVCRT__wutime(const WCHAR *path, struct _utimbuf *t)
+int _wutime(const WCHAR* path, struct _utimbuf *t)
 {
-  int fd = MSVCRT__wopen(path, _O_WRONLY | _O_BINARY);
+  int fd = _wopen(path, _O_WRONLY | _O_BINARY);
 
   if (fd > 0)
   {
-    int retVal = MSVCRT__futime(fd, t);
-    MSVCRT__close(fd);
+    int retVal = _futime(fd, t);
+    _close(fd);
     return retVal;
   }
   return -1;
@@ -1211,10 +1211,10 @@
 /*********************************************************************
  *		_write (MSVCRT.@)
  */
-unsigned int __cdecl MSVCRT__write(int fd, const void *buf, unsigned int count)
+unsigned int _write(int fd, const void* buf, unsigned int count)
 {
   DWORD num_written;
-  HANDLE hand = MSVCRT__fdtoh(fd);
+  HANDLE hand = msvcrt_fdtoh(fd);
 
   /* Dont trace small writes, it gets *very* annoying */
 //  if (count > 32)
@@ -1224,7 +1224,7 @@
 
   /* If appending, go to EOF */
   if (MSVCRT_flags[fd] & _IOAPPEND)
-    MSVCRT__lseek(fd, 0, FILE_END);
+    _lseek(fd, 0, FILE_END);
 
   /* Set _cnt to 0 so optimised binaries will call our implementation
    * of putc/getc.
@@ -1246,15 +1246,15 @@
 /*********************************************************************
  *		_putw (MSVCRT.@)
  */
-int __cdecl MSVCRT__putw(int val, MSVCRT_FILE* file)
+int _putw(int val, MSVCRT_FILE* file)
 {
-  return MSVCRT__write(file->_file, &val, sizeof(val)) == 1? val : MSVCRT_EOF;
+  return _write(file->_file, &val, sizeof(val)) == 1? val : MSVCRT_EOF;
 }
 
 /*********************************************************************
  *		clearerr (MSVCRT.@)
  */
-void __cdecl MSVCRT_clearerr(MSVCRT_FILE* file)
+void MSVCRT_clearerr(MSVCRT_FILE* file)
 {
   TRACE(":file (%p) fd (%d)\n",file,file->_file);
   file->_flag &= ~(_IOERR | _IOEOF);
@@ -1263,15 +1263,15 @@
 /*********************************************************************
  *		fclose (MSVCRT.@)
  */
-int __cdecl MSVCRT_fclose(MSVCRT_FILE* file)
+int MSVCRT_fclose(MSVCRT_FILE* file)
 {
-  return MSVCRT__close(file->_file);
+  return _close(file->_file);
 }
 
 /*********************************************************************
  *		feof (MSVCRT.@)
  */
-int __cdecl MSVCRT_feof(MSVCRT_FILE* file)
+int MSVCRT_feof(MSVCRT_FILE* file)
 {
   return file->_flag & _IOEOF;
 }
@@ -1279,7 +1279,7 @@
 /*********************************************************************
  *		ferror (MSVCRT.@)
  */
-int __cdecl MSVCRT_ferror(MSVCRT_FILE* file)
+int MSVCRT_ferror(MSVCRT_FILE* file)
 {
   return file->_flag & _IOERR;
 }
@@ -1287,18 +1287,18 @@
 /*********************************************************************
  *		fflush (MSVCRT.@)
  */
-int __cdecl MSVCRT_fflush(MSVCRT_FILE* file)
+int MSVCRT_fflush(MSVCRT_FILE* file)
 {
-  return MSVCRT__commit(file->_file);
+  return _commit(file->_file);
 }
 
 /*********************************************************************
  *		fgetc (MSVCRT.@)
  */
-int __cdecl MSVCRT_fgetc(MSVCRT_FILE* file)
+int MSVCRT_fgetc(MSVCRT_FILE* file)
 {
   char c;
-  if (MSVCRT__read(file->_file,&c,1) != 1)
+  if (_read(file->_file,&c,1) != 1)
     return MSVCRT_EOF;
   return c;
 }
@@ -1306,7 +1306,7 @@
 /*********************************************************************
  *		_fgetchar (MSVCRT.@)
  */
-int __cdecl MSVCRT__fgetchar(void)
+int _fgetchar(void)
 {
   return MSVCRT_fgetc(MSVCRT_stdin);
 }
@@ -1314,7 +1314,7 @@
 /*********************************************************************
  *		_filbuf (MSVCRT.@)
  */
-int __cdecl MSVCRT__filbuf(MSVCRT_FILE* file)
+int _filbuf(MSVCRT_FILE* file)
 {
   return MSVCRT_fgetc(file);
 }
@@ -1322,16 +1322,16 @@
 /*********************************************************************
  *		fgetpos (MSVCRT.@)
  */
-int __cdecl MSVCRT_fgetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
+int MSVCRT_fgetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
 {
-  *pos = MSVCRT__tell(file->_file);
+  *pos = _tell(file->_file);
   return (*pos == -1? -1 : 0);
 }
 
 /*********************************************************************
  *		fgets (MSVCRT.@)
  */
-char *__cdecl MSVCRT_fgets(char *s, int size, MSVCRT_FILE* file)
+char *MSVCRT_fgets(char *s, int size, MSVCRT_FILE* file)
 {
   int    cc;
   char * buf_start = s;
@@ -1366,10 +1366,10 @@
 /*********************************************************************
  *		fgetwc (MSVCRT.@)
  */
-WCHAR __cdecl MSVCRT_fgetwc(MSVCRT_FILE* file)
+WCHAR MSVCRT_fgetwc(MSVCRT_FILE* file)
 {
   WCHAR wc;
-  if (MSVCRT__read(file->_file, &wc, sizeof(wc)) != sizeof(wc))
+  if (_read(file->_file, &wc, sizeof(wc)) != sizeof(wc))
     return MSVCRT_WEOF;
   return wc;
 }
@@ -1377,7 +1377,7 @@
 /*********************************************************************
  *		getwc (MSVCRT.@)
  */
-WCHAR __cdecl MSVCRT_getwc(MSVCRT_FILE* file)
+WCHAR MSVCRT_getwc(MSVCRT_FILE* file)
 {
   return MSVCRT_fgetwc(file);
 }
@@ -1385,7 +1385,7 @@
 /*********************************************************************
  *		_fgetwchar (MSVCRT.@)
  */
-WCHAR __cdecl MSVCRT__fgetwchar(void)
+WCHAR _fgetwchar(void)
 {
   return MSVCRT_fgetwc(MSVCRT_stdin);
 }
@@ -1393,17 +1393,17 @@
 /*********************************************************************
  *		getwchar (MSVCRT.@)
  */
-WCHAR __cdecl MSVCRT_getwchar(void)
+WCHAR MSVCRT_getwchar(void)
 {
-  return MSVCRT__fgetwchar();
+  return _fgetwchar();
 }
 
 /*********************************************************************
  *		fputwc (MSVCRT.@)
  */
-WCHAR __cdecl MSVCRT_fputwc(WCHAR wc, MSVCRT_FILE* file)
+WCHAR MSVCRT_fputwc(WCHAR wc, MSVCRT_FILE* file)
 {
-  if (MSVCRT__write(file->_file, &wc, sizeof(wc)) != sizeof(wc))
+  if (_write(file->_file, &wc, sizeof(wc)) != sizeof(wc))
     return MSVCRT_WEOF;
   return wc;
 }
@@ -1411,7 +1411,7 @@
 /*********************************************************************
  *		_fputwchar (MSVCRT.@)
  */
-WCHAR __cdecl MSVCRT__fputwchar(WCHAR wc)
+WCHAR _fputwchar(WCHAR wc)
 {
   return MSVCRT_fputwc(wc, MSVCRT_stdout);
 }
@@ -1419,7 +1419,7 @@
 /*********************************************************************
  *		fopen (MSVCRT.@)
  */
-MSVCRT_FILE* __cdecl MSVCRT_fopen(const char *path, const char *mode)
+MSVCRT_FILE* MSVCRT_fopen(const char *path, const char *mode)
 {
   MSVCRT_FILE* file;
   int flags = 0, plus = 0, fd;
@@ -1464,15 +1464,15 @@
       FIXME(":unknown flag %c not supported\n",mode[-1]);
     }
 
-  fd = MSVCRT__open(path, flags);
+  fd = _open(path, flags);
 
   if (fd < 0)
     return NULL;
 
-  file = MSVCRT__alloc_fp(fd);
+  file = msvcrt_alloc_fp(fd);
   TRACE(":got (%p)\n",file);
   if (!file)
-    MSVCRT__close(fd);
+    _close(fd);
 
   return file;
 }
@@ -1480,7 +1480,7 @@
 /*********************************************************************
  *		_wfopen (MSVCRT.@)
  */
-MSVCRT_FILE *__cdecl MSVCRT__wfopen(const WCHAR *path, const WCHAR *mode)
+MSVCRT_FILE *_wfopen(const WCHAR *path, const WCHAR *mode)
 {
   const unsigned int plen = wcslen(path), mlen = wcslen(mode);
   char *patha = MSVCRT_calloc(plen + 1, 1);
@@ -1505,7 +1505,7 @@
 /*********************************************************************
  *		_fsopen (MSVCRT.@)
  */
-MSVCRT_FILE*  __cdecl MSVCRT__fsopen(const char *path, const char *mode, int share)
+MSVCRT_FILE*  _fsopen(const char *path, const char *mode, int share)
 {
   FIXME(":(%s,%s,%d),ignoring share mode!\n",path,mode,share);
   return MSVCRT_fopen(path,mode);
@@ -1514,25 +1514,25 @@
 /*********************************************************************
  *		_wfsopen (MSVCRT.@)
  */
-MSVCRT_FILE*  __cdecl MSVCRT__wfsopen(const WCHAR *path, const WCHAR *mode, int share)
+MSVCRT_FILE*  _wfsopen(const WCHAR *path, const WCHAR *mode, int share)
 {
   FIXME(":(%s,%s,%d),ignoring share mode!\n",
         debugstr_w(path),debugstr_w(mode),share);
-  return MSVCRT__wfopen(path,mode);
+  return _wfopen(path,mode);
 }
 
 /*********************************************************************
  *		fputc (MSVCRT.@)
  */
-int __cdecl MSVCRT_fputc(int c, MSVCRT_FILE* file)
+int MSVCRT_fputc(int c, MSVCRT_FILE* file)
 {
-  return MSVCRT__write(file->_file, &c, 1) == 1? c : MSVCRT_EOF;
+  return _write(file->_file, &c, 1) == 1? c : MSVCRT_EOF;
 }
 
 /*********************************************************************
  *		_flsbuf (MSVCRT.@)
  */
-int __cdecl MSVCRT__flsbuf(int c, MSVCRT_FILE* file)
+int _flsbuf(int c, MSVCRT_FILE* file)
 {
   return MSVCRT_fputc(c,file);
 }
@@ -1540,7 +1540,7 @@
 /*********************************************************************
  *		_fputchar (MSVCRT.@)
  */
-int __cdecl MSVCRT__fputchar(int c)
+int _fputchar(int c)
 {
   return MSVCRT_fputc(c, MSVCRT_stdout);
 }
@@ -1548,9 +1548,9 @@
 /*********************************************************************
  *		fread (MSVCRT.@)
  */
-DWORD __cdecl MSVCRT_fread(void *ptr, int size, int nmemb, MSVCRT_FILE* file)
+DWORD MSVCRT_fread(void *ptr, int size, int nmemb, MSVCRT_FILE* file)
 {
-  DWORD read = MSVCRT__read(file->_file,ptr, size * nmemb);
+  DWORD read = _read(file->_file,ptr, size * nmemb);
   if (read <= 0)
     return 0;
   return read / size;
@@ -1560,7 +1560,7 @@
  *		freopen (MSVCRT.@)
  *
  */
-MSVCRT_FILE* __cdecl MSVCRT_freopen(const char *path, const char *mode,MSVCRT_FILE* file)
+MSVCRT_FILE* MSVCRT_freopen(const char *path, const char *mode,MSVCRT_FILE* file)
 {
   MSVCRT_FILE* newfile;
   int fd;
@@ -1592,7 +1592,7 @@
     /* And free up the resources allocated by fopen, but
      * not the HANDLE we copied. */
     MSVCRT_free(MSVCRT_files[fd]);
-    MSVCRT__free_fd(newfile->_file);
+    msvcrt_free_fd(newfile->_file);
     return &MSVCRT__iob[fd];
   }
 
@@ -1605,17 +1605,17 @@
 /*********************************************************************
  *		fsetpos (MSVCRT.@)
  */
-int __cdecl MSVCRT_fsetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
+int MSVCRT_fsetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
 {
-  return MSVCRT__lseek(file->_file,*pos,SEEK_SET);
+  return _lseek(file->_file,*pos,SEEK_SET);
 }
 
 /*********************************************************************
  *		fscanf (MSVCRT.@)
  */
-int __cdecl MSVCRT_fscanf(MSVCRT_FILE* file, const char *format, ...)
+int MSVCRT_fscanf(MSVCRT_FILE* file, const char *format, ...)
 {
-    /* NOTE: If you extend this function, extend MSVCRT__cscanf in console.c too */
+    /* NOTE: If you extend this function, extend _cscanf in console.c too */
     int rd = 0;
     int nch;
     va_list ap;
@@ -1736,25 +1736,25 @@
 /*********************************************************************
  *		fseek (MSVCRT.@)
  */
-LONG __cdecl MSVCRT_fseek(MSVCRT_FILE* file, LONG offset, int whence)
+LONG MSVCRT_fseek(MSVCRT_FILE* file, LONG offset, int whence)
 {
-  return MSVCRT__lseek(file->_file,offset,whence);
+  return _lseek(file->_file,offset,whence);
 }
 
 /*********************************************************************
  *		ftell (MSVCRT.@)
  */
-LONG __cdecl MSVCRT_ftell(MSVCRT_FILE* file)
+LONG MSVCRT_ftell(MSVCRT_FILE* file)
 {
-  return MSVCRT__tell(file->_file);
+  return _tell(file->_file);
 }
 
 /*********************************************************************
  *		fwrite (MSVCRT.@)
  */
-unsigned int __cdecl MSVCRT_fwrite(const void *ptr, int size, int nmemb, MSVCRT_FILE* file)
+unsigned int MSVCRT_fwrite(const void *ptr, int size, int nmemb, MSVCRT_FILE* file)
 {
-  unsigned int written = MSVCRT__write(file->_file, ptr, size * nmemb);
+  unsigned int written = _write(file->_file, ptr, size * nmemb);
   if (written <= 0)
     return 0;
   return written / size;
@@ -1763,7 +1763,7 @@
 /*********************************************************************
  *		fputs (MSVCRT.@)
  */
-int __cdecl MSVCRT_fputs(const char *s, MSVCRT_FILE* file)
+int MSVCRT_fputs(const char *s, MSVCRT_FILE* file)
 {
   return MSVCRT_fwrite(s,strlen(s),1,file) == 1 ? 0 : MSVCRT_EOF;
 }
@@ -1771,7 +1771,7 @@
 /*********************************************************************
  *		fputws (MSVCRT.@)
  */
-int __cdecl MSVCRT_fputws(const WCHAR *s, MSVCRT_FILE* file)
+int MSVCRT_fputws(const WCHAR *s, MSVCRT_FILE* file)
 {
   return MSVCRT_fwrite(s,wcslen(s),1,file) == 1 ? 0 : MSVCRT_EOF;
 }
@@ -1779,7 +1779,7 @@
 /*********************************************************************
  *		getchar (MSVCRT.@)
  */
-int __cdecl MSVCRT_getchar(void)
+int MSVCRT_getchar(void)
 {
   return MSVCRT_fgetc(MSVCRT_stdin);
 }
@@ -1787,7 +1787,7 @@
 /*********************************************************************
  *		getc (MSVCRT.@)
  */
-int __cdecl MSVCRT_getc(MSVCRT_FILE* file)
+int MSVCRT_getc(MSVCRT_FILE* file)
 {
   return MSVCRT_fgetc(file);
 }
@@ -1795,7 +1795,7 @@
 /*********************************************************************
  *		gets (MSVCRT.@)
  */
-char *__cdecl MSVCRT_gets(char *buf)
+char *MSVCRT_gets(char *buf)
 {
   int    cc;
   char * buf_start = buf;
@@ -1817,7 +1817,7 @@
 /*********************************************************************
  *		putc (MSVCRT.@)
  */
-int __cdecl MSVCRT_putc(int c, MSVCRT_FILE* file)
+int MSVCRT_putc(int c, MSVCRT_FILE* file)
 {
   return MSVCRT_fputc(c, file);
 }
@@ -1825,7 +1825,7 @@
 /*********************************************************************
  *		putchar (MSVCRT.@)
  */
-void __cdecl MSVCRT_putchar(int c)
+void MSVCRT_putchar(int c)
 {
   MSVCRT_fputc(c, MSVCRT_stdout);
 }
@@ -1833,7 +1833,7 @@
 /*********************************************************************
  *		puts (MSVCRT.@)
  */
-int __cdecl MSVCRT_puts(const char *s)
+int MSVCRT_puts(const char *s)
 {
   int retval = MSVCRT_EOF;
   if (MSVCRT_fwrite(s,strlen(s),1,MSVCRT_stdout) == 1)
@@ -1844,7 +1844,7 @@
 /*********************************************************************
  *		_putws (MSVCRT.@)
  */
-int __cdecl MSVCRT__putws(const WCHAR *s)
+int _putws(const WCHAR *s)
 {
   static const WCHAR nl = (WCHAR)L'\n';
   if (MSVCRT_fwrite(s,wcslen(s),1,MSVCRT_stdout) == 1)
@@ -1855,7 +1855,7 @@
 /*********************************************************************
  *		remove (MSVCRT.@)
  */
-int __cdecl MSVCRT_remove(const char *path)
+int MSVCRT_remove(const char *path)
 {
   TRACE("(%s)\n",path);
   if (DeleteFileA(path))
@@ -1868,7 +1868,7 @@
 /*********************************************************************
  *		_wremove (MSVCRT.@)
  */
-int __cdecl MSVCRT__wremove(const WCHAR *path)
+int _wremove(const WCHAR *path)
 {
   TRACE("(%s)\n",debugstr_w(path));
   if (DeleteFileW(path))
@@ -1881,7 +1881,7 @@
 /*********************************************************************
  *		scanf (MSVCRT.@)
  */
-int __cdecl MSVCRT_scanf(const char *format, ...)
+int MSVCRT_scanf(const char *format, ...)
 {
   va_list valist;
   int res;
@@ -1895,7 +1895,7 @@
 /*********************************************************************
  *		rename (MSVCRT.@)
  */
-int __cdecl MSVCRT_rename(const char *oldpath,const char *newpath)
+int MSVCRT_rename(const char *oldpath,const char *newpath)
 {
   TRACE(":from %s to %s\n",oldpath,newpath);
   if (MoveFileExA(oldpath, newpath, MOVEFILE_REPLACE_EXISTING))
@@ -1908,7 +1908,7 @@
 /*********************************************************************
  *		_wrename (MSVCRT.@)
  */
-int __cdecl MSVCRT__wrename(const WCHAR *oldpath,const WCHAR *newpath)
+int _wrename(const WCHAR *oldpath,const WCHAR *newpath)
 {
   TRACE(":from %s to %s\n",debugstr_w(oldpath),debugstr_w(newpath));
   if (MoveFileExW(oldpath, newpath, MOVEFILE_REPLACE_EXISTING))
@@ -1929,7 +1929,7 @@
 /*********************************************************************
  *		setbuf (MSVCRT.@)
  */
-void __cdecl MSVCRT_setbuf(MSVCRT_FILE* file, char *buf)
+void MSVCRT_setbuf(MSVCRT_FILE* file, char *buf)
 {
   MSVCRT_setvbuf(file, buf, buf ? _IOFBF : _IONBF, BUFSIZ);
 }
@@ -1937,7 +1937,7 @@
 /*********************************************************************
  *		tmpnam (MSVCRT.@)
  */
-char *__cdecl MSVCRT_tmpnam(char *s)
+char *MSVCRT_tmpnam(char *s)
 {
   char tmpbuf[MAX_PATH];
   char* prefix = "TMP";
@@ -1955,13 +1955,13 @@
 /*********************************************************************
  *		tmpfile (MSVCRT.@)
  */
-MSVCRT_FILE* __cdecl MSVCRT_tmpfile(void)
+MSVCRT_FILE* MSVCRT_tmpfile(void)
 {
   char *filename = MSVCRT_tmpnam(NULL);
   int fd;
-  fd = MSVCRT__open(filename, _O_CREAT | _O_BINARY | _O_RDWR | _O_TEMPORARY);
+  fd = _open(filename, _O_CREAT | _O_BINARY | _O_RDWR | _O_TEMPORARY);
   if (fd != -1)
-    return MSVCRT__alloc_fp(fd);
+    return msvcrt_alloc_fp(fd);
   return NULL;
 }
 extern int vsnprintf(void *, unsigned int, const void*, va_list);
@@ -1969,7 +1969,7 @@
 /*********************************************************************
  *		vfprintf (MSVCRT.@)
  */
-int __cdecl MSVCRT_vfprintf(MSVCRT_FILE* file, const char *format, va_list valist)
+int MSVCRT_vfprintf(MSVCRT_FILE* file, const char *format, va_list valist)
 {
   char buf[2048], *mem = buf;
   int written, resize = sizeof(buf), retval;
@@ -1996,12 +1996,12 @@
 /*********************************************************************
  *		vfwprintf (MSVCRT.@)
  */
-int __cdecl MSVCRT_vfwprintf(MSVCRT_FILE* file, const WCHAR *format, va_list valist)
+int MSVCRT_vfwprintf(MSVCRT_FILE* file, const WCHAR *format, va_list valist)
 {
   WCHAR buf[2048], *mem = buf;
   int written, resize = sizeof(buf) / sizeof(WCHAR), retval;
   /* See vfprintf comments */
-  while ((written = MSVCRT__vsnwprintf(mem, resize, format, valist)) == -1 ||
+  while ((written = _vsnwprintf(mem, resize, format, valist)) == -1 ||
           written > resize)
   {
     resize = (written == -1 ? resize * 2 : written + sizeof(WCHAR));
@@ -2019,7 +2019,7 @@
 /*********************************************************************
  *		vprintf (MSVCRT.@)
  */
-int __cdecl MSVCRT_vprintf(const char *format, va_list valist)
+int MSVCRT_vprintf(const char *format, va_list valist)
 {
   return MSVCRT_vfprintf(MSVCRT_stdout,format,valist);
 }
@@ -2027,7 +2027,7 @@
 /*********************************************************************
  *		vwprintf (MSVCRT.@)
  */
-int __cdecl MSVCRT_vwprintf(const WCHAR *format, va_list valist)
+int MSVCRT_vwprintf(const WCHAR *format, va_list valist)
 {
   return MSVCRT_vfwprintf(MSVCRT_stdout,format,valist);
 }
@@ -2035,7 +2035,7 @@
 /*********************************************************************
  *		fprintf (MSVCRT.@)
  */
-int __cdecl MSVCRT_fprintf(MSVCRT_FILE* file, const char *format, ...)
+int MSVCRT_fprintf(MSVCRT_FILE* file, const char *format, ...)
 {
     va_list valist;
     int res;
@@ -2048,7 +2048,7 @@
 /*********************************************************************
  *		fwprintf (MSVCRT.@)
  */
-int __cdecl MSVCRT_fwprintf(MSVCRT_FILE* file, const WCHAR *format, ...)
+int MSVCRT_fwprintf(MSVCRT_FILE* file, const WCHAR *format, ...)
 {
     va_list valist;
     int res;
@@ -2061,7 +2061,7 @@
 /*********************************************************************
  *		printf (MSVCRT.@)
  */
-int __cdecl MSVCRT_printf(const char *format, ...)
+int MSVCRT_printf(const char *format, ...)
 {
     va_list valist;
     int res;
@@ -2074,7 +2074,7 @@
 /*********************************************************************
  *		wprintf (MSVCRT.@)
  */
-int __cdecl MSVCRT_wprintf(const WCHAR *format, ...)
+int MSVCRT_wprintf(const WCHAR *format, ...)
 {
     va_list valist;
     int res;
diff --git a/dlls/msvcrt/heap.c b/dlls/msvcrt/heap.c
index 0e653a6..50fc9cf 100644
--- a/dlls/msvcrt/heap.c
+++ b/dlls/msvcrt/heap.c
@@ -41,7 +41,7 @@
 /*********************************************************************
  *		operator_new (MSVCRT.@)
  */
-void *__cdecl MSVCRT_operator_new(unsigned long size)
+void* MSVCRT_operator_new(unsigned long size)
 {
   void *retval = HeapAlloc(GetProcessHeap(), 0, size);
   TRACE("(%ld) returning %p\n", size, retval);
@@ -55,7 +55,7 @@
 /*********************************************************************
  *		operator_delete (MSVCRT.@)
  */
-void __cdecl MSVCRT_operator_delete(void *mem)
+void MSVCRT_operator_delete(void *mem)
 {
   TRACE("(%p)\n", mem);
   HeapFree(GetProcessHeap(), 0, mem);
@@ -65,7 +65,7 @@
 /*********************************************************************
  *		?_query_new_handler@@YAP6AHI@ZXZ (MSVCRT.@)
  */
-MSVCRT_new_handler_func __cdecl MSVCRT__query_new_handler(void)
+MSVCRT_new_handler_func MSVCRT__query_new_handler(void)
 {
   return MSVCRT_new_handler;
 }
@@ -74,7 +74,7 @@
 /*********************************************************************
  *		?_query_new_mode@@YAHXZ (MSVCRT.@)
  */
-int __cdecl MSVCRT__query_new_mode(void)
+int MSVCRT__query_new_mode(void)
 {
   return MSVCRT_new_mode;
 }
@@ -82,7 +82,7 @@
 /*********************************************************************
  *		?_set_new_handler@@YAP6AHI@ZP6AHI@Z@Z (MSVCRT.@)
  */
-MSVCRT_new_handler_func __cdecl MSVCRT__set_new_handler(MSVCRT_new_handler_func func)
+MSVCRT_new_handler_func MSVCRT__set_new_handler(MSVCRT_new_handler_func func)
 {
   MSVCRT_new_handler_func old_handler;
   LOCK_HEAP;
@@ -95,7 +95,7 @@
 /*********************************************************************
  *		?_set_new_mode@@YAHH@Z (MSVCRT.@)
  */
-int __cdecl MSVCRT__set_new_mode(int mode)
+int MSVCRT__set_new_mode(int mode)
 {
   int old_mode;
   LOCK_HEAP;
@@ -108,7 +108,7 @@
 /*********************************************************************
  *		_expand (MSVCRT.@)
  */
-void *__cdecl MSVCRT__expand(void *mem, unsigned int size)
+void* _expand(void* mem, unsigned int size)
 {
   return HeapReAlloc(GetProcessHeap(), HEAP_REALLOC_IN_PLACE_ONLY, mem, size);
 }
@@ -116,7 +116,7 @@
 /*********************************************************************
  *		_heapchk (MSVCRT.@)
  */
-int __cdecl MSVCRT__heapchk(void)
+int _heapchk(void)
 {
   if (!HeapValidate( GetProcessHeap(), 0, NULL))
   {
@@ -129,7 +129,7 @@
 /*********************************************************************
  *		_heapmin (MSVCRT.@)
  */
-int __cdecl MSVCRT__heapmin(void)
+int _heapmin(void)
 {
   if (!HeapCompact( GetProcessHeap(), 0 ))
   {
@@ -143,7 +143,7 @@
 /*********************************************************************
  *		_heapwalk (MSVCRT.@)
  */
-int __cdecl MSVCRT__heapwalk(MSVCRT_HEAPINFO *next)
+int _heapwalk(MSVCRT_HEAPINFO* next)
 {
   PROCESS_HEAP_ENTRY phe;
 
@@ -184,14 +184,14 @@
 /*********************************************************************
  *		_heapset (MSVCRT.@)
  */
-int __cdecl MSVCRT__heapset(unsigned int value)
+int _heapset(unsigned int value)
 {
   int retval;
   MSVCRT_HEAPINFO heap;
 
   memset( &heap, 0, sizeof(MSVCRT_HEAPINFO) );
   LOCK_HEAP;
-  while ((retval = MSVCRT__heapwalk(&heap)) == MSVCRT_HEAPOK)
+  while ((retval = _heapwalk(&heap)) == MSVCRT_HEAPOK)
   {
     if (heap._useflag == MSVCRT_FREEENTRY)
       memset(heap._pentry, value, heap._size);
@@ -203,7 +203,7 @@
 /*********************************************************************
  *		_msize (MSVCRT.@)
  */
-long __cdecl MSVCRT__msize(void *mem)
+long _msize(void* mem)
 {
   long size = HeapSize(GetProcessHeap(),0,mem);
   if (size == -1)
@@ -217,7 +217,7 @@
 /*********************************************************************
  *		calloc (MSVCRT.@)
  */
-void *__cdecl MSVCRT_calloc(unsigned int size, unsigned int count)
+void* MSVCRT_calloc(unsigned int size, unsigned int count)
 {
   return HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size * count );
 }
@@ -225,7 +225,7 @@
 /*********************************************************************
  *		free (MSVCRT.@)
  */
-void __cdecl MSVCRT_free(void *ptr)
+void MSVCRT_free(void* ptr)
 {
   HeapFree(GetProcessHeap(),0,ptr);
 }
@@ -233,7 +233,7 @@
 /*********************************************************************
  *                  malloc (MSVCRT.@)
  */
-void * __cdecl MSVCRT_malloc(unsigned int size)
+void* MSVCRT_malloc(unsigned int size)
 {
   void *ret = HeapAlloc(GetProcessHeap(),0,size);
   if (!ret)
@@ -244,7 +244,7 @@
 /*********************************************************************
  *		realloc (MSVCRT.@)
  */
-void *__cdecl MSVCRT_realloc(void *ptr, unsigned int size)
+void* MSVCRT_realloc(void* ptr, unsigned int size)
 {
   return HeapReAlloc(GetProcessHeap(), 0, ptr, size);
 }
diff --git a/dlls/msvcrt/locale.c b/dlls/msvcrt/locale.c
index 4307433..f710cbe 100644
--- a/dlls/msvcrt/locale.c
+++ b/dlls/msvcrt/locale.c
@@ -254,7 +254,7 @@
 extern int snprintf(char *, int, const char *, ...);
 
 /* INTERNAL: Set ctype behaviour for a codepage */
-static void MSVCRT_set_ctype(unsigned int codepage, LCID lcid)
+static void msvcrt_set_ctype(unsigned int codepage, LCID lcid)
 {
   CPINFO cp;
 
@@ -297,7 +297,7 @@
 /*********************************************************************
  *		setlocale (MSVCRT.@)
  */
-char *__cdecl MSVCRT_setlocale(int category, const char *locale)
+char* MSVCRT_setlocale(int category, const char* locale)
 {
   LCID lcid = 0;
   locale_search_t lc;
@@ -443,7 +443,7 @@
   case MSVCRT_LC_COLLATE:
     if (!lc_all) break;
   case MSVCRT_LC_CTYPE:
-    MSVCRT_set_ctype(atoi(lc.found_codepage),lcid);
+    msvcrt_set_ctype(atoi(lc.found_codepage),lcid);
     if (!lc_all) break;
   case MSVCRT_LC_MONETARY:
     if (!lc_all) break;
@@ -459,7 +459,7 @@
 /*********************************************************************
  *		_Getdays (MSVCRT.@)
  */
-const char *__cdecl MSVCRT__Getdays(void)
+const char* _Getdays(void)
 {
   static const char *MSVCRT_days = ":Sun:Sunday:Mon:Monday:Tue:Tuesday:Wed:"
                             "Wednesday:Thu:Thursday:Fri:Friday:Sat:Saturday";
@@ -471,7 +471,7 @@
 /*********************************************************************
  *		_Getmonths (MSVCRT.@)
  */
-const char *__cdecl MSVCRT__Getmonths(void)
+const char* _Getmonths(void)
 {
   static const char *MSVCRT_months = ":Jan:January:Feb:February:Mar:March:Apr:"
                 "April:May:May:Jun:June:Jul:July:Aug:August:Sep:September:Oct:"
@@ -484,7 +484,7 @@
 /*********************************************************************
  *		_Getnames (MSVCRT.@)
  */
-const char *__cdecl MSVCRT__Getnames(void)
+const char* _Getnames(void)
 {
   /* FIXME: */
   TRACE("(void) stub");
@@ -494,7 +494,7 @@
 /*********************************************************************
  *		_Strftime (MSVCRT.@)
  */
-const char *__cdecl MSVCRT__Strftime(char *out, unsigned int len, const char *fmt,
+const char* _Strftime(char *out, unsigned int len, const char *fmt,
                                      const void *tm, void *foo)
 {
   /* FIXME: */
@@ -507,7 +507,7 @@
 /*********************************************************************
  *		_setmbcp (MSVCRT.@)
  */
-void __cdecl MSVCRT__setmbcp(int cp)
+void _setmbcp(int cp)
 {
   LOCK_LOCALE;
   if (MSVCRT_current_lc_all_cp != cp)
@@ -521,7 +521,7 @@
 /*********************************************************************
  *		_getmbcp (MSVCRT.@)
  */
-int __cdecl MSVCRT__getmbcp(void)
+int _getmbcp(void)
 {
   return MSVCRT_current_lc_all_cp;
 }
diff --git a/dlls/msvcrt/main.c b/dlls/msvcrt/main.c
index 847e8b1..859f0ac 100644
--- a/dlls/msvcrt/main.c
+++ b/dlls/msvcrt/main.c
@@ -17,23 +17,23 @@
 CRITICAL_SECTION MSVCRT_console_cs;
 CRITICAL_SECTION MSVCRT_locale_cs;
 
-static inline BOOL MSVCRT_init_tls(void);
-static inline BOOL MSVCRT_free_tls(void);
-static inline void MSVCRT_init_critical_sections(void);
-static inline void MSVCRT_free_critical_sections(void);
+static inline BOOL msvcrt_init_tls(void);
+static inline BOOL msvcrt_free_tls(void);
+static inline void msvcrt_init_critical_sections(void);
+static inline void msvcrt_free_critical_sections(void);
 #ifdef __GNUC__
-const char *MSVCRT_get_reason(DWORD reason) __attribute__((unused));
+const char *msvcrt_get_reason(DWORD reason) __attribute__((unused));
 #else
-const char *MSVCRT_get_reason(DWORD reason);
+const char *msvcrt_get_reason(DWORD reason);
 #endif
 
-void MSVCRT_init_io(void);
-void MSVCRT_init_console(void);
-void MSVCRT_free_console(void);
-void MSVCRT_init_args(void);
-void MSVCRT_free_args(void);
-void MSVCRT_init_vtables(void);
-char *__cdecl MSVCRT_setlocale(int category, const char *locale);
+void msvcrt_init_io(void);
+void msvcrt_init_console(void);
+void msvcrt_free_console(void);
+void msvcrt_init_args(void);
+void msvcrt_free_args(void);
+void msvcrt_init_vtables(void);
+char* MSVCRT_setlocale(int category, const char* locale);
 
 
 /*********************************************************************
@@ -44,20 +44,20 @@
   MSVCRT_thread_data *tls;
 
   TRACE("(0x%08x, %s, %p) pid(%ld), tid(%ld), tls(%ld)\n",
-        hinstDLL, MSVCRT_get_reason(fdwReason), lpvReserved,
+        hinstDLL, msvcrt_get_reason(fdwReason), lpvReserved,
         (long)GetCurrentProcessId(), (long)GetCurrentThreadId(),
         (long)MSVCRT_tls_index);
 
   switch (fdwReason)
   {
   case DLL_PROCESS_ATTACH:
-    if (!MSVCRT_init_tls())
+    if (!msvcrt_init_tls())
       return FALSE;
-    MSVCRT_init_vtables();
-    MSVCRT_init_critical_sections();
-    MSVCRT_init_io();
-    MSVCRT_init_console();
-    MSVCRT_init_args();
+    msvcrt_init_vtables();
+    msvcrt_init_critical_sections();
+    msvcrt_init_io();
+    msvcrt_init_console();
+    msvcrt_init_args();
     MSVCRT_setlocale(0, "C");
     TRACE("finished process init\n");
     /* FALL THROUGH for Initial TLS allocation!! */
@@ -74,11 +74,11 @@
     TRACE("finished thread init\n");
     break;
   case DLL_PROCESS_DETACH:
-    MSVCRT_free_critical_sections();
-    MSVCRT__fcloseall();
-    MSVCRT_free_console();
-    MSVCRT_free_args();
-    if (!MSVCRT_free_tls())
+    msvcrt_free_critical_sections();
+    _fcloseall();
+    msvcrt_free_console();
+    msvcrt_free_args();
+    if (!msvcrt_free_tls())
       return FALSE;
     TRACE("finished process free\n");
     break;
@@ -98,7 +98,7 @@
   return TRUE;
 }
 
-static inline BOOL MSVCRT_init_tls(void)
+static inline BOOL msvcrt_init_tls(void)
 {
   MSVCRT_tls_index = TlsAlloc();
 
@@ -110,7 +110,7 @@
   return TRUE;
 }
 
-static inline BOOL MSVCRT_free_tls(void)
+static inline BOOL msvcrt_free_tls(void)
 {
   if (!TlsFree(MSVCRT_tls_index))
   {
@@ -120,7 +120,7 @@
   return TRUE;
 }
 
-static inline void MSVCRT_init_critical_sections(void)
+static inline void msvcrt_init_critical_sections(void)
 {
   InitializeCriticalSectionAndSpinCount(&MSVCRT_heap_cs, 4000);
   InitializeCriticalSection(&MSVCRT_file_cs);
@@ -129,7 +129,7 @@
   InitializeCriticalSection(&MSVCRT_locale_cs);
 }
 
-static inline void MSVCRT_free_critical_sections(void)
+static inline void msvcrt_free_critical_sections(void)
 {
   DeleteCriticalSection(&MSVCRT_locale_cs);
   DeleteCriticalSection(&MSVCRT_console_cs);
@@ -138,7 +138,7 @@
   DeleteCriticalSection(&MSVCRT_heap_cs);
 }
 
-const char *MSVCRT_get_reason(DWORD reason)
+const char* msvcrt_get_reason(DWORD reason)
 {
   switch (reason)
   {
diff --git a/dlls/msvcrt/math.c b/dlls/msvcrt/math.c
index 8e09100..ce9e0f5 100644
--- a/dlls/msvcrt/math.c
+++ b/dlls/msvcrt/math.c
@@ -93,7 +93,7 @@
 } MSVCRT_exception;
 
 
-typedef int (__cdecl *MSVCRT_matherr_func)(MSVCRT_exception *);
+typedef int (*MSVCRT_matherr_func)(MSVCRT_exception *);
 
 static MSVCRT_matherr_func MSVCRT_default_matherr_func = NULL;
 
@@ -108,7 +108,7 @@
 /*********************************************************************
  *		_CIacos (MSVCRT.@)
  */
-double __cdecl MSVCRT__CIacos(void)
+double _CIacos(void)
 {
   FPU_DOUBLE(x);
   if (x < -1.0 || x > 1.0 || !finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
@@ -118,7 +118,7 @@
 /*********************************************************************
  *		_CIasin (MSVCRT.@)
  */
-double __cdecl MSVCRT__CIasin(void)
+double _CIasin(void)
 {
   FPU_DOUBLE(x);
   if (x < -1.0 || x > 1.0 || !finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
@@ -128,7 +128,7 @@
 /*********************************************************************
  *		_CIatan (MSVCRT.@)
  */
-double __cdecl MSVCRT__CIatan(void)
+double _CIatan(void)
 {
   FPU_DOUBLE(x);
   if (!finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
@@ -138,7 +138,7 @@
 /*********************************************************************
  *		_CIatan2 (MSVCRT.@)
  */
-double __cdecl MSVCRT__CIatan2(void)
+double _CIatan2(void)
 {
   FPU_DOUBLES(x,y);
   if (!finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
@@ -148,7 +148,7 @@
 /*********************************************************************
  *		_CIcos (MSVCRT.@)
  */
-double __cdecl MSVCRT__CIcos(void)
+double _CIcos(void)
 {
   FPU_DOUBLE(x);
   if (!finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
@@ -158,7 +158,7 @@
 /*********************************************************************
  *		_CIcosh (MSVCRT.@)
  */
-double __cdecl MSVCRT__CIcosh(void)
+double _CIcosh(void)
 {
   FPU_DOUBLE(x);
   if (!finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
@@ -168,7 +168,7 @@
 /*********************************************************************
  *		_CIexp (MSVCRT.@)
  */
-double __cdecl MSVCRT__CIexp(void)
+double _CIexp(void)
 {
   FPU_DOUBLE(x);
   if (!finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
@@ -178,7 +178,7 @@
 /*********************************************************************
  *		_CIfmod (MSVCRT.@)
  */
-double __cdecl MSVCRT__CIfmod(void)
+double _CIfmod(void)
 {
   FPU_DOUBLES(x,y);
   if (!finite(x) || !finite(y)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
@@ -188,7 +188,7 @@
 /*********************************************************************
  *		_CIlog (MSVCRT.@)
  */
-double __cdecl MSVCRT__CIlog(void)
+double _CIlog(void)
 {
   FPU_DOUBLE(x);
   if (x < 0.0 || !finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
@@ -199,7 +199,7 @@
 /*********************************************************************
  *		_CIlog10 (MSVCRT.@)
  */
-double __cdecl MSVCRT__CIlog10(void)
+double _CIlog10(void)
 {
   FPU_DOUBLE(x);
   if (x < 0.0 || !finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
@@ -210,7 +210,7 @@
 /*********************************************************************
  *		_CIpow (MSVCRT.@)
  */
-double __cdecl MSVCRT__CIpow(void)
+double _CIpow(void)
 {
   double z;
   FPU_DOUBLES(x,y);
@@ -223,7 +223,7 @@
 /*********************************************************************
  *		_CIsin (MSVCRT.@)
  */
-double __cdecl MSVCRT__CIsin(void)
+double _CIsin(void)
 {
   FPU_DOUBLE(x);
   if (!finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
@@ -233,7 +233,7 @@
 /*********************************************************************
  *		_CIsinh (MSVCRT.@)
  */
-double __cdecl MSVCRT__CIsinh(void)
+double _CIsinh(void)
 {
   FPU_DOUBLE(x);
   if (!finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
@@ -243,7 +243,7 @@
 /*********************************************************************
  *		_CIsqrt (MSVCRT.@)
  */
-double __cdecl MSVCRT__CIsqrt(void)
+double _CIsqrt(void)
 {
   FPU_DOUBLE(x);
   if (x < 0.0 || !finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
@@ -253,7 +253,7 @@
 /*********************************************************************
  *		_CItan (MSVCRT.@)
  */
-double __cdecl MSVCRT__CItan(void)
+double _CItan(void)
 {
   FPU_DOUBLE(x);
   if (!finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
@@ -263,7 +263,7 @@
 /*********************************************************************
  *		_CItanh (MSVCRT.@)
  */
-double __cdecl MSVCRT__CItanh(void)
+double _CItanh(void)
 {
   FPU_DOUBLE(x);
   if (!finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
@@ -274,7 +274,7 @@
 
 /* The above cannot be called on non x86 platforms, stub them for linking */
 
-#define IX86_ONLY(func) double __cdecl MSVCRT_##func(void) { return 0.0; }
+#define IX86_ONLY(func) double MSVCRT_##func(void) { return 0.0; }
 
 IX86_ONLY(_CIacos)
 IX86_ONLY(_CIasin)
@@ -298,7 +298,7 @@
 /*********************************************************************
  *		_fpclass (MSVCRT.@)
  */
-int __cdecl MSVCRT__fpclass(double num)
+int _fpclass(double num)
 {
 #if defined(HAVE_FPCLASS) || defined(fpclass)
   switch (fpclass( num ))
@@ -333,7 +333,7 @@
 /*********************************************************************
  *		_rotl (MSVCRT.@)
  */
-unsigned int __cdecl MSVCRT__rotl(unsigned int num, int shift)
+unsigned int _rotl(unsigned int num, int shift)
 {
   shift &= 31;
   return (num << shift) | (num >> (32-shift));
@@ -342,7 +342,7 @@
 /*********************************************************************
  *		_logb (MSVCRT.@)
  */
-double __cdecl MSVCRT__logb(double num)
+double _logb(double num)
 {
   if (!finite(num)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
   return logb(num);
@@ -351,7 +351,7 @@
 /*********************************************************************
  *		_lrotl (MSVCRT.@)
  */
-unsigned long __cdecl MSVCRT__lrotl(unsigned long num, int shift)
+unsigned long _lrotl(unsigned long num, int shift)
 {
   shift &= 0x1f;
   return (num << shift) | (num >> (32-shift));
@@ -360,7 +360,7 @@
 /*********************************************************************
  *		_lrotr (MSVCRT.@)
  */
-unsigned long __cdecl MSVCRT__lrotr(unsigned long num, int shift)
+unsigned long _lrotr(unsigned long num, int shift)
 {
   shift &= 0x1f;
   return (num >> shift) | (num << (32-shift));
@@ -369,7 +369,7 @@
 /*********************************************************************
  *		_rotr (MSVCRT.@)
  */
-unsigned int __cdecl MSVCRT__rotr(unsigned int num, int shift)
+unsigned int _rotr(unsigned int num, int shift)
 {
     shift &= 0x1f;
     return (num >> shift) | (num << (32-shift));
@@ -378,7 +378,7 @@
 /*********************************************************************
  *		_scalb (MSVCRT.@)
  */
-double __cdecl MSVCRT__scalb(double num, long power)
+double _scalb(double num, long power)
 {
   /* Note - Can't forward directly as libc expects y as double */
   double dblpower = (double)power;
@@ -389,7 +389,7 @@
 /*********************************************************************
  *		_matherr (MSVCRT.@)
  */
-int __cdecl MSVCRT__matherr(MSVCRT_exception *e)
+int _matherr(MSVCRT_exception *e)
 {
   if (e)
     TRACE("(%p = %d, %s, %g %g %g)\n",e, e->type, e->name, e->arg1, e->arg2,
@@ -405,7 +405,7 @@
 /*********************************************************************
  *		__setusermatherr (MSVCRT.@)
  */
-void __cdecl MSVCRT___setusermatherr(MSVCRT_matherr_func func)
+void MSVCRT___setusermatherr(MSVCRT_matherr_func func)
 {
   MSVCRT_default_matherr_func = func;
   TRACE(":new matherr handler %p\n", func);
@@ -414,7 +414,7 @@
 /**********************************************************************
  *		_statusfp (MSVCRT.@)
  */
-unsigned int __cdecl MSVCRT__statusfp(void)
+unsigned int _statusfp(void)
 {
    unsigned int retVal = 0;
 #if defined(__GNUC__) && defined(__i386__)
@@ -436,9 +436,9 @@
 /*********************************************************************
  *		_clearfp (MSVCRT.@)
  */
-unsigned int __cdecl MSVCRT__clearfp(void)
+unsigned int _clearfp(void)
 {
-  unsigned int retVal = MSVCRT__statusfp();
+  unsigned int retVal = _statusfp();
 #if defined(__GNUC__) && defined(__i386__)
   __asm__ __volatile__( "fnclex" );
 #else
@@ -450,7 +450,7 @@
 /*********************************************************************
  *		ldexp (MSVCRT.@)
  */
-double __cdecl MSVCRT_ldexp(double num, long exp)
+double MSVCRT_ldexp(double num, long exp)
 {
   double z = ldexp(num,exp);
 
@@ -464,7 +464,7 @@
 /*********************************************************************
  *		_cabs (MSVCRT.@)
  */
-double __cdecl MSVCRT__cabs(MSVCRT_complex num)
+double _cabs(MSVCRT_complex num)
 {
   return sqrt(num.real * num.real + num.imaginary * num.imaginary);
 }
@@ -472,7 +472,7 @@
 /*********************************************************************
  *		_chgsign (MSVCRT.@)
  */
-double __cdecl MSVCRT__chgsign(double num)
+double _chgsign(double num)
 {
   /* FIXME: +-infinity,Nan not tested */
   return -num;
@@ -481,7 +481,7 @@
 /*********************************************************************
  *		_control87 (MSVCRT.@)
  */
-unsigned int __cdecl MSVCRT__control87(unsigned int newval, unsigned int mask)
+unsigned int _control87(unsigned int newval, unsigned int mask)
 {
 #if defined(__GNUC__) && defined(__i386__)
    unsigned int fpword, flags = 0;
@@ -535,17 +535,17 @@
   __asm__ __volatile__( "fldcw %0" : : "m" (fpword) );
   return fpword;
 #else
-  return  MSVCRT__controlfp( newval, mask );
+  return  _controlfp( newval, mask );
 #endif
 }
 
 /*********************************************************************
  *		_controlfp (MSVCRT.@)
  */
-unsigned int __cdecl MSVCRT__controlfp(unsigned int newval, unsigned int mask)
+unsigned int _controlfp(unsigned int newval, unsigned int mask)
 {
 #if defined(__GNUC__) && defined(__i386__)
-  return MSVCRT__control87( newval, mask );
+  return _control87( newval, mask );
 #else
   FIXME(":Not Implemented!\n");
   return 0;
@@ -555,7 +555,7 @@
 /*********************************************************************
  *		_copysign (MSVCRT.@)
  */
-double __cdecl MSVCRT__copysign(double num, double sign)
+double _copysign(double num, double sign)
 {
   /* FIXME: Behaviour for Nan/Inf? */
   if (sign < 0.0)
@@ -566,7 +566,7 @@
 /*********************************************************************
  *		_finite (MSVCRT.@)
  */
-int __cdecl  MSVCRT__finite(double num)
+int  _finite(double num)
 {
   return (finite(num)?1:0); /* See comment for _isnan() */
 }
@@ -574,7 +574,7 @@
 /*********************************************************************
  *		_fpreset (MSVCRT.@)
  */
-void __cdecl MSVCRT__fpreset(void)
+void _fpreset(void)
 {
 #if defined(__GNUC__) && defined(__i386__)
   __asm__ __volatile__( "fninit" );
@@ -586,7 +586,7 @@
 /*********************************************************************
  *		_isnan (MSVCRT.@)
  */
-INT __cdecl  MSVCRT__isnan(double num)
+INT  _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
@@ -597,12 +597,12 @@
 /*********************************************************************
  *		_y0 (MSVCRT.@)
  */
-double __cdecl MSVCRT__y0(double num)
+double _y0(double num)
 {
   double retval;
   if (!finite(num)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
   retval  = y0(num);
-  if (MSVCRT__fpclass(retval) == _FPCLASS_NINF)
+  if (_fpclass(retval) == _FPCLASS_NINF)
   {
     SET_THREAD_VAR(errno,MSVCRT_EDOM);
     retval = sqrt(-1);
@@ -613,12 +613,12 @@
 /*********************************************************************
  *		_y1 (MSVCRT.@)
  */
-double __cdecl MSVCRT__y1(double num)
+double _y1(double num)
 {
   double retval;
   if (!finite(num)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
   retval  = y1(num);
-  if (MSVCRT__fpclass(retval) == _FPCLASS_NINF)
+  if (_fpclass(retval) == _FPCLASS_NINF)
   {
     SET_THREAD_VAR(errno,MSVCRT_EDOM);
     retval = sqrt(-1);
@@ -629,12 +629,12 @@
 /*********************************************************************
  *		_yn (MSVCRT.@)
  */
-double __cdecl MSVCRT__yn(int order, double num)
+double _yn(int order, double num)
 {
   double retval;
   if (!finite(num)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
   retval  = yn(order,num);
-  if (MSVCRT__fpclass(retval) == _FPCLASS_NINF)
+  if (_fpclass(retval) == _FPCLASS_NINF)
   {
     SET_THREAD_VAR(errno,MSVCRT_EDOM);
     retval = sqrt(-1);
@@ -645,7 +645,7 @@
 /*********************************************************************
  *		_nextafter (MSVCRT.@)
  */
-double __cdecl MSVCRT__nextafter(double num, double next)
+double _nextafter(double num, double next)
 {
   double retval;
   if (!finite(num) || !finite(next)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
@@ -661,7 +661,7 @@
  *	[i386] Windows binary compatible - returns the struct in eax/edx.
  */
 #ifdef __i386__
-LONGLONG __cdecl MSVCRT_div(int num, int denom)
+LONGLONG MSVCRT_div(int num, int denom)
 {
   LONGLONG retval;
   div_t dt = div(num,denom);
@@ -674,7 +674,7 @@
  * VERSION
  *	[!i386] Non-x86 can't run win32 apps so we don't need binary compatibility
  */
-div_t __cdecl MSVCRT_div(int num, int denom)
+div_t MSVCRT_div(int num, int denom)
 {
   return div(num,denom);
 }
@@ -687,7 +687,7 @@
  * 	[i386] Windows binary compatible - returns the struct in eax/edx.
  */
 #ifdef __i386__
-ULONGLONG __cdecl MSVCRT_ldiv(long num, long denom)
+ULONGLONG MSVCRT_ldiv(long num, long denom)
 {
   ULONGLONG retval;
   ldiv_t ldt = ldiv(num,denom);
@@ -700,7 +700,7 @@
  * VERSION
  *	[!i386] Non-x86 can't run win32 apps so we don't need binary compatibility
  */
-ldiv_t __cdecl MSVCRT_ldiv(long num, long denom)
+ldiv_t MSVCRT_ldiv(long num, long denom)
 {
   return ldiv(num,denom);
 }
@@ -715,7 +715,7 @@
  *    I _think_ this function is intended to work around the Pentium
  *    fdiv bug.
  */
-void __cdecl MSVCRT__adj_fdiv_m16i(void)
+void _adj_fdiv_m16i(void)
 {
   TRACE("(): stub");
 }
@@ -729,7 +729,7 @@
  *    I _think_ this function is intended to work around the Pentium
  *    fdiv bug.
  */
-void __cdecl MSVCRT__adj_fdiv_m32(void)
+void _adj_fdiv_m32(void)
 {
   TRACE("(): stub");
 }
@@ -743,7 +743,7 @@
  *    I _think_ this function is intended to work around the Pentium
  *    fdiv bug.
  */
-void __cdecl MSVCRT__adj_fdiv_m32i(void)
+void _adj_fdiv_m32i(void)
 {
   TRACE("(): stub");
 }
@@ -757,7 +757,7 @@
  *    I _think_ this function is intended to work around the Pentium
  *    fdiv bug.
  */
-void __cdecl MSVCRT__adj_fdiv_m64(void)
+void _adj_fdiv_m64(void)
 {
   TRACE("(): stub");
 }
@@ -771,7 +771,7 @@
  *    I _think_ this function is intended to work around the Pentium
  *    fdiv bug.
  */
-void __cdecl MSVCRT__adj_fdiv_r(void)
+void _adj_fdiv_r(void)
 {
   TRACE("(): stub");
 }
@@ -785,7 +785,7 @@
  *    I _think_ this function is intended to work around the Pentium
  *    fdiv bug.
  */
-void __cdecl MSVCRT__adj_fdivr_m16i(void)
+void _adj_fdivr_m16i(void)
 {
   TRACE("(): stub");
 }
@@ -799,7 +799,7 @@
  *    I _think_ this function is intended to work around the Pentium
  *    fdiv bug.
  */
-void __cdecl MSVCRT__adj_fdivr_m32(void)
+void _adj_fdivr_m32(void)
 {
   TRACE("(): stub");
 }
@@ -813,7 +813,7 @@
  *    I _think_ this function is intended to work around the Pentium
  *    fdiv bug.
  */
-void __cdecl MSVCRT__adj_fdivr_m32i(void)
+void _adj_fdivr_m32i(void)
 {
   TRACE("(): stub");
 }
@@ -827,7 +827,7 @@
  *    I _think_ this function is intended to work around the Pentium
  *    fdiv bug.
  */
-void __cdecl MSVCRT__adj_fdivr_m64(void)
+void _adj_fdivr_m64(void)
 {
   TRACE("(): stub");
 }
@@ -841,7 +841,7 @@
  *    I _think_ this function is intended to work around the Pentium
  *    fdiv bug.
  */
-void __cdecl MSVCRT__adj_fpatan(void)
+void _adj_fpatan(void)
 {
   TRACE("(): stub");
 }
@@ -855,7 +855,7 @@
  *    I _think_ this function is intended to work around the Pentium
  *    fdiv bug.
  */
-void __cdecl MSVCRT__adj_fprem(void)
+void _adj_fprem(void)
 {
   TRACE("(): stub");
 }
@@ -869,7 +869,7 @@
  *    I _think_ this function is intended to work around the Pentium
  *    fdiv bug.
  */
-void __cdecl MSVCRT__adj_fprem1(void)
+void _adj_fprem1(void)
 {
   TRACE("(): stub");
 }
@@ -883,7 +883,7 @@
  *    I _think_ this function is intended to work around the Pentium
  *    fdiv bug.
  */
-void __cdecl MSVCRT__adj_fptan(void)
+void _adj_fptan(void)
 {
   TRACE("(): stub");
 }
@@ -894,7 +894,7 @@
  *    I _think_ this function should be a variable indicating whether
  *    Pentium fdiv bug safe code should be used.
  */
-void __cdecl MSVCRT__adjust_fdiv(void)
+void _adjust_fdiv(void)
 {
   TRACE("(): stub");
 }
@@ -908,7 +908,7 @@
  *    I _think_ this function is intended to work around the Pentium
  *    fdiv bug.
  */
-void __cdecl MSVCRT__safe_fdiv(void)
+void _safe_fdiv(void)
 {
   TRACE("(): stub");
 }
@@ -922,7 +922,7 @@
  *    I _think_ this function is intended to work around the Pentium
  *    fdiv bug.
  */
-void __cdecl MSVCRT__safe_fdivr(void)
+void _safe_fdivr(void)
 {
   TRACE("(): stub");
 }
@@ -936,7 +936,7 @@
  *    I _think_ this function is intended to work around the Pentium
  *    fdiv bug.
  */
-void __cdecl MSVCRT__safe_fprem(void)
+void _safe_fprem(void)
 {
   TRACE("(): stub");
 }
@@ -951,7 +951,7 @@
  *    I _think_ this function is intended to work around the Pentium
  *    fdiv bug.
  */
-void __cdecl MSVCRT__safe_fprem1(void)
+void _safe_fprem1(void)
 {
   TRACE("(): stub");
 }
diff --git a/dlls/msvcrt/mbcs.c b/dlls/msvcrt/mbcs.c
index 271e06e..bd532f8 100644
--- a/dlls/msvcrt/mbcs.c
+++ b/dlls/msvcrt/mbcs.c
@@ -15,16 +15,16 @@
 unsigned char MSVCRT_mbctype[257];
 int MSVCRT___mb_cur_max = 1;
 
-int __cdecl MSVCRT_isleadbyte(int);
-char *__cdecl MSVCRT__strset(char *, int);
-char *__cdecl MSVCRT__strnset(char *, int, unsigned int);
+int MSVCRT_isleadbyte(int);
+char *_strset(char *, int);
+char *_strnset(char *, int, unsigned int);
 extern unsigned int MSVCRT_current_lc_all_cp;
 
 
 /*********************************************************************
  *		__p__mbctype (MSVCRT.@)
  */
-unsigned char *__cdecl MSVCRT___p__mbctype(void)
+unsigned char *__p__mbctype(void)
 {
   return MSVCRT_mbctype;
 }
@@ -32,7 +32,7 @@
 /*********************************************************************
  *		__p___mb_cur_max(MSVCRT.@)
  */
-int *__cdecl MSVCRT___p___mb_cur_max(void)
+int *__p___mb_cur_max(void)
 {
   return &MSVCRT___mb_cur_max;
 }
@@ -40,7 +40,7 @@
 /*********************************************************************
  *		_mbsnextc(MSVCRT.@)
  */
-unsigned int __cdecl MSVCRT__mbsnextc(const unsigned char *str)
+unsigned int _mbsnextc(const unsigned char *str)
 {
   if(MSVCRT___mb_cur_max > 1 && MSVCRT_isleadbyte(*str))
     return *str << 8 | str[1];
@@ -50,7 +50,7 @@
 /*********************************************************************
  *		_mbscmp(MSVCRT.@)
  */
-int __cdecl MSVCRT__mbscmp(const char *str, const char *cmp)
+int _mbscmp(const char *str, const char *cmp)
 {
   if(MSVCRT___mb_cur_max > 1)
   {
@@ -60,8 +60,8 @@
         return *cmp ? -1 : 0;
       if(!*cmp)
         return 1;
-      strc = MSVCRT__mbsnextc(str);
-      cmpc = MSVCRT__mbsnextc(cmp);
+      strc = _mbsnextc(str);
+      cmpc = _mbsnextc(cmp);
       if(strc != cmpc)
         return strc < cmpc ? -1 : 1;
       str +=(strc > 255) ? 2 : 1;
@@ -74,18 +74,18 @@
 /*********************************************************************
  *		_mbsicmp(MSVCRT.@)
  */
-int __cdecl MSVCRT__mbsicmp(const char *str, const char *cmp)
+int _mbsicmp(const char *str, const char *cmp)
 {
   /* FIXME: No tolower() for mb strings yet */
   if(MSVCRT___mb_cur_max > 1)
-    return MSVCRT__mbscmp(str, cmp);
+    return _mbscmp(str, cmp);
   return strcasecmp(str, cmp); /* ASCII CP */
 }
 
 /*********************************************************************
  *		_mbsncmp    (MSVCRT.@)
  */
-int __cdecl MSVCRT__mbsncmp(const char *str, const char *cmp, unsigned int len)
+int _mbsncmp(const char *str, const char *cmp, unsigned int len)
 {
   if(!len)
     return 0;
@@ -99,8 +99,8 @@
         return *cmp ? -1 : 0;
       if(!*cmp)
         return 1;
-      strc = MSVCRT__mbsnextc(str);
-      cmpc = MSVCRT__mbsnextc(cmp);
+      strc = _mbsnextc(str);
+      cmpc = _mbsnextc(cmp);
       if(strc != cmpc)
         return strc < cmpc ? -1 : 1;
       str +=(strc > 255) ? 2 : 1;
@@ -116,18 +116,18 @@
  *
  * Compare two multibyte strings case insensitively to 'len' characters.
  */
-int __cdecl MSVCRT__mbsnicmp(const char *str, const char *cmp, unsigned int len)
+int _mbsnicmp(const char *str, const char *cmp, unsigned int len)
 {
   /* FIXME: No tolower() for mb strings yet */
   if(MSVCRT___mb_cur_max > 1)
-    return MSVCRT__mbsncmp(str, cmp, len);
+    return _mbsncmp(str, cmp, len);
   return strncasecmp(str, cmp, len); /* ASCII CP */
 }
 
 /*********************************************************************
  *		_mbsinc(MSVCRT.@)
  */
-char *__cdecl MSVCRT__mbsinc(const unsigned char *str)
+char *_mbsinc(const unsigned char *str)
 {
   if(MSVCRT___mb_cur_max > 1 && MSVCRT_isleadbyte(*str))
     return (char *)str + 2; /* MB char */
@@ -138,14 +138,14 @@
 /*********************************************************************
  *		_mbsninc(MSVCRT.@)
  */
-char *MSVCRT__mbsninc(const char *str, unsigned int num)
+char *_mbsninc(const char *str, unsigned int num)
 {
   if(!str || num < 1)
     return NULL;
   if(MSVCRT___mb_cur_max > 1)
   {
     while(num--)
-      str = MSVCRT__mbsinc(str);
+      str = _mbsinc(str);
     return (char *)str;
   }
   return (char *)str + num; /* ASCII CP */
@@ -154,7 +154,7 @@
 /*********************************************************************
  *		_mbslen(MSVCRT.206)
  */
-int __cdecl MSVCRT__mbslen(const unsigned char *str)
+int _mbslen(const unsigned char *str)
 {
   if(MSVCRT___mb_cur_max > 1)
   {
@@ -172,7 +172,7 @@
 /*********************************************************************
  *		_mbsrchr(MSVCRT.@)
  */
-char *__cdecl MSVCRT__mbsrchr(const char *s,unsigned int x)
+char *_mbsrchr(const char *s,unsigned int x)
 {
   /* FIXME: handle multibyte strings */
   return strrchr(s,x);
@@ -181,7 +181,7 @@
 /*********************************************************************
  *		mbtowc(MSVCRT.@)
  */
-int __cdecl MSVCRT_mbtowc(WCHAR *dst, const unsigned char *str, unsigned int n)
+int MSVCRT_mbtowc(WCHAR *dst, const unsigned char *str, unsigned int n)
 {
   if(n <= 0 || !str)
     return 0;
@@ -198,7 +198,7 @@
 /*********************************************************************
  *		_mbccpy(MSVCRT.@)
  */
-void __cdecl MSVCRT__mbccpy(char *dest, const unsigned char *src)
+void _mbccpy(char *dest, const unsigned char *src)
 {
   *dest++ = *src;
   if(MSVCRT___mb_cur_max > 1 && MSVCRT_isleadbyte(*src))
@@ -208,7 +208,7 @@
 /*********************************************************************
  *		_mbbtombc(MSVCRT.@)
  */
-unsigned int __cdecl MSVCRT__mbbtombc(unsigned int c)
+unsigned int _mbbtombc(unsigned int c)
 {
   if(MSVCRT___mb_cur_max > 1 &&
      ((c >= 0x20 && c <=0x7e) ||(c >= 0xa1 && c <= 0xdf)))
@@ -223,7 +223,7 @@
 /*********************************************************************
  *		_mbclen(MSVCRT.@)
  */
-unsigned int __cdecl MSVCRT__mbclen(const unsigned char *str)
+unsigned int _mbclen(const unsigned char *str)
 {
   return MSVCRT_isleadbyte(*str) ? 2 : 1;
 }
@@ -231,7 +231,7 @@
 /*********************************************************************
  *		_ismbbkana(MSVCRT.@)
  */
-int __cdecl MSVCRT__ismbbkana(unsigned int c)
+int _ismbbkana(unsigned int c)
 {
   /* FIXME: use lc_ctype when supported, not lc_all */
   if(MSVCRT_current_lc_all_cp == 932)
@@ -245,7 +245,7 @@
 /*********************************************************************
  *		_ismbchira(MSVCRT.@)
  */
-int __cdecl MSVCRT__ismbchira(unsigned int c)
+int _ismbchira(unsigned int c)
 {
   /* FIXME: use lc_ctype when supported, not lc_all */
   if(MSVCRT_current_lc_all_cp == 932)
@@ -259,13 +259,13 @@
 /*********************************************************************
  *		_ismbckata(MSVCRT.@)
  */
-int __cdecl MSVCRT__ismbckata(unsigned int c)
+int _ismbckata(unsigned int c)
 {
   /* FIXME: use lc_ctype when supported, not lc_all */
   if(MSVCRT_current_lc_all_cp == 932)
   {
     if(c < 256)
-      return MSVCRT__ismbbkana(c);
+      return _ismbbkana(c);
     /* Japanese/Katakana, CP 932 */
     return (c >= 0x8340 && c <= 0x8396 && c != 0x837f);
   }
@@ -275,7 +275,7 @@
 /*********************************************************************
  *		_ismbblead(MSVCRT.@)
  */
-int __cdecl MSVCRT__ismbblead(unsigned int c)
+int _ismbblead(unsigned int c)
 {
   /* FIXME: should reference MSVCRT_mbctype */
   return MSVCRT___mb_cur_max > 1 && MSVCRT_isleadbyte(c);
@@ -285,16 +285,16 @@
 /*********************************************************************
  *		_ismbbtrail(MSVCRT.@)
  */
-int __cdecl MSVCRT__ismbbtrail(unsigned int c)
+int _ismbbtrail(unsigned int c)
 {
   /* FIXME: should reference MSVCRT_mbctype */
-  return !MSVCRT__ismbblead(c);
+  return !_ismbblead(c);
 }
 
 /*********************************************************************
  *		_ismbslead(MSVCRT.@)
  */
-int __cdecl MSVCRT__ismbslead(const unsigned char *start, const unsigned char *str)
+int _ismbslead(const unsigned char *start, const unsigned char *str)
 {
   /* Lead bytes can also be trail bytes if caller messed up
    * iterating through the string...
@@ -313,19 +313,19 @@
 /*********************************************************************
  *		_ismbstrail(MSVCRT.@)
  */
-int __cdecl MSVCRT__ismbstrail(const char *start, const unsigned char *str)
+int _ismbstrail(const char *start, const unsigned char *str)
 {
   /* Must not be a lead, and must be preceeded by one */
-  return !MSVCRT__ismbslead(start, str) && MSVCRT_isleadbyte(str[-1]);
+  return !_ismbslead(start, str) && MSVCRT_isleadbyte(str[-1]);
 }
 
 /*********************************************************************
  *		_mbsdec(MSVCRT.@)
  */
-char *__cdecl MSVCRT__mbsdec(const char *start, const char *cur)
+char *_mbsdec(const char *start, const char *cur)
 {
   if(MSVCRT___mb_cur_max > 1)
-    return (char *)(MSVCRT__ismbstrail(start,cur-1) ? cur - 2 : cur -1);
+    return (char *)(_ismbstrail(start,cur-1) ? cur - 2 : cur -1);
 
   return (char *)cur - 1; /* ASCII CP or SB char */
 }
@@ -333,12 +333,12 @@
 /*********************************************************************
  *		_mbsset(MSVCRT.@)
  */
-char *__cdecl MSVCRT__mbsset(char *str, unsigned int c)
+char *_mbsset(char *str, unsigned int c)
 {
   char *ret = str;
 
   if(MSVCRT___mb_cur_max == 1 || c < 256)
-    return MSVCRT__strset(str, c); /* ASCII CP or SB char */
+    return _strset(str, c); /* ASCII CP or SB char */
 
   c &= 0xffff; /* Strip high bits */
 
@@ -356,7 +356,7 @@
 /*********************************************************************
  *		_mbsnset(MSVCRT.@)
  */
-char *__cdecl MSVCRT__mbsnset(char *str, unsigned int c, unsigned int len)
+char *_mbsnset(char *str, unsigned int c, unsigned int len)
 {
   char *ret = str;
 
@@ -364,7 +364,7 @@
     return ret;
 
   if(MSVCRT___mb_cur_max == 1 || c < 256)
-    return MSVCRT__strnset(str, c, len); /* ASCII CP or SB char */
+    return _strnset(str, c, len); /* ASCII CP or SB char */
 
   c &= 0xffff; /* Strip high bits */
 
@@ -382,7 +382,7 @@
 /*********************************************************************
  *		_mbstrlen(MSVCRT.@)
  */
-int __cdecl MSVCRT__mbstrlen(const unsigned char *str)
+int _mbstrlen(const unsigned char *str)
 {
   if(MSVCRT___mb_cur_max > 1)
   {
@@ -400,7 +400,7 @@
 /*********************************************************************
  *		_mbsncpy(MSVCRT.@)
  */
-char *__cdecl MSVCRT__mbsncpy(char *dst, const char *src, unsigned int len)
+char *_mbsncpy(char *dst, const char *src, unsigned int len)
 {
   if(!len)
     return dst;
@@ -428,12 +428,12 @@
  *
  * Find a multibyte character in a multibyte string.
  */
-char *__cdecl MSVCRT__mbschr(const char *str, unsigned int c)
+char *_mbschr(const char *str, unsigned int c)
 {
   if(MSVCRT___mb_cur_max > 1)
   {
     unsigned int next;
-    while((next = MSVCRT__mbsnextc(str)))
+    while((next = _mbsnextc(str)))
     {
       if(next == c)
         return (char *)str;
@@ -447,7 +447,7 @@
 /*********************************************************************
  *		_mbsnccnt(MSVCRT.@)
  */
-unsigned int __cdecl MSVCRT__mbsnccnt(const unsigned char *str, unsigned int len)
+unsigned int _mbsnccnt(const unsigned char *str, unsigned int len)
 {
   int ret = 0;
 
@@ -472,12 +472,12 @@
 /*********************************************************************
  *		_mbsncat(MSVCRT.@)
  */
-char *__cdecl MSVCRT__mbsncat(char *dst, const unsigned char *src, unsigned int len)
+char *_mbsncat(char *dst, const unsigned char *src, unsigned int len)
 {
   if(MSVCRT___mb_cur_max > 1)
   {
     char *res = dst;
-    dst += MSVCRT__mbslen(dst);
+    dst += _mbslen(dst);
     while(*src && len--)
     {
       *dst = *src;
diff --git a/dlls/msvcrt/misc.c b/dlls/msvcrt/misc.c
index 8d1ec73..0535958 100644
--- a/dlls/msvcrt/misc.c
+++ b/dlls/msvcrt/misc.c
@@ -8,12 +8,12 @@
 
 DEFAULT_DEBUG_CHANNEL(msvcrt);
 
-typedef int (__cdecl *MSVCRT_comp_func)(const void*, const void*);
+typedef int (*MSVCRT_comp_func)(const void*, const void*);
 
 /*********************************************************************
  *		_beep (MSVCRT.@)
  */
-void __cdecl MSVCRT__beep( unsigned int freq, unsigned int duration)
+void _beep( unsigned int freq, unsigned int duration)
 {
     TRACE(":Freq %d, Duration %d\n",freq,duration);
     Beep(freq, duration);
@@ -24,7 +24,7 @@
 /*********************************************************************
  *		rand (MSVCRT.@)
  */
-int __cdecl MSVCRT_rand()
+int MSVCRT_rand()
 {
   return (rand() & 0x7fff);
 }
@@ -32,17 +32,18 @@
 /*********************************************************************
  *		_sleep (MSVCRT.@)
  */
-void __cdecl MSVCRT__sleep(unsigned long timeout)
+void _sleep(unsigned long timeout)
 {
-  TRACE("MSVCRT__sleep for %ld milliseconds\n",timeout);
+  TRACE("_sleep for %ld milliseconds\n",timeout);
   Sleep((timeout)?timeout:1);
 }
 
 /*********************************************************************
  *		_lfind (MSVCRT.@)
  */
-void* __cdecl MSVCRT__lfind(const void * match, const void * start,
-unsigned int * array_size,unsigned int elem_size, MSVCRT_comp_func cf)
+void* _lfind(const void* match, const void* start,
+             unsigned int* array_size, unsigned int elem_size,
+             MSVCRT_comp_func cf)
 {
   unsigned int size = *array_size;
   if (size)
@@ -58,8 +59,9 @@
 /*********************************************************************
  *		_lsearch (MSVCRT.@)
  */
-void * __cdecl MSVCRT__lsearch(const void * match,void *  start,
-unsigned int * array_size,unsigned int elem_size, MSVCRT_comp_func cf)
+void* _lsearch(const void* match, void* start,
+               unsigned int* array_size, unsigned int elem_size,
+               MSVCRT_comp_func cf)
 {
   unsigned int size = *array_size;
   if (size)
@@ -79,7 +81,7 @@
 /*********************************************************************
  *		_chkesp (MSVCRT.@)
  */
-void __cdecl MSVCRT__chkesp(void)
+void _chkesp(void)
 {
 
 }
diff --git a/dlls/msvcrt/msvcrt.h b/dlls/msvcrt/msvcrt.h
index 073b22f..f59a7c1 100644
--- a/dlls/msvcrt/msvcrt.h
+++ b/dlls/msvcrt/msvcrt.h
@@ -34,13 +34,13 @@
   ((MSVCRT_thread_data*)TlsGetValue(MSVCRT_tls_index))->x = y
 
 void  MSVCRT__set_errno(int);
-int   __cdecl MSVCRT__set_new_mode(int mode);
-int   __cdecl MSVCRT__fcloseall(void);
-void *__cdecl MSVCRT_malloc(unsigned int);
-void *__cdecl MSVCRT_calloc(unsigned int, unsigned int);
-void  __cdecl MSVCRT_free(void *);
-int   __cdecl MSVCRT__cputs(const char *);
-int   __cdecl MSVCRT__cprintf( const char *, ... );
-char *__cdecl MSVCRT__strdup(const char *);
+int   MSVCRT__set_new_mode(int mode);
+int   _fcloseall(void);
+void* MSVCRT_malloc(unsigned int);
+void* MSVCRT_calloc(unsigned int, unsigned int);
+void  MSVCRT_free(void *);
+int   _cputs(const char *);
+int   _cprintf( const char *, ... );
+char* _strdup(const char *);
 
 #endif /* __WINE_MSVCRT_H */
diff --git a/dlls/msvcrt/msvcrt.spec b/dlls/msvcrt/msvcrt.spec
index 83d9e1f..3b6ec88 100644
--- a/dlls/msvcrt/msvcrt.spec
+++ b/dlls/msvcrt/msvcrt.spec
@@ -57,30 +57,30 @@
 @ stub ?terminate@@YAXXZ #()
 @ stub ?unexpected@@YAXXZ #()
 @ stdcall ?what@exception@@UBEPBDXZ(ptr) MSVCRT_exception_what
-@ cdecl -noimport _CIacos() MSVCRT__CIacos
-@ cdecl -noimport _CIasin() MSVCRT__CIasin
-@ cdecl -noimport _CIatan() MSVCRT__CIatan
-@ cdecl -noimport _CIatan2() MSVCRT__CIatan2
-@ cdecl -noimport _CIcos() MSVCRT__CIcos
-@ cdecl -noimport _CIcosh() MSVCRT__CIcosh
-@ cdecl -noimport _CIexp() MSVCRT__CIexp
-@ cdecl -noimport _CIfmod() MSVCRT__CIfmod
-@ cdecl -noimport _CIlog() MSVCRT__CIlog
-@ cdecl -noimport _CIlog10() MSVCRT__CIlog10
-@ cdecl -noimport _CIpow() MSVCRT__CIpow
-@ cdecl -noimport _CIsin() MSVCRT__CIsin
-@ cdecl -noimport _CIsinh() MSVCRT__CIsinh
-@ cdecl -noimport _CIsqrt() MSVCRT__CIsqrt
-@ cdecl -noimport _CItan() MSVCRT__CItan
-@ cdecl -noimport _CItanh() MSVCRT__CItanh
+@ cdecl -noimport _CIacos() _CIacos
+@ cdecl -noimport _CIasin() _CIasin
+@ cdecl -noimport _CIatan() _CIatan
+@ cdecl -noimport _CIatan2() _CIatan2
+@ cdecl -noimport _CIcos() _CIcos
+@ cdecl -noimport _CIcosh() _CIcosh
+@ cdecl -noimport _CIexp() _CIexp
+@ cdecl -noimport _CIfmod() _CIfmod
+@ cdecl -noimport _CIlog() _CIlog
+@ cdecl -noimport _CIlog10() _CIlog10
+@ cdecl -noimport _CIpow() _CIpow
+@ cdecl -noimport _CIsin() _CIsin
+@ cdecl -noimport _CIsinh() _CIsinh
+@ cdecl -noimport _CIsqrt() _CIsqrt
+@ cdecl -noimport _CItan() _CItan
+@ cdecl -noimport _CItanh() _CItanh
 @ stub _CxxThrowException
-@ cdecl -i386 -norelay _EH_prolog() MSVCRT__EH_prolog
-@ cdecl _Getdays() MSVCRT__Getdays
-@ cdecl _Getmonths() MSVCRT__Getmonths
-@ cdecl _Getnames() MSVCRT__Getnames
+@ cdecl -i386 -norelay _EH_prolog() _EH_prolog
+@ cdecl _Getdays() _Getdays
+@ cdecl _Getmonths() _Getmonths
+@ cdecl _Getnames() _Getnames
 @ extern _HUGE MSVCRT__HUGE
-@ cdecl _Strftime(str long str ptr ptr) MSVCRT__Strftime
-@ cdecl _XcptFilter(long ptr) MSVCRT__XcptFilter
+@ cdecl _Strftime(str long str ptr ptr) _Strftime
+@ cdecl _XcptFilter(long ptr) _XcptFilter
 @ stub __CxxFrameHandler
 @ stub __CxxLongjmpUnwind
 @ stub __RTCastToVoid
@@ -93,10 +93,10 @@
 @ stub __crtCompareStringA
 @ stub __crtGetLocaleInfoW
 @ stub __crtLCMapStringA
-@ cdecl __dllonexit(ptr ptr ptr) MSVCRT___dllonexit
-@ cdecl __doserrno() MSVCRT___doserrno
+@ cdecl __dllonexit(ptr ptr ptr) __dllonexit
+@ cdecl __doserrno() __doserrno
 @ stub __fpecode #()
-@ cdecl __getmainargs(ptr ptr ptr long ptr) MSVCRT___getmainargs
+@ cdecl __getmainargs(ptr ptr ptr long ptr) __getmainargs
 @ extern __initenv MSVCRT___initenv
 @ cdecl __isascii(long) MSVCRT___isascii
 @ cdecl __iscsym(long) MSVCRT___iscsym
@@ -106,34 +106,34 @@
 @ stub __lc_handle
 @ stub __lconv_init
 @ extern __mb_cur_max MSVCRT___mb_cur_max
-@ cdecl __p___argc() MSVCRT___p___argc
-@ cdecl __p___argv() MSVCRT___p___argv
-@ cdecl __p___initenv() MSVCRT___p___initenv
-@ cdecl __p___mb_cur_max() MSVCRT___p___mb_cur_max
-@ cdecl __p___wargv() MSVCRT___p___wargv
-@ cdecl __p___winitenv() MSVCRT___p___winitenv
-@ cdecl __p__acmdln()  MSVCRT___p__acmdln
+@ cdecl __p___argc() __p___argc
+@ cdecl __p___argv() __p___argv
+@ cdecl __p___initenv() __p___initenv
+@ cdecl __p___mb_cur_max() __p___mb_cur_max
+@ cdecl __p___wargv() __p___wargv
+@ cdecl __p___winitenv() __p___winitenv
+@ cdecl __p__acmdln()  __p__acmdln
 @ stub __p__amblksiz #()
-@ cdecl __p__commode()  MSVCRT___p__commode
+@ cdecl __p__commode()  __p__commode
 @ stub __p__daylight #()
 @ stub __p__dstbias #()
-@ cdecl __p__environ() MSVCRT___p__environ
+@ cdecl __p__environ() __p__environ
 @ stub __p__fileinfo #()
-@ cdecl __p__fmode() MSVCRT___p__fmode
-@ cdecl __p__iob() MSVCRT___p__iob
+@ cdecl __p__fmode() __p__fmode
+@ cdecl __p__iob() __p__iob
 @ stub __p__mbcasemap #()
-@ cdecl __p__mbctype() MSVCRT___p__mbctype
-@ cdecl __p__osver()  MSVCRT___p__osver
-@ cdecl __p__pctype() MSVCRT___p__pctype
+@ cdecl __p__mbctype() __p__mbctype
+@ cdecl __p__osver()  __p__osver
+@ cdecl __p__pctype() __p__pctype
 @ stub __p__pgmptr #()
 @ stub __p__pwctype #()
-@ cdecl __p__timezone() MSVCRT___p__timezone
+@ cdecl __p__timezone() __p__timezone
 @ stub __p__tzname #()
-@ cdecl __p__wcmdln() MSVCRT___p__wcmdln
-@ cdecl __p__wenviron() MSVCRT___p__wenviron
-@ cdecl __p__winmajor() MSVCRT___p__winmajor
-@ cdecl __p__winminor() MSVCRT___p__winminor
-@ cdecl __p__winver() MSVCRT___p__winver
+@ cdecl __p__wcmdln() __p__wcmdln
+@ cdecl __p__wenviron() __p__wenviron
+@ cdecl __p__winmajor() __p__winmajor
+@ cdecl __p__winminor() __p__winminor
+@ cdecl __p__winver() __p__winver
 @ stub __p__wpgmptr #()
 @ stub __pioinfo #()
 @ stub __pxcptinfoptrs #()
@@ -147,70 +147,70 @@
 @ cdecl __unDNameEx() MSVCRT___unDNameEx #FIXME
 @ extern __unguarded_readlc_active MSVCRT___unguarded_readlc_active
 @ extern __wargv MSVCRT___wargv
-@ cdecl __wgetmainargs(ptr ptr ptr long ptr) MSVCRT___wgetmainargs
+@ cdecl __wgetmainargs(ptr ptr ptr long ptr) __wgetmainargs
 @ extern __winitenv MSVCRT___winitenv
-@ cdecl _abnormal_termination() MSVCRT__abnormal_termination
-@ cdecl _access(str long) MSVCRT__access
+@ cdecl _abnormal_termination() _abnormal_termination
+@ cdecl _access(str long) _access
 @ extern _acmdln MSVCRT__acmdln
-@ cdecl _adj_fdiv_m16i() MSVCRT__adj_fdiv_m16i
-@ cdecl _adj_fdiv_m32() MSVCRT__adj_fdiv_m32
-@ cdecl _adj_fdiv_m32i() MSVCRT__adj_fdiv_m32i
-@ cdecl _adj_fdiv_m64() MSVCRT__adj_fdiv_m64
-@ cdecl _adj_fdiv_r() MSVCRT__adj_fdiv_r
-@ cdecl _adj_fdivr_m16i() MSVCRT__adj_fdivr_m16i
-@ cdecl _adj_fdivr_m32() MSVCRT__adj_fdivr_m32
-@ cdecl _adj_fdivr_m32i() MSVCRT__adj_fdivr_m32i
-@ cdecl _adj_fdivr_m64() MSVCRT__adj_fdivr_m64
-@ cdecl _adj_fpatan() MSVCRT__adj_fpatan
-@ cdecl _adj_fprem() MSVCRT__adj_fprem
-@ cdecl _adj_fprem1() MSVCRT__adj_fprem1
-@ cdecl _adj_fptan() MSVCRT__adj_fptan
-@ cdecl _adjust_fdiv() MSVCRT__adjust_fdiv
+@ cdecl _adj_fdiv_m16i() _adj_fdiv_m16i
+@ cdecl _adj_fdiv_m32() _adj_fdiv_m32
+@ cdecl _adj_fdiv_m32i() _adj_fdiv_m32i
+@ cdecl _adj_fdiv_m64() _adj_fdiv_m64
+@ cdecl _adj_fdiv_r() _adj_fdiv_r
+@ cdecl _adj_fdivr_m16i() _adj_fdivr_m16i
+@ cdecl _adj_fdivr_m32() _adj_fdivr_m32
+@ cdecl _adj_fdivr_m32i() _adj_fdivr_m32i
+@ cdecl _adj_fdivr_m64() _adj_fdivr_m64
+@ cdecl _adj_fpatan() _adj_fpatan
+@ cdecl _adj_fprem() _adj_fprem
+@ cdecl _adj_fprem1() _adj_fprem1
+@ cdecl _adj_fptan() _adj_fptan
+@ cdecl _adjust_fdiv() _adjust_fdiv
 @ stub _aexit_rtn
 @ cdecl _amsg_exit(long) MSVCRT__amsg_exit
 @ cdecl _assert(str str long) MSVCRT__assert
 @ stub _atodbl
 @ stub _atoi64 #(str)
 @ stub _atoldbl 
-@ cdecl _beep(long long) MSVCRT__beep
+@ cdecl _beep(long long) _beep
 @ stub _beginthread #(ptr long ptr)
-@ cdecl _beginthreadex (ptr long ptr ptr long ptr) MSVCRT__beginthreadex
+@ cdecl _beginthreadex (ptr long ptr ptr long ptr) _beginthreadex
 @ cdecl _c_exit() MSVCRT__c_exit
-@ cdecl _cabs(long) MSVCRT__cabs
+@ cdecl _cabs(long) _cabs
 @ stub _callnewh
 @ cdecl _cexit() MSVCRT__cexit
-@ cdecl _cgets(str) MSVCRT__cgets
-@ cdecl _chdir(str) MSVCRT__chdir
-@ cdecl _chdrive(long) MSVCRT__chdrive
-@ cdecl _chgsign( double ) MSVCRT__chgsign
-@ cdecl -noimport -i386 _chkesp() MSVCRT__chkesp
-@ cdecl _chmod(str long) MSVCRT__chmod
+@ cdecl _cgets(str) _cgets
+@ cdecl _chdir(str) _chdir
+@ cdecl _chdrive(long) _chdrive
+@ cdecl _chgsign( double ) _chgsign
+@ cdecl -noimport -i386 _chkesp() _chkesp
+@ cdecl _chmod(str long) _chmod
 @ stub _chsize #(long long)
-@ cdecl _clearfp() MSVCRT__clearfp
-@ cdecl _close(long) MSVCRT__close
-@ cdecl _commit(long) MSVCRT__commit
+@ cdecl _clearfp() _clearfp
+@ cdecl _close(long) _close
+@ cdecl _commit(long) _commit
 @ extern _commode MSVCRT__commode
-@ cdecl _control87(long long) MSVCRT__control87
-@ cdecl _controlfp(long long) MSVCRT__controlfp
-@ cdecl _copysign( double double ) MSVCRT__copysign
-@ varargs _cprintf(str) MSVCRT__cprintf
-@ cdecl _cputs(str) MSVCRT__cputs
-@ cdecl _creat(str long) MSVCRT__creat
-@ varargs _cscanf(str) MSVCRT__cscanf
+@ cdecl _control87(long long) _control87
+@ cdecl _controlfp(long long) _controlfp
+@ cdecl _copysign( double double ) _copysign
+@ varargs _cprintf(str) _cprintf
+@ cdecl _cputs(str) _cputs
+@ cdecl _creat(str long) _creat
+@ varargs _cscanf(str) _cscanf
 @ extern _ctype MSVCRT__ctype
-@ cdecl _cwait(ptr long long) MSVCRT__cwait
+@ cdecl _cwait(ptr long long) _cwait
 @ stub _daylight
 @ stub _dstbias
 @ stub _dup #(long)
 @ stub _dup2 #(long long)
 @ cdecl _ecvt( double long ptr ptr) ecvt
 @ stub _endthread #()
-@ cdecl _endthreadex(long) MSVCRT__endthreadex
+@ cdecl _endthreadex(long) _endthreadex
 @ extern _environ MSVCRT__environ
-@ cdecl _eof(long) MSVCRT__eof
+@ cdecl _eof(long) _eof
 @ cdecl _errno() MSVCRT__errno
-@ cdecl _except_handler2(ptr ptr ptr ptr) MSVCRT__except_handler2
-@ cdecl _except_handler3(ptr ptr ptr ptr) MSVCRT__except_handler3
+@ cdecl _except_handler2(ptr ptr ptr ptr) _except_handler2
+@ cdecl _except_handler3(ptr ptr ptr ptr) _except_handler3
 @ stub _execl #(str str) varargs
 @ stub _execle #(str str) varargs
 @ stub _execlp #(str str) varargs
@@ -220,89 +220,89 @@
 @ stub _execvp #(str str)
 @ stub _execvpe #(str str str)
 @ cdecl _exit(long) MSVCRT__exit
-@ cdecl _expand(ptr long) MSVCRT__expand
-@ cdecl _fcloseall() MSVCRT__fcloseall
+@ cdecl _expand(ptr long) _expand
+@ cdecl _fcloseall() _fcloseall
 @ cdecl _fcvt( double long ptr ptr) fcvt
-@ cdecl _fdopen(long str) MSVCRT__fdopen
-@ cdecl _fgetchar() MSVCRT__fgetchar
-@ cdecl _fgetwchar() MSVCRT__fgetwchar
-@ cdecl _filbuf(ptr) MSVCRT__filbuf
+@ cdecl _fdopen(long str) _fdopen
+@ cdecl _fgetchar() _fgetchar
+@ cdecl _fgetwchar() _fgetwchar
+@ cdecl _filbuf(ptr) _filbuf
 @ stub _fileinfo
-@ cdecl _filelength(long) MSVCRT__filelength
+@ cdecl _filelength(long) _filelength
 @ stub _filelengthi64 #(long)
-@ cdecl _fileno(ptr) MSVCRT__fileno
-@ cdecl _findclose(long) MSVCRT__findclose
-@ cdecl _findfirst(str ptr) MSVCRT__findfirst
+@ cdecl _fileno(ptr) _fileno
+@ cdecl _findclose(long) _findclose
+@ cdecl _findfirst(str ptr) _findfirst
 @ stub _findfirsti64 #(str ptr)
-@ cdecl _findnext(long ptr) MSVCRT__findnext
+@ cdecl _findnext(long ptr) _findnext
 @ stub _findnexti64 #(long ptr)
-@ cdecl _finite( double ) MSVCRT__finite
-@ cdecl _flsbuf(long ptr) MSVCRT__flsbuf
-@ cdecl _flushall() MSVCRT__flushall
+@ cdecl _finite( double ) _finite
+@ cdecl _flsbuf(long ptr) _flsbuf
+@ cdecl _flushall() _flushall
 @ extern _fmode MSVCRT__fmode
-@ cdecl _fpclass(double) MSVCRT__fpclass
+@ cdecl _fpclass(double) _fpclass
 @ stub _fpieee_flt
-@ cdecl _fpreset() MSVCRT__fpreset
-@ cdecl _fputchar(long) MSVCRT__fputchar
-@ cdecl _fputwchar(long) MSVCRT__fputwchar
-@ cdecl _fsopen(str str long) MSVCRT__fsopen
-@ cdecl _fstat(long ptr) MSVCRT__fstat
+@ cdecl _fpreset() _fpreset
+@ cdecl _fputchar(long) _fputchar
+@ cdecl _fputwchar(long) _fputwchar
+@ cdecl _fsopen(str str long) _fsopen
+@ cdecl _fstat(long ptr) _fstat
 @ stub _fstati64 #(long ptr)
-@ cdecl _ftime(ptr) MSVCRT__ftime
+@ cdecl _ftime(ptr) _ftime
 @ forward -noimport _ftol ntdll._ftol
-@ cdecl _fullpath(str str long) MSVCRT__fullpath
-@ cdecl _futime(long ptr) MSVCRT__futime
+@ cdecl _fullpath(str str long) _fullpath
+@ cdecl _futime(long ptr) _futime
 @ cdecl _gcvt( double long str) gcvt
-@ cdecl _get_osfhandle(long) MSVCRT__get_osfhandle
+@ cdecl _get_osfhandle(long) _get_osfhandle
 @ stub _get_sbh_threshold #()
-@ cdecl _getch() MSVCRT__getch
-@ cdecl _getche() MSVCRT__getche
-@ cdecl _getcwd(str long) MSVCRT__getcwd
-@ cdecl _getdcwd(long str long) MSVCRT__getdcwd
-@ cdecl _getdiskfree(long ptr) MSVCRT__getdiskfree
+@ cdecl _getch() _getch
+@ cdecl _getche() _getche
+@ cdecl _getcwd(str long) _getcwd
+@ cdecl _getdcwd(long str long) _getdcwd
+@ cdecl _getdiskfree(long ptr) _getdiskfree
 @ forward _getdllprocaddr kernel32.GetProcAddress
-@ cdecl _getdrive() MSVCRT__getdrive
+@ cdecl _getdrive() _getdrive
 @ forward _getdrives kernel32.GetLogicalDrives
 @ stub _getmaxstdio #()
-@ cdecl _getmbcp() MSVCRT__getmbcp
+@ cdecl _getmbcp() _getmbcp
 @ forward _getpid kernel32.GetCurrentProcessId
 @ stub _getsystime #(ptr)
-@ cdecl _getw(ptr) MSVCRT__getw
+@ cdecl _getw(ptr) _getw
 @ stub _getws #(wstr)
-@ cdecl _global_unwind2(ptr) MSVCRT__global_unwind2
+@ cdecl _global_unwind2(ptr) _global_unwind2
 @ stub _heapadd #()
-@ cdecl _heapchk() MSVCRT__heapchk
-@ cdecl _heapmin() MSVCRT__heapmin
-@ cdecl _heapset(long) MSVCRT__heapset
+@ cdecl _heapchk() _heapchk
+@ cdecl _heapmin() _heapmin
+@ cdecl _heapset(long) _heapset
 @ stub _heapused #(ptr ptr)
-@ cdecl _heapwalk(ptr) MSVCRT__heapwalk
+@ cdecl _heapwalk(ptr) _heapwalk
 @ cdecl _hypot(double double) hypot
 @ stub _i64toa #(long str long)
 @ stub _i64tow #(long wstr long)
-@ cdecl _initterm(ptr ptr) MSVCRT__initterm
+@ cdecl _initterm(ptr ptr) _initterm
 @ stub _inp #(long) -i386
 @ stub _inpd #(long) -i386
 @ stub _inpw #(long) -i386
 @ extern _iob MSVCRT__iob
-@ cdecl _isatty(long) MSVCRT__isatty
-@ cdecl _isctype(long long) MSVCRT__isctype
+@ cdecl _isatty(long) _isatty
+@ cdecl _isctype(long long) _isctype
 @ stub _ismbbalnum #(long)
 @ stub _ismbbalpha #(long)
 @ stub _ismbbgraph #(long)
 @ stub _ismbbkalnum #(long)
-@ cdecl _ismbbkana(long) MSVCRT__ismbbkana
+@ cdecl _ismbbkana(long) _ismbbkana
 @ stub _ismbbkprint #(long)
 @ stub _ismbbkpunct #(long)
-@ cdecl _ismbblead(long) MSVCRT__ismbblead
+@ cdecl _ismbblead(long) _ismbblead
 @ stub _ismbbprint #(long)
 @ stub _ismbbpunct #(long)
-@ cdecl _ismbbtrail(long) MSVCRT__ismbbtrail
+@ cdecl _ismbbtrail(long) _ismbbtrail
 @ stub _ismbcalnum #(long)
 @ stub _ismbcalpha #(long)
 @ stub _ismbcdigit #(long)
 @ stub _ismbcgraph #(long)
-@ cdecl _ismbchira(long) MSVCRT__ismbchira
-@ cdecl _ismbckata(long) MSVCRT__ismbckata
+@ cdecl _ismbchira(long) _ismbchira
+@ cdecl _ismbckata(long) _ismbckata
 @ stub _ismbcl0 #(long)
 @ stub _ismbcl1 #(long)
 @ stub _ismbcl2 #(long)
@@ -313,37 +313,38 @@
 @ stub _ismbcspace #(long)
 @ stub _ismbcsymbol #(long)
 @ stub _ismbcupper #(long)
-@ cdecl _ismbslead(ptr ptr) MSVCRT__ismbslead
-@ cdecl _ismbstrail(ptr ptr) MSVCRT__ismbstrail
-@ cdecl _isnan( double ) MSVCRT__isnan
+@ cdecl _ismbslead(ptr ptr) _ismbslead
+@ cdecl _ismbstrail(ptr ptr) _ismbstrail
+@ cdecl _isnan( double ) _isnan
 @ forward -noimport _itoa ntdll._itoa
-@ cdecl _itow(long wstr long) MSVCRT__itow
+@ cdecl _itow(long wstr long) _itow
 @ cdecl _j0(double) j0
 @ cdecl _j1(double) j1
 @ cdecl _jn(long double) jn
-@ cdecl _kbhit() MSVCRT__kbhit
+@ cdecl _kbhit() _kbhit
 @ stub _lfind
-@ cdecl _loaddll(str) MSVCRT__loaddll
-@ cdecl _local_unwind2(ptr long) MSVCRT__local_unwind2
+@ cdecl _loaddll(str) _loaddll
+@ cdecl _local_unwind2(ptr long) _local_unwind2
 @ stub _lock
 @ stub _locking #(long long long)
-@ cdecl _logb( double ) MSVCRT__logb
+@ cdecl _logb( double ) _logb
 @ stub _longjmpex
-@ cdecl _lrotl(long long) MSVCRT__lrotl
-@ cdecl _lrotr(long long) MSVCRT__lrotr
-@ cdecl _lsearch(ptr ptr long long ptr) MSVCRT__lsearch
-@ cdecl _lseek(long long long) MSVCRT__lseek
+@ cdecl _lrotl(long long) _lrotl
+@ cdecl _lrotr(long long) _lrotr
+@ cdecl _lsearch(ptr ptr long long ptr) _lsearch
+@ cdecl _lseek(long long long) _lseek
 @ stub _lseeki64 #(long long long)
 @ forward -noimport _ltoa ntdll._ltoa
 @ stub _ltow #(long)
-@ cdecl _makepath(str str str str str) MSVCRT__makepath
-@ cdecl _mbbtombc(long) MSVCRT__mbbtombc
+@ cdecl _makepath(str str str str str) _makepath
+@ cdecl _matherr(ptr) _matherr
+@ cdecl _mbbtombc(long) _mbbtombc
 @ stub _mbbtype #(long long)
 @ stub _mbcasemap
 @ cdecl _mbccpy (str str) strcpy
 @ stub _mbcjistojms #(long)
 @ stub _mbcjmstojis #(long)
-@ cdecl _mbclen(ptr) MSVCRT__mbclen
+@ cdecl _mbclen(ptr) _mbclen
 @ stub _mbctohira #(long)
 @ stub _mbctokata #(long)
 @ stub _mbctolower #(long)
@@ -352,17 +353,17 @@
 @ stub _mbctype
 @ stub _mbsbtype #(ptr long)
 @ cdecl _mbscat(str str) strcat
-@ cdecl _mbschr(str long) MSVCRT__mbschr
-@ cdecl _mbscmp(str str) MSVCRT__mbscmp
+@ cdecl _mbschr(str long) _mbschr
+@ cdecl _mbscmp(str str) _mbscmp
 @ stub _mbscoll #(str str)
 @ cdecl _mbscpy(ptr str) strcpy
 @ stub _mbscspn #(str str)
-@ cdecl _mbsdec(ptr ptr) MSVCRT__mbsdec
-@ cdecl _mbsdup(str) MSVCRT__strdup
-@ cdecl _mbsicmp(str str) MSVCRT__mbsicmp
+@ cdecl _mbsdec(ptr ptr) _mbsdec
+@ cdecl _mbsdup(str) _strdup
+@ cdecl _mbsicmp(str str) _mbsicmp
 @ stub _mbsicoll #(str str)
-@ cdecl _mbsinc(str) MSVCRT__mbsinc
-@ cdecl _mbslen(str) MSVCRT__mbslen
+@ cdecl _mbsinc(str) _mbsinc
+@ cdecl _mbslen(str) _mbslen
 @ stub _mbslwr #(str)
 @ stub _mbsnbcat #(str str long)
 @ stub _mbsnbcmp #(str str long)
@@ -372,35 +373,35 @@
 @ stub _mbsnbicmp #(str str long)
 @ stub _mbsnbicoll #(str str long)
 @ stub _mbsnbset #(str long long)
-@ cdecl _mbsncat(str str long) MSVCRT__mbsncat
-@ cdecl _mbsnccnt(str long) MSVCRT__mbsnccnt
-@ cdecl _mbsncmp(str str long) MSVCRT__mbsncmp
+@ cdecl _mbsncat(str str long) _mbsncat
+@ cdecl _mbsnccnt(str long) _mbsnccnt
+@ cdecl _mbsncmp(str str long) _mbsncmp
 @ stub _mbsncoll #(ptr str long)
-@ cdecl _mbsncpy(str str long) MSVCRT__mbsncpy
-@ cdecl _mbsnextc(str) MSVCRT__mbsnextc
-@ cdecl _mbsnicmp(str str long) MSVCRT__mbsnicmp
+@ cdecl _mbsncpy(str str long) _mbsncpy
+@ cdecl _mbsnextc(str) _mbsnextc
+@ cdecl _mbsnicmp(str str long) _mbsnicmp
 @ stub _mbsnicoll #(str str long)
-@ cdecl _mbsninc(str long) MSVCRT__mbsninc
-@ cdecl _mbsnset(str long long) MSVCRT__mbsnset
+@ cdecl _mbsninc(str long) _mbsninc
+@ cdecl _mbsnset(str long long) _mbsnset
 @ stub _mbspbrk #(str str)
-@ cdecl _mbsrchr(str long) MSVCRT__mbsrchr
+@ cdecl _mbsrchr(str long) _mbsrchr
 @ stub _mbsrev #(str)
-@ cdecl _mbsset(str long) MSVCRT__mbsset
+@ cdecl _mbsset(str long) _mbsset
 @ stub _mbsspn #(str str)
 @ stub _mbsspnp #(str str)
 @ cdecl _mbsstr(str str) strstr
 @ stub _mbstok #(str str)
-@ cdecl _mbstrlen(str) MSVCRT__mbstrlen
+@ cdecl _mbstrlen(str) _mbstrlen
 @ stub _mbsupr #(str)
 @ cdecl _memccpy(ptr ptr long long) memccpy
 @ forward -noimport _memicmp ntdll._memicmp
-@ cdecl _mkdir(str) MSVCRT__mkdir
-@ cdecl _mktemp(str) MSVCRT__mktemp
-@ cdecl _msize(ptr) MSVCRT__msize
-@ cdecl _nextafter(double double) MSVCRT__nextafter
-@ cdecl _onexit(ptr) MSVCRT__onexit
-@ cdecl _open(str long) MSVCRT__open
-@ cdecl _open_osfhandle(long long) MSVCRT__open_osfhandle
+@ cdecl _mkdir(str) _mkdir
+@ cdecl _mktemp(str) _mktemp
+@ cdecl _msize(ptr) _msize
+@ cdecl _nextafter(double double) _nextafter
+@ cdecl _onexit(ptr) _onexit
+@ cdecl _open(str long) _open
+@ cdecl _open_osfhandle(long long) _open_osfhandle
 @ stub _osver
 @ stub _outp #(long long)
 @ stub _outpd #(long long)
@@ -410,23 +411,23 @@
 @ stub _pgmptr
 @ stub _pipe #(ptr long long)
 @ stub _popen #(str str)
-@ cdecl _purecall() MSVCRT__purecall
-@ cdecl _putch(long) MSVCRT__putch
-@ cdecl _putenv(str) MSVCRT__putenv
-@ cdecl _putw(long ptr) MSVCRT__putw
-@ cdecl _putws(wstr) MSVCRT__putws
+@ cdecl _purecall() _purecall
+@ cdecl _putch(long) _putch
+@ cdecl _putenv(str) _putenv
+@ cdecl _putw(long ptr) _putw
+@ cdecl _putws(wstr) _putws
 @ stub _pwctype
-@ cdecl _read(long ptr long) MSVCRT__read
-@ cdecl _rmdir(str) MSVCRT__rmdir
-@ cdecl _rmtmp() MSVCRT__rmtmp
-@ cdecl _rotl(long long) MSVCRT__rotl
-@ cdecl _rotr(long long) MSVCRT__rotr
-@ cdecl _safe_fdiv() MSVCRT__safe_fdiv
-@ cdecl _safe_fdivr() MSVCRT__safe_fdivr
-@ cdecl _safe_fprem() MSVCRT__safe_fprem
-@ cdecl _safe_fprem1() MSVCRT__safe_fprem1
-@ cdecl _scalb( double long) MSVCRT__scalb
-@ cdecl _searchenv(str str str) MSVCRT__searchenv
+@ cdecl _read(long ptr long) _read
+@ cdecl _rmdir(str) _rmdir
+@ cdecl _rmtmp() _rmtmp
+@ cdecl _rotl(long long) _rotl
+@ cdecl _rotr(long long) _rotr
+@ cdecl _safe_fdiv() _safe_fdiv
+@ cdecl _safe_fdivr() _safe_fdivr
+@ cdecl _safe_fprem() _safe_fprem
+@ cdecl _safe_fprem1() _safe_fprem1
+@ cdecl _scalb( double long) _scalb
+@ cdecl _searchenv(str str str) _searchenv
 @ stub _seh_longjmp_unwind
 @ stub _set_error_mode #(long)
 @ stub _set_sbh_threshold #(long)
@@ -434,10 +435,10 @@
 @ cdecl _setjmp(ptr) MSVCRT__setjmp
 @ cdecl _setjmp3(ptr long) MSVCRT__setjmp3
 @ stub _setmaxstdio #(long)
-@ cdecl _setmbcp(long) MSVCRT__setmbcp
-@ cdecl _setmode(long long) MSVCRT__setmode
+@ cdecl _setmbcp(long) _setmbcp
+@ cdecl _setmode(long long) _setmode
 @ stub _setsystime #(ptr long)
-@ cdecl _sleep(long) MSVCRT__sleep
+@ cdecl _sleep(long) _sleep
 @ varargs _snprintf(str long str) snprintf
 @ forward -noimport _snwprintf ntdll._snwprintf
 @ cdecl _sopen(str long long) MSVCRT__sopen
@@ -445,68 +446,68 @@
 @ stub _spawnle #(str str) varargs
 @ stub _spawnlp #(str str) varargs
 @ stub _spawnlpe #(str str) varargs
-@ cdecl _spawnv(long str ptr) MSVCRT__spawnv
-@ cdecl _spawnve(long str ptr ptr) MSVCRT__spawnve
-@ cdecl _spawnvp(long str ptr) MSVCRT__spawnvp
-@ cdecl _spawnvpe(long str ptr ptr) MSVCRT__spawnvpe
+@ cdecl _spawnv(long str ptr) _spawnv
+@ cdecl _spawnve(long str ptr ptr) _spawnve
+@ cdecl _spawnvp(long str ptr) _spawnvp
+@ cdecl _spawnvpe(long str ptr ptr) _spawnvpe
 @ forward -noimport _splitpath ntdll._splitpath
-@ cdecl _stat(str ptr) MSVCRT__stat
+@ cdecl _stat(str ptr) _stat
 @ stub _stati64 #(str ptr)
-@ cdecl _statusfp() MSVCRT__statusfp
+@ cdecl _statusfp() _statusfp
 @ cdecl _strcmpi(str str) strcasecmp
-@ cdecl _strdate(str) MSVCRT__strdate
-@ cdecl _strdup(str) MSVCRT__strdup
-@ cdecl _strerror(long) MSVCRT__strerror
+@ cdecl _strdate(str) _strdate
+@ cdecl _strdup(str) _strdup
+@ cdecl _strerror(long) _strerror
 @ cdecl _stricmp(str str) strcasecmp
 @ stub _stricoll #(str str)
 @ forward -noimport _strlwr ntdll._strlwr
 @ stub _strncoll #(str str long)
 @ cdecl _strnicmp(str str long) strncasecmp
 @ stub _strnicoll #(str str long)
-@ cdecl _strnset(str long long) MSVCRT__strnset
-@ cdecl _strrev(str) MSVCRT__strrev
-@ cdecl _strset(str long) MSVCRT__strset
-@ cdecl _strtime(str) MSVCRT__strtime
+@ cdecl _strnset(str long long) _strnset
+@ cdecl _strrev(str) _strrev
+@ cdecl _strset(str long) _strset
+@ cdecl _strtime(str) _strtime
 @ forward -noimport _strupr ntdll._strupr
-@ cdecl _swab(str str long) MSVCRT__swab
-@ stub _sys_errlist #()
-@ stub _sys_nerr #()
-@ cdecl _tell(long) MSVCRT__tell
+@ cdecl _swab(str str long) _swab
+@ stub _sys_errlist #() # FIXME: This is supposed to be a variable!
+@ stub _sys_nerr #() # FIXME: This is supposed to be a variable!
+@ cdecl _tell(long) _tell
 @ stub _telli64 #(long)
-@ cdecl _tempnam(str str) MSVCRT__tempnam
+@ cdecl _tempnam(str str) _tempnam
 @ stub _timezone #()
-@ cdecl _tolower(long) MSVCRT__tolower
-@ cdecl _toupper(long) MSVCRT__toupper
+@ cdecl _tolower(long) _tolower
+@ cdecl _toupper(long) _toupper
 @ stub _tzname
 @ stub _tzset #()
 @ stub _ui64toa #(long str long)
 @ stub _ui64tow #(long wstr long)
 @ forward -noimport _ultoa ntdll._ultoa
 @ forward -noimport _ultow ntdll._ultow
-@ cdecl _umask(long) MSVCRT__umask
-@ cdecl _ungetch(long) MSVCRT__ungetch
-@ cdecl _unlink(str) MSVCRT__unlink
-@ cdecl _unloaddll(long) MSVCRT__unloaddll
+@ cdecl _umask(long) _umask
+@ cdecl _ungetch(long) _ungetch
+@ cdecl _unlink(str) _unlink
+@ cdecl _unloaddll(long) _unloaddll
 @ stub _unlock
-@ cdecl _utime(str ptr) MSVCRT__utime
+@ cdecl _utime(str ptr) _utime
 @ cdecl _vsnprintf(ptr long ptr ptr) vsnprintf
-@ cdecl _vsnwprintf(wstr long wstr long) MSVCRT__vsnwprintf
-@ cdecl _waccess(wstr long) MSVCRT__waccess
+@ cdecl _vsnwprintf(wstr long wstr long) _vsnwprintf
+@ cdecl _waccess(wstr long) _waccess
 @ stub _wasctime #(ptr)
-@ cdecl _wchdir(wstr) MSVCRT__wchdir
-@ cdecl _wchmod(wstr long) MSVCRT__wchmod
+@ cdecl _wchdir(wstr) _wchdir
+@ cdecl _wchmod(wstr long) _wchmod
 @ extern _wcmdln MSVCRT__wcmdln
-@ cdecl _wcreat(wstr long) MSVCRT__wcreat
-@ cdecl _wcsdup(wstr) MSVCRT__wcsdup
+@ cdecl _wcreat(wstr long) _wcreat
+@ cdecl _wcsdup(wstr) _wcsdup
 @ forward -noimport _wcsicmp ntdll._wcsicmp
-@ cdecl _wcsicoll(wstr wstr) MSVCRT__wcsicoll
+@ cdecl _wcsicoll(wstr wstr) _wcsicoll
 @ forward -noimport _wcslwr ntdll._wcslwr
 @ stub _wcsncoll #(wstr wstr long)
 @ forward -noimport _wcsnicmp ntdll._wcsnicmp
 @ stub _wcsnicoll #(wstr wstr long)
-@ cdecl _wcsnset(wstr long long) MSVCRT__wcsnset
-@ cdecl _wcsrev(wstr) MSVCRT__wcsrev
-@ cdecl _wcsset(wstr long) MSVCRT__wcsset
+@ cdecl _wcsnset(wstr long long) _wcsnset
+@ cdecl _wcsrev(wstr) _wcsrev
+@ cdecl _wcsset(wstr long) _wcsset
 @ forward -noimport _wcsupr ntdll._wcsupr
 @ stub _wctime #(ptr)
 @ extern _wenviron MSVCRT__wenviron
@@ -518,33 +519,33 @@
 @ stub _wexecve #(wstr wstr wstr)
 @ stub _wexecvp #(wstr wstr)
 @ stub _wexecvpe #(wstr wstr wstr)
-@ cdecl _wfdopen(long wstr) MSVCRT__wfdopen
-@ cdecl _wfindfirst(wstr ptr) MSVCRT__wfindfirst
+@ cdecl _wfdopen(long wstr) _wfdopen
+@ cdecl _wfindfirst(wstr ptr) _wfindfirst
 @ stub _wfindfirsti64 #(wstr ptr)
-@ cdecl _wfindnext(long ptr)  MSVCRT__wfindnext
+@ cdecl _wfindnext(long ptr)  _wfindnext
 @ stub _wfindnexti64 #(long ptr)
-@ cdecl _wfopen(wstr wstr) MSVCRT__wfopen
+@ cdecl _wfopen(wstr wstr) _wfopen
 @ stub _wfreopen #(wstr wstr ptr)
-@ cdecl _wfsopen(wstr wstr long) MSVCRT__wfsopen
+@ cdecl _wfsopen(wstr wstr long) _wfsopen
 @ stub _wfullpath #(wstr wstr long)
-@ cdecl _wgetcwd(wstr long) MSVCRT__wgetcwd
-@ cdecl _wgetdcwd(long wstr long) MSVCRT__wgetdcwd
-@ cdecl _wgetenv(wstr) MSVCRT__wgetenv
+@ cdecl _wgetcwd(wstr long) _wgetcwd
+@ cdecl _wgetdcwd(long wstr long) _wgetdcwd
+@ cdecl _wgetenv(wstr) _wgetenv
 @ extern _winmajor MSVCRT__winmajor
 @ extern _winminor MSVCRT__winminor
 @ extern _winver MSVCRT__winver
 @ stub _wmakepath #(wstr wstr wstr wstr wstr)
-@ cdecl _wmkdir(wstr) MSVCRT__wmkdir
-@ cdecl _wmktemp(wstr) MSVCRT__wmktemp
-@ cdecl _wopen(wstr long) MSVCRT__wopen
+@ cdecl _wmkdir(wstr) _wmkdir
+@ cdecl _wmktemp(wstr) _wmktemp
+@ cdecl _wopen(wstr long) _wopen
 @ stub _wperror #(wstr)
 @ stub _wpgmptr
 @ stub _wpopen #(wstr wstr)
-@ cdecl _wputenv(wstr) MSVCRT__wputenv
-@ cdecl _wremove(wstr) MSVCRT__wremove
-@ cdecl _wrename(wstr wstr) MSVCRT__wrename
-@ cdecl _write(long ptr long) MSVCRT__write
-@ cdecl _wrmdir(wstr) MSVCRT__wrmdir
+@ cdecl _wputenv(wstr) _wputenv
+@ cdecl _wremove(wstr) _wremove
+@ cdecl _wrename(wstr wstr) _wrename
+@ cdecl _write(long ptr long) _write
+@ cdecl _wrmdir(wstr) _wrmdir
 @ stub _wsearchenv #(wstr wstr wstr)
 @ stub _wsetlocale #(long wstr)
 @ stub _wsopen #(wstr long long) varargs
@@ -556,22 +557,22 @@
 @ stub _wspawnve #(long wstr wstr wstr)
 @ stub _wspawnvp #(long wstr wstr)
 @ stub _wspawnvpe #(long wstr wstr wstr)
-@ cdecl _wsplitpath(wstr wstr wstr wstr wstr) MSVCRT__wsplitpath
-@ cdecl _wstat(wstr ptr) MSVCRT__wstat
+@ cdecl _wsplitpath(wstr wstr wstr wstr wstr) _wsplitpath
+@ cdecl _wstat(wstr ptr) _wstat
 @ stub _wstati64 #(wstr ptr)
 @ stub _wstrdate #(wstr)
 @ stub _wstrtime #(wstr)
 @ stub _wsystem #(wstr)
-@ cdecl _wtempnam(wstr wstr) MSVCRT__wtempnam
+@ cdecl _wtempnam(wstr wstr) _wtempnam
 @ stub _wtmpnam #(wstr)
 @ forward -noimport _wtoi NTDLL._wtoi
 @ stub _wtoi64 #(wstr)
 @ forward _wtol NTDLL._wtol
-@ cdecl _wunlink(wstr) MSVCRT__wunlink
-@ cdecl _wutime(wstr ptr) MSVCRT__wutime
-@ cdecl _y0(double) MSVCRT__y0
-@ cdecl _y1(double) MSVCRT__y1
-@ cdecl _yn(long double ) MSVCRT__yn
+@ cdecl _wunlink(wstr) _wunlink
+@ cdecl _wutime(wstr ptr) _wutime
+@ cdecl _y0(double) _y0
+@ cdecl _y1(double) _y1
+@ cdecl _yn(long double ) _yn
 @ cdecl abort() MSVCRT_abort
 @ forward -noimport abs ntdll.abs
 @ cdecl acos( double ) acos
diff --git a/dlls/msvcrt/process.c b/dlls/msvcrt/process.c
index d8d5401..c2841bc 100644
--- a/dlls/msvcrt/process.c
+++ b/dlls/msvcrt/process.c
@@ -23,17 +23,17 @@
 #define _P_NOWAITO 3
 #define _P_DETACH  4
 
-void __cdecl MSVCRT__exit(int);
-void __cdecl MSVCRT__searchenv(const char* file, const char* env, char *buf);
+void MSVCRT__exit(int);
+void _searchenv(const char* file, const char* env, char *buf);
 
-/* FIXME: Check file extenstions for app to run */
+/* FIXME: Check file extensions for app to run */
 static const unsigned int EXE = 'e' << 16 | 'x' << 8 | 'e';
 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';
 
 /* INTERNAL: Spawn a child process */
-static int __MSVCRT__spawn(int flags, const char *exe, char * args, char *env)
+static int msvcrt_spawn(int flags, const char* exe, char* args, char* env)
 {
   STARTUPINFOA si;
   PROCESS_INFORMATION pi;
@@ -83,7 +83,7 @@
 }
 
 /* INTERNAL: Convert argv list to a single 'delim'-separated string */
-static char * __MSVCRT__argvtos(const char * *arg, char delim)
+static char* msvcrt_argvtos(const char* *arg, char delim)
 {
   const char **search = arg;
   long size = 0;
@@ -119,7 +119,7 @@
 /*********************************************************************
  *		_cwait (MSVCRT.@)
  */
-int __cdecl MSVCRT__cwait(int *status, int pid, int action)
+int _cwait(int *status, int pid, int action)
 {
   HANDLE hPid = (HANDLE)pid;
   int doserrno;
@@ -152,11 +152,11 @@
 /*********************************************************************
  *		_spawnve (MSVCRT.@)
  */
-int __cdecl MSVCRT__spawnve(int flags, const char *name, const char **argv,
+int _spawnve(int flags, const char* name, const char **argv,
                             const char **envv)
 {
-  char * args = __MSVCRT__argvtos(argv,' ');
-  char * envs = __MSVCRT__argvtos(envv,0);
+  char * args = msvcrt_argvtos(argv,' ');
+  char * envs = msvcrt_argvtos(envv,0);
   const char *fullname = name;
   int ret = -1;
 
@@ -165,7 +165,7 @@
 
   if (args)
   {
-    ret = __MSVCRT__spawn(flags, fullname, args, envs);
+    ret = msvcrt_spawn(flags, fullname, args, envs);
     MSVCRT_free(args);
   }
   if (envs)
@@ -177,43 +177,43 @@
 /*********************************************************************
  *		_spawnv (MSVCRT.@)
  */
-int __cdecl MSVCRT__spawnv(int flags, const char *name, const char **argv)
+int _spawnv(int flags, const char* name, const char **argv)
 {
-  return MSVCRT__spawnve(flags, name, argv, NULL);
+  return _spawnve(flags, name, argv, NULL);
 }
 
 /*********************************************************************
  *		_spawnvpe (MSVCRT.@)
  */
-int __cdecl MSVCRT__spawnvpe(int flags, const char *name, const char **argv,
+int _spawnvpe(int flags, const char* name, const char **argv,
                             const char **envv)
 {
   char fullname[MAX_PATH];
-  MSVCRT__searchenv(name, "PATH", fullname);
-  return MSVCRT__spawnve(flags, fullname[0] ? fullname : name, argv, envv);
+  _searchenv(name, "PATH", fullname);
+  return _spawnve(flags, fullname[0] ? fullname : name, argv, envv);
 }
 
 /*********************************************************************
  *		_spawnvp (MSVCRT.@)
  */
-int __cdecl MSVCRT__spawnvp(int flags, const char *name, const char **argv)
+int _spawnvp(int flags, const char* name, const char **argv)
 {
-  return MSVCRT__spawnvpe(flags, name, argv, NULL);
+  return _spawnvpe(flags, name, argv, NULL);
 }
 
 /*********************************************************************
  *		system (MSVCRT.@)
  */
-int __cdecl MSVCRT_system(const char *cmd)
+int MSVCRT_system(const char* cmd)
 {
   /* FIXME: should probably launch cmd interpreter in COMSPEC */
-  return __MSVCRT__spawn(_P_WAIT, cmd, NULL, NULL);
+  return msvcrt_spawn(_P_WAIT, cmd, NULL, NULL);
 }
 
 /*********************************************************************
  *		_loaddll (MSVCRT.@)
  */
-int __cdecl MSVCRT__loaddll(const char *dllname)
+int _loaddll(const char* dllname)
 {
   return LoadLibraryA(dllname);
 }
@@ -221,7 +221,7 @@
 /*********************************************************************
  *		_unloaddll (MSVCRT.@)
  */
-int __cdecl MSVCRT__unloaddll(int dll)
+int _unloaddll(int dll)
 {
   if (FreeLibrary((HANDLE)dll))
     return 0;
diff --git a/dlls/msvcrt/string.c b/dlls/msvcrt/string.c
index 1736707..22d5c3e 100644
--- a/dlls/msvcrt/string.c
+++ b/dlls/msvcrt/string.c
@@ -12,7 +12,7 @@
 DEFAULT_DEBUG_CHANNEL(msvcrt);
 
 /* INTERNAL: MSVCRT_malloc() based strndup */
-char * MSVCRT__strndup(const char * buf, unsigned int size)
+char* msvcrt_strndup(const char* buf, unsigned int size)
 {
   char* ret;
   unsigned int len = strlen(buf), max_len;
@@ -31,7 +31,7 @@
 /*********************************************************************
  *		_strdec (MSVCRT.@)
  */
-char * __cdecl MSVCRT__strdec(const char * str1, const char * str2)
+char* _strdec(const char* str1, const char* str2)
 {
   /* Hmm. While the docs suggest that the following should work... */
   /*  return (str2<=str1?0:str2-1); */
@@ -43,7 +43,7 @@
 /*********************************************************************
  *		_strdup (MSVCRT.@)
  */
-char * __cdecl MSVCRT__strdup(const char * str)
+char* _strdup(const char* str)
 {
     char * ret = MSVCRT_malloc(strlen(str)+1);
     if (ret) strcpy( ret, str );
@@ -53,7 +53,7 @@
 /*********************************************************************
  *		_strinc (MSVCRT.@)
  */
-char * __cdecl MSVCRT__strinc(const char * str)
+char* _strinc(const char* str)
 {
   return (char*)str+1;
 }
@@ -61,7 +61,7 @@
 /*********************************************************************
  *		_strnextc (MSVCRT.@)
  */
-unsigned int  __cdecl MSVCRT__strnextc(const char * str)
+unsigned int _strnextc(const char* str)
 {
   return (unsigned int)*str;
 }
@@ -71,7 +71,7 @@
  *
  * Return a pointer to the 'n'th character in a string
  */
-char * __cdecl MSVCRT__strninc(char * str, unsigned int n)
+char* _strninc(char* str, unsigned int n)
 {
   return str + n;
 }
@@ -79,7 +79,7 @@
 /*********************************************************************
  *		_strnset (MSVCRT.@)
  */
-char * __cdecl MSVCRT__strnset(char * str, int value, unsigned int len)
+char* _strnset(char* str, int value, unsigned int len)
 {
   if (len > 0 && str)
     while (*str && len--)
@@ -90,7 +90,7 @@
 /*********************************************************************
  *		_strrev (MSVCRT.@)
  */
-char * __cdecl MSVCRT__strrev (char * str)
+char* _strrev(char* str)
 {
   char * p1;
   char * p2;
@@ -109,7 +109,7 @@
 /*********************************************************************
  *		_strset (MSVCRT.@)
  */
-char *  __cdecl MSVCRT__strset (char * str, int value)
+char* _strset(char* str, int value)
 {
   char *ptr = str;
   while (*ptr)
@@ -121,7 +121,7 @@
 /*********************************************************************
  *		_strncnt (MSVCRT.@)
  */
-unsigned int __cdecl MSVCRT__strncnt(char * str, unsigned int max)
+unsigned int _strncnt(char* str, unsigned int max)
 {
   unsigned int len = strlen(str);
   return (len > max? max : len);
@@ -130,7 +130,7 @@
 /*********************************************************************
  *		_strspnp (MSVCRT.@)
  */
-char * __cdecl MSVCRT__strspnp(char * str1, char * str2)
+char* _strspnp(char* str1, char* str2)
 {
   str1 += strspn(str1,str2);
   return *str1? str1 : 0;
@@ -139,7 +139,7 @@
 /*********************************************************************
  *		_swab (MSVCRT.@)
  */
-void __cdecl MSVCRT__swab(char * src, char * dst, int len)
+void _swab(char* src, char* dst, int len)
 {
   if (len > 1)
   {
diff --git a/dlls/msvcrt/thread.c b/dlls/msvcrt/thread.c
index 6cc734b..89a5d04 100644
--- a/dlls/msvcrt/thread.c
+++ b/dlls/msvcrt/thread.c
@@ -11,11 +11,11 @@
 /*********************************************************************
  *		_beginthreadex (MSVCRT.@)
  */
-unsigned long __cdecl MSVCRT__beginthreadex(void *sec,
-                                            unsigned int stack,
-                                            LPTHREAD_START_ROUTINE start,
-                                            void *arg, unsigned int flag,
-                                            unsigned int*addr)
+unsigned long _beginthreadex(void* sec,
+                             unsigned int stack,
+                             LPTHREAD_START_ROUTINE start,
+                             void* arg, unsigned int flag,
+                             unsigned int* addr)
 {
   TRACE("(%p,%d,%p,%p,%d,%p)\n",sec, stack,start, arg,flag,addr);
   /* FIXME */
@@ -25,7 +25,7 @@
 /*********************************************************************
  *		_endthreadex (MSVCRT.@)
  */
-void __cdecl MSVCRT__endthreadex(unsigned int retval)
+void _endthreadex(unsigned int retval)
 {
   TRACE("(%d)\n",retval);
   /* FIXME */
diff --git a/dlls/msvcrt/time.c b/dlls/msvcrt/time.c
index 4240f96..fbb1eb8 100644
--- a/dlls/msvcrt/time.c
+++ b/dlls/msvcrt/time.c
@@ -22,7 +22,7 @@
 
 
 /* INTERNAL: Return formatted current time/date */
-char * MSVCRT_get_current_time(char * out, const char * format)
+char* msvcrt_get_current_time(char* out, const char* format)
 {
   static const time_t bad_time = (time_t)-1;
   time_t t;
@@ -40,23 +40,23 @@
 /**********************************************************************
  *		_strdate (MSVCRT.@)
  */
-char * __cdecl MSVCRT__strdate (char * date)
+char* _strdate(char* date)
 {
-  return MSVCRT_get_current_time(date,"%m/%d/%y");
+  return msvcrt_get_current_time(date,"%m/%d/%y");
 }
 
 /*********************************************************************
  *		_strtime (MSVCRT.@)
  */
-char * __cdecl MSVCRT__strtime (char * date)
+char* _strtime(char* date)
 {
-  return MSVCRT_get_current_time(date,"%H:%M:%S");
+  return msvcrt_get_current_time(date,"%H:%M:%S");
 }
 
 /*********************************************************************
  *		clock (MSVCRT.@)
  */
-clock_t __cdecl MSVCRT_clock(void)
+clock_t MSVCRT_clock(void)
 {
   struct tms alltimes;
   clock_t res;
@@ -73,7 +73,7 @@
 /*********************************************************************
  *		difftime (MSVCRT.@)
  */
-double __cdecl MSVCRT_difftime (time_t time1, time_t time2)
+double MSVCRT_difftime(time_t time1, time_t time2)
 {
     return (double)(time1 - time2);
 }
@@ -81,7 +81,7 @@
 /*********************************************************************
  *		time (MSVCRT.@)
  */
-time_t __cdecl MSVCRT_time(time_t *buf)
+time_t MSVCRT_time(time_t* buf)
 {
   time_t curtime = time(NULL);
   return buf ? *buf = curtime : curtime;
@@ -90,7 +90,7 @@
 /*********************************************************************
  *		_ftime (MSVCRT.@)
  */
-void __cdecl MSVCRT__ftime (MSVCRT_timeb *buf)
+void _ftime(MSVCRT_timeb* buf)
 {
   buf->time = MSVCRT_time(NULL);
   buf->millitm = 0; /* FIXME */
diff --git a/dlls/msvcrt/wcs.c b/dlls/msvcrt/wcs.c
index 784756c..4ba83cc 100644
--- a/dlls/msvcrt/wcs.c
+++ b/dlls/msvcrt/wcs.c
@@ -14,7 +14,7 @@
 
 
 /* INTERNAL: MSVCRT_malloc() based wstrndup */
-LPWSTR MSVCRT__wstrndup(LPCWSTR buf, unsigned int size)
+LPWSTR msvcrt_wstrndup(LPCWSTR buf, unsigned int size)
 {
   WCHAR* ret;
   unsigned int len = strlenW(buf), max_len;
@@ -33,7 +33,7 @@
 /*********************************************************************
  *		_wcsdup (MSVCRT.@)
  */
-LPWSTR __cdecl MSVCRT__wcsdup( LPCWSTR str )
+LPWSTR _wcsdup( LPCWSTR str )
 {
   LPWSTR ret = NULL;
   if (str)
@@ -48,7 +48,7 @@
 /*********************************************************************
  *		_wcsicoll (MSVCRT.@)
  */
-INT __cdecl MSVCRT__wcsicoll( LPCWSTR str1, LPCWSTR str2 )
+INT _wcsicoll( LPCWSTR str1, LPCWSTR str2 )
 {
   /* FIXME: handle collates */
   return strcmpiW( str1, str2 );
@@ -57,7 +57,7 @@
 /*********************************************************************
  *		_wcsnset (MSVCRT.@)
  */
-LPWSTR __cdecl MSVCRT__wcsnset( LPWSTR str, WCHAR c, INT n )
+LPWSTR _wcsnset( LPWSTR str, WCHAR c, INT n )
 {
   LPWSTR ret = str;
   while ((n-- > 0) && *str) *str++ = c;
@@ -67,7 +67,7 @@
 /*********************************************************************
  *		_wcsrev (MSVCRT.@)
  */
-LPWSTR __cdecl MSVCRT__wcsrev( LPWSTR str )
+LPWSTR _wcsrev( LPWSTR str )
 {
   LPWSTR ret = str;
   LPWSTR end = str + strlenW(str) - 1;
@@ -83,7 +83,7 @@
 /*********************************************************************
  *		_wcsset (MSVCRT.@)
  */
-LPWSTR __cdecl MSVCRT__wcsset( LPWSTR str, WCHAR c )
+LPWSTR _wcsset( LPWSTR str, WCHAR c )
 {
   LPWSTR ret = str;
   while (*str) *str++ = c;
@@ -93,7 +93,7 @@
 /*********************************************************************
  *		_vsnwprintf (MSVCRT.@)
  */
-int __cdecl MSVCRT__vsnwprintf(WCHAR *str, unsigned int len,
+int _vsnwprintf(WCHAR *str, unsigned int len,
                               const WCHAR *format, va_list valist)
 {
 /* If you fix a bug in this function, fix it in ntdll/wcstring.c also! */
@@ -219,15 +219,15 @@
 /*********************************************************************
  *		vswprintf (MSVCRT.@)
  */
-int __cdecl MSVCRT_vswprintf( LPWSTR str, LPCWSTR format, va_list args )
+int MSVCRT_vswprintf( LPWSTR str, LPCWSTR format, va_list args )
 {
-  return MSVCRT__vsnwprintf( str, INT_MAX, format, args );
+  return _vsnwprintf( str, INT_MAX, format, args );
 }
 
 /*********************************************************************
  *		wcscoll (MSVCRT.@)
  */
-DWORD __cdecl MSVCRT_wcscoll( LPCWSTR str1, LPCWSTR str2 )
+DWORD MSVCRT_wcscoll( LPCWSTR str1, LPCWSTR str2 )
 {
   /* FIXME: handle collates */
   return strcmpW( str1, str2 );
@@ -236,7 +236,7 @@
 /*********************************************************************
  *		wcspbrk (MSVCRT.@)
  */
-LPWSTR __cdecl MSVCRT_wcspbrk( LPCWSTR str, LPCWSTR accept )
+LPWSTR MSVCRT_wcspbrk( LPCWSTR str, LPCWSTR accept )
 {
   LPCWSTR p;
   while (*str)
@@ -250,7 +250,7 @@
 /*********************************************************************
  *		wctomb (MSVCRT.@)
  */
-INT __cdecl MSVCRT_wctomb( char *dst, WCHAR ch )
+INT MSVCRT_wctomb( char *dst, WCHAR ch )
 {
   return WideCharToMultiByte( CP_ACP, 0, &ch, 1, dst, 6, NULL, NULL );
 }
@@ -258,7 +258,7 @@
 /*********************************************************************
  *		iswalnum (MSVCRT.@)
  */
-INT __cdecl MSVCRT_iswalnum( WCHAR wc )
+INT MSVCRT_iswalnum( WCHAR wc )
 {
   return get_char_typeW(wc) & (C1_ALPHA|C1_DIGIT|C1_LOWER|C1_UPPER);
 }
@@ -266,7 +266,7 @@
 /*********************************************************************
  *		iswalpha (MSVCRT.@)
  */
-INT __cdecl MSVCRT_iswalpha( WCHAR wc )
+INT MSVCRT_iswalpha( WCHAR wc )
 {
   return get_char_typeW(wc) & (C1_ALPHA|C1_LOWER|C1_UPPER);
 }
@@ -274,7 +274,7 @@
 /*********************************************************************
  *		iswcntrl (MSVCRT.@)
  */
-INT __cdecl MSVCRT_iswcntrl( WCHAR wc )
+INT MSVCRT_iswcntrl( WCHAR wc )
 {
   return get_char_typeW(wc) & C1_CNTRL;
 }
@@ -282,7 +282,7 @@
 /*********************************************************************
  *		iswdigit (MSVCRT.@)
  */
-INT __cdecl MSVCRT_iswdigit( WCHAR wc )
+INT MSVCRT_iswdigit( WCHAR wc )
 {
   return get_char_typeW(wc) & C1_DIGIT;
 }
@@ -290,7 +290,7 @@
 /*********************************************************************
  *		iswgraph (MSVCRT.@)
  */
-INT __cdecl MSVCRT_iswgraph( WCHAR wc )
+INT MSVCRT_iswgraph( WCHAR wc )
 {
   return get_char_typeW(wc) & (C1_ALPHA|C1_PUNCT|C1_DIGIT|C1_LOWER|C1_UPPER);
 }
@@ -298,7 +298,7 @@
 /*********************************************************************
  *		iswlower (MSVCRT.@)
  */
-INT __cdecl MSVCRT_iswlower( WCHAR wc )
+INT MSVCRT_iswlower( WCHAR wc )
 {
   return get_char_typeW(wc) & C1_LOWER;
 }
@@ -306,7 +306,7 @@
 /*********************************************************************
  *		iswprint (MSVCRT.@)
  */
-INT __cdecl MSVCRT_iswprint( WCHAR wc )
+INT MSVCRT_iswprint( WCHAR wc )
 {
   return get_char_typeW(wc) & (C1_ALPHA|C1_BLANK|C1_PUNCT|C1_DIGIT|C1_LOWER|C1_UPPER);
 }
@@ -314,7 +314,7 @@
 /*********************************************************************
  *		iswpunct (MSVCRT.@)
  */
-INT __cdecl MSVCRT_iswpunct( WCHAR wc )
+INT MSVCRT_iswpunct( WCHAR wc )
 {
   return get_char_typeW(wc) & C1_PUNCT;
 }
@@ -322,7 +322,7 @@
 /*********************************************************************
  *		iswspace (MSVCRT.@)
  */
-INT __cdecl MSVCRT_iswspace( WCHAR wc )
+INT MSVCRT_iswspace( WCHAR wc )
 {
   return get_char_typeW(wc) & C1_SPACE;
 }
@@ -330,7 +330,7 @@
 /*********************************************************************
  *		iswupper (MSVCRT.@)
  */
-INT __cdecl MSVCRT_iswupper( WCHAR wc )
+INT MSVCRT_iswupper( WCHAR wc )
 {
   return get_char_typeW(wc) & C1_UPPER;
 }
@@ -338,19 +338,19 @@
 /*********************************************************************
  *		iswxdigit (MSVCRT.@)
  */
-INT __cdecl MSVCRT_iswxdigit( WCHAR wc )
+INT MSVCRT_iswxdigit( WCHAR wc )
 {
   return get_char_typeW(wc) & C1_XDIGIT;
 }
 
-extern char *__cdecl _itoa( long , char *, int);
-extern char *__cdecl _ultoa( long , char *, int);
-extern char *__cdecl _ltoa( long , char *, int);
+extern char *_itoa( long , char *, int);
+extern char *_ultoa( long , char *, int);
+extern char *_ltoa( long , char *, int);
 
 /*********************************************************************
  *		_itow (MSVCRT.@)
  */
-WCHAR* __cdecl MSVCRT__itow(int value,WCHAR* out,int base)
+WCHAR* _itow(int value,WCHAR* out,int base)
 {
   char buf[64];
   _itoa(value, buf, base);
@@ -361,7 +361,7 @@
 /*********************************************************************
  *		_ltow (MSVCRT.@)
  */
-WCHAR* __cdecl MSVCRT__ltow(long value,WCHAR* out,int base)
+WCHAR* _ltow(long value,WCHAR* out,int base)
 {
   char buf[128];
   _ltoa(value, buf, base);
@@ -372,7 +372,7 @@
 /*********************************************************************
  *		_ultow (MSVCRT.@)
  */
-WCHAR* __cdecl MSVCRT__ultow(unsigned long value,WCHAR* out,int base)
+WCHAR* _ultow(unsigned long value,WCHAR* out,int base)
 {
   char buf[128];
   _ultoa(value, buf, base);