| /* |
| * MSVCRT string functions |
| * |
| * Copyright 1996,1998 Marcus Meissner |
| * Copyright 1996 Jukka Iivonen |
| * Copyright 1997,2000 Uwe Bonnes |
| * Copyright 2000 Jon Griffiths |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #define _ISOC99_SOURCE |
| #include "config.h" |
| #include "wine/port.h" |
| |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <math.h> |
| #include <limits.h> |
| #include <errno.h> |
| #include "msvcrt.h" |
| #include "winnls.h" |
| #include "wine/debug.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(msvcrt); |
| |
| /********************************************************************* |
| * _mbsdup (MSVCRT.@) |
| * _strdup (MSVCRT.@) |
| */ |
| char* CDECL MSVCRT__strdup(const char* str) |
| { |
| if(str) |
| { |
| char * ret = MSVCRT_malloc(strlen(str)+1); |
| if (ret) strcpy( ret, str ); |
| return ret; |
| } |
| else return 0; |
| } |
| |
| /********************************************************************* |
| * _strlwr_s_l (MSVCRT.@) |
| */ |
| int CDECL _strlwr_s_l(char *str, MSVCRT_size_t len, MSVCRT__locale_t locale) |
| { |
| char *ptr = str; |
| |
| if (!str || !len) |
| { |
| *MSVCRT__errno() = MSVCRT_EINVAL; |
| return MSVCRT_EINVAL; |
| } |
| |
| while (len && *ptr) |
| { |
| len--; |
| ptr++; |
| } |
| |
| if (!len) |
| { |
| str[0] = '\0'; |
| *MSVCRT__errno() = MSVCRT_EINVAL; |
| return MSVCRT_EINVAL; |
| } |
| |
| while (*str) |
| { |
| *str = MSVCRT__tolower_l((unsigned char)*str, locale); |
| str++; |
| } |
| |
| return 0; |
| } |
| |
| /********************************************************************* |
| * _strlwr_s (MSVCRT.@) |
| */ |
| int CDECL _strlwr_s(char *str, MSVCRT_size_t len) |
| { |
| return _strlwr_s_l(str, len, NULL); |
| } |
| |
| /********************************************************************* |
| * _strlwr_l (MSVCRT.@) |
| */ |
| char* CDECL _strlwr_l(char *str, MSVCRT__locale_t locale) |
| { |
| _strlwr_s_l(str, -1, locale); |
| return str; |
| } |
| |
| /********************************************************************* |
| * _strlwr (MSVCRT.@) |
| */ |
| char* CDECL MSVCRT__strlwr(char *str) |
| { |
| _strlwr_s_l(str, -1, NULL); |
| return str; |
| } |
| |
| /********************************************************************* |
| * _strupr_s_l (MSVCRT.@) |
| */ |
| int CDECL _strupr_s_l(char *str, MSVCRT_size_t len, MSVCRT__locale_t locale) |
| { |
| char *ptr = str; |
| |
| if (!str || !len) |
| { |
| *MSVCRT__errno() = MSVCRT_EINVAL; |
| return MSVCRT_EINVAL; |
| } |
| |
| while (len && *ptr) |
| { |
| len--; |
| ptr++; |
| } |
| |
| if (!len) |
| { |
| str[0] = '\0'; |
| *MSVCRT__errno() = MSVCRT_EINVAL; |
| return MSVCRT_EINVAL; |
| } |
| |
| while (*str) |
| { |
| *str = MSVCRT__toupper_l((unsigned char)*str, locale); |
| str++; |
| } |
| |
| return 0; |
| } |
| |
| /********************************************************************* |
| * _strupr_s (MSVCRT.@) |
| */ |
| int CDECL _strupr_s(char *str, MSVCRT_size_t len) |
| { |
| return _strupr_s_l(str, len, NULL); |
| } |
| |
| /********************************************************************* |
| * _strupr_l (MSVCRT.@) |
| */ |
| char* CDECL MSVCRT__strupr_l(char *str, MSVCRT__locale_t locale) |
| { |
| _strupr_s_l(str, -1, locale); |
| return str; |
| } |
| |
| /********************************************************************* |
| * _strupr (MSVCRT.@) |
| */ |
| char* CDECL MSVCRT__strupr(char *str) |
| { |
| _strupr_s_l(str, -1, NULL); |
| return str; |
| } |
| |
| /********************************************************************* |
| * _strnset (MSVCRT.@) |
| */ |
| char* CDECL MSVCRT__strnset(char* str, int value, MSVCRT_size_t len) |
| { |
| if (len > 0 && str) |
| while (*str && len--) |
| *str++ = value; |
| return str; |
| } |
| |
| /********************************************************************* |
| * _strrev (MSVCRT.@) |
| */ |
| char* CDECL MSVCRT__strrev(char* str) |
| { |
| char * p1; |
| char * p2; |
| |
| if (str && *str) |
| for (p1 = str, p2 = str + strlen(str) - 1; p2 > p1; ++p1, --p2) |
| { |
| *p1 ^= *p2; |
| *p2 ^= *p1; |
| *p1 ^= *p2; |
| } |
| |
| return str; |
| } |
| |
| /********************************************************************* |
| * _strset (MSVCRT.@) |
| */ |
| char* CDECL _strset(char* str, int value) |
| { |
| char *ptr = str; |
| while (*ptr) |
| *ptr++ = value; |
| |
| return str; |
| } |
| |
| /********************************************************************* |
| * strtok (MSVCRT.@) |
| */ |
| char * CDECL MSVCRT_strtok( char *str, const char *delim ) |
| { |
| thread_data_t *data = msvcrt_get_thread_data(); |
| char *ret; |
| |
| if (!str) |
| if (!(str = data->strtok_next)) return NULL; |
| |
| while (*str && strchr( delim, *str )) str++; |
| if (!*str) return NULL; |
| ret = str++; |
| while (*str && !strchr( delim, *str )) str++; |
| if (*str) *str++ = 0; |
| data->strtok_next = str; |
| return ret; |
| } |
| |
| /********************************************************************* |
| * strtok_s (MSVCRT.@) |
| */ |
| char * CDECL MSVCRT_strtok_s(char *str, const char *delim, char **ctx) |
| { |
| if (!MSVCRT_CHECK_PMT(delim != NULL) || !MSVCRT_CHECK_PMT(ctx != NULL) || |
| !MSVCRT_CHECK_PMT(str != NULL || *ctx != NULL)) { |
| *MSVCRT__errno() = MSVCRT_EINVAL; |
| return NULL; |
| } |
| |
| if(!str) |
| str = *ctx; |
| |
| while(*str && strchr(delim, *str)) |
| str++; |
| if(!*str) |
| return NULL; |
| |
| *ctx = str+1; |
| while(**ctx && !strchr(delim, **ctx)) |
| (*ctx)++; |
| if(**ctx) |
| *(*ctx)++ = 0; |
| |
| return str; |
| } |
| |
| /********************************************************************* |
| * _swab (MSVCRT.@) |
| */ |
| void CDECL MSVCRT__swab(char* src, char* dst, int len) |
| { |
| if (len > 1) |
| { |
| len = (unsigned)len >> 1; |
| |
| while (len--) { |
| char s0 = src[0]; |
| char s1 = src[1]; |
| *dst++ = s1; |
| *dst++ = s0; |
| src = src + 2; |
| } |
| } |
| } |
| |
| /********************************************************************* |
| * strtod_l (MSVCRT.@) |
| */ |
| double CDECL MSVCRT_strtod_l( const char *str, char **end, MSVCRT__locale_t locale) |
| { |
| MSVCRT_pthreadlocinfo locinfo; |
| unsigned __int64 d=0, hlp; |
| unsigned fpcontrol; |
| int exp=0, sign=1; |
| const char *p; |
| double ret; |
| BOOL found_digit = FALSE; |
| |
| if (!MSVCRT_CHECK_PMT(str != NULL)) { |
| *MSVCRT__errno() = MSVCRT_EINVAL; |
| return 0; |
| } |
| |
| if(!locale) |
| locinfo = get_locinfo(); |
| else |
| locinfo = locale->locinfo; |
| |
| /* FIXME: use *_l functions */ |
| p = str; |
| while(isspace(*p)) |
| p++; |
| |
| if(*p == '-') { |
| sign = -1; |
| p++; |
| } else if(*p == '+') |
| p++; |
| |
| while(isdigit(*p)) { |
| found_digit = TRUE; |
| hlp = d*10+*(p++)-'0'; |
| if(d>MSVCRT_UI64_MAX/10 || hlp<d) { |
| exp++; |
| break; |
| } else |
| d = hlp; |
| } |
| while(isdigit(*p)) { |
| exp++; |
| p++; |
| } |
| |
| if(*p == *locinfo->lconv->decimal_point) |
| p++; |
| |
| while(isdigit(*p)) { |
| found_digit = TRUE; |
| hlp = d*10+*(p++)-'0'; |
| if(d>MSVCRT_UI64_MAX/10 || hlp<d) |
| break; |
| |
| d = hlp; |
| exp--; |
| } |
| while(isdigit(*p)) |
| p++; |
| |
| if(!found_digit) { |
| if(end) |
| *end = (char*)str; |
| return 0.0; |
| } |
| |
| if(*p=='e' || *p=='E' || *p=='d' || *p=='D') { |
| int e=0, s=1; |
| |
| p++; |
| if(*p == '-') { |
| s = -1; |
| p++; |
| } else if(*p == '+') |
| p++; |
| |
| if(isdigit(*p)) { |
| while(isdigit(*p)) { |
| if(e>INT_MAX/10 || (e=e*10+*p-'0')<0) |
| e = INT_MAX; |
| p++; |
| } |
| e *= s; |
| |
| if(exp<0 && e<0 && exp+e>=0) exp = INT_MIN; |
| else if(exp>0 && e>0 && exp+e<0) exp = INT_MAX; |
| else exp += e; |
| } else { |
| if(*p=='-' || *p=='+') |
| p--; |
| p--; |
| } |
| } |
| |
| fpcontrol = _control87(0, 0); |
| _control87(MSVCRT__EM_DENORMAL|MSVCRT__EM_INVALID|MSVCRT__EM_ZERODIVIDE |
| |MSVCRT__EM_OVERFLOW|MSVCRT__EM_UNDERFLOW|MSVCRT__EM_INEXACT, 0xffffffff); |
| |
| if(exp>0) |
| ret = (double)sign*d*pow(10, exp); |
| else |
| ret = (double)sign*d/pow(10, -exp); |
| |
| _control87(fpcontrol, 0xffffffff); |
| |
| if((d && ret==0.0) || isinf(ret)) |
| *MSVCRT__errno() = MSVCRT_ERANGE; |
| |
| if(end) |
| *end = (char*)p; |
| |
| return ret; |
| } |
| |
| /********************************************************************* |
| * strtod (MSVCRT.@) |
| */ |
| double CDECL MSVCRT_strtod( const char *str, char **end ) |
| { |
| return MSVCRT_strtod_l( str, end, NULL ); |
| } |
| |
| /********************************************************************* |
| * atof (MSVCRT.@) |
| */ |
| double CDECL MSVCRT_atof( const char *str ) |
| { |
| return MSVCRT_strtod_l(str, NULL, NULL); |
| } |
| |
| /********************************************************************* |
| * _atof_l (MSVCRT.@) |
| */ |
| double CDECL MSVCRT__atof_l( const char *str, MSVCRT__locale_t locale) |
| { |
| return MSVCRT_strtod_l(str, NULL, locale); |
| } |
| |
| /********************************************************************* |
| * _atoflt_l (MSVCRT.@) |
| */ |
| int CDECL MSVCRT__atoflt_l( MSVCRT__CRT_FLOAT *value, char *str, MSVCRT__locale_t locale) |
| { |
| MSVCRT_pthreadlocinfo locinfo; |
| unsigned __int64 d=0, hlp; |
| unsigned fpcontrol; |
| int exp=0, sign=1; |
| const char *p; |
| int ret=0; |
| BOOL found_digit = FALSE; |
| |
| if(!locale) |
| locinfo = get_locinfo(); |
| else |
| locinfo = locale->locinfo; |
| |
| /* FIXME: use *_l functions */ |
| p = str; |
| while(isspace(*p)) |
| p++; |
| |
| if(*p == '-') { |
| sign = -1; |
| p++; |
| } else if(*p == '+') |
| p++; |
| |
| while(isdigit(*p)) { |
| found_digit = TRUE; |
| hlp = d*10+*(p++)-'0'; |
| if(d>MSVCRT_UI64_MAX/10 || hlp<d) { |
| exp++; |
| break; |
| } else |
| d = hlp; |
| } |
| while(isdigit(*p)) { |
| exp++; |
| p++; |
| } |
| |
| if(*p == *locinfo->lconv->decimal_point) |
| p++; |
| |
| while(isdigit(*p)) { |
| found_digit = TRUE; |
| hlp = d*10+*(p++)-'0'; |
| if(d>MSVCRT_UI64_MAX/10 || hlp<d) |
| break; |
| |
| d = hlp; |
| exp--; |
| } |
| while(isdigit(*p)) |
| p++; |
| |
| if(!found_digit) { |
| value->f = 0.0; |
| return 0; |
| } |
| |
| if(*p=='e' || *p=='E' || *p=='d' || *p=='D') { |
| int e=0, s=1; |
| |
| p++; |
| if(*p == '-') { |
| s = -1; |
| p++; |
| } else if(*p == '+') |
| p++; |
| |
| if(isdigit(*p)) { |
| while(isdigit(*p)) { |
| if(e>INT_MAX/10 || (e=e*10+*p-'0')<0) |
| e = INT_MAX; |
| p++; |
| } |
| e *= s; |
| |
| if(exp<0 && e<0 && exp+e>=0) exp = INT_MIN; |
| else if(exp>0 && e>0 && exp+e<0) exp = INT_MAX; |
| else exp += e; |
| } else { |
| if(*p=='-' || *p=='+') |
| p--; |
| p--; |
| } |
| } |
| |
| fpcontrol = _control87(0, 0); |
| _control87(MSVCRT__EM_DENORMAL|MSVCRT__EM_INVALID|MSVCRT__EM_ZERODIVIDE |
| |MSVCRT__EM_OVERFLOW|MSVCRT__EM_UNDERFLOW|MSVCRT__EM_INEXACT, 0xffffffff); |
| |
| if(exp>0) |
| value->f = (float)sign*d*powf(10, exp); |
| else |
| value->f = (float)sign*d/powf(10, -exp); |
| |
| _control87(fpcontrol, 0xffffffff); |
| |
| if((d && value->f==0.0) || isinf(value->f)) |
| ret = exp > 0 ? MSVCRT__OVERFLOW : MSVCRT__UNDERFLOW; |
| |
| return ret; |
| } |
| |
| /********************************************************************* |
| * _strcoll_l (MSVCRT.@) |
| */ |
| int CDECL MSVCRT_strcoll_l( const char* str1, const char* str2, MSVCRT__locale_t locale ) |
| { |
| MSVCRT_pthreadlocinfo locinfo; |
| |
| if(!locale) |
| locinfo = get_locinfo(); |
| else |
| locinfo = locale->locinfo; |
| |
| return CompareStringA(locinfo->lc_handle[MSVCRT_LC_CTYPE], 0, str1, -1, str2, -1)-2; |
| } |
| |
| /********************************************************************* |
| * strcoll (MSVCRT.@) |
| */ |
| int CDECL MSVCRT_strcoll( const char* str1, const char* str2 ) |
| { |
| return MSVCRT_strcoll_l(str1, str2, NULL); |
| } |
| |
| /********************************************************************* |
| * _stricoll_l (MSVCRT.@) |
| */ |
| int CDECL MSVCRT__stricoll_l( const char* str1, const char* str2, MSVCRT__locale_t locale ) |
| { |
| MSVCRT_pthreadlocinfo locinfo; |
| |
| if(!locale) |
| locinfo = get_locinfo(); |
| else |
| locinfo = locale->locinfo; |
| |
| return CompareStringA(locinfo->lc_handle[MSVCRT_LC_CTYPE], NORM_IGNORECASE, |
| str1, -1, str2, -1)-2; |
| } |
| |
| /********************************************************************* |
| * _stricoll (MSVCRT.@) |
| */ |
| int CDECL MSVCRT__stricoll( const char* str1, const char* str2 ) |
| { |
| return MSVCRT__stricoll_l(str1, str2, NULL); |
| } |
| |
| /********************************************************************* |
| * _strncoll_l (MSVCRT.@) |
| */ |
| int CDECL MSVCRT_strncoll_l( const char* str1, const char* str2, MSVCRT_size_t count, MSVCRT__locale_t locale ) |
| { |
| MSVCRT_pthreadlocinfo locinfo; |
| |
| if(!locale) |
| locinfo = get_locinfo(); |
| else |
| locinfo = locale->locinfo; |
| |
| return CompareStringA(locinfo->lc_handle[MSVCRT_LC_CTYPE], 0, str1, count, str2, count)-2; |
| } |
| |
| /********************************************************************* |
| * strncoll (MSVCRT.@) |
| */ |
| int CDECL MSVCRT_strncoll( const char* str1, const char* str2, MSVCRT_size_t count ) |
| { |
| return MSVCRT_strncoll_l(str1, str2, count, NULL); |
| } |
| |
| /********************************************************************* |
| * _strnicoll_l (MSVCRT.@) |
| */ |
| int CDECL MSVCRT__strnicoll_l( const char* str1, const char* str2, MSVCRT_size_t count, MSVCRT__locale_t locale ) |
| { |
| MSVCRT_pthreadlocinfo locinfo; |
| |
| if(!locale) |
| locinfo = get_locinfo(); |
| else |
| locinfo = locale->locinfo; |
| |
| return CompareStringA(locinfo->lc_handle[MSVCRT_LC_CTYPE], NORM_IGNORECASE, |
| str1, count, str2, count)-2; |
| } |
| |
| /********************************************************************* |
| * _strnicoll (MSVCRT.@) |
| */ |
| int CDECL MSVCRT__strnicoll( const char* str1, const char* str2, MSVCRT_size_t count ) |
| { |
| return MSVCRT__strnicoll_l(str1, str2, count, NULL); |
| } |
| |
| /********************************************************************* |
| * strcpy_s (MSVCRT.@) |
| */ |
| int CDECL MSVCRT_strcpy_s( char* dst, MSVCRT_size_t elem, const char* src ) |
| { |
| MSVCRT_size_t i; |
| if(!elem) return MSVCRT_EINVAL; |
| if(!dst) return MSVCRT_EINVAL; |
| if(!src) |
| { |
| dst[0] = '\0'; |
| return MSVCRT_EINVAL; |
| } |
| |
| for(i = 0; i < elem; i++) |
| { |
| if((dst[i] = src[i]) == '\0') return 0; |
| } |
| dst[0] = '\0'; |
| return MSVCRT_ERANGE; |
| } |
| |
| /********************************************************************* |
| * strcat_s (MSVCRT.@) |
| */ |
| int CDECL MSVCRT_strcat_s( char* dst, MSVCRT_size_t elem, const char* src ) |
| { |
| MSVCRT_size_t i, j; |
| if(!dst) return MSVCRT_EINVAL; |
| if(elem == 0) return MSVCRT_EINVAL; |
| if(!src) |
| { |
| dst[0] = '\0'; |
| return MSVCRT_EINVAL; |
| } |
| |
| for(i = 0; i < elem; i++) |
| { |
| if(dst[i] == '\0') |
| { |
| for(j = 0; (j + i) < elem; j++) |
| { |
| if((dst[j + i] = src[j]) == '\0') return 0; |
| } |
| } |
| } |
| /* Set the first element to 0, not the first element after the skipped part */ |
| dst[0] = '\0'; |
| return MSVCRT_ERANGE; |
| } |
| |
| /********************************************************************* |
| * strncat_s (MSVCRT.@) |
| */ |
| int CDECL MSVCRT_strncat_s( char* dst, MSVCRT_size_t elem, const char* src, MSVCRT_size_t count ) |
| { |
| MSVCRT_size_t i, j; |
| if(!MSVCRT_CHECK_PMT(dst != 0) || !MSVCRT_CHECK_PMT(elem != 0)) |
| return MSVCRT_EINVAL; |
| if(!MSVCRT_CHECK_PMT(src != 0)) |
| { |
| dst[0] = '\0'; |
| return MSVCRT_EINVAL; |
| } |
| |
| for(i = 0; i < elem; i++) |
| { |
| if(dst[i] == '\0') |
| { |
| for(j = 0; (j + i) < elem; j++) |
| { |
| if(count == MSVCRT__TRUNCATE && j + i == elem - 1) |
| { |
| dst[j + i] = '\0'; |
| return MSVCRT_STRUNCATE; |
| } |
| if(j == count || (dst[j + i] = src[j]) == '\0') |
| { |
| dst[j + i] = '\0'; |
| return 0; |
| } |
| } |
| } |
| } |
| /* Set the first element to 0, not the first element after the skipped part */ |
| dst[0] = '\0'; |
| return MSVCRT_ERANGE; |
| } |
| |
| /********************************************************************* |
| * strxfrm (MSVCRT.@) |
| */ |
| MSVCRT_size_t CDECL MSVCRT_strxfrm( char *dest, const char *src, MSVCRT_size_t len ) |
| { |
| /* FIXME: handle Windows locale */ |
| return strxfrm( dest, src, len ); |
| } |
| |
| /******************************************************************** |
| * _atoldbl (MSVCRT.@) |
| */ |
| int CDECL MSVCRT__atoldbl(MSVCRT__LDOUBLE *value, const char *str) |
| { |
| /* FIXME needs error checking for huge/small values */ |
| #ifdef HAVE_STRTOLD |
| long double ld; |
| TRACE("str %s value %p\n",str,value); |
| ld = strtold(str,0); |
| memcpy(value, &ld, 10); |
| #else |
| FIXME("stub, str %s value %p\n",str,value); |
| #endif |
| return 0; |
| } |
| |
| /******************************************************************** |
| * __STRINGTOLD (MSVCRT.@) |
| */ |
| int CDECL __STRINGTOLD( MSVCRT__LDOUBLE *value, char **endptr, const char *str, int flags ) |
| { |
| #ifdef HAVE_STRTOLD |
| long double ld; |
| FIXME("%p %p %s %x partial stub\n", value, endptr, str, flags ); |
| ld = strtold(str,0); |
| memcpy(value, &ld, 10); |
| #else |
| FIXME("%p %p %s %x stub\n", value, endptr, str, flags ); |
| #endif |
| return 0; |
| } |
| |
| /****************************************************************** |
| * strtol (MSVCRT.@) |
| */ |
| MSVCRT_long CDECL MSVCRT_strtol(const char* nptr, char** end, int base) |
| { |
| /* wrapper to forward libc error code to msvcrt's error codes */ |
| long ret; |
| |
| errno = 0; |
| ret = strtol(nptr, end, base); |
| switch (errno) |
| { |
| case ERANGE: *MSVCRT__errno() = MSVCRT_ERANGE; break; |
| case EINVAL: *MSVCRT__errno() = MSVCRT_EINVAL; break; |
| default: |
| /* cope with the fact that we may use 64bit long integers on libc |
| * while msvcrt always uses 32bit long integers |
| */ |
| if (ret > MSVCRT_LONG_MAX) |
| { |
| ret = MSVCRT_LONG_MAX; |
| *MSVCRT__errno() = MSVCRT_ERANGE; |
| } |
| else if (ret < -MSVCRT_LONG_MAX - 1) |
| { |
| ret = -MSVCRT_LONG_MAX - 1; |
| *MSVCRT__errno() = MSVCRT_ERANGE; |
| } |
| break; |
| } |
| |
| return ret; |
| } |
| |
| /****************************************************************** |
| * strtoul (MSVCRT.@) |
| */ |
| MSVCRT_ulong CDECL MSVCRT_strtoul(const char* nptr, char** end, int base) |
| { |
| /* wrapper to forward libc error code to msvcrt's error codes */ |
| unsigned long ret; |
| |
| errno = 0; |
| ret = strtoul(nptr, end, base); |
| switch (errno) |
| { |
| case ERANGE: *MSVCRT__errno() = MSVCRT_ERANGE; break; |
| case EINVAL: *MSVCRT__errno() = MSVCRT_EINVAL; break; |
| default: |
| /* cope with the fact that we may use 64bit long integers on libc |
| * while msvcrt always uses 32bit long integers |
| */ |
| if (ret > MSVCRT_ULONG_MAX) |
| { |
| ret = MSVCRT_ULONG_MAX; |
| *MSVCRT__errno() = MSVCRT_ERANGE; |
| } |
| break; |
| } |
| |
| return ret; |
| } |
| |
| /****************************************************************** |
| * strnlen (MSVCRT.@) |
| */ |
| MSVCRT_size_t CDECL MSVCRT_strnlen(const char *s, MSVCRT_size_t maxlen) |
| { |
| MSVCRT_size_t i; |
| |
| for(i=0; i<maxlen; i++) |
| if(!s[i]) break; |
| |
| return i; |
| } |
| |
| /********************************************************************* |
| * _strtoi64_l (MSVCRT.@) |
| * |
| * FIXME: locale parameter is ignored |
| */ |
| __int64 CDECL MSVCRT_strtoi64_l(const char *nptr, char **endptr, int base, MSVCRT__locale_t locale) |
| { |
| BOOL negative = FALSE; |
| __int64 ret = 0; |
| |
| TRACE("(%s %p %d %p)\n", debugstr_a(nptr), endptr, base, locale); |
| |
| if (!MSVCRT_CHECK_PMT(nptr != NULL) || !MSVCRT_CHECK_PMT(base == 0 || base >= 2) || |
| !MSVCRT_CHECK_PMT(base <= 36)) { |
| return 0; |
| } |
| |
| while(isspace(*nptr)) nptr++; |
| |
| if(*nptr == '-') { |
| negative = TRUE; |
| nptr++; |
| } else if(*nptr == '+') |
| nptr++; |
| |
| if((base==0 || base==16) && *nptr=='0' && tolower(*(nptr+1))=='x') { |
| base = 16; |
| nptr += 2; |
| } |
| |
| if(base == 0) { |
| if(*nptr=='0') |
| base = 8; |
| else |
| base = 10; |
| } |
| |
| while(*nptr) { |
| char cur = tolower(*nptr); |
| int v; |
| |
| if(isdigit(cur)) { |
| if(cur >= '0'+base) |
| break; |
| v = cur-'0'; |
| } else { |
| if(cur<'a' || cur>='a'+base-10) |
| break; |
| v = cur-'a'+10; |
| } |
| |
| if(negative) |
| v = -v; |
| |
| nptr++; |
| |
| if(!negative && (ret>MSVCRT_I64_MAX/base || ret*base>MSVCRT_I64_MAX-v)) { |
| ret = MSVCRT_I64_MAX; |
| *MSVCRT__errno() = MSVCRT_ERANGE; |
| } else if(negative && (ret<MSVCRT_I64_MIN/base || ret*base<MSVCRT_I64_MIN-v)) { |
| ret = MSVCRT_I64_MIN; |
| *MSVCRT__errno() = MSVCRT_ERANGE; |
| } else |
| ret = ret*base + v; |
| } |
| |
| if(endptr) |
| *endptr = (char*)nptr; |
| |
| return ret; |
| } |
| |
| /********************************************************************* |
| * _strtoi64 (MSVCRT.@) |
| */ |
| __int64 CDECL MSVCRT_strtoi64(const char *nptr, char **endptr, int base) |
| { |
| return MSVCRT_strtoi64_l(nptr, endptr, base, NULL); |
| } |
| |
| /********************************************************************* |
| * _strtoui64_l (MSVCRT.@) |
| * |
| * FIXME: locale parameter is ignored |
| */ |
| unsigned __int64 CDECL MSVCRT_strtoui64_l(const char *nptr, char **endptr, int base, MSVCRT__locale_t locale) |
| { |
| BOOL negative = FALSE; |
| unsigned __int64 ret = 0; |
| |
| TRACE("(%s %p %d %p)\n", debugstr_a(nptr), endptr, base, locale); |
| |
| if (!MSVCRT_CHECK_PMT(nptr != NULL) || !MSVCRT_CHECK_PMT(base == 0 || base >= 2) || |
| !MSVCRT_CHECK_PMT(base <= 36)) { |
| return 0; |
| } |
| |
| while(isspace(*nptr)) nptr++; |
| |
| if(*nptr == '-') { |
| negative = TRUE; |
| nptr++; |
| } else if(*nptr == '+') |
| nptr++; |
| |
| if((base==0 || base==16) && *nptr=='0' && tolower(*(nptr+1))=='x') { |
| base = 16; |
| nptr += 2; |
| } |
| |
| if(base == 0) { |
| if(*nptr=='0') |
| base = 8; |
| else |
| base = 10; |
| } |
| |
| while(*nptr) { |
| char cur = tolower(*nptr); |
| int v; |
| |
| if(isdigit(cur)) { |
| if(cur >= '0'+base) |
| break; |
| v = *nptr-'0'; |
| } else { |
| if(cur<'a' || cur>='a'+base-10) |
| break; |
| v = cur-'a'+10; |
| } |
| |
| nptr++; |
| |
| if(ret>MSVCRT_UI64_MAX/base || ret*base>MSVCRT_UI64_MAX-v) { |
| ret = MSVCRT_UI64_MAX; |
| *MSVCRT__errno() = MSVCRT_ERANGE; |
| } else |
| ret = ret*base + v; |
| } |
| |
| if(endptr) |
| *endptr = (char*)nptr; |
| |
| return negative ? -ret : ret; |
| } |
| |
| /********************************************************************* |
| * _strtoui64 (MSVCRT.@) |
| */ |
| unsigned __int64 CDECL MSVCRT_strtoui64(const char *nptr, char **endptr, int base) |
| { |
| return MSVCRT_strtoui64_l(nptr, endptr, base, NULL); |
| } |
| |
| /********************************************************************* |
| * _ltoa_s (MSVCRT.@) |
| */ |
| int CDECL _ltoa_s(MSVCRT_long value, char *str, MSVCRT_size_t size, int radix) |
| { |
| MSVCRT_ulong val; |
| unsigned int digit; |
| int is_negative; |
| char buffer[33], *pos; |
| size_t len; |
| |
| if (!MSVCRT_CHECK_PMT(str != NULL) || !MSVCRT_CHECK_PMT(size > 0) || |
| !MSVCRT_CHECK_PMT(radix >= 2) || !MSVCRT_CHECK_PMT(radix <= 36)) |
| { |
| if (str && size) |
| str[0] = '\0'; |
| |
| *MSVCRT__errno() = MSVCRT_EINVAL; |
| return MSVCRT_EINVAL; |
| } |
| |
| if (value < 0 && radix == 10) |
| { |
| is_negative = 1; |
| val = -value; |
| } |
| else |
| { |
| is_negative = 0; |
| val = value; |
| } |
| |
| pos = buffer + 32; |
| *pos = '\0'; |
| |
| do |
| { |
| digit = val % radix; |
| val /= radix; |
| |
| if (digit < 10) |
| *--pos = '0' + digit; |
| else |
| *--pos = 'a' + digit - 10; |
| } |
| while (val != 0); |
| |
| if (is_negative) |
| *--pos = '-'; |
| |
| len = buffer + 33 - pos; |
| if (len > size) |
| { |
| size_t i; |
| char *p = str; |
| |
| /* Copy the temporary buffer backwards up to the available number of |
| * characters. Don't copy the negative sign if present. */ |
| |
| if (is_negative) |
| { |
| p++; |
| size--; |
| } |
| |
| for (pos = buffer + 31, i = 0; i < size; i++) |
| *p++ = *pos--; |
| |
| str[0] = '\0'; |
| MSVCRT_INVALID_PMT("str[size] is too small"); |
| *MSVCRT__errno() = MSVCRT_ERANGE; |
| return MSVCRT_ERANGE; |
| } |
| |
| memcpy(str, pos, len); |
| return 0; |
| } |
| |
| /********************************************************************* |
| * _ltow_s (MSVCRT.@) |
| */ |
| int CDECL _ltow_s(MSVCRT_long value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix) |
| { |
| MSVCRT_ulong val; |
| unsigned int digit; |
| int is_negative; |
| MSVCRT_wchar_t buffer[33], *pos; |
| size_t len; |
| |
| if (!MSVCRT_CHECK_PMT(str != NULL) || !MSVCRT_CHECK_PMT(size > 0) || |
| !MSVCRT_CHECK_PMT(radix >= 2) || !MSVCRT_CHECK_PMT(radix <= 36)) |
| { |
| if (str && size) |
| str[0] = '\0'; |
| |
| *MSVCRT__errno() = MSVCRT_EINVAL; |
| return MSVCRT_EINVAL; |
| } |
| |
| if (value < 0 && radix == 10) |
| { |
| is_negative = 1; |
| val = -value; |
| } |
| else |
| { |
| is_negative = 0; |
| val = value; |
| } |
| |
| pos = buffer + 32; |
| *pos = '\0'; |
| |
| do |
| { |
| digit = val % radix; |
| val /= radix; |
| |
| if (digit < 10) |
| *--pos = '0' + digit; |
| else |
| *--pos = 'a' + digit - 10; |
| } |
| while (val != 0); |
| |
| if (is_negative) |
| *--pos = '-'; |
| |
| len = buffer + 33 - pos; |
| if (len > size) |
| { |
| size_t i; |
| MSVCRT_wchar_t *p = str; |
| |
| /* Copy the temporary buffer backwards up to the available number of |
| * characters. Don't copy the negative sign if present. */ |
| |
| if (is_negative) |
| { |
| p++; |
| size--; |
| } |
| |
| for (pos = buffer + 31, i = 0; i < size; i++) |
| *p++ = *pos--; |
| |
| MSVCRT_INVALID_PMT("str[size] is too small"); |
| str[0] = '\0'; |
| *MSVCRT__errno() = MSVCRT_ERANGE; |
| return MSVCRT_ERANGE; |
| } |
| |
| memcpy(str, pos, len * sizeof(MSVCRT_wchar_t)); |
| return 0; |
| } |
| |
| /********************************************************************* |
| * _itoa_s (MSVCRT.@) |
| */ |
| int CDECL _itoa_s(int value, char *str, MSVCRT_size_t size, int radix) |
| { |
| return _ltoa_s(value, str, size, radix); |
| } |
| |
| /********************************************************************* |
| * _itow_s (MSVCRT.@) |
| */ |
| int CDECL _itow_s(int value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix) |
| { |
| return _ltow_s(value, str, size, radix); |
| } |
| |
| /********************************************************************* |
| * _ui64toa_s (MSVCRT.@) |
| */ |
| int CDECL MSVCRT__ui64toa_s(unsigned __int64 value, char *str, |
| MSVCRT_size_t size, int radix) |
| { |
| char buffer[65], *pos; |
| int digit; |
| |
| if (!MSVCRT_CHECK_PMT(str != NULL) || !MSVCRT_CHECK_PMT(size > 0) || |
| !MSVCRT_CHECK_PMT(radix>=2) || !MSVCRT_CHECK_PMT(radix<=36)) { |
| *MSVCRT__errno() = MSVCRT_EINVAL; |
| return MSVCRT_EINVAL; |
| } |
| |
| pos = buffer+64; |
| *pos = '\0'; |
| |
| do { |
| digit = value%radix; |
| value /= radix; |
| |
| if(digit < 10) |
| *--pos = '0'+digit; |
| else |
| *--pos = 'a'+digit-10; |
| }while(value != 0); |
| |
| if(buffer-pos+65 > size) { |
| MSVCRT_INVALID_PMT("str[size] is too small"); |
| *MSVCRT__errno() = MSVCRT_EINVAL; |
| return MSVCRT_EINVAL; |
| } |
| |
| memcpy(str, pos, buffer-pos+65); |
| return 0; |
| } |
| |
| /********************************************************************* |
| * _ui64tow_s (MSVCRT.@) |
| */ |
| int CDECL MSVCRT__ui64tow_s( unsigned __int64 value, MSVCRT_wchar_t *str, |
| MSVCRT_size_t size, int radix ) |
| { |
| MSVCRT_wchar_t buffer[65], *pos; |
| int digit; |
| |
| if (!MSVCRT_CHECK_PMT(str != NULL) || !MSVCRT_CHECK_PMT(size > 0) || |
| !MSVCRT_CHECK_PMT(radix>=2) || !MSVCRT_CHECK_PMT(radix<=36)) { |
| *MSVCRT__errno() = MSVCRT_EINVAL; |
| return MSVCRT_EINVAL; |
| } |
| |
| pos = &buffer[64]; |
| *pos = '\0'; |
| |
| do { |
| digit = value % radix; |
| value = value / radix; |
| if (digit < 10) |
| *--pos = '0' + digit; |
| else |
| *--pos = 'a' + digit - 10; |
| } while (value != 0); |
| |
| if(buffer-pos+65 > size) { |
| MSVCRT_INVALID_PMT("str[size] is too small"); |
| *MSVCRT__errno() = MSVCRT_EINVAL; |
| return MSVCRT_EINVAL; |
| } |
| |
| memcpy(str, pos, buffer-pos+65); |
| return 0; |
| } |
| |
| /********************************************************************* |
| * _ultoa_s (MSVCRT.@) |
| */ |
| int CDECL _ultoa_s(MSVCRT_ulong value, char *str, MSVCRT_size_t size, int radix) |
| { |
| MSVCRT_ulong digit; |
| char buffer[33], *pos; |
| size_t len; |
| |
| if (!str || !size || radix < 2 || radix > 36) |
| { |
| if (str && size) |
| str[0] = '\0'; |
| |
| *MSVCRT__errno() = MSVCRT_EINVAL; |
| return MSVCRT_EINVAL; |
| } |
| |
| pos = buffer + 32; |
| *pos = '\0'; |
| |
| do |
| { |
| digit = value % radix; |
| value /= radix; |
| |
| if (digit < 10) |
| *--pos = '0' + digit; |
| else |
| *--pos = 'a' + digit - 10; |
| } |
| while (value != 0); |
| |
| len = buffer + 33 - pos; |
| if (len > size) |
| { |
| size_t i; |
| char *p = str; |
| |
| /* Copy the temporary buffer backwards up to the available number of |
| * characters. */ |
| |
| for (pos = buffer + 31, i = 0; i < size; i++) |
| *p++ = *pos--; |
| |
| str[0] = '\0'; |
| *MSVCRT__errno() = MSVCRT_ERANGE; |
| return MSVCRT_ERANGE; |
| } |
| |
| memcpy(str, pos, len); |
| return 0; |
| } |
| |
| /********************************************************************* |
| * _ultow_s (MSVCRT.@) |
| */ |
| int CDECL _ultow_s(MSVCRT_ulong value, WCHAR *str, MSVCRT_size_t size, int radix) |
| { |
| MSVCRT_ulong digit; |
| WCHAR buffer[33], *pos; |
| size_t len; |
| |
| if (!str || !size || radix < 2 || radix > 36) |
| { |
| if (str && size) |
| str[0] = '\0'; |
| |
| *MSVCRT__errno() = MSVCRT_EINVAL; |
| return MSVCRT_EINVAL; |
| } |
| |
| pos = buffer + 32; |
| *pos = '\0'; |
| |
| do |
| { |
| digit = value % radix; |
| value /= radix; |
| |
| if (digit < 10) |
| *--pos = '0' + digit; |
| else |
| *--pos = 'a' + digit - 10; |
| } |
| while (value != 0); |
| |
| len = buffer + 33 - pos; |
| if (len > size) |
| { |
| size_t i; |
| WCHAR *p = str; |
| |
| /* Copy the temporary buffer backwards up to the available number of |
| * characters. */ |
| |
| for (pos = buffer + 31, i = 0; i < size; i++) |
| *p++ = *pos--; |
| |
| str[0] = '\0'; |
| *MSVCRT__errno() = MSVCRT_ERANGE; |
| return MSVCRT_ERANGE; |
| } |
| |
| memcpy(str, pos, len * sizeof(WCHAR)); |
| return 0; |
| } |
| |
| /********************************************************************* |
| * _i64toa_s (MSVCRT.@) |
| */ |
| int CDECL _i64toa_s(__int64 value, char *str, MSVCRT_size_t size, int radix) |
| { |
| unsigned __int64 val; |
| unsigned int digit; |
| int is_negative; |
| char buffer[65], *pos; |
| size_t len; |
| |
| if (!MSVCRT_CHECK_PMT(str != NULL) || !MSVCRT_CHECK_PMT(size > 0) || |
| !MSVCRT_CHECK_PMT(radix >= 2) || !MSVCRT_CHECK_PMT(radix <= 36)) |
| { |
| if (str && size) |
| str[0] = '\0'; |
| |
| *MSVCRT__errno() = MSVCRT_EINVAL; |
| return MSVCRT_EINVAL; |
| } |
| |
| if (value < 0 && radix == 10) |
| { |
| is_negative = 1; |
| val = -value; |
| } |
| else |
| { |
| is_negative = 0; |
| val = value; |
| } |
| |
| pos = buffer + 64; |
| *pos = '\0'; |
| |
| do |
| { |
| digit = val % radix; |
| val /= radix; |
| |
| if (digit < 10) |
| *--pos = '0' + digit; |
| else |
| *--pos = 'a' + digit - 10; |
| } |
| while (val != 0); |
| |
| if (is_negative) |
| *--pos = '-'; |
| |
| len = buffer + 65 - pos; |
| if (len > size) |
| { |
| size_t i; |
| char *p = str; |
| |
| /* Copy the temporary buffer backwards up to the available number of |
| * characters. Don't copy the negative sign if present. */ |
| |
| if (is_negative) |
| { |
| p++; |
| size--; |
| } |
| |
| for (pos = buffer + 63, i = 0; i < size; i++) |
| *p++ = *pos--; |
| |
| str[0] = '\0'; |
| MSVCRT_INVALID_PMT("str[size] is too small"); |
| *MSVCRT__errno() = MSVCRT_ERANGE; |
| return MSVCRT_ERANGE; |
| } |
| |
| memcpy(str, pos, len); |
| return 0; |
| } |
| |
| /********************************************************************* |
| * _i64tow_s (MSVCRT.@) |
| */ |
| int CDECL _i64tow_s(__int64 value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix) |
| { |
| unsigned __int64 val; |
| unsigned int digit; |
| int is_negative; |
| MSVCRT_wchar_t buffer[65], *pos; |
| size_t len; |
| |
| if (!MSVCRT_CHECK_PMT(str != NULL) || !MSVCRT_CHECK_PMT(size > 0) || |
| !MSVCRT_CHECK_PMT(radix >= 2) || !MSVCRT_CHECK_PMT(radix <= 36)) |
| { |
| if (str && size) |
| str[0] = '\0'; |
| |
| *MSVCRT__errno() = MSVCRT_EINVAL; |
| return MSVCRT_EINVAL; |
| } |
| |
| if (value < 0 && radix == 10) |
| { |
| is_negative = 1; |
| val = -value; |
| } |
| else |
| { |
| is_negative = 0; |
| val = value; |
| } |
| |
| pos = buffer + 64; |
| *pos = '\0'; |
| |
| do |
| { |
| digit = val % radix; |
| val /= radix; |
| |
| if (digit < 10) |
| *--pos = '0' + digit; |
| else |
| *--pos = 'a' + digit - 10; |
| } |
| while (val != 0); |
| |
| if (is_negative) |
| *--pos = '-'; |
| |
| len = buffer + 65 - pos; |
| if (len > size) |
| { |
| size_t i; |
| MSVCRT_wchar_t *p = str; |
| |
| /* Copy the temporary buffer backwards up to the available number of |
| * characters. Don't copy the negative sign if present. */ |
| |
| if (is_negative) |
| { |
| p++; |
| size--; |
| } |
| |
| for (pos = buffer + 63, i = 0; i < size; i++) |
| *p++ = *pos--; |
| |
| MSVCRT_INVALID_PMT("str[size] is too small"); |
| str[0] = '\0'; |
| *MSVCRT__errno() = MSVCRT_ERANGE; |
| return MSVCRT_ERANGE; |
| } |
| |
| memcpy(str, pos, len * sizeof(MSVCRT_wchar_t)); |
| return 0; |
| } |
| |
| #define I10_OUTPUT_MAX_PREC 21 |
| /* Internal structure used by $I10_OUTPUT */ |
| struct _I10_OUTPUT_DATA { |
| short pos; |
| char sign; |
| BYTE len; |
| char str[I10_OUTPUT_MAX_PREC+1]; /* add space for '\0' */ |
| }; |
| |
| /********************************************************************* |
| * $I10_OUTPUT (MSVCRT.@) |
| * ld80 - long double (Intel 80 bit FP in 12 bytes) to be printed to data |
| * prec - precision of part, we're interested in |
| * flag - 0 for first prec digits, 1 for fractional part |
| * data - data to be populated |
| * |
| * return value |
| * 0 if given double is NaN or INF |
| * 1 otherwise |
| * |
| * FIXME |
| * Native sets last byte of data->str to '0' or '9', I don't know what |
| * it means. Current implementation sets it always to '0'. |
| */ |
| int CDECL MSVCRT_I10_OUTPUT(MSVCRT__LDOUBLE ld80, int prec, int flag, struct _I10_OUTPUT_DATA *data) |
| { |
| static const char inf_str[] = "1#INF"; |
| static const char nan_str[] = "1#QNAN"; |
| |
| /* MS' long double type wants 12 bytes for Intel's 80 bit FP format. |
| * Some UNIX have sizeof(long double) == 16, yet only 80 bit are used. |
| * Assume long double uses 80 bit FP, never seen 128 bit FP. */ |
| long double ld = 0; |
| double d; |
| char format[8]; |
| char buf[I10_OUTPUT_MAX_PREC+9]; /* 9 = strlen("0.e+0000") + '\0' */ |
| char *p; |
| |
| memcpy(&ld, &ld80, 10); |
| d = ld; |
| TRACE("(%lf %d %x %p)\n", d, prec, flag, data); |
| |
| if(d<0) { |
| data->sign = '-'; |
| d = -d; |
| } else |
| data->sign = ' '; |
| |
| if(isinf(d)) { |
| data->pos = 1; |
| data->len = 5; |
| memcpy(data->str, inf_str, sizeof(inf_str)); |
| |
| return 0; |
| } |
| |
| if(isnan(d)) { |
| data->pos = 1; |
| data->len = 6; |
| memcpy(data->str, nan_str, sizeof(nan_str)); |
| |
| return 0; |
| } |
| |
| if(flag&1) { |
| int exp = 1+floor(log10(d)); |
| |
| prec += exp; |
| if(exp < 0) |
| prec--; |
| } |
| prec--; |
| |
| if(prec+1 > I10_OUTPUT_MAX_PREC) |
| prec = I10_OUTPUT_MAX_PREC-1; |
| else if(prec < 0) { |
| d = 0.0; |
| prec = 0; |
| } |
| |
| sprintf(format, "%%.%dle", prec); |
| sprintf(buf, format, d); |
| |
| buf[1] = buf[0]; |
| data->pos = atoi(buf+prec+3); |
| if(buf[1] != '0') |
| data->pos++; |
| |
| for(p = buf+prec+1; p>buf+1 && *p=='0'; p--); |
| data->len = p-buf; |
| |
| memcpy(data->str, buf+1, data->len); |
| data->str[data->len] = '\0'; |
| |
| if(buf[1]!='0' && prec-data->len+1>0) |
| memcpy(data->str+data->len+1, buf+data->len+1, prec-data->len+1); |
| |
| return 1; |
| } |
| #undef I10_OUTPUT_MAX_PREC |
