Skip to content

W
wine-winehq
Commit 203a8f82 authored by Francois Gouget's avatar Francois Gouget Committed by Alexandre Julliard
Browse files
Options

Adjust the 'MSVCRT_' prefix to match the msvcrt headers

Prefix internal methods with 'msvcrt_' instead of 'MSVCRT_', '__MSVCRT_', etc. Remove '_cdecl', it's unnecessary
parent 77c1618d
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 349 additions and 348 deletions
dlls/msvcrt/console.c
View file @ 203a8f82
......@@ -21,7 +21,7 @@ static HANDLE MSVCRT_console_out= INVALID_HANDLE_VALUE;
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 @@ void MSVCRT_init_console(void)
}
/* 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 @@ void MSVCRT_free_console(void)
/*********************************************************************
* _cputs (MSVCRT.@)
*/
int __cdecl MSVCRT__cputs(const char * str)
int _cputs(const char* str)
{
DWORD count;
int retval = MSVCRT_EOF;
......@@ -67,7 +67,7 @@ int __cdecl MSVCRT__cputs(const char * str)
/*********************************************************************
* _getch (MSVCRT.@)
*/
int __cdecl MSVCRT__getch(void)
int _getch(void)
{
int retval = MSVCRT_EOF;
......@@ -112,7 +112,7 @@ int __cdecl MSVCRT__getch(void)
/*********************************************************************
* _putch (MSVCRT.@)
*/
int __cdecl MSVCRT__putch(int c)
int _putch(int c)
{
int retval = MSVCRT_EOF;
DWORD count;
......@@ -126,13 +126,13 @@ int __cdecl MSVCRT__putch(int c)
/*********************************************************************
* _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 @@ int __cdecl MSVCRT__getche(void)
/*********************************************************************
* _cgets (MSVCRT.@)
*/
char *__cdecl MSVCRT__cgets(char *str)
char* _cgets(char* str)
{
char *buf = str + 2;
int c;
......@@ -149,7 +149,7 @@ char *__cdecl MSVCRT__cgets(char *str)
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 @@ char *__cdecl MSVCRT__cgets(char *str)
/*********************************************************************
* _ungetch (MSVCRT.@)
*/
int __cdecl MSVCRT__ungetch(int c)
int _ungetch(int c)
{
int retval = MSVCRT_EOF;
LOCK_CONSOLE;
......@@ -174,7 +174,7 @@ int __cdecl MSVCRT__ungetch(int c)
/*********************************************************************
* _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 @@ int __cdecl MSVCRT__cscanf( const char * format, ... )
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 __cdecl MSVCRT__cscanf( const char * format, ... )
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 @@ int __cdecl MSVCRT__cscanf( const char * format, ... )
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 @@ int __cdecl MSVCRT__cscanf( const char * format, ... )
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 @@ int __cdecl MSVCRT__cscanf( const char * format, ... )
/* 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 @@ int __cdecl MSVCRT__cscanf( const char * format, ... )
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 @@ int __cdecl MSVCRT__cscanf( const char * format, ... )
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 @@ int __cdecl MSVCRT__cscanf( const char * format, ... )
/*********************************************************************
* _kbhit (MSVCRT.@)
*/
int __cdecl MSVCRT__kbhit(void)
int _kbhit(void)
{
int retval = 0;
......@@ -338,7 +338,7 @@ extern int snprintf(char *, int, const char *, ...);
/*********************************************************************
* _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 @@ int __cdecl MSVCRT__cprintf( const char * format, ... )
}
va_end(valist);
LOCK_CONSOLE;
retval = MSVCRT__cputs( mem );
retval = _cputs( mem );
UNLOCK_CONSOLE;
if (mem != buf)
MSVCRT_free (mem);
......
dlls/msvcrt/ctype.c
View file @ 203a8f82
......@@ -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 _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 _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_ _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 int MSVCRT___mb_cur_max;
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 @@ WORD** MSVCRT___p__pctype(void)
/*********************************************************************
* _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 @@ int __cdecl MSVCRT__isctype(int c, int type)
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 @@ int __cdecl MSVCRT__isctype(int c, int type)
/*********************************************************************
* 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 @@ int __cdecl MSVCRT___isascii(int c)
/*********************************************************************
* __toascii (MSVCRT.@)
*/
int __cdecl MSVCRT___toascii(int c)
int MSVCRT___toascii(int c)
{
return (unsigned)c & 0x7f;
}
......@@ -212,7 +211,7 @@ int __cdecl MSVCRT___toascii(int c)
* iswascii (MSVCRT.@)
*
*/
int __cdecl MSVCRT_iswascii(WCHAR c)
int MSVCRT_iswascii(WCHAR c)
{
return ((unsigned)c < 0x80);
}
......@@ -220,7 +219,7 @@ int __cdecl MSVCRT_iswascii(WCHAR c)
/*********************************************************************
* __iscsym (MSVCRT.@)
*/
int __cdecl MSVCRT___iscsym(int c)
int MSVCRT___iscsym(int c)
{
return (c < 127 && (isalnum(c) || c == '_'));
}
......@@ -228,7 +227,7 @@ int __cdecl MSVCRT___iscsym(int c)
/*********************************************************************
* __iscsymf (MSVCRT.@)
*/
int __cdecl MSVCRT___iscsymf(int c)
int MSVCRT___iscsymf(int c)
{
return (c < 127 && (isalpha(c) || c == '_'));
}
......@@ -236,7 +235,7 @@ int __cdecl MSVCRT___iscsymf(int c)
/*********************************************************************
* _toupper (MSVCRT.@)
*/
int __cdecl MSVCRT__toupper(int c)
int MSVCRT__toupper(int c)
{
return c - 0x20; /* sic */
}
......@@ -244,7 +243,7 @@ int __cdecl MSVCRT__toupper(int c)
/*********************************************************************
* _tolower (MSVCRT.@)
*/
int __cdecl MSVCRT__tolower(int c)
int MSVCRT__tolower(int c)
{
return c + 0x20; /* sic */
}
dlls/msvcrt/data.c
View file @ 203a8f82
......@@ -37,87 +37,87 @@ WCHAR **MSVCRT___winitenv;
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 @@ static WCHAR *wstrdupa(const char *str)
* 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 @@ void MSVCRT_init_args(void)
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 @@ void MSVCRT_init_args(void)
/* INTERNAL: free memory used by args */
void MSVCRT_free_args(void)
void msvcrt_free_args(void)
{
/* FIXME */
}
......@@ -232,7 +232,7 @@ void MSVCRT_free_args(void)
/*********************************************************************
* __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 @@ void __cdecl MSVCRT___getmainargs(int *argc, char ***argv, char **environ,
/*********************************************************************
* __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 @@ void __cdecl MSVCRT___wgetmainargs(int *argc, WCHAR ***wargv, WCHAR **wenviron,
/*********************************************************************
* _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 @@ unsigned int __cdecl MSVCRT__initterm(MSVCRT__INITTERMFUN *start,MSVCRT__INITTER
/*********************************************************************
* __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;
......
dlls/msvcrt/environ.c
View file @ 203a8f82
......@@ -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 @@ char *__cdecl MSVCRT_getenv(const char *name)
/*********************************************************************
* _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 @@ WCHAR *__cdecl MSVCRT__wgetenv(const WCHAR *name)
/*********************************************************************
* _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 @@ int __cdecl MSVCRT__putenv(const char *str)
/*********************************************************************
* _wputenv (MSVCRT.@)
*/
int __cdecl MSVCRT__wputenv(const WCHAR *str)
int _wputenv(const WCHAR *str)
{
WCHAR name[256], value[512];
WCHAR *dst = name;
......
dlls/msvcrt/errno.c
View file @ 203a8f82
......@@ -73,7 +73,7 @@ void MSVCRT__set_errno(int err)
/*********************************************************************
* _errno (MSVCRT.@)
*/
int *__cdecl MSVCRT__errno(void)
int* MSVCRT__errno(void)
{
return GET_THREAD_VAR_PTR(errno);
}
......@@ -81,7 +81,7 @@ int *__cdecl MSVCRT__errno(void)
/*********************************************************************
* __doserrno (MSVCRT.@)
*/
int *__cdecl MSVCRT___doserrno(void)
int* __doserrno(void)
{
return GET_THREAD_VAR_PTR(doserrno);
}
......@@ -91,7 +91,7 @@ char *strerror(int);
/*********************************************************************
* strerror (MSVCRT.@)
*/
char * __cdecl MSVCRT_strerror (int err)
char* MSVCRT_strerror(int err)
{
return strerror(err); /* FIXME */
}
......@@ -101,19 +101,19 @@ char * __cdecl MSVCRT_strerror (int err)
*/
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)));
}
dlls/msvcrt/except.c
View file @ 203a8f82
......@@ -21,8 +21,8 @@ typedef void (*MSVCRT_sig_handler_func)(void);
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 @@ typedef struct _MSVCRT_EXCEPTION_FRAME
__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 @@ static DWORD __cdecl MSVCRT_nested_handler(PEXCEPTION_RECORD rec,
/*********************************************************************
* _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 @@ int __cdecl MSVCRT__XcptFilter(int ex, PEXCEPTION_POINTERS ptr)
*/
#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 @@ __ASM_GLOBAL_FUNC(MSVCRT__EH_prolog,
/*******************************************************************
* _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 @@ void __cdecl MSVCRT__global_unwind2(PEXCEPTION_FRAME frame)
/*******************************************************************
* _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 @@ void __cdecl MSVCRT__local_unwind2(MSVCRT_EXCEPTION_FRAME *frame,
/*********************************************************************
* _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 @@ int __cdecl MSVCRT__except_handler2(PEXCEPTION_RECORD rec,
/*********************************************************************
* _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 @@ int __cdecl MSVCRT__except_handler3(PEXCEPTION_RECORD rec,
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 @@ int __cdecl MSVCRT__except_handler3(PEXCEPTION_RECORD rec,
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 @@ int __cdecl MSVCRT__except_handler3(PEXCEPTION_RECORD rec,
/*********************************************************************
* _abnormal_termination (MSVCRT.@)
*/
int __cdecl MSVCRT__abnormal_termination(void)
int _abnormal_termination(void)
{
FIXME("(void)stub\n");
return 0;
......@@ -226,7 +226,7 @@ int __cdecl MSVCRT__abnormal_termination(void)
/*******************************************************************
* _setjmp (MSVCRT.@)
*/
int __cdecl MSVCRT__setjmp(LPDWORD *jmpbuf)
int MSVCRT__setjmp(LPDWORD* jmpbuf)
{
FIXME(":(%p): stub\n",jmpbuf);
return 0;
......@@ -244,7 +244,7 @@ int __cdecl MSVCRT__setjmp3(LPDWORD *jmpbuf, int x)
/*********************************************************************
* 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 @@ void __cdecl MSVCRT_longjmp(jmp_buf env, int val)
/*********************************************************************
* 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;
......
dlls/msvcrt/exit.c
View file @ 203a8f82
......@@ -12,14 +12,14 @@ extern CRITICAL_SECTION MSVCRT_exit_cs;
#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 @@ void __MSVCRT__call_atexit(void)
/*********************************************************************
* __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 @@ MSVCRT_atexit_func __cdecl MSVCRT___dllonexit(MSVCRT_atexit_func func,
/*********************************************************************
* _exit (MSVCRT.@)
*/
void __cdecl MSVCRT__exit(int exitcode)
void MSVCRT__exit(int exitcode)
{
TRACE("(%d)\n", exitcode);
ExitProcess(exitcode);
......@@ -84,7 +84,7 @@ void __cdecl MSVCRT__exit(int exitcode)
/*********************************************************************
* _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 @@ void __cdecl MSVCRT__amsg_exit(int errnum)
{
/* 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 @@ void __cdecl MSVCRT__c_exit(void)
/*********************************************************************
* _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 @@ void __cdecl MSVCRT__cexit(void)
/*********************************************************************
* _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 @@ void __cdecl MSVCRT__cexit(void)
/*********************************************************************
* exit (MSVCRT.@)
*/
void __cdecl MSVCRT_exit(int exitcode)
void MSVCRT_exit(int exitcode)
{
TRACE("(%d)\n",exitcode);
LOCK_EXIT;
......@@ -191,16 +191,16 @@ void __cdecl MSVCRT_exit(int exitcode)
/*********************************************************************
* 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 );
......
dlls/msvcrt/heap.c
View file @ 203a8f82
......@@ -41,7 +41,7 @@ static int MSVCRT_new_mode;
/*********************************************************************
* 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 @@ void *__cdecl MSVCRT_operator_new(unsigned long size)
/*********************************************************************
* 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 @@ void __cdecl MSVCRT_operator_delete(void *mem)
/*********************************************************************
* ?_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 @@ MSVCRT_new_handler_func __cdecl MSVCRT__query_new_handler(void)
/*********************************************************************
* ?_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 @@ int __cdecl MSVCRT__query_new_mode(void)
/*********************************************************************
* ?_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 @@ MSVCRT_new_handler_func __cdecl MSVCRT__set_new_handler(MSVCRT_new_handler_func
/*********************************************************************
* ?_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 @@ int __cdecl MSVCRT__set_new_mode(int mode)
/*********************************************************************
* _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 @@ void *__cdecl MSVCRT__expand(void *mem, unsigned int size)
/*********************************************************************
* _heapchk (MSVCRT.@)
*/
int __cdecl MSVCRT__heapchk(void)
int _heapchk(void)
{
if (!HeapValidate( GetProcessHeap(), 0, NULL))
{
......@@ -129,7 +129,7 @@ int __cdecl MSVCRT__heapchk(void)
/*********************************************************************
* _heapmin (MSVCRT.@)
*/
int __cdecl MSVCRT__heapmin(void)
int _heapmin(void)
{
if (!HeapCompact( GetProcessHeap(), 0 ))
{
......@@ -143,7 +143,7 @@ int __cdecl MSVCRT__heapmin(void)
/*********************************************************************
* _heapwalk (MSVCRT.@)
*/
int __cdecl MSVCRT__heapwalk(MSVCRT_HEAPINFO *next)
int _heapwalk(MSVCRT_HEAPINFO* next)
{
PROCESS_HEAP_ENTRY phe;
......@@ -184,14 +184,14 @@ int __cdecl MSVCRT__heapwalk(MSVCRT_HEAPINFO *next)
/*********************************************************************
* _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 @@ int __cdecl MSVCRT__heapset(unsigned int value)
/*********************************************************************
* _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 @@ long __cdecl MSVCRT__msize(void *mem)
/*********************************************************************
* 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 @@ void *__cdecl MSVCRT_calloc(unsigned int size, unsigned int count)
/*********************************************************************
* free (MSVCRT.@)
*/
void __cdecl MSVCRT_free(void *ptr)
void MSVCRT_free(void* ptr)
{
HeapFree(GetProcessHeap(),0,ptr);
}
......@@ -233,7 +233,7 @@ void __cdecl MSVCRT_free(void *ptr)
/*********************************************************************
* 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 @@ void * __cdecl MSVCRT_malloc(unsigned int size)
/*********************************************************************
* 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);
}
dlls/msvcrt/locale.c
View file @ 203a8f82
......@@ -254,7 +254,7 @@ static LCID MSVCRT_locale_to_LCID(locale_search_t* locale)
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 @@ static void MSVCRT_set_ctype(unsigned int codepage, LCID lcid)
/*********************************************************************
* 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 @@ char *__cdecl MSVCRT_setlocale(int category, const char *locale)
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 @@ char *__cdecl MSVCRT_setlocale(int category, const char *locale)
/*********************************************************************
* _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 @@ const char *__cdecl MSVCRT__Getdays(void)
/*********************************************************************
* _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 @@ const char *__cdecl MSVCRT__Getmonths(void)
/*********************************************************************
* _Getnames (MSVCRT.@)
*/
const char *__cdecl MSVCRT__Getnames(void)
const char* _Getnames(void)
{
/* FIXME: */
TRACE("(void) stub");
......@@ -494,7 +494,7 @@ const char *__cdecl MSVCRT__Getnames(void)
/*********************************************************************
* _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 @@ const char *__cdecl MSVCRT__Strftime(char *out, unsigned int len, const char *fm
/*********************************************************************
* _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 @@ void __cdecl MSVCRT__setmbcp(int cp)
/*********************************************************************
* _getmbcp (MSVCRT.@)
*/
int __cdecl MSVCRT__getmbcp(void)
int _getmbcp(void)
{
return MSVCRT_current_lc_all_cp;
}
......
dlls/msvcrt/main.c
View file @ 203a8f82
......@@ -17,23 +17,23 @@ CRITICAL_SECTION MSVCRT_exit_cs;
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 @@ BOOL WINAPI MSVCRT_Init(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
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 @@ BOOL WINAPI MSVCRT_Init(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
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 @@ BOOL WINAPI MSVCRT_Init(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
return TRUE;
}
static inline BOOL MSVCRT_init_tls(void)
static inline BOOL msvcrt_init_tls(void)
{
MSVCRT_tls_index = TlsAlloc();
......@@ -110,7 +110,7 @@ static inline BOOL MSVCRT_init_tls(void)
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 @@ static inline BOOL MSVCRT_free_tls(void)
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 @@ static inline void MSVCRT_init_critical_sections(void)
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 @@ static inline void MSVCRT_free_critical_sections(void)
DeleteCriticalSection(&MSVCRT_heap_cs);
}
const char *MSVCRT_get_reason(DWORD reason)
const char* msvcrt_get_reason(DWORD reason)
{
switch (reason)
{
......
dlls/msvcrt/misc.c
View file @ 203a8f82
......@@ -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 @@ extern int rand(void);
/*********************************************************************
* rand (MSVCRT.@)
*/
int __cdecl MSVCRT_rand()
int MSVCRT_rand()
{
return (rand() & 0x7fff);
}
......@@ -32,17 +32,18 @@ int __cdecl MSVCRT_rand()
/*********************************************************************
* _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 @@ unsigned int * array_size,unsigned int elem_size, MSVCRT_comp_func cf)
/*********************************************************************
* _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 @@ unsigned int * array_size,unsigned int elem_size, MSVCRT_comp_func cf)
/*********************************************************************
* _chkesp (MSVCRT.@)
*/
void __cdecl MSVCRT__chkesp(void)
void _chkesp(void)
{
}
dlls/msvcrt/msvcrt.h
View file @ 203a8f82
......@@ -34,13 +34,13 @@ typedef struct __MSVCRT_thread_data
((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 */
dlls/msvcrt/process.c
View file @ 203a8f82
......@@ -23,17 +23,17 @@ DEFAULT_DEBUG_CHANNEL(msvcrt);
#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 @@ static int __MSVCRT__spawn(int flags, const char *exe, char * args, char *env)
}
/* 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 @@ static char * __MSVCRT__argvtos(const char * *arg, char delim)
/*********************************************************************
* _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 @@ int __cdecl MSVCRT__cwait(int *status, int pid, int action)
/*********************************************************************
* _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 @@ int __cdecl MSVCRT__spawnve(int flags, const char *name, const char **argv,
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 @@ int __cdecl MSVCRT__spawnve(int flags, const char *name, const char **argv,
/*********************************************************************
* _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 @@ int __cdecl MSVCRT__loaddll(const char *dllname)
/*********************************************************************
* _unloaddll (MSVCRT.@)
*/
int __cdecl MSVCRT__unloaddll(int dll)
int _unloaddll(int dll)
{
if (FreeLibrary((HANDLE)dll))
return 0;
......
dlls/msvcrt/string.c
View file @ 203a8f82
......@@ -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 @@ char * MSVCRT__strndup(const char * buf, unsigned int size)
/*********************************************************************
* _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 @@ char * __cdecl MSVCRT__strdec(const char * str1, const char * str2)
/*********************************************************************
* _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 @@ char * __cdecl MSVCRT__strdup(const char * str)
/*********************************************************************
* _strinc (MSVCRT.@)
*/
char * __cdecl MSVCRT__strinc(const char * str)
char* _strinc(const char* str)
{
return (char*)str+1;
}
......@@ -61,7 +61,7 @@ char * __cdecl MSVCRT__strinc(const char * str)
/*********************************************************************
* _strnextc (MSVCRT.@)
*/
unsigned int __cdecl MSVCRT__strnextc(const char * str)
unsigned int _strnextc(const char* str)
{
return (unsigned int)*str;
}
......@@ -71,7 +71,7 @@ unsigned int __cdecl MSVCRT__strnextc(const char * str)
*
* 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 @@ char * __cdecl MSVCRT__strninc(char * str, unsigned int n)
/*********************************************************************
* _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 @@ char * __cdecl MSVCRT__strnset(char * str, int value, unsigned int len)
/*********************************************************************
* _strrev (MSVCRT.@)
*/
char * __cdecl MSVCRT__strrev (char * str)
char* _strrev(char* str)
{
char * p1;
char * p2;
......@@ -109,7 +109,7 @@ char * __cdecl MSVCRT__strrev (char * str)
/*********************************************************************
* _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 @@ char * __cdecl MSVCRT__strset (char * str, int value)
/*********************************************************************
* _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 @@ unsigned int __cdecl MSVCRT__strncnt(char * str, unsigned int max)
/*********************************************************************
* _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 @@ char * __cdecl MSVCRT__strspnp(char * str1, char * str2)
/*********************************************************************
* _swab (MSVCRT.@)
*/
void __cdecl MSVCRT__swab(char * src, char * dst, int len)
void _swab(char* src, char* dst, int len)
{
if (len > 1)
{
......
dlls/msvcrt/thread.c
View file @ 203a8f82
......@@ -11,11 +11,11 @@ DEFAULT_DEBUG_CHANNEL(msvcrt);
/*********************************************************************
* _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 @@ unsigned long __cdecl MSVCRT__beginthreadex(void *sec,
/*********************************************************************
* _endthreadex (MSVCRT.@)
*/
void __cdecl MSVCRT__endthreadex(unsigned int retval)
void _endthreadex(unsigned int retval)
{
TRACE("(%d)\n",retval);
/* FIXME */
......
dlls/msvcrt/time.c
View file @ 203a8f82
......@@ -22,7 +22,7 @@ typedef struct __MSVCRT_timeb
/* 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 @@ char * MSVCRT_get_current_time(char * out, const char * format)
/**********************************************************************
* _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 @@ clock_t __cdecl MSVCRT_clock(void)
/*********************************************************************
* 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 @@ double __cdecl MSVCRT_difftime (time_t time1, time_t time2)
/*********************************************************************
* 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 @@ time_t __cdecl MSVCRT_time(time_t *buf)
/*********************************************************************
* _ftime (MSVCRT.@)
*/
void __cdecl MSVCRT__ftime (MSVCRT_timeb *buf)
void _ftime(MSVCRT_timeb* buf)
{
buf->time = MSVCRT_time(NULL);
buf->millitm = 0; /* FIXME */
......
dlls/msvcrt/wcs.c
View file @ 203a8f82
......@@ -14,7 +14,7 @@ DEFAULT_DEBUG_CHANNEL(msvcrt);
/* 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 @@ LPWSTR MSVCRT__wstrndup(LPCWSTR buf, unsigned int size)
/*********************************************************************
* _wcsdup (MSVCRT.@)
*/
LPWSTR __cdecl MSVCRT__wcsdup( LPCWSTR str )
LPWSTR _wcsdup( LPCWSTR str )
{
LPWSTR ret = NULL;
if (str)
......@@ -48,7 +48,7 @@ LPWSTR __cdecl MSVCRT__wcsdup( LPCWSTR str )
/*********************************************************************
* _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 @@ INT __cdecl MSVCRT__wcsicoll( LPCWSTR str1, LPCWSTR str2 )
/*********************************************************************
* _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 @@ LPWSTR __cdecl MSVCRT__wcsnset( LPWSTR str, WCHAR c, INT n )
/*********************************************************************
* _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 @@ LPWSTR __cdecl MSVCRT__wcsrev( LPWSTR str )
/*********************************************************************
* _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 @@ LPWSTR __cdecl MSVCRT__wcsset( LPWSTR str, WCHAR c )
/*********************************************************************
* _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 @@ int __cdecl MSVCRT__vsnwprintf(WCHAR *str, unsigned int len,
/*********************************************************************
* 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 @@ DWORD __cdecl MSVCRT_wcscoll( LPCWSTR str1, LPCWSTR str2 )
/*********************************************************************
* 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 @@ LPWSTR __cdecl MSVCRT_wcspbrk( LPCWSTR str, LPCWSTR accept )
/*********************************************************************
* 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 @@ INT __cdecl MSVCRT_wctomb( char *dst, WCHAR ch )
/*********************************************************************
* 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 @@ INT __cdecl MSVCRT_iswalnum( WCHAR wc )
/*********************************************************************
* 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 @@ INT __cdecl MSVCRT_iswalpha( WCHAR wc )
/*********************************************************************
* iswcntrl (MSVCRT.@)
*/
INT __cdecl MSVCRT_iswcntrl( WCHAR wc )
INT MSVCRT_iswcntrl( WCHAR wc )
{
return get_char_typeW(wc) & C1_CNTRL;
}
......@@ -282,7 +282,7 @@ INT __cdecl MSVCRT_iswcntrl( WCHAR wc )
/*********************************************************************
* iswdigit (MSVCRT.@)
*/
INT __cdecl MSVCRT_iswdigit( WCHAR wc )
INT MSVCRT_iswdigit( WCHAR wc )
{
return get_char_typeW(wc) & C1_DIGIT;
}
......@@ -290,7 +290,7 @@ INT __cdecl MSVCRT_iswdigit( WCHAR wc )
/*********************************************************************
* 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 @@ INT __cdecl MSVCRT_iswgraph( WCHAR wc )
/*********************************************************************
* iswlower (MSVCRT.@)
*/
INT __cdecl MSVCRT_iswlower( WCHAR wc )
INT MSVCRT_iswlower( WCHAR wc )
{
return get_char_typeW(wc) & C1_LOWER;
}
......@@ -306,7 +306,7 @@ INT __cdecl MSVCRT_iswlower( WCHAR wc )
/*********************************************************************
* 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 @@ INT __cdecl MSVCRT_iswprint( WCHAR wc )
/*********************************************************************
* iswpunct (MSVCRT.@)
*/
INT __cdecl MSVCRT_iswpunct( WCHAR wc )
INT MSVCRT_iswpunct( WCHAR wc )
{
return get_char_typeW(wc) & C1_PUNCT;
}
......@@ -322,7 +322,7 @@ INT __cdecl MSVCRT_iswpunct( WCHAR wc )
/*********************************************************************
* iswspace (MSVCRT.@)
*/
INT __cdecl MSVCRT_iswspace( WCHAR wc )
INT MSVCRT_iswspace( WCHAR wc )
{
return get_char_typeW(wc) & C1_SPACE;
}
......@@ -330,7 +330,7 @@ INT __cdecl MSVCRT_iswspace( WCHAR wc )
/*********************************************************************
* iswupper (MSVCRT.@)
*/
INT __cdecl MSVCRT_iswupper( WCHAR wc )
INT MSVCRT_iswupper( WCHAR wc )
{
return get_char_typeW(wc) & C1_UPPER;
}
......@@ -338,19 +338,19 @@ INT __cdecl MSVCRT_iswupper( WCHAR wc )
/*********************************************************************
* 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 @@ WCHAR* __cdecl MSVCRT__itow(int value,WCHAR* out,int base)
/*********************************************************************
* _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 @@ WCHAR* __cdecl MSVCRT__ltow(long value,WCHAR* out,int base)
/*********************************************************************
* _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);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment