ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

msvcrt: Use errno values from public header. 

Signed-off-by: Piotr Caban <piotr@codeweavers.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
This commit is contained in:
Piotr Caban 2020-11-30 14:37:27 +01:00 committed by Alexandre Julliard
parent fbc9110d23
commit 1317b935ef
18 changed files with 569 additions and 610 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
dlls/msvcrt/ctype.c
View File

@ -451,7 +451,7 @@ int CDECL MSVCRT__toupper_l(int c, _locale_t locale)
if(locinfo->pctype[(c>>8)&255] & MSVCRT__LEADBYTE)
*p++ = (c>>8) & 255;
else {
*MSVCRT__errno() = MSVCRT_EILSEQ;
*MSVCRT__errno() = EILSEQ;
str[1] = 0;
}
*p++ = c & 255;
@ -505,7 +505,7 @@ int CDECL MSVCRT__tolower_l(int c, _locale_t locale)
if(locinfo->pctype[(c>>8)&255] & MSVCRT__LEADBYTE)
*p++ = (c>>8) & 255;
else {
*MSVCRT__errno() = MSVCRT_EILSEQ;
*MSVCRT__errno() = EILSEQ;
str[1] = 0;
}
*p++ = c & 255;

16
dlls/msvcrt/data.c
View File

@ -249,7 +249,7 @@ WCHAR** CDECL MSVCRT___p__wpgmptr(void) { return &MSVCRT__wpgmptr; }
*/
int CDECL _get_pgmptr(char** p)
{
if (!MSVCRT_CHECK_PMT(p)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(p)) return EINVAL;
*p = MSVCRT__pgmptr;
return 0;
@ -260,7 +260,7 @@ int CDECL _get_pgmptr(char** p)
*/
int CDECL _get_wpgmptr(WCHAR** p)
{
if (!MSVCRT_CHECK_PMT(p)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(p)) return EINVAL;
*p = MSVCRT__wpgmptr;
return 0;
}
@ -277,7 +277,7 @@ int CDECL MSVCRT__set_fmode(int mode)
{
/* TODO: support _O_WTEXT */
if(!MSVCRT_CHECK_PMT(mode==MSVCRT__O_TEXT || mode==MSVCRT__O_BINARY))
return MSVCRT_EINVAL;
return EINVAL;
MSVCRT__fmode = mode;
return 0;
@ -289,7 +289,7 @@ int CDECL MSVCRT__set_fmode(int mode)
int CDECL MSVCRT__get_fmode(int *mode)
{
if(!MSVCRT_CHECK_PMT(mode))
return MSVCRT_EINVAL;
return EINVAL;
*mode = MSVCRT__fmode;
return 0;
@ -366,7 +366,7 @@ wchar_t*** CDECL __p___winitenv(void) { return &MSVCRT___winitenv; }
*/
int CDECL MSVCRT__get_osplatform(int *pValue)
{
if (!MSVCRT_CHECK_PMT(pValue != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(pValue != NULL)) return EINVAL;
*pValue = MSVCRT__osplatform;
return 0;
}
@ -787,7 +787,7 @@ wchar_t* CDECL _get_wide_winmain_command_line(void)
*/
int CDECL MSVCRT__get_winmajor(int* value)
{
if (!MSVCRT_CHECK_PMT(value != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(value != NULL)) return EINVAL;
*value = MSVCRT__winmajor;
return 0;
}
@ -797,7 +797,7 @@ int CDECL MSVCRT__get_winmajor(int* value)
*/
int CDECL MSVCRT__get_winminor(int* value)
{
if (!MSVCRT_CHECK_PMT(value != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(value != NULL)) return EINVAL;
*value = MSVCRT__winminor;
return 0;
}
@ -807,7 +807,7 @@ int CDECL MSVCRT__get_winminor(int* value)
*/
int CDECL MSVCRT__get_osver(int* value)
{
if (!MSVCRT_CHECK_PMT(value != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(value != NULL)) return EINVAL;
*value = MSVCRT__osver;
return 0;
}

106
dlls/msvcrt/dir.c
View File

@ -297,7 +297,7 @@ int CDECL MSVCRT__chdrive(int newdrive)
{
msvcrt_set_errno(GetLastError());
if (newdrive <= 0)
*MSVCRT__errno() = MSVCRT_EACCES;
*MSVCRT__errno() = EACCES;
return -1;
}
return 0;
@ -571,7 +571,7 @@ int CDECL MSVCRT__findnext(intptr_t hand, struct MSVCRT__finddata_t * ft)
if (!FindNextFileA((HANDLE)hand, &find_data))
{
*MSVCRT__errno() = MSVCRT_ENOENT;
*MSVCRT__errno() = ENOENT;
return -1;
}
@ -588,7 +588,7 @@ int CDECL MSVCRT__findnext32(intptr_t hand, struct MSVCRT__finddata32_t * ft)
if (!FindNextFileA((HANDLE)hand, &find_data))
{
*MSVCRT__errno() = MSVCRT_ENOENT;
*MSVCRT__errno() = ENOENT;
return -1;
}
@ -605,7 +605,7 @@ int CDECL MSVCRT__wfindnext32(intptr_t hand, struct MSVCRT__wfinddata32_t * ft)
if (!FindNextFileW((HANDLE)hand, &find_data))
{
*MSVCRT__errno() = MSVCRT_ENOENT;
*MSVCRT__errno() = ENOENT;
return -1;
}
@ -624,7 +624,7 @@ int CDECL MSVCRT__wfindnext(intptr_t hand, struct MSVCRT__wfinddata_t * ft)
if (!FindNextFileW((HANDLE)hand, &find_data))
{
*MSVCRT__errno() = MSVCRT_ENOENT;
*MSVCRT__errno() = ENOENT;
return -1;
}
@ -643,7 +643,7 @@ int CDECL MSVCRT__findnexti64(intptr_t hand, struct MSVCRT__finddatai64_t * ft)
if (!FindNextFileA((HANDLE)hand, &find_data))
{
*MSVCRT__errno() = MSVCRT_ENOENT;
*MSVCRT__errno() = ENOENT;
return -1;
}
@ -662,7 +662,7 @@ int CDECL MSVCRT__findnext64(intptr_t hand, struct MSVCRT__finddata64_t * ft)
if (!FindNextFileA((HANDLE)hand, &find_data))
{
*MSVCRT__errno() = MSVCRT_ENOENT;
*MSVCRT__errno() = ENOENT;
return -1;
}
@ -681,7 +681,7 @@ int CDECL MSVCRT__wfindnext64(intptr_t hand, struct MSVCRT__wfinddata64_t * ft)
if (!FindNextFileW((HANDLE)hand, &find_data))
{
*MSVCRT__errno() = MSVCRT_ENOENT;
*MSVCRT__errno() = ENOENT;
return -1;
}
@ -700,7 +700,7 @@ int CDECL MSVCRT__findnext64i32(intptr_t hand, struct MSVCRT__finddata64i32_t *
if (!FindNextFileA((HANDLE)hand, &find_data))
{
*MSVCRT__errno() = MSVCRT_ENOENT;
*MSVCRT__errno() = ENOENT;
return -1;
}
@ -719,7 +719,7 @@ int CDECL MSVCRT__wfindnexti64(intptr_t hand, struct MSVCRT__wfinddatai64_t * ft
if (!FindNextFileW((HANDLE)hand, &find_data))
{
*MSVCRT__errno() = MSVCRT_ENOENT;
*MSVCRT__errno() = ENOENT;
return -1;
}
@ -738,7 +738,7 @@ int CDECL MSVCRT__wfindnext64i32(intptr_t hand, struct MSVCRT__wfinddata64i32_t
if (!FindNextFileW((HANDLE)hand, &find_data))
{
*MSVCRT__errno() = MSVCRT_ENOENT;
*MSVCRT__errno() = ENOENT;
return -1;
}
@ -775,7 +775,7 @@ char* CDECL MSVCRT__getcwd(char * buf, int size)
}
else if (dir_len >= size)
{
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return NULL; /* buf too small */
}
strcpy(buf,dir);
@ -802,7 +802,7 @@ wchar_t* CDECL MSVCRT__wgetcwd(wchar_t * buf, int size)
}
if (dir_len >= size)
{
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return NULL; /* buf too small */
}
MSVCRT_wcscpy(buf,dir);
@ -862,14 +862,14 @@ char* CDECL MSVCRT__getdcwd(int drive, char * buf, int size)
drivespec[0] += drive - 1;
if (GetDriveTypeA(drivespec) < DRIVE_REMOVABLE)
{
*MSVCRT__errno() = MSVCRT_EACCES;
*MSVCRT__errno() = EACCES;
return NULL;
}
dir_len = GetFullPathNameA(drivespec,MAX_PATH,dir,&dummy);
if (dir_len >= size || dir_len < 1)
{
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return NULL; /* buf too small */
}
@ -904,14 +904,14 @@ wchar_t* CDECL MSVCRT__wgetdcwd(int drive, wchar_t * buf, int size)
drivespec[0] += drive - 1;
if (GetDriveTypeW(drivespec) < DRIVE_REMOVABLE)
{
*MSVCRT__errno() = MSVCRT_EACCES;
*MSVCRT__errno() = EACCES;
return NULL;
}
dir_len = GetFullPathNameW(drivespec,MAX_PATH,dir,&dummy);
if (dir_len >= size || dir_len < 1)
{
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return NULL; /* buf too small */
}
@ -1055,8 +1055,8 @@ int CDECL MSVCRT__splitpath_s(const char* inpath,
(!ext && sz_ext) ||
(ext && !sz_ext))
{
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
if (inpath[0] && inpath[1] == ':')
@ -1119,8 +1119,8 @@ do_error:
if (dir) dir[0] = '\0';
if (fname) fname[0]= '\0';
if (ext) ext[0]= '\0';
*MSVCRT__errno() = MSVCRT_ERANGE;
return MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return ERANGE;
}
/*********************************************************************
@ -1155,8 +1155,8 @@ int CDECL MSVCRT__wsplitpath_s(const wchar_t* inpath,
(!ext && sz_ext) ||
(ext && !sz_ext))
{
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
if (inpath[0] && inpath[1] == ':')
@ -1211,8 +1211,8 @@ do_error:
if (dir) dir[0] = '\0';
if (fname) fname[0]= '\0';
if (ext) ext[0]= '\0';
*MSVCRT__errno() = MSVCRT_ERANGE;
return MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return ERANGE;
}
/*********************************************************************
@ -1253,7 +1253,7 @@ wchar_t * CDECL MSVCRT__wfullpath(wchar_t * absPath, const wchar_t* relPath, siz
if (size < 4)
{
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return NULL;
}
@ -1307,7 +1307,7 @@ char * CDECL MSVCRT__fullpath(char * absPath, const char* relPath, unsigned int
if (size < 4)
{
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return NULL;
}
@ -1443,8 +1443,8 @@ int CDECL MSVCRT__makepath_s(char *path, size_t size, const char *drive,
if (!path || !size)
{
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
if (drive && drive[0])
@ -1530,8 +1530,8 @@ int CDECL MSVCRT__makepath_s(char *path, size_t size, const char *drive,
range:
path[0] = '\0';
*MSVCRT__errno() = MSVCRT_ERANGE;
return MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return ERANGE;
}
/*********************************************************************
@ -1547,8 +1547,8 @@ int CDECL MSVCRT__wmakepath_s(wchar_t *path, size_t size, const wchar_t *drive,
if (!path || !size)
{
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
if (drive && drive[0])
@ -1634,8 +1634,8 @@ int CDECL MSVCRT__wmakepath_s(wchar_t *path, size_t size, const wchar_t *drive,
range:
path[0] = '\0';
*MSVCRT__errno() = MSVCRT_ERANGE;
return MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return ERANGE;
}
/*********************************************************************
@ -1647,9 +1647,9 @@ int CDECL MSVCRT__searchenv_s(const char* file, const char* env, char *buf, size
char path[MAX_PATH];
size_t path_len, fname_len;
if (!MSVCRT_CHECK_PMT(file != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(buf != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(count > 0)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(file != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(buf != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(count > 0)) return EINVAL;
if (count > MAX_PATH)
FIXME("count > MAX_PATH not supported\n");
@ -1669,8 +1669,8 @@ int CDECL MSVCRT__searchenv_s(const char* file, const char* env, char *buf, size
envVal = MSVCRT_getenv(env);
if (!envVal)
{
*MSVCRT__errno() = MSVCRT_ENOENT;
return MSVCRT_ENOENT;
*MSVCRT__errno() = ENOENT;
return ENOENT;
}
penv = envVal;
@ -1711,16 +1711,16 @@ int CDECL MSVCRT__searchenv_s(const char* file, const char* env, char *buf, size
{
if (path_len + fname_len + 1 > count)
{
MSVCRT_INVALID_PMT("buf[count] is too small", MSVCRT_ERANGE);
return MSVCRT_ERANGE;
MSVCRT_INVALID_PMT("buf[count] is too small", ERANGE);
return ERANGE;
}
memcpy(buf, path, path_len + fname_len + 1);
return 0;
}
}
*MSVCRT__errno() = MSVCRT_ENOENT;
return MSVCRT_ENOENT;
*MSVCRT__errno() = ENOENT;
return ENOENT;
}
/*********************************************************************
@ -1741,9 +1741,9 @@ int CDECL MSVCRT__wsearchenv_s(const wchar_t* file, const wchar_t* env,
wchar_t path[MAX_PATH];
size_t path_len, fname_len;
if (!MSVCRT_CHECK_PMT(file != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(buf != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(count > 0)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(file != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(buf != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(count > 0)) return EINVAL;
if (count > MAX_PATH)
FIXME("count > MAX_PATH not supported\n");
@ -1763,8 +1763,8 @@ int CDECL MSVCRT__wsearchenv_s(const wchar_t* file, const wchar_t* env,
envVal = MSVCRT__wgetenv(env);
if (!envVal)
{
*MSVCRT__errno() = MSVCRT_ENOENT;
return MSVCRT_ENOENT;
*MSVCRT__errno() = ENOENT;
return ENOENT;
}
penv = envVal;
@ -1805,16 +1805,16 @@ int CDECL MSVCRT__wsearchenv_s(const wchar_t* file, const wchar_t* env,
{
if (path_len + fname_len + 1 > count)
{
MSVCRT_INVALID_PMT("buf[count] is too small", MSVCRT_ERANGE);
return MSVCRT_ERANGE;
MSVCRT_INVALID_PMT("buf[count] is too small", ERANGE);
return ERANGE;
}
memcpy(buf, path, (path_len + fname_len + 1) * sizeof(wchar_t));
return 0;
}
}
*MSVCRT__errno() = MSVCRT_ENOENT;
return MSVCRT_ENOENT;
*MSVCRT__errno() = ENOENT;
return ENOENT;
}
/*********************************************************************

36
dlls/msvcrt/environ.c
View File

@ -216,16 +216,16 @@ int CDECL _dupenv_s(char **buffer, size_t *numberOfElements, const char *varname
char *e;
size_t sz;
if (!MSVCRT_CHECK_PMT(buffer != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(varname != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(buffer != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(varname != NULL)) return EINVAL;
if (!(e = MSVCRT_getenv(varname))) return *MSVCRT__errno() = MSVCRT_EINVAL;
if (!(e = MSVCRT_getenv(varname))) return *MSVCRT__errno() = EINVAL;
sz = strlen(e) + 1;
if (!(*buffer = MSVCRT_malloc(sz)))
{
if (numberOfElements) *numberOfElements = 0;
return *MSVCRT__errno() = MSVCRT_ENOMEM;
return *MSVCRT__errno() = ENOMEM;
}
strcpy(*buffer, e);
if (numberOfElements) *numberOfElements = sz;
@ -241,16 +241,16 @@ int CDECL _wdupenv_s(wchar_t **buffer, size_t *numberOfElements,
wchar_t *e;
size_t sz;
if (!MSVCRT_CHECK_PMT(buffer != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(varname != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(buffer != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(varname != NULL)) return EINVAL;
if (!(e = MSVCRT__wgetenv(varname))) return *MSVCRT__errno() = MSVCRT_EINVAL;
if (!(e = MSVCRT__wgetenv(varname))) return *MSVCRT__errno() = EINVAL;
sz = MSVCRT_wcslen(e) + 1;
if (!(*buffer = MSVCRT_malloc(sz * sizeof(wchar_t))))
{
if (numberOfElements) *numberOfElements = 0;
return *MSVCRT__errno() = MSVCRT_ENOMEM;
return *MSVCRT__errno() = ENOMEM;
}
MSVCRT_wcscpy(*buffer, e);
if (numberOfElements) *numberOfElements = sz;
@ -266,19 +266,19 @@ int CDECL getenv_s(size_t *pReturnValue, char* buffer, size_t numberOfElements,
{
char *e;
if (!MSVCRT_CHECK_PMT(pReturnValue != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(!(buffer == NULL && numberOfElements > 0))) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(varname != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(pReturnValue != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(!(buffer == NULL && numberOfElements > 0))) return EINVAL;
if (!MSVCRT_CHECK_PMT(varname != NULL)) return EINVAL;
if (!(e = MSVCRT_getenv(varname)))
{
*pReturnValue = 0;
return *MSVCRT__errno() = MSVCRT_EINVAL;
return *MSVCRT__errno() = EINVAL;
}
*pReturnValue = strlen(e) + 1;
if (numberOfElements < *pReturnValue)
{
return *MSVCRT__errno() = MSVCRT_ERANGE;
return *MSVCRT__errno() = ERANGE;
}
strcpy(buffer, e);
return 0;
@ -292,19 +292,19 @@ int CDECL _wgetenv_s(size_t *pReturnValue, wchar_t *buffer, size_t numberOfEleme
{
wchar_t *e;
if (!MSVCRT_CHECK_PMT(pReturnValue != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(!(buffer == NULL && numberOfElements > 0))) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(varname != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(pReturnValue != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(!(buffer == NULL && numberOfElements > 0))) return EINVAL;
if (!MSVCRT_CHECK_PMT(varname != NULL)) return EINVAL;
if (!(e = MSVCRT__wgetenv(varname)))
{
*pReturnValue = 0;
return *MSVCRT__errno() = MSVCRT_EINVAL;
return *MSVCRT__errno() = EINVAL;
}
*pReturnValue = MSVCRT_wcslen(e) + 1;
if (numberOfElements < *pReturnValue)
{
return *MSVCRT__errno() = MSVCRT_ERANGE;
return *MSVCRT__errno() = ERANGE;
}
MSVCRT_wcscpy(buffer, e);
return 0;

52
dlls/msvcrt/errno.c
View File

@ -150,7 +150,7 @@ void msvcrt_set_errno(int err)
ERR_CASE(ERROR_NOT_LOCKED)
ERR_CASE(ERROR_INVALID_ACCESS)
ERR_CASE(ERROR_SHARING_VIOLATION)
ERR_MAPS(ERROR_LOCK_VIOLATION, MSVCRT_EACCES);
ERR_MAPS(ERROR_LOCK_VIOLATION, EACCES);
ERR_CASE(ERROR_FILE_NOT_FOUND)
ERR_CASE(ERROR_NO_MORE_FILES)
ERR_CASE(ERROR_BAD_PATHNAME)
@ -158,33 +158,33 @@ void msvcrt_set_errno(int err)
ERR_CASE(ERROR_INVALID_DRIVE)
ERR_CASE(ERROR_BAD_NET_NAME)
ERR_CASE(ERROR_FILENAME_EXCED_RANGE)
ERR_MAPS(ERROR_PATH_NOT_FOUND, MSVCRT_ENOENT);
ERR_MAPS(ERROR_IO_DEVICE, MSVCRT_EIO);
ERR_MAPS(ERROR_BAD_FORMAT, MSVCRT_ENOEXEC);
ERR_MAPS(ERROR_INVALID_HANDLE, MSVCRT_EBADF);
ERR_MAPS(ERROR_PATH_NOT_FOUND, ENOENT);
ERR_MAPS(ERROR_IO_DEVICE, EIO);
ERR_MAPS(ERROR_BAD_FORMAT, ENOEXEC);
ERR_MAPS(ERROR_INVALID_HANDLE, EBADF);
ERR_CASE(ERROR_OUTOFMEMORY)
ERR_CASE(ERROR_INVALID_BLOCK)
ERR_CASE(ERROR_NOT_ENOUGH_QUOTA)
ERR_MAPS(ERROR_ARENA_TRASHED, MSVCRT_ENOMEM);
ERR_MAPS(ERROR_BUSY, MSVCRT_EBUSY);
ERR_MAPS(ERROR_ARENA_TRASHED, ENOMEM);
ERR_MAPS(ERROR_BUSY, EBUSY);
ERR_CASE(ERROR_ALREADY_EXISTS)
ERR_MAPS(ERROR_FILE_EXISTS, MSVCRT_EEXIST);
ERR_MAPS(ERROR_BAD_DEVICE, MSVCRT_ENODEV);
ERR_MAPS(ERROR_TOO_MANY_OPEN_FILES, MSVCRT_EMFILE);
ERR_MAPS(ERROR_DISK_FULL, MSVCRT_ENOSPC);
ERR_MAPS(ERROR_BROKEN_PIPE, MSVCRT_EPIPE);
ERR_MAPS(ERROR_POSSIBLE_DEADLOCK, MSVCRT_EDEADLK);
ERR_MAPS(ERROR_DIR_NOT_EMPTY, MSVCRT_ENOTEMPTY);
ERR_MAPS(ERROR_BAD_ENVIRONMENT, MSVCRT_E2BIG);
ERR_MAPS(ERROR_FILE_EXISTS, EEXIST);
ERR_MAPS(ERROR_BAD_DEVICE, ENODEV);
ERR_MAPS(ERROR_TOO_MANY_OPEN_FILES, EMFILE);
ERR_MAPS(ERROR_DISK_FULL, ENOSPC);
ERR_MAPS(ERROR_BROKEN_PIPE, EPIPE);
ERR_MAPS(ERROR_POSSIBLE_DEADLOCK, EDEADLK);
ERR_MAPS(ERROR_DIR_NOT_EMPTY, ENOTEMPTY);
ERR_MAPS(ERROR_BAD_ENVIRONMENT, E2BIG);
ERR_CASE(ERROR_WAIT_NO_CHILDREN)
ERR_MAPS(ERROR_CHILD_NOT_COMPLETE, MSVCRT_ECHILD);
ERR_MAPS(ERROR_CHILD_NOT_COMPLETE, ECHILD);
ERR_CASE(ERROR_NO_PROC_SLOTS)
ERR_CASE(ERROR_MAX_THRDS_REACHED)
ERR_MAPS(ERROR_NESTING_NOT_ALLOWED, MSVCRT_EAGAIN);
ERR_MAPS(ERROR_NESTING_NOT_ALLOWED, EAGAIN);
default:
/* Remaining cases map to EINVAL */
/* FIXME: may be missing some errors above */
*errno_ptr = MSVCRT_EINVAL;
*errno_ptr = EINVAL;
}
}
@ -230,7 +230,7 @@ __msvcrt_ulong* CDECL MSVCRT___doserrno(void)
int CDECL _get_errno(int *pValue)
{
if (!pValue)
return MSVCRT_EINVAL;
return EINVAL;
*pValue = *MSVCRT__errno();
return 0;
@ -242,7 +242,7 @@ int CDECL _get_errno(int *pValue)
int CDECL _get_doserrno(int *pValue)
{
if (!pValue)
return MSVCRT_EINVAL;
return EINVAL;
*pValue = *MSVCRT___doserrno();
return 0;
@ -290,8 +290,8 @@ int CDECL MSVCRT_strerror_s(char *buffer, size_t numberOfElements, int errnum)
if (!buffer || !numberOfElements)
{
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
if (errnum < 0 || errnum > MSVCRT__sys_nerr)
@ -377,8 +377,8 @@ void CDECL MSVCRT__wperror(const wchar_t* str)
*/
int CDECL MSVCRT__wcserror_s(wchar_t* buffer, size_t nc, int err)
{
if (!MSVCRT_CHECK_PMT(buffer != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(nc > 0)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(buffer != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(nc > 0)) return EINVAL;
if (err < 0 || err > MSVCRT__sys_nerr) err = MSVCRT__sys_nerr;
MultiByteToWideChar(CP_ACP, 0, MSVCRT__sys_errlist[err], -1, buffer, nc);
@ -413,8 +413,8 @@ int CDECL MSVCRT___wcserror_s(wchar_t* buffer, size_t nc, const wchar_t* str)
if (str && *str) len += MSVCRT_wcslen(str) + 2 /* ': ' */;
if (len > nc)
{
MSVCRT_INVALID_PMT("buffer[nc] is too small", MSVCRT_ERANGE);
return MSVCRT_ERANGE;
MSVCRT_INVALID_PMT("buffer[nc] is too small", ERANGE);
return ERANGE;
}
if (str && *str)
{

2
dlls/msvcrt/except_i386.c
View File

@ -118,7 +118,7 @@ typedef struct _SCOPETABLE
void * (*lpfnHandler)(void);
} SCOPETABLE, *PSCOPETABLE;
typedef struct _MSVCRT_EXCEPTION_FRAME
typedef struct MSVCRT_EXCEPTION_FRAME
{
EXCEPTION_REGISTRATION_RECORD *prev;
void (*handler)(PEXCEPTION_RECORD, EXCEPTION_REGISTRATION_RECORD*,

170
dlls/msvcrt/file.c
View File

@ -277,7 +277,7 @@ static inline BOOL alloc_pioinfo_block(int fd)
if(fd<0 || fd>=MSVCRT_MAX_FILES)
{
*MSVCRT__errno() = MSVCRT_ENFILE;
*MSVCRT__errno() = ENFILE;
return FALSE;
}
@ -285,7 +285,7 @@ static inline BOOL alloc_pioinfo_block(int fd)
if(!block)
{
WARN(":out of memory!\n");
*MSVCRT__errno() = MSVCRT_ENOMEM;
*MSVCRT__errno() = ENOMEM;
return FALSE;
}
for(i=0; i<MSVCRT_FD_BLOCK_SIZE; i++)
@ -338,7 +338,7 @@ static inline ioinfo* get_ioinfo_alloc(int *fd)
}
WARN(":files exhausted!\n");
*MSVCRT__errno() = MSVCRT_ENFILE;
*MSVCRT__errno() = ENFILE;
return &MSVCRT___badioinfo;
}
@ -363,7 +363,7 @@ static inline MSVCRT_FILE* msvcrt_get_file(int i)
MSVCRT_fstream[i/MSVCRT_FD_BLOCK_SIZE] = MSVCRT_calloc(MSVCRT_FD_BLOCK_SIZE, sizeof(file_crit));
if(!MSVCRT_fstream[i/MSVCRT_FD_BLOCK_SIZE]) {
ERR("out of memory\n");
*MSVCRT__errno() = MSVCRT_ENOMEM;
*MSVCRT__errno() = ENOMEM;
return NULL;
}
@ -477,7 +477,7 @@ static int msvcrt_init_fp(MSVCRT_FILE* file, int fd, unsigned stream_flags)
{
WARN(":invalid fd %d\n",fd);
*MSVCRT___doserrno() = 0;
*MSVCRT__errno() = MSVCRT_EBADF;
*MSVCRT__errno() = EBADF;
return -1;
}
file->_ptr = file->_base = NULL;
@ -1050,9 +1050,9 @@ int CDECL MSVCRT__close(int fd)
TRACE(":fd (%d) handle (%p)\n", fd, info->handle);
if (fd == MSVCRT_NO_CONSOLE_FD) {
*MSVCRT__errno() = MSVCRT_EBADF;
*MSVCRT__errno() = EBADF;
ret = -1;
} else if (!MSVCRT_CHECK_PMT_ERR(info->wxflag & WX_OPEN, MSVCRT_EBADF)) {
} else if (!MSVCRT_CHECK_PMT_ERR(info->wxflag & WX_OPEN, EBADF)) {
ret = -1;
} else if (fd == MSVCRT_STDOUT_FILENO &&
info->handle == get_ioinfo_nolock(MSVCRT_STDERR_FILENO)->handle) {
@ -1127,7 +1127,7 @@ int CDECL MSVCRT__dup2(int od, int nd)
}
else
{
*MSVCRT__errno() = MSVCRT_EBADF;
*MSVCRT__errno() = EBADF;
ret = -1;
}
@ -1261,7 +1261,7 @@ __int64 CDECL MSVCRT__lseeki64(int fd, __int64 offset, int whence)
if (info->handle == INVALID_HANDLE_VALUE)
{
*MSVCRT__errno() = MSVCRT_EBADF;
*MSVCRT__errno() = EBADF;
release_ioinfo(info);
return -1;
}
@ -1269,7 +1269,7 @@ __int64 CDECL MSVCRT__lseeki64(int fd, __int64 offset, int whence)
if (whence < 0 || whence > 2)
{
release_ioinfo(info);
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return -1;
}
@ -1348,7 +1348,7 @@ int CDECL MSVCRT__locking(int fd, int mode, LONG nbytes)
if (mode < 0 || mode > 4)
{
release_ioinfo(info);
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return -1;
}
@ -1364,7 +1364,7 @@ int CDECL MSVCRT__locking(int fd, int mode, LONG nbytes)
{
release_ioinfo(info);
FIXME ("Seek failed\n");
*MSVCRT__errno() = MSVCRT_EINVAL; /* FIXME */
*MSVCRT__errno() = EINVAL; /* FIXME */
return -1;
}
if (mode == MSVCRT__LK_LOCK || mode == MSVCRT__LK_RLCK)
@ -1453,7 +1453,7 @@ int CDECL MSVCRT__chsize_s(int fd, __int64 size)
TRACE("(fd=%d, size=%s)\n", fd, wine_dbgstr_longlong(size));
if (!MSVCRT_CHECK_PMT(size >= 0)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(size >= 0)) return EINVAL;
info = get_ioinfo(fd);
@ -1507,7 +1507,7 @@ int CDECL MSVCRT_clearerr_s(MSVCRT_FILE* file)
{
TRACE(":file (%p)\n",file);
if (!MSVCRT_CHECK_PMT(file != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(file != NULL)) return EINVAL;
MSVCRT__lock_file(file);
file->_flag &= ~(MSVCRT__IOERR | MSVCRT__IOEOF);
@ -1551,7 +1551,7 @@ static int msvcrt_get_flags(const wchar_t* mode, int *open_flags, int* stream_fl
*stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOWRT;
break;
default:
MSVCRT_INVALID_PMT(0, MSVCRT_EINVAL);
MSVCRT_INVALID_PMT(0, EINVAL);
return -1;
}
@ -1627,7 +1627,7 @@ static int msvcrt_get_flags(const wchar_t* mode, int *open_flags, int* stream_fl
}
else
{
MSVCRT_INVALID_PMT(0, MSVCRT_EINVAL);
MSVCRT_INVALID_PMT(0, EINVAL);
return -1;
}
@ -1929,7 +1929,7 @@ intptr_t CDECL MSVCRT__get_osfhandle(int fd)
TRACE(":fd (%d) handle (%p)\n",fd,hand);
if(hand == INVALID_HANDLE_VALUE)
*MSVCRT__errno() = MSVCRT_EBADF;
*MSVCRT__errno() = EBADF;
return (intptr_t)hand;
}
@ -1941,7 +1941,7 @@ int CDECL MSVCRT__mktemp_s(char *pattern, size_t size)
DWORD len, xno, id;
if(!MSVCRT_CHECK_PMT(pattern!=NULL))
return MSVCRT_EINVAL;
return EINVAL;
for(len=0; len<size; len++)
if(!pattern[len])
@ -1949,12 +1949,12 @@ int CDECL MSVCRT__mktemp_s(char *pattern, size_t size)
if(!MSVCRT_CHECK_PMT(len!=size && len>=6)) {
if(size)
pattern[0] = 0;
return MSVCRT_EINVAL;
return EINVAL;
}
for(xno=1; xno<=6; xno++)
if(!MSVCRT_CHECK_PMT(pattern[len-xno] == 'X'))
return MSVCRT_EINVAL;
return EINVAL;
id = GetCurrentProcessId();
for(xno=1; xno<6; xno++) {
@ -1968,8 +1968,8 @@ int CDECL MSVCRT__mktemp_s(char *pattern, size_t size)
}
pattern[0] = 0;
*MSVCRT__errno() = MSVCRT_EEXIST;
return MSVCRT_EEXIST;
*MSVCRT__errno() = EEXIST;
return EEXIST;
}
/*********************************************************************
@ -2016,7 +2016,7 @@ int CDECL MSVCRT__wmktemp_s(wchar_t *pattern, size_t size)
DWORD len, xno, id;
if(!MSVCRT_CHECK_PMT(pattern!=NULL))
return MSVCRT_EINVAL;
return EINVAL;
for(len=0; len<size; len++)
if(!pattern[len])
@ -2024,12 +2024,12 @@ int CDECL MSVCRT__wmktemp_s(wchar_t *pattern, size_t size)
if(!MSVCRT_CHECK_PMT(len!=size && len>=6)) {
if(size)
pattern[0] = 0;
return MSVCRT_EINVAL;
return EINVAL;
}
for(xno=1; xno<=6; xno++)
if(!MSVCRT_CHECK_PMT(pattern[len-xno] == 'X'))
return MSVCRT_EINVAL;
return EINVAL;
id = GetCurrentProcessId();
for(xno=1; xno<6; xno++) {
@ -2043,8 +2043,8 @@ int CDECL MSVCRT__wmktemp_s(wchar_t *pattern, size_t size)
}
pattern[0] = 0;
*MSVCRT__errno() = MSVCRT_EEXIST;
return MSVCRT_EEXIST;
*MSVCRT__errno() = EEXIST;
return EEXIST;
}
/*********************************************************************
@ -2122,7 +2122,7 @@ int CDECL MSVCRT__pipe(int *pfds, unsigned int psize, int textmode)
if (!pfds)
{
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return -1;
}
@ -2148,14 +2148,14 @@ int CDECL MSVCRT__pipe(int *pfds, unsigned int psize, int textmode)
{
MSVCRT__close(pfds[0]);
CloseHandle(writeHandle);
*MSVCRT__errno() = MSVCRT_EMFILE;
*MSVCRT__errno() = EMFILE;
}
}
else
{
CloseHandle(readHandle);
CloseHandle(writeHandle);
*MSVCRT__errno() = MSVCRT_EMFILE;
*MSVCRT__errno() = EMFILE;
}
}
else
@ -2200,7 +2200,7 @@ int CDECL MSVCRT__wsopen_dispatch( const wchar_t* path, int oflags, int shflags,
TRACE("path: (%s) oflags: 0x%04x shflags: 0x%04x pmode: 0x%04x fd*: %p secure: %d\n",
debugstr_w(path), oflags, shflags, pmode, fd, secure);
if (!MSVCRT_CHECK_PMT( fd != NULL )) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT( fd != NULL )) return EINVAL;
*fd = -1;
wxflag = split_oflags(oflags);
@ -2214,7 +2214,7 @@ int CDECL MSVCRT__wsopen_dispatch( const wchar_t* path, int oflags, int shflags,
if (oflags & MSVCRT__O_CREAT)
{
if (secure && !MSVCRT_CHECK_PMT(!(pmode & ~(MSVCRT__S_IREAD | MSVCRT__S_IWRITE))))
return MSVCRT_EINVAL;
return EINVAL;
if (oflags & MSVCRT__O_EXCL)
creation = CREATE_NEW;
@ -2247,7 +2247,7 @@ int CDECL MSVCRT__wsopen_dispatch( const wchar_t* path, int oflags, int shflags,
break;
default:
ERR( "Unhandled shflags 0x%x\n", shflags );
return MSVCRT_EINVAL;
return EINVAL;
}
if (!(pmode & ~MSVCRT_umask & MSVCRT__S_IWRITE))
@ -2394,10 +2394,10 @@ int CDECL MSVCRT__sopen_dispatch( const char *path, int oflags, int shflags,
int ret;
if (!MSVCRT_CHECK_PMT(fd != NULL))
return MSVCRT_EINVAL;
return EINVAL;
*fd = -1;
if(!MSVCRT_CHECK_PMT(path && (pathW = msvcrt_wstrdupa(path))))
return MSVCRT_EINVAL;
return EINVAL;
ret = MSVCRT__wsopen_dispatch(pathW, oflags, shflags, pmode, fd, secure);
MSVCRT_free(pathW);
@ -2759,14 +2759,14 @@ static int read_i(int fd, ioinfo *fdinfo, void *buf, unsigned int count)
TRACE(":fd (%d) handle (%p) buf (%p) len (%d)\n", fd, fdinfo->handle, buf, count);
if (fdinfo->handle == INVALID_HANDLE_VALUE)
{
*MSVCRT__errno() = MSVCRT_EBADF;
*MSVCRT__errno() = EBADF;
return -1;
}
utf16 = (fdinfo->exflag & EF_UTF16) != 0;
if (((fdinfo->exflag&EF_UTF8) || utf16) && count&1)
{
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return -1;
}
@ -2909,7 +2909,7 @@ int CDECL MSVCRT__read(int fd, void *buf, unsigned int count)
int num_read;
if(fd == MSVCRT_NO_CONSOLE_FD) {
*MSVCRT__errno() = MSVCRT_EBADF;
*MSVCRT__errno() = EBADF;
return -1;
}
@ -2931,13 +2931,13 @@ int CDECL MSVCRT__setmode(int fd,int mode)
if(mode!=MSVCRT__O_TEXT && mode!=MSVCRT__O_BINARY && mode!=MSVCRT__O_WTEXT
&& mode!=MSVCRT__O_U16TEXT && mode!=MSVCRT__O_U8TEXT) {
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
release_ioinfo(info);
return -1;
}
if(info == &MSVCRT___badioinfo) {
*MSVCRT__errno() = MSVCRT_EBADF;
*MSVCRT__errno() = EBADF;
return EOF;
}
@ -2978,14 +2978,14 @@ int CDECL MSVCRT_stat64(const char* path, struct MSVCRT__stat64 * buf)
if (plen==2 && path[1]==':')
{
*MSVCRT__errno() = MSVCRT_ENOENT;
*MSVCRT__errno() = ENOENT;
return -1;
}
#if _MSVCR_VER<140
if (plen>=2 && path[plen-2]!=':' && (path[plen-1]=='\\' || path[plen-1]=='/'))
{
*MSVCRT__errno() = MSVCRT_ENOENT;
*MSVCRT__errno() = ENOENT;
return -1;
}
#endif
@ -2993,7 +2993,7 @@ int CDECL MSVCRT_stat64(const char* path, struct MSVCRT__stat64 * buf)
if (!GetFileAttributesExA(path, GetFileExInfoStandard, &hfi))
{
TRACE("failed (%d)\n",GetLastError());
*MSVCRT__errno() = MSVCRT_ENOENT;
*MSVCRT__errno() = ENOENT;
return -1;
}
@ -3134,14 +3134,14 @@ int CDECL MSVCRT__wstat64(const wchar_t* path, struct MSVCRT__stat64 * buf)
if (plen==2 && path[1]==':')
{
*MSVCRT__errno() = MSVCRT_ENOENT;
*MSVCRT__errno() = ENOENT;
return -1;
}
#if _MSVCR_VER<140
if (plen>=2 && path[plen-2]!=':' && (path[plen-1]=='\\' || path[plen-1]=='/'))
{
*MSVCRT__errno() = MSVCRT_ENOENT;
*MSVCRT__errno() = ENOENT;
return -1;
}
#endif
@ -3149,7 +3149,7 @@ int CDECL MSVCRT__wstat64(const wchar_t* path, struct MSVCRT__stat64 * buf)
if (!GetFileAttributesExW(path, GetFileExInfoStandard, &hfi))
{
TRACE("failed (%d)\n",GetLastError());
*MSVCRT__errno() = MSVCRT_ENOENT;
*MSVCRT__errno() = ENOENT;
return -1;
}
@ -3441,14 +3441,14 @@ int CDECL MSVCRT__write(int fd, const void* buf, unsigned int count)
if (hand == INVALID_HANDLE_VALUE || fd == MSVCRT_NO_CONSOLE_FD)
{
*MSVCRT__errno() = MSVCRT_EBADF;
*MSVCRT__errno() = EBADF;
release_ioinfo(info);
return -1;
}
if (((info->exflag&EF_UTF8) || (info->exflag&EF_UTF16)) && count&1)
{
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
release_ioinfo(info);
return -1;
}
@ -3508,7 +3508,7 @@ int CDECL MSVCRT__write(int fd, const void* buf, unsigned int count)
info->dbcsBufferUsed = TRUE;
break;
#else
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
release_ioinfo(info);
return -1;
#endif
@ -3948,7 +3948,7 @@ int CDECL MSVCRT__flsbuf(int c, MSVCRT_FILE* file)
if(!(file->_flag & MSVCRT__IOWRT)) {
if(!(file->_flag & MSVCRT__IORW)) {
file->_flag |= MSVCRT__IOERR;
*MSVCRT__errno() = MSVCRT_EBADF;
*MSVCRT__errno() = EBADF;
return EOF;
}
file->_flag |= MSVCRT__IOWRT;
@ -4158,14 +4158,14 @@ MSVCRT_FILE * CDECL MSVCRT__fsopen(const char *path, const char *mode, int share
if (path && !(pathW = msvcrt_wstrdupa(path))) {
MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return NULL;
}
if (mode && !(modeW = msvcrt_wstrdupa(mode)))
{
MSVCRT_free(pathW);
MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return NULL;
}
@ -4190,9 +4190,9 @@ MSVCRT_FILE * CDECL MSVCRT_fopen(const char *path, const char *mode)
int CDECL MSVCRT_fopen_s(MSVCRT_FILE** pFile,
const char *filename, const char *mode)
{
if (!MSVCRT_CHECK_PMT(pFile != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(filename != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(mode != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(pFile != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(filename != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(mode != NULL)) return EINVAL;
*pFile = MSVCRT_fopen(filename, mode);
@ -4215,9 +4215,9 @@ MSVCRT_FILE * CDECL MSVCRT__wfopen(const wchar_t *path, const wchar_t *mode)
int CDECL MSVCRT__wfopen_s(MSVCRT_FILE** pFile, const wchar_t *filename,
const wchar_t *mode)
{
if (!MSVCRT_CHECK_PMT(pFile != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(filename != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(mode != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(pFile != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(filename != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(mode != NULL)) return EINVAL;
*pFile = MSVCRT__wfopen(filename, mode);
@ -4414,7 +4414,7 @@ size_t CDECL MSVCRT__fread_nolock_s(void *buf, size_t buf_size, size_t elem_size
if(stream->_cnt > 0) {
size_t size = bytes_left<stream->_cnt ? bytes_left : stream->_cnt;
if(!MSVCRT_CHECK_PMT_ERR(size <= buf_size-buf_pos, MSVCRT_ERANGE)) {
if(!MSVCRT_CHECK_PMT_ERR(size <= buf_size-buf_pos, ERANGE)) {
memset(buf, 0, buf_size);
return 0;
}
@ -4428,7 +4428,7 @@ size_t CDECL MSVCRT__fread_nolock_s(void *buf, size_t buf_size, size_t elem_size
if(c == EOF)
break;
if(!MSVCRT_CHECK_PMT_ERR(buf_size != buf_pos, MSVCRT_ERANGE)) {
if(!MSVCRT_CHECK_PMT_ERR(buf_size != buf_pos, ERANGE)) {
memset(buf, 0, buf_size);
return 0;
}
@ -4479,10 +4479,10 @@ MSVCRT_FILE* CDECL MSVCRT__wfreopen(const wchar_t *path, const wchar_t *mode, MS
int CDECL MSVCRT__wfreopen_s(MSVCRT_FILE** pFile,
const wchar_t *path, const wchar_t *mode, MSVCRT_FILE* file)
{
if (!MSVCRT_CHECK_PMT(pFile != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(path != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(mode != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(file != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(pFile != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(path != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(mode != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(file != NULL)) return EINVAL;
*pFile = MSVCRT__wfreopen(path, mode, file);
@ -4520,10 +4520,10 @@ MSVCRT_FILE* CDECL MSVCRT_freopen(const char *path, const char *mode, MSVCRT_FIL
int CDECL MSVCRT_freopen_s(MSVCRT_FILE** pFile,
const char *path, const char *mode, MSVCRT_FILE* file)
{
if (!MSVCRT_CHECK_PMT(pFile != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(path != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(mode != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(file != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(pFile != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(path != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(mode != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(file != NULL)) return EINVAL;
*pFile = MSVCRT_freopen(path, mode, file);
@ -4943,12 +4943,12 @@ static int tmpnam_helper(char *s, size_t size, int *tmpnam_unique, int tmp_max)
char *p = s;
int digits;
if (!MSVCRT_CHECK_PMT(s != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(s != NULL)) return EINVAL;
if (size < 3) {
if (size) *s = 0;
*MSVCRT__errno() = MSVCRT_ERANGE;
return MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return ERANGE;
}
*p++ = '\\';
*p++ = 's';
@ -4956,8 +4956,8 @@ static int tmpnam_helper(char *s, size_t size, int *tmpnam_unique, int tmp_max)
digits = msvcrt_int_to_base32(GetCurrentProcessId(), tmpstr);
if (digits+1 > size) {
*s = 0;
*MSVCRT__errno() = MSVCRT_ERANGE;
return MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return ERANGE;
}
memcpy(p, tmpstr, digits*sizeof(tmpstr[0]));
p += digits;
@ -4973,8 +4973,8 @@ static int tmpnam_helper(char *s, size_t size, int *tmpnam_unique, int tmp_max)
digits = msvcrt_int_to_base32(digits, tmpstr);
if (digits+1 > size) {
*s = 0;
*MSVCRT__errno() = MSVCRT_ERANGE;
return MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return ERANGE;
}
memcpy(p, tmpstr, digits*sizeof(tmpstr[0]));
p[digits] = 0;
@ -5014,12 +5014,12 @@ static int wtmpnam_helper(wchar_t *s, size_t size, int *tmpnam_unique, int tmp_m
wchar_t *p = s;
int digits;
if (!MSVCRT_CHECK_PMT(s != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(s != NULL)) return EINVAL;
if (size < 3) {
if (size) *s = 0;
*MSVCRT__errno() = MSVCRT_ERANGE;
return MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return ERANGE;
}
*p++ = '\\';
*p++ = 's';
@ -5027,8 +5027,8 @@ static int wtmpnam_helper(wchar_t *s, size_t size, int *tmpnam_unique, int tmp_m
digits = msvcrt_int_to_base32_w(GetCurrentProcessId(), tmpstr);
if (digits+1 > size) {
*s = 0;
*MSVCRT__errno() = MSVCRT_ERANGE;
return MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return ERANGE;
}
memcpy(p, tmpstr, digits*sizeof(tmpstr[0]));
p += digits;
@ -5044,8 +5044,8 @@ static int wtmpnam_helper(wchar_t *s, size_t size, int *tmpnam_unique, int tmp_m
digits = msvcrt_int_to_base32_w(digits, tmpstr);
if (digits+1 > size) {
*s = 0;
*MSVCRT__errno() = MSVCRT_ERANGE;
return MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return ERANGE;
}
memcpy(p, tmpstr, digits*sizeof(tmpstr[0]));
p[digits] = 0;
@ -5116,7 +5116,7 @@ MSVCRT_FILE* CDECL MSVCRT_tmpfile(void)
*/
int CDECL MSVCRT_tmpfile_s(MSVCRT_FILE** file)
{
if (!MSVCRT_CHECK_PMT(file != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(file != NULL)) return EINVAL;
*file = MSVCRT_tmpfile();
return 0;
@ -5165,7 +5165,7 @@ static int vfprintf_helper(DWORD options, MSVCRT_FILE* file, const char *format,
ret = create_positional_ctx_a(args_ctx, format, valist);
if(ret < 0) {
MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return ret;
} else if(!ret)
options &= ~MSVCRT_PRINTF_POSITIONAL_PARAMS;
@ -5197,7 +5197,7 @@ static int vfwprintf_helper(DWORD options, MSVCRT_FILE* file, const wchar_t *for
ret = create_positional_ctx_w(args_ctx, format, valist);
if(ret < 0) {
MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return ret;
} else if(!ret)
options &= ~MSVCRT_PRINTF_POSITIONAL_PARAMS;

56
dlls/msvcrt/heap.c
View File

@ -335,7 +335,7 @@ int CDECL _heapset(unsigned int value)
int CDECL _heapadd(void* mem, size_t size)
{
TRACE("(%p,%Iu) unsupported in Win32\n", mem,size);
*MSVCRT__errno() = MSVCRT_ENOSYS;
*MSVCRT__errno() = ENOSYS;
return -1;
}
@ -388,7 +388,7 @@ void* CDECL DECLSPEC_HOTPATCH MSVCRT_calloc(size_t count, size_t size)
if (size && bytes / size != count)
{
*MSVCRT__errno() = MSVCRT_ENOMEM;
*MSVCRT__errno() = ENOMEM;
return NULL;
}
@ -438,7 +438,7 @@ void* CDECL MSVCRT_malloc(size_t size)
} while(_callnewh(size));
if (!ret)
*MSVCRT__errno() = MSVCRT_ENOMEM;
*MSVCRT__errno() = ENOMEM;
return ret;
}
@ -490,7 +490,7 @@ void* CDECL _recalloc(void *mem, size_t num, size_t size)
ret = MSVCRT_realloc(mem, size);
if(!ret) {
*MSVCRT__errno() = MSVCRT_ENOMEM;
*MSVCRT__errno() = ENOMEM;
return NULL;
}
@ -564,14 +564,14 @@ void * CDECL _aligned_offset_malloc(size_t size, size_t alignment, size_t offset
/* alignment must be a power of 2 */
if ((alignment & (alignment - 1)) != 0)
{
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return NULL;
}
/* offset must be less than size */
if (offset && offset >= size)
{
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return NULL;
}
@ -621,14 +621,14 @@ void * CDECL _aligned_offset_realloc(void *memblock, size_t size,
/* alignment must be a power of 2 */
if ((alignment & (alignment - 1)) != 0)
{
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return NULL;
}
/* offset must be less than size */
if (offset >= size)
{
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return NULL;
}
@ -646,7 +646,7 @@ void * CDECL _aligned_offset_realloc(void *memblock, size_t size,
saved = SAVED_PTR(memblock);
if (memblock != ALIGN_PTR(*saved, alignment, offset))
{
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return NULL;
}
@ -739,9 +739,9 @@ int CDECL MSVCRT_memmove_s(void *dest, size_t numberOfElements, const void *src,
if(!count)
return 0;
if (!MSVCRT_CHECK_PMT(dest != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(src != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT_ERR( count <= numberOfElements, MSVCRT_ERANGE )) return MSVCRT_ERANGE;
if (!MSVCRT_CHECK_PMT(dest != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(src != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT_ERR( count <= numberOfElements, ERANGE )) return ERANGE;
memmove(dest, src, count);
return 0;
@ -763,9 +763,9 @@ int CDECL wmemmove_s(wchar_t *dest, size_t numberOfElements,
* http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1225.pdf
* in that it does not zero the output buffer on constraint violation.
*/
if (!MSVCRT_CHECK_PMT(dest != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(src != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT_ERR(count <= numberOfElements, MSVCRT_ERANGE)) return MSVCRT_ERANGE;
if (!MSVCRT_CHECK_PMT(dest != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(src != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT_ERR(count <= numberOfElements, ERANGE)) return ERANGE;
memmove(dest, src, sizeof(wchar_t)*count);
return 0;
@ -782,16 +782,16 @@ int CDECL MSVCRT_memcpy_s(void *dest, size_t numberOfElements, const void *src,
if(!count)
return 0;
if (!MSVCRT_CHECK_PMT(dest != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(dest != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(src != NULL))
{
memset(dest, 0, numberOfElements);
return MSVCRT_EINVAL;
return EINVAL;
}
if (!MSVCRT_CHECK_PMT_ERR( count <= numberOfElements, MSVCRT_ERANGE ))
if (!MSVCRT_CHECK_PMT_ERR( count <= numberOfElements, ERANGE ))
{
memset(dest, 0, numberOfElements);
return MSVCRT_ERANGE;
return ERANGE;
}
memmove(dest, src, count);
@ -810,15 +810,15 @@ int CDECL wmemcpy_s(wchar_t *dest, size_t numberOfElements,
if (!count)
return 0;
if (!MSVCRT_CHECK_PMT(dest != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(dest != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(src != NULL)) {
memset(dest, 0, numberOfElements*sizeof(wchar_t));
return MSVCRT_EINVAL;
return EINVAL;
}
if (!MSVCRT_CHECK_PMT_ERR(count <= numberOfElements, MSVCRT_ERANGE)) {
if (!MSVCRT_CHECK_PMT_ERR(count <= numberOfElements, ERANGE)) {
memset(dest, 0, numberOfElements*sizeof(wchar_t));
return MSVCRT_ERANGE;
return ERANGE;
}
memmove(dest, src, sizeof(wchar_t)*count);
@ -842,9 +842,9 @@ int CDECL MSVCRT_strncpy_s(char *dest, size_t numberOfElements,
return 0;
}
if (!MSVCRT_CHECK_PMT(dest != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(src != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(numberOfElements != 0)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(dest != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(src != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(numberOfElements != 0)) return EINVAL;
if(count!=MSVCRT__TRUNCATE && count<numberOfElements)
end = count;
@ -859,9 +859,9 @@ int CDECL MSVCRT_strncpy_s(char *dest, size_t numberOfElements,
return 0;
}
MSVCRT_INVALID_PMT("dest[numberOfElements] is too small", MSVCRT_EINVAL);
MSVCRT_INVALID_PMT("dest[numberOfElements] is too small", EINVAL);
dest[0] = '\0';
return MSVCRT_EINVAL;
return EINVAL;
}
BOOL msvcrt_init_heap(void)

120
dlls/msvcrt/math.c
View File

@ -101,11 +101,11 @@ static double math_error(int type, const char *name, double arg1, double arg2, d
switch (type)
{
case _DOMAIN:
*MSVCRT__errno() = MSVCRT_EDOM;
*MSVCRT__errno() = EDOM;
break;
case _SING:
case _OVERFLOW:
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
break;
case _UNDERFLOW:
/* don't set errno */
@ -189,7 +189,7 @@ float CDECL MSVCRT__copysignf( float x, float y )
*/
float CDECL MSVCRT__nextafterf( float num, float next )
{
if (!isfinite(num) || !isfinite(next)) *MSVCRT__errno() = MSVCRT_EDOM;
if (!isfinite(num) || !isfinite(next)) *MSVCRT__errno() = EDOM;
return unix_funcs->nextafterf( num, next );
}
@ -1578,9 +1578,9 @@ double CDECL MSVCRT_floor( double x )
double CDECL MSVCRT_fma( double x, double y, double z )
{
double w = unix_funcs->fma(x, y, z);
if ((isinf(x) && y == 0) || (x == 0 && isinf(y))) *MSVCRT__errno() = MSVCRT_EDOM;
else if (isinf(x) && isinf(z) && x != z) *MSVCRT__errno() = MSVCRT_EDOM;
else if (isinf(y) && isinf(z) && y != z) *MSVCRT__errno() = MSVCRT_EDOM;
if ((isinf(x) && y == 0) || (x == 0 && isinf(y))) *MSVCRT__errno() = EDOM;
else if (isinf(x) && isinf(z) && x != z) *MSVCRT__errno() = EDOM;
else if (isinf(y) && isinf(z) && y != z) *MSVCRT__errno() = EDOM;
return w;
}
@ -1590,9 +1590,9 @@ double CDECL MSVCRT_fma( double x, double y, double z )
float CDECL MSVCRT_fmaf( float x, float y, float z )
{
float w = unix_funcs->fmaf(x, y, z);
if ((isinf(x) && y == 0) || (x == 0 && isinf(y))) *MSVCRT__errno() = MSVCRT_EDOM;
else if (isinf(x) && isinf(z) && x != z) *MSVCRT__errno() = MSVCRT_EDOM;
else if (isinf(y) && isinf(z) && y != z) *MSVCRT__errno() = MSVCRT_EDOM;
if ((isinf(x) && y == 0) || (x == 0 && isinf(y))) *MSVCRT__errno() = EDOM;
else if (isinf(x) && isinf(z) && x != z) *MSVCRT__errno() = EDOM;
else if (isinf(y) && isinf(z) && y != z) *MSVCRT__errno() = EDOM;
return w;
}
@ -2057,7 +2057,7 @@ int CDECL _controlfp_s(unsigned int *cur, unsigned int newval, unsigned int mask
if (!MSVCRT_CHECK_PMT( !(newval & mask & ~all_flags) ))
{
if (cur) *cur = _controlfp( 0, 0 ); /* retrieve it anyway */
return MSVCRT_EINVAL;
return EINVAL;
}
val = _controlfp( newval, mask );
if (cur) *cur = val;
@ -2283,11 +2283,11 @@ double CDECL MSVCRT__y0(double num)
{
double retval;
if (!isfinite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
if (!isfinite(num)) *MSVCRT__errno() = EDOM;
retval = unix_funcs->y0( num );
if (MSVCRT__fpclass(retval) == MSVCRT__FPCLASS_NINF)
{
*MSVCRT__errno() = MSVCRT_EDOM;
*MSVCRT__errno() = EDOM;
retval = NAN;
}
return retval;
@ -2300,11 +2300,11 @@ double CDECL MSVCRT__y1(double num)
{
double retval;
if (!isfinite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
if (!isfinite(num)) *MSVCRT__errno() = EDOM;
retval = unix_funcs->y1( num );
if (MSVCRT__fpclass(retval) == MSVCRT__FPCLASS_NINF)
{
*MSVCRT__errno() = MSVCRT_EDOM;
*MSVCRT__errno() = EDOM;
retval = NAN;
}
return retval;
@ -2317,11 +2317,11 @@ double CDECL MSVCRT__yn(int order, double num)
{
double retval;
if (!isfinite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
if (!isfinite(num)) *MSVCRT__errno() = EDOM;
retval = unix_funcs->yn( order, num );
if (MSVCRT__fpclass(retval) == MSVCRT__FPCLASS_NINF)
{
*MSVCRT__errno() = MSVCRT_EDOM;
*MSVCRT__errno() = EDOM;
retval = NAN;
}
return retval;
@ -2354,7 +2354,7 @@ double CDECL MSVCRT_nexttoward(double num, double next)
if (!(MSVCRT__fpclass(ret) & (MSVCRT__FPCLASS_PN | MSVCRT__FPCLASS_NN
| MSVCRT__FPCLASS_SNAN | MSVCRT__FPCLASS_QNAN)) && !isinf(num))
{
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
}
return ret;
}
@ -2368,7 +2368,7 @@ float CDECL MSVCRT_nexttowardf(float num, double next)
if (!(MSVCRT__fpclass(ret) & (MSVCRT__FPCLASS_PN | MSVCRT__FPCLASS_NN
| MSVCRT__FPCLASS_SNAN | MSVCRT__FPCLASS_QNAN)) && !isinf(num))
{
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
}
return ret;
}
@ -2381,7 +2381,7 @@ float CDECL MSVCRT_nexttowardf(float num, double next)
double CDECL MSVCRT__nextafter(double num, double next)
{
double retval;
if (!isfinite(num) || !isfinite(next)) *MSVCRT__errno() = MSVCRT_EDOM;
if (!isfinite(num) || !isfinite(next)) *MSVCRT__errno() = EDOM;
retval = unix_funcs->nextafter(num,next);
return retval;
}
@ -2439,11 +2439,11 @@ int CDECL MSVCRT__ecvt_s( char *buffer, size_t length, double number, int ndigit
char *result;
const char infret[] = "1#INF";
if (!MSVCRT_CHECK_PMT(buffer != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(decpt != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(sign != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT_ERR( length > 2, MSVCRT_ERANGE )) return MSVCRT_ERANGE;
if (!MSVCRT_CHECK_PMT_ERR(ndigits < (int)length - 1, MSVCRT_ERANGE )) return MSVCRT_ERANGE;
if (!MSVCRT_CHECK_PMT(buffer != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(decpt != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(sign != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT_ERR( length > 2, ERANGE )) return ERANGE;
if (!MSVCRT_CHECK_PMT_ERR(ndigits < (int)length - 1, ERANGE )) return ERANGE;
/* special case - inf */
if(number == HUGE_VAL || number == -HUGE_VAL)
@ -2585,8 +2585,8 @@ int CDECL MSVCRT__fcvt_s(char* outbuffer, size_t size, double number, int ndigit
if (!outbuffer || !decpt || !sign || size == 0)
{
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
if (number < 0)
@ -2667,12 +2667,12 @@ int CDECL MSVCRT__fcvt_s(char* outbuffer, size_t size, double number, int ndigit
char * CDECL MSVCRT__gcvt( double number, int ndigit, char *buff )
{
if(!buff) {
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return NULL;
}
if(ndigit < 0) {
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return NULL;
}
@ -2688,23 +2688,23 @@ int CDECL MSVCRT__gcvt_s(char *buff, size_t size, double number, int digits)
int len;
if(!buff) {
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
if( digits<0 || digits>=size) {
if(size)
buff[0] = '\0';
*MSVCRT__errno() = MSVCRT_ERANGE;
return MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return ERANGE;
}
len = MSVCRT__scprintf("%.*g", digits, number);
if(len > size) {
buff[0] = '\0';
*MSVCRT__errno() = MSVCRT_ERANGE;
return MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return ERANGE;
}
MSVCRT_sprintf(buff, "%.*g", digits, number);
@ -3300,7 +3300,7 @@ LDOUBLE CDECL MSVCR120_cbrtl(LDOUBLE x)
double CDECL MSVCR120_exp2(double x)
{
double ret = unix_funcs->exp2( x );
if (isfinite(x) && !isfinite(ret)) *MSVCRT__errno() = MSVCRT_ERANGE;
if (isfinite(x) && !isfinite(ret)) *MSVCRT__errno() = ERANGE;
return ret;
}
@ -3310,7 +3310,7 @@ double CDECL MSVCR120_exp2(double x)
float CDECL MSVCR120_exp2f(float x)
{
float ret = unix_funcs->exp2f( x );
if (isfinite(x) && !isfinite(ret)) *MSVCRT__errno() = MSVCRT_ERANGE;
if (isfinite(x) && !isfinite(ret)) *MSVCRT__errno() = ERANGE;
return ret;
}
@ -3328,7 +3328,7 @@ LDOUBLE CDECL MSVCR120_exp2l(LDOUBLE x)
double CDECL MSVCR120_expm1(double x)
{
double ret = unix_funcs->expm1( x );
if (isfinite(x) && !isfinite(ret)) *MSVCRT__errno() = MSVCRT_ERANGE;
if (isfinite(x) && !isfinite(ret)) *MSVCRT__errno() = ERANGE;
return ret;
}
@ -3338,7 +3338,7 @@ double CDECL MSVCR120_expm1(double x)
float CDECL MSVCR120_expm1f(float x)
{
float ret = unix_funcs->expm1f( x );
if (isfinite(x) && !isfinite(ret)) *MSVCRT__errno() = MSVCRT_ERANGE;
if (isfinite(x) && !isfinite(ret)) *MSVCRT__errno() = ERANGE;
return ret;
}
@ -3355,8 +3355,8 @@ LDOUBLE CDECL MSVCR120_expm1l(LDOUBLE x)
*/
double CDECL MSVCR120_log1p(double x)
{
if (x < -1) *MSVCRT__errno() = MSVCRT_EDOM;
else if (x == -1) *MSVCRT__errno() = MSVCRT_ERANGE;
if (x < -1) *MSVCRT__errno() = EDOM;
else if (x == -1) *MSVCRT__errno() = ERANGE;
return unix_funcs->log1p( x );
}
@ -3365,8 +3365,8 @@ double CDECL MSVCR120_log1p(double x)
*/
float CDECL MSVCR120_log1pf(float x)
{
if (x < -1) *MSVCRT__errno() = MSVCRT_EDOM;
else if (x == -1) *MSVCRT__errno() = MSVCRT_ERANGE;
if (x < -1) *MSVCRT__errno() = EDOM;
else if (x == -1) *MSVCRT__errno() = ERANGE;
return unix_funcs->log1pf( x );
}
@ -3383,8 +3383,8 @@ LDOUBLE CDECL MSVCR120_log1pl(LDOUBLE x)
*/
double CDECL MSVCR120_log2(double x)
{
if (x < 0) *MSVCRT__errno() = MSVCRT_EDOM;
else if (x == 0) *MSVCRT__errno() = MSVCRT_ERANGE;
if (x < 0) *MSVCRT__errno() = EDOM;
else if (x == 0) *MSVCRT__errno() = ERANGE;
return unix_funcs->log2( x );
}
@ -3393,8 +3393,8 @@ double CDECL MSVCR120_log2(double x)
*/
float CDECL MSVCR120_log2f(float x)
{
if (x < 0) *MSVCRT__errno() = MSVCRT_EDOM;
else if (x == 0) *MSVCRT__errno() = MSVCRT_ERANGE;
if (x < 0) *MSVCRT__errno() = EDOM;
else if (x == 0) *MSVCRT__errno() = ERANGE;
return unix_funcs->log2f( x );
}
@ -3838,7 +3838,7 @@ double CDECL MSVCR120_acosh(double x)
{
fenv_t env;
*MSVCRT__errno() = MSVCRT_EDOM;
*MSVCRT__errno() = EDOM;
MSVCRT_fegetenv(&env);
env._Fe_stat |= FE_INVALID;
MSVCRT_fesetenv(&env);
@ -3856,7 +3856,7 @@ float CDECL MSVCR120_acoshf(float x)
{
fenv_t env;
*MSVCRT__errno() = MSVCRT_EDOM;
*MSVCRT__errno() = EDOM;
MSVCRT_fegetenv(&env);
env._Fe_stat |= FE_INVALID;
MSVCRT_fesetenv(&env);
@ -3883,7 +3883,7 @@ double CDECL MSVCR120_atanh(double x)
if (x > 1 || x < -1) {
fenv_t env;
*MSVCRT__errno() = MSVCRT_EDOM;
*MSVCRT__errno() = EDOM;
/* on Linux atanh returns -NAN in this case */
MSVCRT_fegetenv(&env);
@ -3893,7 +3893,7 @@ double CDECL MSVCR120_atanh(double x)
}
ret = unix_funcs->atanh( x );
if (!isfinite(ret)) *MSVCRT__errno() = MSVCRT_ERANGE;
if (!isfinite(ret)) *MSVCRT__errno() = ERANGE;
return ret;
}
@ -3907,7 +3907,7 @@ float CDECL MSVCR120_atanhf(float x)
if (x > 1 || x < -1) {
fenv_t env;
*MSVCRT__errno() = MSVCRT_EDOM;
*MSVCRT__errno() = EDOM;
MSVCRT_fegetenv(&env);
env._Fe_stat |= FE_INVALID;
@ -3917,7 +3917,7 @@ float CDECL MSVCR120_atanhf(float x)
ret = unix_funcs->atanh( x );
if (!isfinite(ret)) *MSVCRT__errno() = MSVCRT_ERANGE;
if (!isfinite(ret)) *MSVCRT__errno() = ERANGE;
return ret;
}
@ -3968,8 +3968,8 @@ LDOUBLE CDECL MSVCR120_scalbnl(LDOUBLE num, __msvcrt_long power)
double CDECL MSVCR120_remainder(double x, double y)
{
/* this matches 64-bit Windows. 32-bit Windows is slightly different */
if(!isfinite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
if(isnan(y) || y==0.0) *MSVCRT__errno() = MSVCRT_EDOM;
if(!isfinite(x)) *MSVCRT__errno() = EDOM;
if(isnan(y) || y==0.0) *MSVCRT__errno() = EDOM;
return unix_funcs->remainder( x, y );
}
@ -3979,8 +3979,8 @@ double CDECL MSVCR120_remainder(double x, double y)
float CDECL MSVCR120_remainderf(float x, float y)
{
/* this matches 64-bit Windows. 32-bit Windows is slightly different */
if(!isfinite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
if(isnan(y) || y==0.0f) *MSVCRT__errno() = MSVCRT_EDOM;
if(!isfinite(x)) *MSVCRT__errno() = EDOM;
if(isnan(y) || y==0.0f) *MSVCRT__errno() = EDOM;
return unix_funcs->remainderf( x, y );
}
@ -3997,8 +3997,8 @@ LDOUBLE CDECL MSVCR120_remainderl(LDOUBLE x, LDOUBLE y)
*/
double CDECL MSVCR120_remquo(double x, double y, int *quo)
{
if(!isfinite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
if(isnan(y) || y==0.0) *MSVCRT__errno() = MSVCRT_EDOM;
if(!isfinite(x)) *MSVCRT__errno() = EDOM;
if(isnan(y) || y==0.0) *MSVCRT__errno() = EDOM;
return unix_funcs->remquo( x, y, quo );
}
@ -4007,8 +4007,8 @@ double CDECL MSVCR120_remquo(double x, double y, int *quo)
*/
float CDECL MSVCR120_remquof(float x, float y, int *quo)
{
if(!isfinite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
if(isnan(y) || y==0.0f) *MSVCRT__errno() = MSVCRT_EDOM;
if(!isfinite(x)) *MSVCRT__errno() = EDOM;
if(isnan(y) || y==0.0f) *MSVCRT__errno() = EDOM;
return unix_funcs->remquof( x, y, quo );
}

88
dlls/msvcrt/mbcs.c
View File

@ -390,7 +390,7 @@ int CDECL _setmbcp(int cp)
mbcinfo = create_mbcinfo(cp, -1, get_mbcinfo());
if(!mbcinfo)
{
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return -1;
}
@ -675,20 +675,20 @@ int CDECL _mbccpy_s_l(unsigned char* dest, size_t maxsize,
int *copied, const unsigned char* src, _locale_t locale)
{
if(copied) *copied = 0;
if(!MSVCRT_CHECK_PMT(dest != NULL && maxsize >= 1)) return MSVCRT_EINVAL;
if(!MSVCRT_CHECK_PMT(dest != NULL && maxsize >= 1)) return EINVAL;
dest[0] = 0;
if(!MSVCRT_CHECK_PMT(src != NULL)) return MSVCRT_EINVAL;
if(!MSVCRT_CHECK_PMT(src != NULL)) return EINVAL;
if(_ismbblead_l(*src, locale)) {
if(!src[1]) {
if(copied) *copied = 1;
*MSVCRT__errno() = MSVCRT_EILSEQ;
return MSVCRT_EILSEQ;
*MSVCRT__errno() = EILSEQ;
return EILSEQ;
}
if(maxsize < 2) {
MSVCRT_INVALID_PMT("dst buffer is too small", MSVCRT_ERANGE);
return MSVCRT_ERANGE;
MSVCRT_INVALID_PMT("dst buffer is too small", ERANGE);
return ERANGE;
}
*dest++ = *src++;
@ -783,11 +783,11 @@ int CDECL _mbsnbcpy_s_l(unsigned char* dst, size_t size,
size_t pos = 0;
if(!dst || size == 0)
return MSVCRT_EINVAL;
return EINVAL;
if(!src)
{
dst[0] = '\0';
return MSVCRT_EINVAL;
return EINVAL;
}
if(!n)
return 0;
@ -800,7 +800,7 @@ int CDECL _mbsnbcpy_s_l(unsigned char* dst, size_t size,
if(pos == size)
{
dst[0] = '\0';
return MSVCRT_ERANGE;
return ERANGE;
}
is_lead = (!is_lead && _ismbblead(*src));
n--;
@ -818,7 +818,7 @@ int CDECL _mbsnbcpy_s_l(unsigned char* dst, size_t size,
if(pos == size)
{
dst[0] = '\0';
return MSVCRT_ERANGE;
return ERANGE;
}
if(!(*src)) break;
@ -831,7 +831,7 @@ int CDECL _mbsnbcpy_s_l(unsigned char* dst, size_t size,
else
{
dst[0] = '\0';
return MSVCRT_ERANGE;
return ERANGE;
}
return 0;
@ -1216,32 +1216,32 @@ int CDECL _mbscat_s_l( unsigned char *dst, size_t size,
size_t i, j;
int ret = 0;
if(!MSVCRT_CHECK_PMT(dst != NULL)) return MSVCRT_EINVAL;
if(!MSVCRT_CHECK_PMT(src != NULL)) return MSVCRT_EINVAL;
if(!MSVCRT_CHECK_PMT(dst != NULL)) return EINVAL;
if(!MSVCRT_CHECK_PMT(src != NULL)) return EINVAL;
for(i=0; i<size; i++)
if(!dst[i]) break;
if(i == size) {
MSVCRT_INVALID_PMT("dst is not NULL-terminated", MSVCRT_EINVAL);
MSVCRT_INVALID_PMT("dst is not NULL-terminated", EINVAL);
if(size) dst[0] = 0;
return MSVCRT_EINVAL;
return EINVAL;
}
if(i && _ismbblead_l(dst[i-1], locale)) {
ret = MSVCRT_EILSEQ;
ret = EILSEQ;
i--;
}
for(j=0; src[j] && i+j<size; j++)
dst[i+j] = src[j];
if(i+j == size) {
MSVCRT_INVALID_PMT("dst buffer is too small", MSVCRT_ERANGE);
MSVCRT_INVALID_PMT("dst buffer is too small", ERANGE);
dst[0] = 0;
return MSVCRT_ERANGE;
return ERANGE;
}
if(j && _ismbblead_l(src[j-1], locale)) {
ret = MSVCRT_EILSEQ;
ret = EILSEQ;
j--;
}
@ -1950,8 +1950,8 @@ int CDECL _mbsnbcat_s(unsigned char *dst, size_t size, const unsigned char *src,
if (dst && size)
*dst = '\0';
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
/* Find the null terminator of the destination buffer. */
@ -1961,8 +1961,8 @@ int CDECL _mbsnbcat_s(unsigned char *dst, size_t size, const unsigned char *src,
if (!size)
{
*dst = '\0';
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
/* If necessary, check that the character preceding the null terminator is
@ -1978,8 +1978,8 @@ int CDECL _mbsnbcat_s(unsigned char *dst, size_t size, const unsigned char *src,
if (!size)
{
*dst = '\0';
*MSVCRT__errno() = MSVCRT_ERANGE;
return MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return ERANGE;
}
}
@ -2052,8 +2052,8 @@ int CDECL _mbslwr_s(unsigned char* s, size_t len)
}
else if (!s || !len)
{
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
if (get_mbcinfo()->ismbcodepage)
{
@ -2074,8 +2074,8 @@ int CDECL _mbslwr_s(unsigned char* s, size_t len)
if (*s)
{
*s = '\0';
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
return 0;
}
@ -2120,8 +2120,8 @@ int CDECL _mbsupr_s(unsigned char* s, size_t len)
}
else if (!s || !len)
{
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
if (get_mbcinfo()->ismbcodepage)
{
@ -2142,8 +2142,8 @@ int CDECL _mbsupr_s(unsigned char* s, size_t len)
if (*s)
{
*s = '\0';
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
return 0;
}
@ -2374,7 +2374,7 @@ size_t CDECL _mbstrlen_l(const char* str, _locale_t locale)
len = MultiByteToWideChar(locinfo->lc_codepage, MB_ERR_INVALID_CHARS,
str, -1, NULL, 0);
if (!len) {
*MSVCRT__errno() = MSVCRT_EILSEQ;
*MSVCRT__errno() = EILSEQ;
return -1;
}
return len - 1;
@ -2512,7 +2512,7 @@ size_t CDECL MSVCRT__mbstowcs_l(wchar_t *wcstr, const char *mbstr,
size_t i, size;
if(!mbstr) {
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return -1;
}
@ -2537,7 +2537,7 @@ size_t CDECL MSVCRT__mbstowcs_l(wchar_t *wcstr, const char *mbstr,
size = MultiByteToWideChar(locinfo->lc_codepage,
MB_ERR_INVALID_CHARS, mbstr, -1, NULL, 0);
if(!size) {
*MSVCRT__errno() = MSVCRT_EILSEQ;
*MSVCRT__errno() = EILSEQ;
return -1;
}
return size - 1;
@ -2555,7 +2555,7 @@ size_t CDECL MSVCRT__mbstowcs_l(wchar_t *wcstr, const char *mbstr,
MB_ERR_INVALID_CHARS, mbstr, size, wcstr, count);
if(!size) {
if(count) wcstr[0] = '\0';
*MSVCRT__errno() = MSVCRT_EILSEQ;
*MSVCRT__errno() = EILSEQ;
return -1;
}
}
@ -2591,10 +2591,10 @@ int CDECL MSVCRT__mbstowcs_s_l(size_t *ret, wchar_t *wcstr,
return 0;
}
if (!MSVCRT_CHECK_PMT(wcstr != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(wcstr != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(mbstr != NULL)) {
if(size) wcstr[0] = '\0';
return MSVCRT_EINVAL;
return EINVAL;
}
if(count==MSVCRT__TRUNCATE || size<count)
@ -2607,12 +2607,12 @@ int CDECL MSVCRT__mbstowcs_s_l(size_t *ret, wchar_t *wcstr,
wcstr[conv++] = '\0';
else if(conv==size && count==MSVCRT__TRUNCATE && wcstr[conv-1]!='\0') {
wcstr[conv-1] = '\0';
err = MSVCRT_STRUNCATE;
err = STRUNCATE;
}else if(conv==size && wcstr[conv-1]!='\0') {
MSVCRT_INVALID_PMT("wcstr[size] is too small", MSVCRT_ERANGE);
MSVCRT_INVALID_PMT("wcstr[size] is too small", ERANGE);
if(size)
wcstr[0] = '\0';
return MSVCRT_ERANGE;
return ERANGE;
}
if(ret)
@ -2675,7 +2675,7 @@ int CDECL MSVCRT_mbsrtowcs_s(size_t *ret, wchar_t *wcstr, size_t len,
if(!ret) ret = &tmp;
if(!MSVCRT_CHECK_PMT(!!wcstr == !!len)) {
*ret = -1;
return MSVCRT_EINVAL;
return EINVAL;
}
*ret = MSVCRT_mbsrtowcs(wcstr, mbstr, count>len ? len : count, state);

4
dlls/msvcrt/misc.c
View File

@ -69,8 +69,8 @@ int CDECL MSVCRT_rand_s(unsigned int *pval)
{
if (!pval || !RtlGenRandom(pval, sizeof(*pval)))
{
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
return 0;
}

44
dlls/msvcrt/msvcrt.h
View File

@ -20,6 +20,7 @@
#ifndef __WINE_MSVCRT_H
#define __WINE_MSVCRT_H
#include <errno.h>
#include <stdarg.h>
#include <stdint.h>
#include <wchar.h>
@ -588,47 +589,6 @@ struct MSVCRT__stat64 {
#define MSVCRT__P_NOWAITO 3
#define MSVCRT__P_DETACH 4
#define MSVCRT_EPERM 1
#define MSVCRT_ENOENT 2
#define MSVCRT_ESRCH 3
#define MSVCRT_EINTR 4
#define MSVCRT_EIO 5
#define MSVCRT_ENXIO 6
#define MSVCRT_E2BIG 7
#define MSVCRT_ENOEXEC 8
#define MSVCRT_EBADF 9
#define MSVCRT_ECHILD 10
#define MSVCRT_EAGAIN 11
#define MSVCRT_ENOMEM 12
#define MSVCRT_EACCES 13
#define MSVCRT_EFAULT 14
#define MSVCRT_EBUSY 16
#define MSVCRT_EEXIST 17
#define MSVCRT_EXDEV 18
#define MSVCRT_ENODEV 19
#define MSVCRT_ENOTDIR 20
#define MSVCRT_EISDIR 21
#define MSVCRT_EINVAL 22
#define MSVCRT_ENFILE 23
#define MSVCRT_EMFILE 24
#define MSVCRT_ENOTTY 25
#define MSVCRT_EFBIG 27
#define MSVCRT_ENOSPC 28
#define MSVCRT_ESPIPE 29
#define MSVCRT_EROFS 30
#define MSVCRT_EMLINK 31
#define MSVCRT_EPIPE 32
#define MSVCRT_EDOM 33
#define MSVCRT_ERANGE 34
#define MSVCRT_EDEADLK 36
#define MSVCRT_EDEADLOCK MSVCRT_EDEADLK
#define MSVCRT_ENAMETOOLONG 38
#define MSVCRT_ENOLCK 39
#define MSVCRT_ENOSYS 40
#define MSVCRT_ENOTEMPTY 41
#define MSVCRT_EILSEQ 42
#define MSVCRT_STRUNCATE 80
#define MSVCRT_LC_ALL 0
#define MSVCRT_LC_COLLATE 1
#define MSVCRT_LC_CTYPE 2
@ -1009,7 +969,7 @@ int fpnum_double(struct fpnum*, double*) DECLSPEC_HIDDEN;
*/
#define MSVCRT_INVALID_PMT(x,err) (*MSVCRT__errno() = (err), MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0))
#define MSVCRT_CHECK_PMT_ERR(x,err) ((x) || (MSVCRT_INVALID_PMT( 0, (err) ), FALSE))
#define MSVCRT_CHECK_PMT(x) MSVCRT_CHECK_PMT_ERR((x), MSVCRT_EINVAL)
#define MSVCRT_CHECK_PMT(x) MSVCRT_CHECK_PMT_ERR((x), EINVAL)
#define MSVCRT__ARGMAX 100
typedef int (*puts_clbk_a)(void*, int, const char*);

4
dlls/msvcrt/printf.h
View File

@ -1126,7 +1126,7 @@ int FUNC_NAME(pf_printf)(FUNC_NAME(puts_clbk) pf_puts, void *puts_ctx, const API
int *used;
if(!n_format_enabled) {
MSVCRT_INVALID_PMT("\'n\' format specifier disabled", MSVCRT_EINVAL);
MSVCRT_INVALID_PMT("\'n\' format specifier disabled", EINVAL);
return -1;
}
@ -1189,7 +1189,7 @@ int FUNC_NAME(pf_printf)(FUNC_NAME(puts_clbk) pf_puts, void *puts_ctx, const API
} else {
if(invoke_invalid_param_handler) {
MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return -1;
}

8
dlls/msvcrt/process.c
View File

@ -139,7 +139,7 @@ static intptr_t msvcrt_spawn(int flags, const wchar_t* exe, wchar_t* cmdline,
if ((unsigned)flags > MSVCRT__P_DETACH)
{
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return -1;
}
@ -372,7 +372,7 @@ intptr_t CDECL _cwait(int *status, intptr_t pid, int action)
if (doserrno == ERROR_INVALID_HANDLE)
{
*MSVCRT__errno() = MSVCRT_ECHILD;
*MSVCRT__errno() = ECHILD;
*MSVCRT___doserrno() = doserrno;
}
else
@ -1191,7 +1191,7 @@ int CDECL MSVCRT__pclose(MSVCRT_FILE* file)
if(i == popen_handles_size)
{
_unlock(_POPEN_LOCK);
*MSVCRT__errno() = MSVCRT_EBADF;
*MSVCRT__errno() = EBADF;
return -1;
}
@ -1228,7 +1228,7 @@ int CDECL _wsystem(const wchar_t* cmd)
{
if (comspec == NULL)
{
*MSVCRT__errno() = MSVCRT_ENOENT;
*MSVCRT__errno() = ENOENT;
return 0;
}
HeapFree(GetProcessHeap(), 0, comspec);

169
dlls/msvcrt/string.c
View File

@ -27,7 +27,6 @@
#include <math.h>
#include <limits.h>
#include <locale.h>
#include <errno.h>
#include <float.h>
#include "msvcrt.h"
#include "bnum.h"
@ -61,8 +60,8 @@ int CDECL MSVCRT__strlwr_s_l(char *str, size_t len, _locale_t locale)
if (!str || !len)
{
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
while (len && *ptr)
@ -74,8 +73,8 @@ int CDECL MSVCRT__strlwr_s_l(char *str, size_t len, _locale_t locale)
if (!len)
{
str[0] = '\0';
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
if(!locale)
@ -140,8 +139,8 @@ int CDECL MSVCRT__strupr_s_l(char *str, size_t len, _locale_t locale)
if (!str || !len)
{
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
while (len && *ptr)
@ -153,8 +152,8 @@ int CDECL MSVCRT__strupr_s_l(char *str, size_t len, _locale_t locale)
if (!len)
{
str[0] = '\0';
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
if(!locale)
@ -217,8 +216,8 @@ int CDECL MSVCRT__strnset_s(char *str, size_t size, int c, size_t count)
size_t i;
if(!str && !size && !count) return 0;
if(!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
if(!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
if(!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
if(!MSVCRT_CHECK_PMT(size > 0)) return EINVAL;
for(i=0; i<size-1 && i<count; i++) {
if(!str[i]) return 0;
@ -229,8 +228,8 @@ int CDECL MSVCRT__strnset_s(char *str, size_t size, int c, size_t count)
str[0] = 0;
MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
/*********************************************************************
@ -385,12 +384,12 @@ int fpnum_double(struct fpnum *fp, double *d)
if (fp->exp > 1<<EXP_BITS)
{
*d = fp->sign * INFINITY;
return MSVCRT_ERANGE;
return ERANGE;
}
if (fp->exp < -(1<<EXP_BITS))
{
*d = fp->sign * 0.0;
return MSVCRT_ERANGE;
return ERANGE;
}
fp->exp += MANT_BITS - 1;
@ -450,12 +449,12 @@ int fpnum_double(struct fpnum *fp, double *d)
if (fp->exp >= (1<<EXP_BITS)-1)
{
*d = fp->sign * INFINITY;
return MSVCRT_ERANGE;
return ERANGE;
}
if (!fp->m || fp->exp < 0)
{
*d = fp->sign * 0.0;
return MSVCRT_ERANGE;
return ERANGE;
}
if (fp->sign == -1)
@ -512,7 +511,7 @@ int fpnum_ldouble(struct fpnum *fp, MSVCRT__LDOUBLE *d)
d->x80[2] = (1 << LDBL_EXP_BITS) - 1;
if (fp->sign == -1)
d->x80[2] |= 1 << LDBL_EXP_BITS;
return MSVCRT_ERANGE;
return ERANGE;
}
if (fp->exp < -(1<<LDBL_EXP_BITS))
{
@ -521,7 +520,7 @@ int fpnum_ldouble(struct fpnum *fp, MSVCRT__LDOUBLE *d)
d->x80[2] = 0;
if (fp->sign == -1)
d->x80[2] |= 1 << LDBL_EXP_BITS;
return MSVCRT_ERANGE;
return ERANGE;
}
fp->exp += LDBL_MANT_BITS - 1;
@ -574,7 +573,7 @@ int fpnum_ldouble(struct fpnum *fp, MSVCRT__LDOUBLE *d)
d->x80[2] = (1 << LDBL_EXP_BITS) - 1;
if (fp->sign == -1)
d->x80[2] |= 1 << LDBL_EXP_BITS;
return MSVCRT_ERANGE;
return ERANGE;
}
if (!fp->m || fp->exp < 0)
{
@ -583,7 +582,7 @@ int fpnum_ldouble(struct fpnum *fp, MSVCRT__LDOUBLE *d)
d->x80[2] = 0;
if (fp->sign == -1)
d->x80[2] |= 1 << LDBL_EXP_BITS;
return MSVCRT_ERANGE;
return ERANGE;
}
d->x80[0] = fp->m;
@ -1274,12 +1273,12 @@ char* CDECL strcpy(char *dst, const char *src)
int CDECL MSVCRT_strcpy_s( char* dst, size_t elem, const char* src )
{
size_t i;
if(!elem) return MSVCRT_EINVAL;
if(!dst) return MSVCRT_EINVAL;
if(!elem) return EINVAL;
if(!dst) return EINVAL;
if(!src)
{
dst[0] = '\0';
return MSVCRT_EINVAL;
return EINVAL;
}
for(i = 0; i < elem; i++)
@ -1287,7 +1286,7 @@ int CDECL MSVCRT_strcpy_s( char* dst, size_t elem, const char* src )
if((dst[i] = src[i]) == '\0') return 0;
}
dst[0] = '\0';
return MSVCRT_ERANGE;
return ERANGE;
}
/*********************************************************************
@ -1296,12 +1295,12 @@ int CDECL MSVCRT_strcpy_s( char* dst, size_t elem, const char* src )
int CDECL MSVCRT_strcat_s( char* dst, size_t elem, const char* src )
{
size_t i, j;
if(!dst) return MSVCRT_EINVAL;
if(elem == 0) return MSVCRT_EINVAL;
if(!dst) return EINVAL;
if(elem == 0) return EINVAL;
if(!src)
{
dst[0] = '\0';
return MSVCRT_EINVAL;
return EINVAL;
}
for(i = 0; i < elem; i++)
@ -1316,7 +1315,7 @@ int CDECL MSVCRT_strcat_s( char* dst, size_t elem, const char* src )
}
/* Set the first element to 0, not the first element after the skipped part */
dst[0] = '\0';
return MSVCRT_ERANGE;
return ERANGE;
}
/*********************************************************************
@ -1337,12 +1336,12 @@ int CDECL MSVCRT_strncat_s( char* dst, size_t elem, const char* src, size_t coun
{
size_t i, j;
if (!MSVCRT_CHECK_PMT(dst != 0)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(elem != 0)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(dst != 0)) return EINVAL;
if (!MSVCRT_CHECK_PMT(elem != 0)) return EINVAL;
if (!MSVCRT_CHECK_PMT(src != 0))
{
dst[0] = '\0';
return MSVCRT_EINVAL;
return EINVAL;
}
for(i = 0; i < elem; i++)
@ -1354,7 +1353,7 @@ int CDECL MSVCRT_strncat_s( char* dst, size_t elem, const char* src, size_t coun
if(count == MSVCRT__TRUNCATE && j + i == elem - 1)
{
dst[j + i] = '\0';
return MSVCRT_STRUNCATE;
return STRUNCATE;
}
if(j == count || (dst[j + i] = src[j]) == '\0')
{
@ -1366,7 +1365,7 @@ int CDECL MSVCRT_strncat_s( char* dst, size_t elem, const char* src, size_t coun
}
/* Set the first element to 0, not the first element after the skipped part */
dst[0] = '\0';
return MSVCRT_ERANGE;
return ERANGE;
}
/*********************************************************************
@ -1412,14 +1411,14 @@ size_t CDECL MSVCRT__strxfrm_l( char *dest, const char *src,
LCMAP_SORTKEY, src, -1, NULL, 0);
if(!ret) {
if(len) dest[0] = 0;
*MSVCRT__errno() = MSVCRT_EILSEQ;
*MSVCRT__errno() = EILSEQ;
return INT_MAX;
}
if(!len) return ret-1;
if(ret > len) {
dest[0] = 0;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return ret-1;
}
@ -1580,10 +1579,10 @@ __int64 CDECL MSVCRT_strtoi64_l(const char *nptr, char **endptr, int base, _loca
if(!negative && (ret>I64_MAX/base || ret*base>I64_MAX-v)) {
ret = I64_MAX;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
} else if(negative && (ret<I64_MIN/base || ret*base<I64_MIN-v)) {
ret = I64_MIN;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
} else
ret = ret*base + v;
}
@ -1611,10 +1610,10 @@ int __cdecl MSVCRT__atoi_l(const char *str, _locale_t locale)
if(ret > INT_MAX) {
ret = INT_MAX;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
} else if(ret < INT_MIN) {
ret = INT_MIN;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
}
return ret;
}
@ -1679,10 +1678,10 @@ __msvcrt_long CDECL MSVCRT__atol_l(const char *str, _locale_t locale)
if(ret > LONG_MAX) {
ret = LONG_MAX;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
} else if(ret < LONG_MIN) {
ret = LONG_MIN;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
}
return ret;
}
@ -1729,10 +1728,10 @@ __msvcrt_long CDECL MSVCRT__strtol_l(const char* nptr,
if(ret > LONG_MAX) {
ret = LONG_MAX;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
} else if(ret < LONG_MIN) {
ret = LONG_MIN;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
}
return ret;
@ -1755,10 +1754,10 @@ __msvcrt_ulong CDECL MSVCRT_strtoul_l(const char* nptr, char** end, int base, _l
if(ret > ULONG_MAX) {
ret = ULONG_MAX;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
}else if(ret < -(__int64)ULONG_MAX) {
ret = 1;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
}
return ret;
@ -1829,7 +1828,7 @@ unsigned __int64 CDECL MSVCRT_strtoui64_l(const char *nptr, char **endptr, int b
if(ret>UI64_MAX/base || ret*base>UI64_MAX-v) {
ret = UI64_MAX;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
} else
ret = ret*base + v;
}
@ -1904,8 +1903,8 @@ static int ltoa_helper(__msvcrt_long value, char *str, size_t size, int radix)
*p++ = *pos--;
str[0] = '\0';
MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
return MSVCRT_ERANGE;
MSVCRT_INVALID_PMT("str[size] is too small", ERANGE);
return ERANGE;
}
memcpy(str, pos, len);
@ -1917,12 +1916,12 @@ static int ltoa_helper(__msvcrt_long value, char *str, size_t size, int radix)
*/
int CDECL MSVCRT__ltoa_s(__msvcrt_long value, char *str, size_t size, int radix)
{
if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(size > 0)) return EINVAL;
if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
{
str[0] = '\0';
return MSVCRT_EINVAL;
return EINVAL;
}
return ltoa_helper(value, str, size, radix);
@ -1939,12 +1938,12 @@ int CDECL MSVCRT__ltow_s(__msvcrt_long value, wchar_t *str, size_t size, int rad
wchar_t buffer[33], *pos;
size_t len;
if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(size > 0)) return EINVAL;
if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
{
str[0] = '\0';
return MSVCRT_EINVAL;
return EINVAL;
}
if (value < 0 && radix == 10)
@ -1995,8 +1994,8 @@ int CDECL MSVCRT__ltow_s(__msvcrt_long value, wchar_t *str, size_t size, int rad
*p++ = *pos--;
str[0] = '\0';
MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
return MSVCRT_ERANGE;
MSVCRT_INVALID_PMT("str[size] is too small", ERANGE);
return ERANGE;
}
memcpy(str, pos, len * sizeof(wchar_t));
@ -2036,12 +2035,12 @@ int CDECL MSVCRT__ui64toa_s(unsigned __int64 value, char *str,
char buffer[65], *pos;
int digit;
if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(size > 0)) return EINVAL;
if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
{
str[0] = '\0';
return MSVCRT_EINVAL;
return EINVAL;
}
pos = buffer+64;
@ -2058,8 +2057,8 @@ int CDECL MSVCRT__ui64toa_s(unsigned __int64 value, char *str,
}while(value != 0);
if(buffer-pos+65 > size) {
MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_EINVAL);
return MSVCRT_EINVAL;
MSVCRT_INVALID_PMT("str[size] is too small", EINVAL);
return EINVAL;
}
memcpy(str, pos, buffer-pos+65);
@ -2075,12 +2074,12 @@ int CDECL MSVCRT__ui64tow_s( unsigned __int64 value, wchar_t *str,
wchar_t buffer[65], *pos;
int digit;
if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(size > 0)) return EINVAL;
if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
{
str[0] = '\0';
return MSVCRT_EINVAL;
return EINVAL;
}
pos = &buffer[64];
@ -2096,8 +2095,8 @@ int CDECL MSVCRT__ui64tow_s( unsigned __int64 value, wchar_t *str,
} while (value != 0);
if(buffer-pos+65 > size) {
MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_EINVAL);
return MSVCRT_EINVAL;
MSVCRT_INVALID_PMT("str[size] is too small", EINVAL);
return EINVAL;
}
memcpy(str, pos, (buffer-pos+65)*sizeof(wchar_t));
@ -2118,8 +2117,8 @@ int CDECL MSVCRT__ultoa_s(__msvcrt_ulong value, char *str, size_t size, int radi
if (str && size)
str[0] = '\0';
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
pos = buffer + 32;
@ -2150,8 +2149,8 @@ int CDECL MSVCRT__ultoa_s(__msvcrt_ulong value, char *str, size_t size, int radi
*p++ = *pos--;
str[0] = '\0';
*MSVCRT__errno() = MSVCRT_ERANGE;
return MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return ERANGE;
}
memcpy(str, pos, len);
@ -2172,8 +2171,8 @@ int CDECL MSVCRT__ultow_s(__msvcrt_ulong value, wchar_t *str, size_t size, int r
if (str && size)
str[0] = '\0';
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
pos = buffer + 32;
@ -2204,8 +2203,8 @@ int CDECL MSVCRT__ultow_s(__msvcrt_ulong value, wchar_t *str, size_t size, int r
*p++ = *pos--;
str[0] = '\0';
*MSVCRT__errno() = MSVCRT_ERANGE;
return MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return ERANGE;
}
memcpy(str, pos, len * sizeof(wchar_t));
@ -2223,12 +2222,12 @@ int CDECL MSVCRT__i64toa_s(__int64 value, char *str, size_t size, int radix)
char buffer[65], *pos;
size_t len;
if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(size > 0)) return EINVAL;
if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
{
str[0] = '\0';
return MSVCRT_EINVAL;
return EINVAL;
}
if (value < 0 && radix == 10)
@ -2279,8 +2278,8 @@ int CDECL MSVCRT__i64toa_s(__int64 value, char *str, size_t size, int radix)
*p++ = *pos--;
str[0] = '\0';
MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
return MSVCRT_ERANGE;
MSVCRT_INVALID_PMT("str[size] is too small", ERANGE);
return ERANGE;
}
memcpy(str, pos, len);
@ -2298,12 +2297,12 @@ int CDECL MSVCRT__i64tow_s(__int64 value, wchar_t *str, size_t size, int radix)
wchar_t buffer[65], *pos;
size_t len;
if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(size > 0)) return EINVAL;
if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
{
str[0] = '\0';
return MSVCRT_EINVAL;
return EINVAL;
}
if (value < 0 && radix == 10)
@ -2354,8 +2353,8 @@ int CDECL MSVCRT__i64tow_s(__int64 value, wchar_t *str, size_t size, int radix)
*p++ = *pos--;
str[0] = '\0';
MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
return MSVCRT_ERANGE;
MSVCRT_INVALID_PMT("str[size] is too small", ERANGE);
return ERANGE;
}
memcpy(str, pos, len * sizeof(wchar_t));

6
dlls/msvcrt/thread.c
View File

@ -121,7 +121,7 @@ uintptr_t CDECL _beginthread(
trampoline = MSVCRT_malloc(sizeof(*trampoline));
if(!trampoline) {
*MSVCRT__errno() = MSVCRT_EAGAIN;
*MSVCRT__errno() = EAGAIN;
return -1;
}
@ -129,7 +129,7 @@ uintptr_t CDECL _beginthread(
trampoline, CREATE_SUSPENDED, NULL);
if(!thread) {
MSVCRT_free(trampoline);
*MSVCRT__errno() = MSVCRT_EAGAIN;
*MSVCRT__errno() = EAGAIN;
return -1;
}
@ -139,7 +139,7 @@ uintptr_t CDECL _beginthread(
if(ResumeThread(thread) == -1) {
MSVCRT_free(trampoline);
*MSVCRT__errno() = MSVCRT_EAGAIN;
*MSVCRT__errno() = EAGAIN;
return -1;
}

150
dlls/msvcrt/time.c
View File

@ -235,7 +235,7 @@ static __time64_t mktime_helper(struct tm *mstm, BOOL local)
}
if(ret<70 || ret>1100) {
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return -1;
}
@ -245,7 +245,7 @@ static __time64_t mktime_helper(struct tm *mstm, BOOL local)
st.wYear = ret+1900;
if(!SystemTimeToFileTime(&st, &ft)) {
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return -1;
}
@ -300,7 +300,7 @@ static __time64_t mktime_helper(struct tm *mstm, BOOL local)
mstm->tm_isdst = use_dst ? 1 : 0;
if(ret < TICKS_1601_TO_1970) {
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return -1;
}
ret = (ret-TICKS_1601_TO_1970)/TICKSPERSEC;
@ -388,8 +388,8 @@ int CDECL _localtime64_s(struct tm *res, const __time64_t *secs)
if (res)
write_invalid_msvcrt_tm(res);
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
_tzset_init();
@ -462,8 +462,8 @@ int CDECL _localtime32_s(struct tm *time, const __time32_t *secs)
if (time)
write_invalid_msvcrt_tm(time);
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
secs64 = *secs;
@ -500,8 +500,8 @@ int CDECL MSVCRT__gmtime64_s(struct tm *res, const __time64_t *secs)
write_invalid_msvcrt_tm(res);
}
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
time = *secs * (ULONGLONG)TICKSPERSEC + TICKS_1601_TO_1970;
@ -604,13 +604,13 @@ int CDECL _strdate_s(char* date, size_t size)
date[0] = '\0';
if(!date) {
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
if(size < 9) {
*MSVCRT__errno() = MSVCRT_ERANGE;
return MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return ERANGE;
}
MSVCRT__strdate(date);
@ -635,13 +635,13 @@ int CDECL _wstrdate_s(wchar_t* date, size_t size)
date[0] = '\0';
if(!date) {
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
if(size < 9) {
*MSVCRT__errno() = MSVCRT_ERANGE;
return MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return ERANGE;
}
MSVCRT__wstrdate(date);
@ -666,13 +666,13 @@ int CDECL _strtime_s(char* time, size_t size)
time[0] = '\0';
if(!time) {
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
if(size < 9) {
*MSVCRT__errno() = MSVCRT_ERANGE;
return MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return ERANGE;
}
MSVCRT__strtime(time);
@ -697,13 +697,13 @@ int CDECL _wstrtime_s(wchar_t* time, size_t size)
time[0] = '\0';
if(!time) {
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
if(size < 9) {
*MSVCRT__errno() = MSVCRT_ERANGE;
return MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return ERANGE;
}
MSVCRT__wstrtime(time);
@ -777,7 +777,7 @@ void CDECL MSVCRT__ftime64(struct __timeb64 *buf)
*/
int CDECL MSVCRT__ftime64_s(struct __timeb64 *buf)
{
if (!MSVCRT_CHECK_PMT( buf != NULL )) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT( buf != NULL )) return EINVAL;
MSVCRT__ftime64(buf);
return 0;
}
@ -801,7 +801,7 @@ void CDECL MSVCRT__ftime32(struct __timeb32 *buf)
*/
int CDECL MSVCRT__ftime32_s(struct __timeb32 *buf)
{
if (!MSVCRT_CHECK_PMT( buf != NULL )) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT( buf != NULL )) return EINVAL;
MSVCRT__ftime32(buf);
return 0;
}
@ -886,7 +886,7 @@ int * CDECL MSVCRT___p__dstbias(void)
*/
int CDECL MSVCRT__get_dstbias(int *seconds)
{
if (!MSVCRT_CHECK_PMT(seconds != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(seconds != NULL)) return EINVAL;
*seconds = MSVCRT__dstbias;
return 0;
}
@ -916,14 +916,14 @@ int CDECL MSVCRT__get_tzname(size_t *ret, char *buf, size_t bufsize, int index)
timezone = tzname_dst;
break;
default:
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
if(!ret || (!buf && bufsize > 0) || (buf && !bufsize))
{
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
*ret = strlen(timezone)+1;
@ -932,7 +932,7 @@ int CDECL MSVCRT__get_tzname(size_t *ret, char *buf, size_t bufsize, int index)
if(*ret > bufsize)
{
buf[0] = 0;
return MSVCRT_ERANGE;
return ERANGE;
}
strcpy(buf, timezone);
@ -963,7 +963,7 @@ static inline BOOL strftime_nstr(STRFTIME_CHAR *str, size_t *pos,
{
if(*pos >= max) {
*str = 0;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return FALSE;
}
@ -992,7 +992,7 @@ static inline BOOL strftime_int(STRFTIME_CHAR *str, size_t *pos, size_t max,
#endif
if(len == -1) {
*str = 0;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return FALSE;
}
@ -1186,7 +1186,7 @@ static size_t strftime_impl(STRFTIME_CHAR *str, size_t max,
if(!str || !format) {
if(str && max)
*str = 0;
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return 0;
}
@ -1478,7 +1478,7 @@ static size_t strftime_impl(STRFTIME_CHAR *str, size_t max,
#else
if(MSVCRT__mbstowcs_s_l(&tmp, str+ret, max-ret,
mstm->tm_isdst ? tzname_dst : tzname_std,
MSVCRT__TRUNCATE, loc) == MSVCRT_STRUNCATE)
MSVCRT__TRUNCATE, loc) == STRUNCATE)
ret = max;
#endif
ret += tmp-1;
@ -1505,7 +1505,7 @@ static size_t strftime_impl(STRFTIME_CHAR *str, size_t max,
break;
default:
WARN("unknown format %c\n", *format);
MSVCRT_INVALID_PMT("unknown format", MSVCRT_EINVAL);
MSVCRT_INVALID_PMT("unknown format", EINVAL);
goto einval_error;
}
}
@ -1513,7 +1513,7 @@ static size_t strftime_impl(STRFTIME_CHAR *str, size_t max,
if(ret == max) {
if(max)
*str = 0;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return 0;
}
@ -1662,7 +1662,7 @@ static char* asctime_buf(char *buf, const struct tm *mstm)
|| mstm->tm_wday<0 || mstm->tm_wday>6
|| mstm->tm_year<0 || mstm->tm_mday<0
|| mstm->tm_mday>MonthLengths[IsLeapYear(1900+mstm->tm_year)][mstm->tm_mon]) {
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return NULL;
}
@ -1690,7 +1690,7 @@ char * CDECL MSVCRT_asctime(const struct tm *mstm)
if (!data->asctime_buffer) {
data->asctime_buffer = MSVCRT_malloc(26);
if (!data->asctime_buffer) {
*MSVCRT__errno() = MSVCRT_ENOMEM;
*MSVCRT__errno() = ENOMEM;
return NULL;
}
}
@ -1703,18 +1703,18 @@ char * CDECL MSVCRT_asctime(const struct tm *mstm)
*/
int CDECL MSVCRT_asctime_s(char* time, size_t size, const struct tm *mstm)
{
if (!MSVCRT_CHECK_PMT(time != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(time != NULL)) return EINVAL;
if (size) time[0] = 0;
if (!MSVCRT_CHECK_PMT(size >= 26)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(mstm != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(mstm->tm_sec >= 0 && mstm->tm_sec < 60)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(mstm->tm_min >= 0 && mstm->tm_min < 60)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(mstm->tm_hour >= 0 && mstm->tm_hour < 24)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(mstm->tm_mon >= 0 && mstm->tm_mon < 12)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(mstm->tm_wday >= 0 && mstm->tm_wday < 7)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(mstm->tm_year >= 0)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(mstm->tm_mday >= 0)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(mstm->tm_mday <= MonthLengths[IsLeapYear(1900+mstm->tm_year)][mstm->tm_mon])) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(size >= 26)) return EINVAL;
if (!MSVCRT_CHECK_PMT(mstm != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(mstm->tm_sec >= 0 && mstm->tm_sec < 60)) return EINVAL;
if (!MSVCRT_CHECK_PMT(mstm->tm_min >= 0 && mstm->tm_min < 60)) return EINVAL;
if (!MSVCRT_CHECK_PMT(mstm->tm_hour >= 0 && mstm->tm_hour < 24)) return EINVAL;
if (!MSVCRT_CHECK_PMT(mstm->tm_mon >= 0 && mstm->tm_mon < 12)) return EINVAL;
if (!MSVCRT_CHECK_PMT(mstm->tm_wday >= 0 && mstm->tm_wday < 7)) return EINVAL;
if (!MSVCRT_CHECK_PMT(mstm->tm_year >= 0)) return EINVAL;
if (!MSVCRT_CHECK_PMT(mstm->tm_mday >= 0)) return EINVAL;
if (!MSVCRT_CHECK_PMT(mstm->tm_mday <= MonthLengths[IsLeapYear(1900+mstm->tm_year)][mstm->tm_mon])) return EINVAL;
asctime_buf(time, mstm);
return 0;
@ -1731,7 +1731,7 @@ wchar_t * CDECL MSVCRT__wasctime(const struct tm *mstm)
if(!data->wasctime_buffer) {
data->wasctime_buffer = MSVCRT_malloc(26*sizeof(wchar_t));
if(!data->wasctime_buffer) {
*MSVCRT__errno() = MSVCRT_ENOMEM;
*MSVCRT__errno() = ENOMEM;
return NULL;
}
}
@ -1751,10 +1751,10 @@ int CDECL MSVCRT__wasctime_s(wchar_t* time, size_t size, const struct tm *mstm)
char buffer[26];
int ret;
if (!MSVCRT_CHECK_PMT(time != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(time != NULL)) return EINVAL;
if (size) time[0] = 0;
if (!MSVCRT_CHECK_PMT(size >= 26)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(mstm != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(size >= 26)) return EINVAL;
if (!MSVCRT_CHECK_PMT(mstm != NULL)) return EINVAL;
ret = MSVCRT_asctime_s(buffer, sizeof(buffer), mstm);
if(ret)
@ -1781,11 +1781,11 @@ int CDECL MSVCRT__ctime64_s(char *res, size_t len, const __time64_t *time)
{
struct tm *t;
if (!MSVCRT_CHECK_PMT( res != NULL )) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT( len >= 26 )) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT( res != NULL )) return EINVAL;
if (!MSVCRT_CHECK_PMT( len >= 26 )) return EINVAL;
res[0] = '\0';
if (!MSVCRT_CHECK_PMT( time != NULL )) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT( *time > 0 )) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT( time != NULL )) return EINVAL;
if (!MSVCRT_CHECK_PMT( *time > 0 )) return EINVAL;
t = MSVCRT__localtime64( time );
strcpy( res, MSVCRT_asctime( t ) );
@ -1810,11 +1810,11 @@ int CDECL MSVCRT__ctime32_s(char *res, size_t len, const __time32_t *time)
{
struct tm *t;
if (!MSVCRT_CHECK_PMT( res != NULL )) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT( len >= 26 )) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT( res != NULL )) return EINVAL;
if (!MSVCRT_CHECK_PMT( len >= 26 )) return EINVAL;
res[0] = '\0';
if (!MSVCRT_CHECK_PMT( time != NULL )) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT( *time > 0 )) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT( time != NULL )) return EINVAL;
if (!MSVCRT_CHECK_PMT( *time > 0 )) return EINVAL;
t = MSVCRT__localtime32( time );
strcpy( res, MSVCRT_asctime( t ) );
@ -1876,12 +1876,12 @@ int CDECL MSVCRT__wctime64_s(wchar_t *buf,
struct tm tm;
int ret;
if(!MSVCRT_CHECK_PMT(buf != NULL)) return MSVCRT_EINVAL;
if(!MSVCRT_CHECK_PMT(size != 0)) return MSVCRT_EINVAL;
if(!MSVCRT_CHECK_PMT(buf != NULL)) return EINVAL;
if(!MSVCRT_CHECK_PMT(size != 0)) return EINVAL;
buf[0] = 0;
if(!MSVCRT_CHECK_PMT(time != NULL)) return MSVCRT_EINVAL;
if(!MSVCRT_CHECK_PMT(*time >= 0)) return MSVCRT_EINVAL;
if(!MSVCRT_CHECK_PMT(*time <= _MAX__TIME64_T)) return MSVCRT_EINVAL;
if(!MSVCRT_CHECK_PMT(time != NULL)) return EINVAL;
if(!MSVCRT_CHECK_PMT(*time >= 0)) return EINVAL;
if(!MSVCRT_CHECK_PMT(*time <= _MAX__TIME64_T)) return EINVAL;
ret = _localtime64_s(&tm, time);
if(ret != 0)
@ -1899,11 +1899,11 @@ int CDECL MSVCRT__wctime32_s(wchar_t *buf, size_t size,
struct tm tm;
int ret;
if(!MSVCRT_CHECK_PMT(buf != NULL)) return MSVCRT_EINVAL;
if(!MSVCRT_CHECK_PMT(size != 0)) return MSVCRT_EINVAL;
if(!MSVCRT_CHECK_PMT(buf != NULL)) return EINVAL;
if(!MSVCRT_CHECK_PMT(size != 0)) return EINVAL;
buf[0] = 0;
if(!MSVCRT_CHECK_PMT(time != NULL)) return MSVCRT_EINVAL;
if(!MSVCRT_CHECK_PMT(*time >= 0)) return MSVCRT_EINVAL;
if(!MSVCRT_CHECK_PMT(time != NULL)) return EINVAL;
if(!MSVCRT_CHECK_PMT(*time >= 0)) return EINVAL;
ret = _localtime32_s(&tm, time);
if(ret != 0)
@ -1919,7 +1919,7 @@ int CDECL MSVCRT__wctime32_s(wchar_t *buf, size_t size,
*/
int CDECL _get_timezone(LONG *timezone)
{
if(!MSVCRT_CHECK_PMT(timezone != NULL)) return MSVCRT_EINVAL;
if(!MSVCRT_CHECK_PMT(timezone != NULL)) return EINVAL;
*timezone = MSVCRT___timezone;
return 0;
@ -1930,7 +1930,7 @@ int CDECL _get_timezone(LONG *timezone)
*/
int CDECL _get_daylight(int *hours)
{
if(!MSVCRT_CHECK_PMT(hours != NULL)) return MSVCRT_EINVAL;
if(!MSVCRT_CHECK_PMT(hours != NULL)) return EINVAL;
*hours = MSVCRT___daylight;
return 0;

144
dlls/msvcrt/wcs.c
View File

@ -297,8 +297,8 @@ int CDECL MSVCRT__wcsnset_s( wchar_t *str, size_t size, wchar_t c, size_t count
size_t i;
if(!str && !size && !count) return 0;
if(!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
if(!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
if(!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
if(!MSVCRT_CHECK_PMT(size > 0)) return EINVAL;
for(i=0; i<size-1 && i<count; i++) {
if(!str[i]) return 0;
@ -309,8 +309,8 @@ int CDECL MSVCRT__wcsnset_s( wchar_t *str, size_t size, wchar_t c, size_t count
str[0] = 0;
MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
/*********************************************************************
@ -336,15 +336,15 @@ int CDECL MSVCRT__wcsset_s( wchar_t *str, size_t n, wchar_t c )
{
wchar_t *p = str;
if(!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
if(!MSVCRT_CHECK_PMT(n)) return MSVCRT_EINVAL;
if(!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
if(!MSVCRT_CHECK_PMT(n)) return EINVAL;
while(*p && --n) *p++ = c;
if(!n) {
str[0] = 0;
MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
return 0;
}
@ -370,8 +370,8 @@ int CDECL MSVCRT__wcsupr_s_l( wchar_t* str, size_t n, _locale_t locale )
if (!str || !n)
{
if (str) *str = '\0';
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
if(!locale)
@ -393,8 +393,8 @@ int CDECL MSVCRT__wcsupr_s_l( wchar_t* str, size_t n, _locale_t locale )
/* MSDN claims that the function should return and set errno to
* ERANGE, which doesn't seem to be true based on the tests. */
*str = '\0';
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
/******************************************************************
@ -434,8 +434,8 @@ int CDECL MSVCRT__wcslwr_s_l( wchar_t* str, size_t n, _locale_t locale )
if (!str || !n)
{
if (str) *str = '\0';
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
if(!locale)
@ -457,8 +457,8 @@ int CDECL MSVCRT__wcslwr_s_l( wchar_t* str, size_t n, _locale_t locale )
/* MSDN claims that the function should return and set errno to
* ERANGE, which doesn't seem to be true based on the tests. */
*str = '\0';
*MSVCRT__errno() = MSVCRT_EINVAL;
return MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return EINVAL;
}
/******************************************************************
@ -602,7 +602,7 @@ static size_t MSVCRT_wcsrtombs_l(char *mbstr, const wchar_t **wcstr,
for(i=0; i<count; i++) {
if((*wcstr)[i] > 255) {
*MSVCRT__errno() = MSVCRT_EILSEQ;
*MSVCRT__errno() = EILSEQ;
return -1;
}
@ -618,7 +618,7 @@ static size_t MSVCRT_wcsrtombs_l(char *mbstr, const wchar_t **wcstr,
tmp = WideCharToMultiByte(locinfo->lc_codepage, WC_NO_BEST_FIT_CHARS,
*wcstr, -1, NULL, 0, NULL, pused_default);
if(!tmp || used_default) {
*MSVCRT__errno() = MSVCRT_EILSEQ;
*MSVCRT__errno() = EILSEQ;
return -1;
}
return tmp-1;
@ -631,7 +631,7 @@ static size_t MSVCRT_wcsrtombs_l(char *mbstr, const wchar_t **wcstr,
size = WideCharToMultiByte(locinfo->lc_codepage, WC_NO_BEST_FIT_CHARS,
*wcstr, 1, buf, 3, NULL, pused_default);
if(!size || used_default) {
*MSVCRT__errno() = MSVCRT_EILSEQ;
*MSVCRT__errno() = EILSEQ;
return -1;
}
if(tmp+size > count)
@ -697,10 +697,10 @@ static int MSVCRT_wcsrtombs_s_l(size_t *ret, char *mbstr, size_t size,
return 0;
}
if (!MSVCRT_CHECK_PMT(mbstr != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(mbstr != NULL)) return EINVAL;
if (size) mbstr[0] = '\0';
if (!MSVCRT_CHECK_PMT(wcstr != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(*wcstr != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(wcstr != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(*wcstr != NULL)) return EINVAL;
if(count==MSVCRT__TRUNCATE || size<count)
conv = size;
@ -719,13 +719,13 @@ static int MSVCRT_wcsrtombs_s_l(size_t *ret, char *mbstr, size_t size,
else if(conv==size && (count==MSVCRT__TRUNCATE || mbstr[conv-1]=='\0')) {
mbstr[conv-1] = '\0';
if(count==MSVCRT__TRUNCATE)
err = MSVCRT_STRUNCATE;
err = STRUNCATE;
}else {
MSVCRT_INVALID_PMT("mbstr[size] is too small", MSVCRT_ERANGE);
MSVCRT_INVALID_PMT("mbstr[size] is too small", ERANGE);
conv = 0;
if(size)
mbstr[0] = '\0';
err = MSVCRT_ERANGE;
err = ERANGE;
}
if(ret)
@ -969,7 +969,7 @@ static int CDECL MSVCRT_vsnprintf_s_l_opt( char *str, size_t sizeOfBuffer,
if(ret<0 || ret==len) {
if(count!=MSVCRT__TRUNCATE && count>sizeOfBuffer) {
MSVCRT_INVALID_PMT("str[sizeOfBuffer] is too small", MSVCRT_ERANGE);
MSVCRT_INVALID_PMT("str[sizeOfBuffer] is too small", ERANGE);
memset(str, 0, sizeOfBuffer);
} else
str[len-1] = '\0';
@ -999,7 +999,7 @@ static int MSVCRT_vsnwprintf_s_l_opt( wchar_t *str, size_t sizeOfBuffer,
if(ret<0 || ret==len) {
if(count!=MSVCRT__TRUNCATE && count>sizeOfBuffer) {
MSVCRT_INVALID_PMT("str[sizeOfBuffer] is too small", MSVCRT_ERANGE);
MSVCRT_INVALID_PMT("str[sizeOfBuffer] is too small", ERANGE);
memset(str, 0, sizeOfBuffer*sizeof(wchar_t));
} else
str[len-1] = '\0';
@ -1168,7 +1168,7 @@ int CDECL MSVCRT__vscprintf_p_l(const char *format,
ret = create_positional_ctx_a(args_ctx, format, args);
if(ret < 0) {
MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return ret;
} else if(ret == 0) {
ret = pf_printf_a(puts_clbk_str_a, &puts_ctx, format, locale,
@ -1346,7 +1346,7 @@ static int MSVCRT_vswprintf_p_l_opt(wchar_t *buffer, size_t length,
ret = create_positional_ctx_w(args_ctx, format, args);
if(ret < 0) {
MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return ret;
} else if(ret == 0)
ret = pf_printf_w(puts_clbk_str_w, &puts_ctx, format, locale, MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER | options,
@ -1725,7 +1725,7 @@ static int MSVCRT_vsprintf_p_l_opt(char *buffer, size_t length, const char *form
ret = create_positional_ctx_a(args_ctx, format, args);
if(ret < 0) {
MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
*MSVCRT__errno() = MSVCRT_EINVAL;
*MSVCRT__errno() = EINVAL;
return ret;
} else if(ret == 0)
ret = pf_printf_a(puts_clbk_str_a, &puts_ctx, format, locale,
@ -1952,7 +1952,7 @@ int CDECL MSVCRT__wctomb_s_l(int *len, char *mbchar, size_t size,
*len = -1;
if(!MSVCRT_CHECK_PMT(size <= INT_MAX))
return MSVCRT_EINVAL;
return EINVAL;
if(!locale)
locinfo = get_locinfo();
@ -1963,12 +1963,12 @@ int CDECL MSVCRT__wctomb_s_l(int *len, char *mbchar, size_t size,
if(wch > 0xff) {
if(mbchar && size>0)
memset(mbchar, 0, size);
*MSVCRT__errno() = MSVCRT_EILSEQ;
return MSVCRT_EILSEQ;
*MSVCRT__errno() = EILSEQ;
return EILSEQ;
}
if(!MSVCRT_CHECK_PMT_ERR(size >= 1, MSVCRT_ERANGE))
return MSVCRT_ERANGE;
if(!MSVCRT_CHECK_PMT_ERR(size >= 1, ERANGE))
return ERANGE;
*mbchar = wch;
if(len)
@ -1983,12 +1983,12 @@ int CDECL MSVCRT__wctomb_s_l(int *len, char *mbchar, size_t size,
if(mbchar && size>0)
memset(mbchar, 0, size);
MSVCRT_INVALID_PMT("insufficient buffer size", MSVCRT_ERANGE);
return MSVCRT_ERANGE;
MSVCRT_INVALID_PMT("insufficient buffer size", ERANGE);
return ERANGE;
}
*MSVCRT__errno() = MSVCRT_EILSEQ;
return MSVCRT_EILSEQ;
*MSVCRT__errno() = EILSEQ;
return EILSEQ;
}
if(len)
@ -2295,21 +2295,21 @@ INT CDECL MSVCRT_wcscpy_s( wchar_t* wcDest, size_t numElement, const wchar_t *w
{
size_t size = 0;
if(!MSVCRT_CHECK_PMT(wcDest)) return MSVCRT_EINVAL;
if(!MSVCRT_CHECK_PMT(numElement)) return MSVCRT_EINVAL;
if(!MSVCRT_CHECK_PMT(wcDest)) return EINVAL;
if(!MSVCRT_CHECK_PMT(numElement)) return EINVAL;
if(!MSVCRT_CHECK_PMT(wcSrc))
{
wcDest[0] = 0;
return MSVCRT_EINVAL;
return EINVAL;
}
size = MSVCRT_wcslen(wcSrc) + 1;
if(!MSVCRT_CHECK_PMT_ERR(size <= numElement, MSVCRT_ERANGE))
if(!MSVCRT_CHECK_PMT_ERR(size <= numElement, ERANGE))
{
wcDest[0] = 0;
return MSVCRT_ERANGE;
return ERANGE;
}
memmove( wcDest, wcSrc, size*sizeof(WCHAR) );
@ -2354,12 +2354,12 @@ INT CDECL MSVCRT_wcsncpy_s( wchar_t* wcDest, size_t numElement, const wchar_t *w
return 0;
if (!wcDest || !numElement)
return MSVCRT_EINVAL;
return EINVAL;
if (!wcSrc)
{
*wcDest = 0;
return count ? MSVCRT_EINVAL : 0;
return count ? EINVAL : 0;
}
while (numElement && count && *wcSrc)
@ -2371,12 +2371,12 @@ INT CDECL MSVCRT_wcsncpy_s( wchar_t* wcDest, size_t numElement, const wchar_t *w
if (!numElement && truncate)
{
*(p-1) = 0;
return MSVCRT_STRUNCATE;
return STRUNCATE;
}
else if (!numElement)
{
*wcDest = 0;
return MSVCRT_ERANGE;
return ERANGE;
}
*p = 0;
@ -2391,11 +2391,11 @@ INT CDECL MSVCRT_wcscat_s(wchar_t* dst, size_t elem, const wchar_t* src)
{
wchar_t* ptr = dst;
if (!dst || elem == 0) return MSVCRT_EINVAL;
if (!dst || elem == 0) return EINVAL;
if (!src)
{
dst[0] = '\0';
return MSVCRT_EINVAL;
return EINVAL;
}
/* seek to end of dst string (or elem if no end of string is found */
@ -2406,7 +2406,7 @@ INT CDECL MSVCRT_wcscat_s(wchar_t* dst, size_t elem, const wchar_t* src)
}
/* not enough space */
dst[0] = '\0';
return MSVCRT_ERANGE;
return ERANGE;
}
/***********************************************************************
@ -2429,9 +2429,9 @@ INT CDECL MSVCRT_wcsncat_s(wchar_t *dst, size_t elem,
wchar_t dststart;
INT ret = 0;
if (!MSVCRT_CHECK_PMT(dst != NULL)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(elem > 0)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(src != NULL || count == 0)) return MSVCRT_EINVAL;
if (!MSVCRT_CHECK_PMT(dst != NULL)) return EINVAL;
if (!MSVCRT_CHECK_PMT(elem > 0)) return EINVAL;
if (!MSVCRT_CHECK_PMT(src != NULL || count == 0)) return EINVAL;
if (count == 0)
return 0;
@ -2443,8 +2443,8 @@ INT CDECL MSVCRT_wcsncat_s(wchar_t *dst, size_t elem,
}
if (dststart == elem)
{
MSVCRT_INVALID_PMT("dst[elem] is not NULL terminated\n", MSVCRT_EINVAL);
return MSVCRT_EINVAL;
MSVCRT_INVALID_PMT("dst[elem] is not NULL terminated\n", EINVAL);
return EINVAL;
}
if (count == MSVCRT__TRUNCATE)
@ -2453,7 +2453,7 @@ INT CDECL MSVCRT_wcsncat_s(wchar_t *dst, size_t elem,
if (srclen >= (elem - dststart))
{
srclen = elem - dststart - 1;
ret = MSVCRT_STRUNCATE;
ret = STRUNCATE;
}
}
else
@ -2464,9 +2464,9 @@ INT CDECL MSVCRT_wcsncat_s(wchar_t *dst, size_t elem,
dst[dststart+srclen] = '\0';
return ret;
}
MSVCRT_INVALID_PMT("dst[elem] is too small", MSVCRT_ERANGE);
MSVCRT_INVALID_PMT("dst[elem] is too small", ERANGE);
dst[0] = '\0';
return MSVCRT_ERANGE;
return ERANGE;
}
/*********************************************************************
@ -2552,10 +2552,10 @@ __int64 CDECL MSVCRT__wcstoi64_l(const wchar_t *nptr,
if(!negative && (ret>I64_MAX/base || ret*base>I64_MAX-v)) {
ret = I64_MAX;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
} else if(negative && (ret<I64_MIN/base || ret*base<I64_MIN-v)) {
ret = I64_MIN;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
} else
ret = ret*base + v;
}
@ -2585,10 +2585,10 @@ __msvcrt_long CDECL MSVCRT__wcstol_l(const wchar_t *s,
if(ret > LONG_MAX) {
ret = LONG_MAX;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
}else if(ret < LONG_MIN) {
ret = LONG_MIN;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
}
return ret;
}
@ -2611,10 +2611,10 @@ int __cdecl MSVCRT__wtoi_l(const wchar_t *str, _locale_t locale)
if(ret > INT_MAX) {
ret = INT_MAX;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
} else if(ret < INT_MIN) {
ret = INT_MIN;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
}
return ret;
}
@ -2636,10 +2636,10 @@ __msvcrt_long __cdecl MSVCRT__wtol_l(const wchar_t *str, _locale_t locale)
if(ret > LONG_MAX) {
ret = LONG_MAX;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
} else if(ret < LONG_MIN) {
ret = LONG_MIN;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
}
return ret;
}
@ -2722,7 +2722,7 @@ unsigned __int64 CDECL MSVCRT__wcstoui64_l(const wchar_t *nptr,
if(ret>UI64_MAX/base || ret*base>UI64_MAX-v) {
ret = UI64_MAX;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
} else
ret = ret*base + v;
}
@ -2752,10 +2752,10 @@ __msvcrt_ulong __cdecl MSVCRT__wcstoul_l(const wchar_t *s,
if(ret > ULONG_MAX) {
ret = ULONG_MAX;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
}else if(ret < -(__int64)ULONG_MAX) {
ret = 1;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
}
return ret;
}
@ -2927,14 +2927,14 @@ size_t CDECL MSVCRT__wcsxfrm_l(wchar_t *dest, const wchar_t *src,
LCMAP_SORTKEY, src, -1, NULL, 0);
if(!ret) {
if(len) dest[0] = 0;
*MSVCRT__errno() = MSVCRT_EILSEQ;
*MSVCRT__errno() = EILSEQ;
return INT_MAX;
}
if(!len) return ret-1;
if(ret > len) {
dest[0] = 0;
*MSVCRT__errno() = MSVCRT_ERANGE;
*MSVCRT__errno() = ERANGE;
return ret-1;
}