| /* | |
| * NTDLL string functions | |
| * | |
| * Copyright 2000 Alexandre Julliard | |
| * Copyright 2000 Jon Griffiths | |
| * Copyright 2003 Thomas Mertes | |
| * | |
| * 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 | |
| */ | |
| #include "config.h" | |
| #include "wine/port.h" | |
| #include <ctype.h> | |
| #include <limits.h> | |
| #include <stdarg.h> | |
| #include <stdlib.h> | |
| #include <stdio.h> | |
| #include <string.h> | |
| #include "windef.h" | |
| #include "winternl.h" | |
| /********************************************************************* | |
| * memchr (NTDLL.@) | |
| */ | |
| void * __cdecl NTDLL_memchr( const void *ptr, int c, size_t n ) | |
| { | |
| return memchr( ptr, c, n ); | |
| } | |
| /********************************************************************* | |
| * memcmp (NTDLL.@) | |
| */ | |
| int __cdecl NTDLL_memcmp( const void *ptr1, const void *ptr2, size_t n ) | |
| { | |
| return memcmp( ptr1, ptr2, n ); | |
| } | |
| /********************************************************************* | |
| * memcpy (NTDLL.@) | |
| * | |
| * NOTES | |
| * Behaves like memmove. | |
| */ | |
| void * __cdecl NTDLL_memcpy( void *dst, const void *src, size_t n ) | |
| { | |
| return memmove( dst, src, n ); | |
| } | |
| /********************************************************************* | |
| * memmove (NTDLL.@) | |
| */ | |
| void * __cdecl NTDLL_memmove( void *dst, const void *src, size_t n ) | |
| { | |
| return memmove( dst, src, n ); | |
| } | |
| /********************************************************************* | |
| * memset (NTDLL.@) | |
| */ | |
| void * __cdecl NTDLL_memset( void *dst, int c, size_t n ) | |
| { | |
| return memset( dst, c, n ); | |
| } | |
| /********************************************************************* | |
| * strcat (NTDLL.@) | |
| */ | |
| char * __cdecl NTDLL_strcat( char *dst, const char *src ) | |
| { | |
| return strcat( dst, src ); | |
| } | |
| /********************************************************************* | |
| * strchr (NTDLL.@) | |
| */ | |
| char * __cdecl NTDLL_strchr( const char *str, int c ) | |
| { | |
| return strchr( str, c ); | |
| } | |
| /********************************************************************* | |
| * strcmp (NTDLL.@) | |
| */ | |
| int __cdecl NTDLL_strcmp( const char *str1, const char *str2 ) | |
| { | |
| return strcmp( str1, str2 ); | |
| } | |
| /********************************************************************* | |
| * strcpy (NTDLL.@) | |
| */ | |
| char * __cdecl NTDLL_strcpy( char *dst, const char *src ) | |
| { | |
| return strcpy( dst, src ); | |
| } | |
| /********************************************************************* | |
| * strcspn (NTDLL.@) | |
| */ | |
| size_t __cdecl NTDLL_strcspn( const char *str, const char *reject ) | |
| { | |
| return strcspn( str, reject ); | |
| } | |
| /********************************************************************* | |
| * strlen (NTDLL.@) | |
| */ | |
| size_t __cdecl NTDLL_strlen( const char *str ) | |
| { | |
| return strlen( str ); | |
| } | |
| /********************************************************************* | |
| * strncat (NTDLL.@) | |
| */ | |
| char * __cdecl NTDLL_strncat( char *dst, const char *src, size_t len ) | |
| { | |
| return strncat( dst, src, len ); | |
| } | |
| /********************************************************************* | |
| * strncmp (NTDLL.@) | |
| */ | |
| int __cdecl NTDLL_strncmp( const char *str1, const char *str2, size_t len ) | |
| { | |
| return strncmp( str1, str2, len ); | |
| } | |
| /********************************************************************* | |
| * strncpy (NTDLL.@) | |
| */ | |
| char * __cdecl NTDLL_strncpy( char *dst, const char *src, size_t len ) | |
| { | |
| return strncpy( dst, src, len ); | |
| } | |
| /********************************************************************* | |
| * strpbrk (NTDLL.@) | |
| */ | |
| char * __cdecl NTDLL_strpbrk( const char *str, const char *accept ) | |
| { | |
| return strpbrk( str, accept ); | |
| } | |
| /********************************************************************* | |
| * strrchr (NTDLL.@) | |
| */ | |
| char * __cdecl NTDLL_strrchr( const char *str, int c ) | |
| { | |
| return strrchr( str, c ); | |
| } | |
| /********************************************************************* | |
| * strspn (NTDLL.@) | |
| */ | |
| size_t __cdecl NTDLL_strspn( const char *str, const char *accept ) | |
| { | |
| return strspn( str, accept ); | |
| } | |
| /********************************************************************* | |
| * strstr (NTDLL.@) | |
| */ | |
| char * __cdecl NTDLL_strstr( const char *haystack, const char *needle ) | |
| { | |
| return strstr( haystack, needle ); | |
| } | |
| /********************************************************************* | |
| * _memccpy (NTDLL.@) | |
| */ | |
| void * __cdecl _memccpy( void *dst, const void *src, int c, size_t n ) | |
| { | |
| return memccpy( dst, src, c, n ); | |
| } | |
| /********************************************************************* | |
| * _memicmp (NTDLL.@) | |
| * | |
| * Compare two blocks of memory as strings, ignoring case. | |
| * | |
| * PARAMS | |
| * s1 [I] First string to compare to s2 | |
| * s2 [I] Second string to compare to s1 | |
| * len [I] Number of bytes to compare | |
| * | |
| * RETURNS | |
| * An integer less than, equal to, or greater than zero indicating that | |
| * s1 is less than, equal to or greater than s2 respectively. | |
| * | |
| * NOTES | |
| * Any Nul characters in s1 or s2 are ignored. This function always | |
| * compares up to len bytes or the first place where s1 and s2 differ. | |
| */ | |
| INT __cdecl _memicmp( LPCSTR s1, LPCSTR s2, DWORD len ) | |
| { | |
| int ret = 0; | |
| while (len--) | |
| { | |
| if ((ret = tolower(*s1) - tolower(*s2))) break; | |
| s1++; | |
| s2++; | |
| } | |
| return ret; | |
| } | |
| /********************************************************************* | |
| * _stricmp (NTDLL.@) | |
| * _strcmpi (NTDLL.@) | |
| */ | |
| int __cdecl _stricmp( LPCSTR str1, LPCSTR str2 ) | |
| { | |
| return strcasecmp( str1, str2 ); | |
| } | |
| /********************************************************************* | |
| * _strnicmp (NTDLL.@) | |
| */ | |
| int __cdecl _strnicmp( LPCSTR str1, LPCSTR str2, size_t n ) | |
| { | |
| return strncasecmp( str1, str2, n ); | |
| } | |
| /********************************************************************* | |
| * _strupr (NTDLL.@) | |
| * | |
| * Convert a string to upper case. | |
| * | |
| * PARAMS | |
| * str [I/O] String to convert | |
| * | |
| * RETURNS | |
| * str. There is no error return, if str is NULL or invalid, this | |
| * function will crash. | |
| */ | |
| LPSTR __cdecl _strupr( LPSTR str ) | |
| { | |
| LPSTR ret = str; | |
| for ( ; *str; str++) *str = toupper(*str); | |
| return ret; | |
| } | |
| /********************************************************************* | |
| * _strlwr (NTDLL.@) | |
| * | |
| * Convert a string to lowercase | |
| * | |
| * PARAMS | |
| * str [I/O] String to convert | |
| * | |
| * RETURNS | |
| * str. There is no error return, if str is NULL or invalid, this | |
| * function will crash. | |
| */ | |
| LPSTR __cdecl _strlwr( LPSTR str ) | |
| { | |
| LPSTR ret = str; | |
| for ( ; *str; str++) *str = tolower(*str); | |
| return ret; | |
| } | |
| /********************************************************************* | |
| * tolower (NTDLL.@) | |
| */ | |
| int __cdecl NTDLL_tolower( int c ) | |
| { | |
| return tolower( c ); | |
| } | |
| /********************************************************************* | |
| * toupper (NTDLL.@) | |
| */ | |
| int __cdecl NTDLL_toupper( int c ) | |
| { | |
| return toupper( c ); | |
| } | |
| /********************************************************************* | |
| * isalnum (NTDLL.@) | |
| */ | |
| int __cdecl NTDLL_isalnum( int c ) | |
| { | |
| return isalnum( c ); | |
| } | |
| /********************************************************************* | |
| * isalpha (NTDLL.@) | |
| */ | |
| int __cdecl NTDLL_isalpha( int c ) | |
| { | |
| return isalpha( c ); | |
| } | |
| /********************************************************************* | |
| * iscntrl (NTDLL.@) | |
| */ | |
| int __cdecl NTDLL_iscntrl( int c ) | |
| { | |
| return iscntrl( c ); | |
| } | |
| /********************************************************************* | |
| * isdigit (NTDLL.@) | |
| */ | |
| int __cdecl NTDLL_isdigit( int c ) | |
| { | |
| return isdigit( c ); | |
| } | |
| /********************************************************************* | |
| * isgraph (NTDLL.@) | |
| */ | |
| int __cdecl NTDLL_isgraph( int c ) | |
| { | |
| return isgraph( c ); | |
| } | |
| /********************************************************************* | |
| * islower (NTDLL.@) | |
| */ | |
| int __cdecl NTDLL_islower( int c ) | |
| { | |
| return islower( c ); | |
| } | |
| /********************************************************************* | |
| * isprint (NTDLL.@) | |
| */ | |
| int __cdecl NTDLL_isprint( int c ) | |
| { | |
| return isprint( c ); | |
| } | |
| /********************************************************************* | |
| * ispunct (NTDLL.@) | |
| */ | |
| int __cdecl NTDLL_ispunct( int c ) | |
| { | |
| return ispunct( c ); | |
| } | |
| /********************************************************************* | |
| * isspace (NTDLL.@) | |
| */ | |
| int __cdecl NTDLL_isspace( int c ) | |
| { | |
| return isspace( c ); | |
| } | |
| /********************************************************************* | |
| * isupper (NTDLL.@) | |
| */ | |
| int __cdecl NTDLL_isupper( int c ) | |
| { | |
| return isupper( c ); | |
| } | |
| /********************************************************************* | |
| * isxdigit (NTDLL.@) | |
| */ | |
| int __cdecl NTDLL_isxdigit( int c ) | |
| { | |
| return isxdigit( c ); | |
| } | |
| /********************************************************************* | |
| * __isascii (NTDLL.@) | |
| */ | |
| int CDECL NTDLL___isascii(int c) | |
| { | |
| return (unsigned)c < 0x80; | |
| } | |
| /********************************************************************* | |
| * __toascii (NTDLL.@) | |
| */ | |
| int CDECL NTDLL___toascii(int c) | |
| { | |
| return (unsigned)c & 0x7f; | |
| } | |
| /********************************************************************* | |
| * __iscsym (NTDLL.@) | |
| */ | |
| int CDECL NTDLL___iscsym(int c) | |
| { | |
| return (c < 127 && (isalnum(c) || c == '_')); | |
| } | |
| /********************************************************************* | |
| * __iscsymf (NTDLL.@) | |
| */ | |
| int CDECL NTDLL___iscsymf(int c) | |
| { | |
| return (c < 127 && (isalpha(c) || c == '_')); | |
| } | |
| /********************************************************************* | |
| * _toupper (NTDLL.@) | |
| */ | |
| int CDECL NTDLL__toupper(int c) | |
| { | |
| return c - 0x20; /* sic */ | |
| } | |
| /********************************************************************* | |
| * _tolower (NTDLL.@) | |
| */ | |
| int CDECL NTDLL__tolower(int c) | |
| { | |
| return c + 0x20; /* sic */ | |
| } | |
| /********************************************************************* | |
| * strtol (NTDLL.@) | |
| */ | |
| LONG __cdecl NTDLL_strtol( const char *nptr, char **endptr, int base ) | |
| { | |
| return strtol( nptr, endptr, base ); | |
| } | |
| /********************************************************************* | |
| * strtoul (NTDLL.@) | |
| */ | |
| ULONG __cdecl NTDLL_strtoul( const char *nptr, char **endptr, int base ) | |
| { | |
| return strtoul( nptr, endptr, base ); | |
| } | |
| /********************************************************************* | |
| * _ultoa (NTDLL.@) | |
| * | |
| * Convert an unsigned long integer to a string. | |
| * | |
| * RETURNS | |
| * str. | |
| * | |
| * NOTES | |
| * - Converts value to a Nul terminated string which is copied to str. | |
| * - The maximum length of the copied str is 33 bytes. | |
| * - Does not check if radix is in the range of 2 to 36. | |
| * - If str is NULL it crashes, as the native function does. | |
| */ | |
| char * __cdecl _ultoa( | |
| ULONG value, /* [I] Value to be converted */ | |
| char *str, /* [O] Destination for the converted value */ | |
| int radix) /* [I] Number base for conversion */ | |
| { | |
| char buffer[33]; | |
| char *pos; | |
| int digit; | |
| pos = &buffer[32]; | |
| *pos = '\0'; | |
| do { | |
| digit = value % radix; | |
| value = value / radix; | |
| if (digit < 10) { | |
| *--pos = '0' + digit; | |
| } else { | |
| *--pos = 'a' + digit - 10; | |
| } /* if */ | |
| } while (value != 0L); | |
| memcpy(str, pos, &buffer[32] - pos + 1); | |
| return str; | |
| } | |
| /********************************************************************* | |
| * _ltoa (NTDLL.@) | |
| * | |
| * Convert a long integer to a string. | |
| * | |
| * RETURNS | |
| * str. | |
| * | |
| * NOTES | |
| * - Converts value to a Nul terminated string which is copied to str. | |
| * - The maximum length of the copied str is 33 bytes. If radix | |
| * is 10 and value is negative, the value is converted with sign. | |
| * - Does not check if radix is in the range of 2 to 36. | |
| * - If str is NULL it crashes, as the native function does. | |
| */ | |
| char * __cdecl _ltoa( | |
| LONG value, /* [I] Value to be converted */ | |
| char *str, /* [O] Destination for the converted value */ | |
| int radix) /* [I] Number base for conversion */ | |
| { | |
| ULONG val; | |
| int negative; | |
| char buffer[33]; | |
| char *pos; | |
| int digit; | |
| if (value < 0 && radix == 10) { | |
| negative = 1; | |
| val = -value; | |
| } else { | |
| negative = 0; | |
| val = value; | |
| } /* if */ | |
| pos = &buffer[32]; | |
| *pos = '\0'; | |
| do { | |
| digit = val % radix; | |
| val = val / radix; | |
| if (digit < 10) { | |
| *--pos = '0' + digit; | |
| } else { | |
| *--pos = 'a' + digit - 10; | |
| } /* if */ | |
| } while (val != 0L); | |
| if (negative) { | |
| *--pos = '-'; | |
| } /* if */ | |
| memcpy(str, pos, &buffer[32] - pos + 1); | |
| return str; | |
| } | |
| /********************************************************************* | |
| * _itoa (NTDLL.@) | |
| * | |
| * Converts an integer to a string. | |
| * | |
| * RETURNS | |
| * str. | |
| * | |
| * NOTES | |
| * - Converts value to a '\0' terminated string which is copied to str. | |
| * - The maximum length of the copied str is 33 bytes. If radix | |
| * is 10 and value is negative, the value is converted with sign. | |
| * - Does not check if radix is in the range of 2 to 36. | |
| * - If str is NULL it crashes, as the native function does. | |
| */ | |
| char * __cdecl _itoa( | |
| int value, /* [I] Value to be converted */ | |
| char *str, /* [O] Destination for the converted value */ | |
| int radix) /* [I] Number base for conversion */ | |
| { | |
| return _ltoa(value, str, radix); | |
| } | |
| /********************************************************************* | |
| * _ui64toa (NTDLL.@) | |
| * | |
| * Converts a large unsigned integer to a string. | |
| * | |
| * RETURNS | |
| * str. | |
| * | |
| * NOTES | |
| * - Converts value to a '\0' terminated string which is copied to str. | |
| * - The maximum length of the copied str is 65 bytes. | |
| * - Does not check if radix is in the range of 2 to 36. | |
| * - If str is NULL it crashes, as the native function does. | |
| */ | |
| char * __cdecl _ui64toa( | |
| ULONGLONG value, /* [I] Value to be converted */ | |
| char *str, /* [O] Destination for the converted value */ | |
| int radix) /* [I] Number base for conversion */ | |
| { | |
| char buffer[65]; | |
| char *pos; | |
| int digit; | |
| pos = &buffer[64]; | |
| *pos = '\0'; | |
| do { | |
| digit = value % radix; | |
| value = value / radix; | |
| if (digit < 10) { | |
| *--pos = '0' + digit; | |
| } else { | |
| *--pos = 'a' + digit - 10; | |
| } /* if */ | |
| } while (value != 0L); | |
| memcpy(str, pos, &buffer[64] - pos + 1); | |
| return str; | |
| } | |
| /********************************************************************* | |
| * _i64toa (NTDLL.@) | |
| * | |
| * Converts a large integer to a string. | |
| * | |
| * RETURNS | |
| * str. | |
| * | |
| * NOTES | |
| * - Converts value to a Nul terminated string which is copied to str. | |
| * - The maximum length of the copied str is 65 bytes. If radix | |
| * is 10 and value is negative, the value is converted with sign. | |
| * - Does not check if radix is in the range of 2 to 36. | |
| * - If str is NULL it crashes, as the native function does. | |
| * | |
| * DIFFERENCES | |
| * - The native DLL converts negative values (for base 10) wrong: | |
| *| -1 is converted to -18446744073709551615 | |
| *| -2 is converted to -18446744073709551614 | |
| *| -9223372036854775807 is converted to -9223372036854775809 | |
| *| -9223372036854775808 is converted to -9223372036854775808 | |
| * The native msvcrt _i64toa function and our ntdll _i64toa function | |
| * do not have this bug. | |
| */ | |
| char * __cdecl _i64toa( | |
| LONGLONG value, /* [I] Value to be converted */ | |
| char *str, /* [O] Destination for the converted value */ | |
| int radix) /* [I] Number base for conversion */ | |
| { | |
| ULONGLONG val; | |
| int negative; | |
| char buffer[65]; | |
| char *pos; | |
| int digit; | |
| if (value < 0 && radix == 10) { | |
| negative = 1; | |
| val = -value; | |
| } else { | |
| negative = 0; | |
| val = value; | |
| } /* if */ | |
| pos = &buffer[64]; | |
| *pos = '\0'; | |
| do { | |
| digit = val % radix; | |
| val = val / radix; | |
| if (digit < 10) { | |
| *--pos = '0' + digit; | |
| } else { | |
| *--pos = 'a' + digit - 10; | |
| } /* if */ | |
| } while (val != 0L); | |
| if (negative) { | |
| *--pos = '-'; | |
| } /* if */ | |
| memcpy(str, pos, &buffer[64] - pos + 1); | |
| return str; | |
| } | |
| /********************************************************************* | |
| * _atoi64 (NTDLL.@) | |
| * | |
| * Convert a string to a large integer. | |
| * | |
| * PARAMS | |
| * str [I] String to be converted | |
| * | |
| * RETURNS | |
| * Success: The integer value represented by str. | |
| * Failure: 0. Note that this cannot be distinguished from a successful | |
| * return, if the string contains "0". | |
| * | |
| * NOTES | |
| * - Accepts: {whitespace} [+|-] {digits} | |
| * - No check is made for value overflow, only the lower 64 bits are assigned. | |
| * - If str is NULL it crashes, as the native function does. | |
| */ | |
| LONGLONG __cdecl _atoi64( const char *str ) | |
| { | |
| ULONGLONG RunningTotal = 0; | |
| BOOL bMinus = FALSE; | |
| while (*str == ' ' || (*str >= '\011' && *str <= '\015')) { | |
| str++; | |
| } /* while */ | |
| if (*str == '+') { | |
| str++; | |
| } else if (*str == '-') { | |
| bMinus = TRUE; | |
| str++; | |
| } /* if */ | |
| while (*str >= '0' && *str <= '9') { | |
| RunningTotal = RunningTotal * 10 + *str - '0'; | |
| str++; | |
| } /* while */ | |
| return bMinus ? -RunningTotal : RunningTotal; | |
| } | |
| /********************************************************************* | |
| * atoi (NTDLL.@) | |
| */ | |
| int __cdecl NTDLL_atoi( const char *nptr ) | |
| { | |
| return _atoi64( nptr ); | |
| } | |
| /********************************************************************* | |
| * atol (NTDLL.@) | |
| */ | |
| LONG __cdecl NTDLL_atol( const char *nptr ) | |
| { | |
| return _atoi64( nptr ); | |
| } | |
| /* helper function for *scanf. Returns the value of character c in the | |
| * given base, or -1 if the given character is not a digit of the base. | |
| */ | |
| static int char2digit( char c, int base ) | |
| { | |
| if ((c >= '0' && c <= '9') && (c <= '0'+base-1)) return (c-'0'); | |
| if (base <= 10) return -1; | |
| if ((c >= 'A') && (c <= 'Z') && (c <= 'A'+base-11)) return (c-'A'+10); | |
| if ((c >= 'a') && (c <= 'z') && (c <= 'a'+base-11)) return (c-'a'+10); | |
| return -1; | |
| } | |
| static int NTDLL_vsscanf( const char *str, const char *format, __ms_va_list ap) | |
| { | |
| int rd = 0, consumed = 0; | |
| int nch; | |
| if (!*format) return 0; | |
| nch = (consumed++, *str++); | |
| if (nch == '\0') | |
| return EOF; | |
| while (*format) | |
| { | |
| if (isspace( *format )) | |
| { | |
| /* skip whitespace */ | |
| while ((nch != '\0') && isspace( nch )) | |
| nch = (consumed++, *str++); | |
| } | |
| else if (*format == '%') | |
| { | |
| int st = 0; | |
| BOOLEAN suppress = 0; | |
| int width = 0; | |
| int base; | |
| int h_prefix = 0; | |
| BOOLEAN l_prefix = FALSE; | |
| BOOLEAN L_prefix = FALSE; | |
| BOOLEAN w_prefix = FALSE; | |
| BOOLEAN I64_prefix = FALSE; | |
| BOOLEAN prefix_finished = FALSE; | |
| format++; | |
| /* a leading asterisk means 'suppress assignment of this field' */ | |
| if (*format == '*') | |
| { | |
| format++; | |
| suppress = TRUE; | |
| } | |
| /* look for width specification */ | |
| while (isdigit( *format )) | |
| { | |
| width *= 10; | |
| width += *format++ - '0'; | |
| } | |
| if (width == 0) width = -1; /* no width spec seen */ | |
| /* read prefix (if any) */ | |
| while (!prefix_finished) | |
| { | |
| switch (*format) | |
| { | |
| case 'h': h_prefix++; break; | |
| case 'l': | |
| if (*(format+1) == 'l') | |
| { | |
| I64_prefix = TRUE; | |
| format++; | |
| } | |
| l_prefix = TRUE; | |
| break; | |
| case 'w': w_prefix = TRUE; break; | |
| case 'L': L_prefix = TRUE; break; | |
| case 'I': | |
| if (*(format + 1) == '6' && | |
| *(format + 2) == '4') | |
| { | |
| I64_prefix = TRUE; | |
| format += 2; | |
| } | |
| break; | |
| default: | |
| prefix_finished = TRUE; | |
| } | |
| if (!prefix_finished) format++; | |
| } | |
| /* read type */ | |
| switch (*format) | |
| { | |
| case 'p': | |
| case 'P': /* pointer. */ | |
| if (sizeof(void *) == sizeof(LONGLONG)) I64_prefix = TRUE; | |
| /* fall through */ | |
| case 'x': | |
| case 'X': /* hexadecimal integer. */ | |
| base = 16; | |
| goto number; | |
| case 'o': /* octal integer */ | |
| base = 8; | |
| goto number; | |
| case 'u': /* unsigned decimal integer */ | |
| base = 10; | |
| goto number; | |
| case 'd': /* signed decimal integer */ | |
| base = 10; | |
| goto number; | |
| case 'i': /* generic integer */ | |
| base = 0; | |
| number: | |
| { | |
| /* read an integer */ | |
| ULONGLONG cur = 0; | |
| BOOLEAN negative = FALSE; | |
| BOOLEAN seendigit = FALSE; | |
| /* skip initial whitespace */ | |
| while ((nch != '\0') && isspace( nch )) | |
| nch = (consumed++, *str++); | |
| /* get sign */ | |
| if (nch == '-' || nch == '+') | |
| { | |
| negative = (nch == '-'); | |
| nch = (consumed++, *str++); | |
| if (width > 0) width--; | |
| } | |
| /* look for leading indication of base */ | |
| if (width != 0 && nch == '0' && *format != 'p' && *format != 'P') | |
| { | |
| nch = (consumed++, *str++); | |
| if (width > 0) width--; | |
| seendigit = TRUE; | |
| if (width != 0 && (nch == 'x' || nch == 'X')) | |
| { | |
| if (base == 0) | |
| base = 16; | |
| if (base == 16) | |
| { | |
| nch = (consumed++, *str++); | |
| if (width > 0) width--; | |
| seendigit = FALSE; | |
| } | |
| } else if (base == 0) | |
| base = 8; | |
| } | |
| /* format %i without indication of base */ | |
| if (base == 0) | |
| base = 10; | |
| /* throw away leading zeros */ | |
| while (width != 0 && nch == '0') | |
| { | |
| nch = (consumed++, *str++); | |
| if (width > 0) width--; | |
| seendigit = TRUE; | |
| } | |
| if (width != 0 && char2digit( nch, base ) != -1) | |
| { | |
| cur = char2digit( nch, base ); | |
| nch = (consumed++, *str++); | |
| if (width > 0) width--; | |
| seendigit = TRUE; | |
| } | |
| /* read until no more digits */ | |
| while (width != 0 && nch != '\0' && char2digit( nch, base ) != -1) | |
| { | |
| cur = cur*base + char2digit( nch, base ); | |
| nch = (consumed++, *str++); | |
| if (width > 0) width--; | |
| seendigit = TRUE; | |
| } | |
| /* okay, done! */ | |
| if (!seendigit) break; /* not a valid number */ | |
| st = 1; | |
| if (!suppress) | |
| { | |
| #define _SET_NUMBER_( type ) *va_arg( ap, type* ) = negative ? -cur : cur | |
| if (I64_prefix) _SET_NUMBER_( LONGLONG ); | |
| else if (l_prefix) _SET_NUMBER_( LONG ); | |
| else if (h_prefix == 1) _SET_NUMBER_( short int ); | |
| else _SET_NUMBER_( int ); | |
| } | |
| } | |
| break; | |
| case 'e': | |
| case 'E': | |
| case 'f': | |
| case 'g': | |
| case 'G': | |
| { /* read a float */ | |
| long double cur = 1, expcnt = 10; | |
| ULONGLONG d, hlp; | |
| int exp = 0; | |
| BOOLEAN negative = FALSE; | |
| /*unsigned fpcontrol;*/ | |
| BOOLEAN negexp; | |
| /* skip initial whitespace */ | |
| while (nch != '\0' && isspace( nch )) | |
| nch = (consumed++, *str++); | |
| /* get sign */ | |
| if (nch == '-' || nch == '+') | |
| { | |
| negative = (nch == '-'); | |
| if (width > 0) width--; | |
| if (width == 0) break; | |
| nch = (consumed++, *str++); | |
| } | |
| /* get first digit */ | |
| if ('.' != nch) | |
| { | |
| if (!isdigit( nch )) break; | |
| d = nch - '0'; | |
| nch = (consumed++, *str++); | |
| if (width > 0) width--; | |
| /* read until no more digits */ | |
| while (width != 0 && nch != '\0' && isdigit( nch )) | |
| { | |
| hlp = d * 10 + nch - '0'; | |
| nch = (consumed++, *str++); | |
| if (width > 0) width--; | |
| if(d > (ULONGLONG)-1/10 || hlp < d) | |
| { | |
| exp++; | |
| break; | |
| } | |
| else | |
| d = hlp; | |
| } | |
| while (width != 0 && nch != '\0' && isdigit( nch )) | |
| { | |
| exp++; | |
| nch = (consumed++, *str++); | |
| if (width > 0) width--; | |
| } | |
| } | |
| else | |
| d = 0; /* Fix: .8 -> 0.8 */ | |
| /* handle decimals */ | |
| if (width != 0 && nch == '.') | |
| { | |
| nch = (consumed++, *str++); | |
| if (width > 0) width--; | |
| while (width != 0 && nch != '\0' && isdigit( nch )) | |
| { | |
| hlp = d * 10 + nch - '0'; | |
| nch = (consumed++, *str++); | |
| if (width > 0) width--; | |
| if(d > (ULONGLONG)-1/10 || hlp < d) | |
| break; | |
| d = hlp; | |
| exp--; | |
| } | |
| while (width != 0 && nch != '\0' && isdigit( nch )) | |
| { | |
| nch = (consumed++, *str++); | |
| if (width > 0) width--; | |
| } | |
| } | |
| /* handle exponent */ | |
| if (width != 0 && (nch == 'e' || nch == 'E')) | |
| { | |
| int sign = 1, e = 0; | |
| nch = (consumed++, *str++); | |
| if (width > 0) width--; | |
| if (width != 0 && (nch == '+' || nch == '-')) | |
| { | |
| if(nch == '-') | |
| sign = -1; | |
| nch = (consumed++, *str++); | |
| if (width > 0) width--; | |
| } | |
| /* exponent digits */ | |
| while (width != 0 && nch != '\0' && isdigit( nch )) | |
| { | |
| if (e > INT_MAX/10 || (e = e * 10 + nch - '0') < 0) | |
| e = INT_MAX; | |
| nch = (consumed++, *str++); | |
| if (width > 0) width--; | |
| } | |
| e *= sign; | |
| if(exp < 0 && e < 0 && e+exp > 0) exp = INT_MIN; | |
| else if(exp > 0 && e > 0 && e+exp < 0) exp = INT_MAX; | |
| else exp += e; | |
| } | |
| /*fpcontrol = _control87(0, 0); | |
| _control87(MSVCRT__EM_DENORMAL|MSVCRT__EM_INVALID|MSVCRT__EM_ZERODIVIDE | |
| |MSVCRT__EM_OVERFLOW|MSVCRT__EM_UNDERFLOW|MSVCRT__EM_INEXACT, 0xffffffff);*/ | |
| negexp = (exp < 0); | |
| if (negexp) | |
| exp = -exp; | |
| /* update 'cur' with this exponent. */ | |
| while (exp) | |
| { | |
| if(exp & 1) | |
| cur *= expcnt; | |
| exp /= 2; | |
| expcnt = expcnt*expcnt; | |
| } | |
| cur = (negexp ? d/cur : d*cur); | |
| /*_control87(fpcontrol, 0xffffffff);*/ | |
| st = 1; | |
| if (!suppress) | |
| { | |
| if (L_prefix || l_prefix) _SET_NUMBER_( double ); | |
| else _SET_NUMBER_( float ); | |
| } | |
| } | |
| break; | |
| /* According to msdn, | |
| * 's' reads a character string in a call to fscanf | |
| * and 'S' a wide character string and vice versa in a | |
| * call to fwscanf. The 'h', 'w' and 'l' prefixes override | |
| * this behaviour. 'h' forces reading char * but 'l' and 'w' | |
| * force reading WCHAR. */ | |
| case 's': | |
| if (w_prefix || l_prefix) goto widecharstring; | |
| else if (h_prefix) goto charstring; | |
| else goto charstring; | |
| case 'S': | |
| if (w_prefix || l_prefix) goto widecharstring; | |
| else if (h_prefix) goto charstring; | |
| else goto widecharstring; | |
| charstring: | |
| { /* read a word into a char */ | |
| char *sptr = suppress ? NULL : va_arg( ap, char * ); | |
| char *sptr_beg = sptr; | |
| unsigned size = UINT_MAX; | |
| /* skip initial whitespace */ | |
| while (nch != '\0' && isspace( nch )) | |
| nch = (consumed++, *str++); | |
| /* read until whitespace */ | |
| while (width != 0 && nch != '\0' && !isspace( nch )) | |
| { | |
| if (!suppress) | |
| { | |
| *sptr++ = nch; | |
| if(size > 1) size--; | |
| else | |
| { | |
| *sptr_beg = 0; | |
| return rd; | |
| } | |
| } | |
| st++; | |
| nch = (consumed++, *str++); | |
| if (width > 0) width--; | |
| } | |
| /* terminate */ | |
| if (st && !suppress) *sptr = 0; | |
| } | |
| break; | |
| widecharstring: | |
| { /* read a word into a WCHAR * */ | |
| WCHAR *sptr = suppress ? NULL : va_arg( ap, WCHAR * ); | |
| WCHAR *sptr_beg = sptr; | |
| unsigned size = UINT_MAX; | |
| /* skip initial whitespace */ | |
| while (nch != '\0' && isspace( nch )) | |
| nch = (consumed++, *str++); | |
| /* read until whitespace */ | |
| while (width != 0 && nch != '\0' && !isspace( nch )) | |
| { | |
| if (!suppress) | |
| { | |
| *sptr++ = nch; | |
| if (size > 1) size--; | |
| else | |
| { | |
| *sptr_beg = 0; | |
| return rd; | |
| } | |
| } | |
| st++; | |
| nch = (consumed++, *str++); | |
| if (width > 0) width--; | |
| } | |
| /* terminate */ | |
| if (st && !suppress) *sptr = 0; | |
| } | |
| break; | |
| /* 'c' and 'C work analogously to 's' and 'S' as described | |
| * above */ | |
| case 'c': | |
| if (w_prefix || l_prefix) goto widecharacter; | |
| else if (h_prefix) goto character; | |
| else goto character; | |
| case 'C': | |
| if (w_prefix || l_prefix) goto widecharacter; | |
| else if (h_prefix) goto character; | |
| else goto widecharacter; | |
| character: | |
| { /* read single character into char */ | |
| char *str = suppress ? NULL : va_arg( ap, char * ); | |
| char *pstr = str; | |
| unsigned size = UINT_MAX; | |
| if (width == -1) width = 1; | |
| while (width && nch != '\0') | |
| { | |
| if (!suppress) | |
| { | |
| *str++ = nch; | |
| if(size) size--; | |
| else | |
| { | |
| *pstr = 0; | |
| return rd; | |
| } | |
| } | |
| st++; | |
| width--; | |
| nch = (consumed++, *str++); | |
| } | |
| } | |
| break; | |
| widecharacter: | |
| { /* read single character into a WCHAR */ | |
| WCHAR *str = suppress ? NULL : va_arg( ap, WCHAR * ); | |
| WCHAR *pstr = str; | |
| unsigned size = UINT_MAX; | |
| if (width == -1) width = 1; | |
| while (width && nch != '\0') | |
| { | |
| if (!suppress) | |
| { | |
| *str++ = nch; | |
| if (size) size--; | |
| else | |
| { | |
| *pstr = 0; | |
| return rd; | |
| } | |
| } | |
| st++; | |
| width--; | |
| nch = (consumed++, *str++); | |
| } | |
| } | |
| break; | |
| case 'n': | |
| { | |
| if (!suppress) | |
| { | |
| int *n = va_arg( ap, int * ); | |
| *n = consumed - 1; | |
| } | |
| /* This is an odd one: according to the standard, | |
| * "Execution of a %n directive does not increment the | |
| * assignment count returned at the completion of | |
| * execution" even if it wasn't suppressed with the | |
| * '*' flag. The Corrigendum to the standard seems | |
| * to contradict this (comment out the assignment to | |
| * suppress below if you want to implement these | |
| * alternate semantics) but the windows program I'm | |
| * looking at expects the behavior I've coded here | |
| * (which happens to be what glibc does as well). | |
| */ | |
| suppress = TRUE; | |
| st = 1; | |
| } | |
| break; | |
| case '[': | |
| { | |
| char *str = suppress ? NULL : va_arg( ap, char * ); | |
| char *sptr = str; | |
| RTL_BITMAP bitMask; | |
| ULONG Mask[8]; | |
| BOOLEAN invert = FALSE; /* Set if we are NOT to find the chars */ | |
| unsigned size = UINT_MAX; | |
| RtlInitializeBitMap( &bitMask, Mask, sizeof(Mask) * 8 ); | |
| /* Read the format */ | |
| format++; | |
| if (*format == '^') | |
| { | |
| invert = TRUE; | |
| format++; | |
| } | |
| if (*format == ']') | |
| { | |
| RtlSetBits( &bitMask, ']', 1 ); | |
| format++; | |
| } | |
| while (*format && (*format != ']')) | |
| { | |
| /* According to msdn: | |
| * "Note that %[a-z] and %[z-a] are interpreted as equivalent to %[abcde...z]." */ | |
| if ((*format == '-') && (*(format + 1) != ']')) | |
| { | |
| if ((*(format - 1)) < *(format + 1)) | |
| RtlSetBits( &bitMask, *(format - 1) +1 , *(format + 1) - *(format - 1) ); | |
| else | |
| RtlSetBits( &bitMask, *(format + 1) , *(format - 1) - *(format + 1) ); | |
| format++; | |
| } | |
| else | |
| RtlSetBits( &bitMask, *format, 1 ); | |
| format++; | |
| } | |
| /* read until char is not suitable */ | |
| while (width != 0 && nch != '\0') | |
| { | |
| if (!invert) | |
| { | |
| if(RtlAreBitsSet( &bitMask, nch, 1 )) | |
| { | |
| if (!suppress) *sptr++ = nch; | |
| } | |
| else | |
| break; | |
| } | |
| else | |
| { | |
| if (RtlAreBitsClear( &bitMask, nch, 1 )) | |
| { | |
| if (!suppress) *sptr++ = nch; | |
| } | |
| else | |
| break; | |
| } | |
| st++; | |
| nch = (consumed++, *str++); | |
| if (width > 0) width--; | |
| if(size > 1) size--; | |
| else | |
| { | |
| *str = 0; | |
| return rd; | |
| } | |
| } | |
| /* terminate */ | |
| if (!suppress) *sptr = 0; | |
| } | |
| break; | |
| default: | |
| /* From spec: "if a percent sign is followed by a character | |
| * that has no meaning as a format-control character, that | |
| * character and the following characters are treated as | |
| * an ordinary sequence of characters, that is, a sequence | |
| * of characters that must match the input. For example, | |
| * to specify that a percent-sign character is to be input, | |
| * use %%." */ | |
| while (nch != '\0' && isspace( nch )) | |
| nch = (consumed++, *str++); | |
| if (nch == *format) | |
| { | |
| suppress = TRUE; /* whoops no field to be read */ | |
| st = 1; /* but we got what we expected */ | |
| nch = (consumed++, *str++); | |
| } | |
| break; | |
| } | |
| if (st && !suppress) rd++; | |
| else if (!st) break; | |
| } | |
| /* A non-white-space character causes scanf to read, but not store, | |
| * a matching non-white-space character. */ | |
| else | |
| { | |
| if (nch == *format) | |
| nch = (consumed++, *str++); | |
| else break; | |
| } | |
| format++; | |
| } | |
| if (nch != '\0') | |
| { | |
| consumed--, str--; | |
| } | |
| return rd; | |
| } | |
| /********************************************************************* | |
| * sscanf (NTDLL.@) | |
| */ | |
| int __cdecl NTDLL_sscanf( const char *str, const char *format, ... ) | |
| { | |
| int ret; | |
| __ms_va_list valist; | |
| __ms_va_start( valist, format ); | |
| ret = NTDLL_vsscanf( str, format, valist ); | |
| __ms_va_end( valist ); | |
| return ret; | |
| } | |
| /********************************************************************* | |
| * _splitpath (NTDLL.@) | |
| * | |
| * Split a path into its component pieces. | |
| * | |
| * PARAMS | |
| * inpath [I] Path to split | |
| * drv [O] Destination for drive component (e.g. "A:"). Must be at least 3 characters. | |
| * dir [O] Destination for directory component. Should be at least MAX_PATH characters. | |
| * fname [O] Destination for File name component. Should be at least MAX_PATH characters. | |
| * ext [O] Destination for file extension component. Should be at least MAX_PATH characters. | |
| * | |
| * RETURNS | |
| * Nothing. | |
| */ | |
| void __cdecl _splitpath(const char* inpath, char * drv, char * dir, | |
| char* fname, char * ext ) | |
| { | |
| const char *p, *end; | |
| if (inpath[0] && inpath[1] == ':') | |
| { | |
| if (drv) | |
| { | |
| drv[0] = inpath[0]; | |
| drv[1] = inpath[1]; | |
| drv[2] = 0; | |
| } | |
| inpath += 2; | |
| } | |
| else if (drv) drv[0] = 0; | |
| /* look for end of directory part */ | |
| end = NULL; | |
| for (p = inpath; *p; p++) if (*p == '/' || *p == '\\') end = p + 1; | |
| if (end) /* got a directory */ | |
| { | |
| if (dir) | |
| { | |
| memcpy( dir, inpath, end - inpath ); | |
| dir[end - inpath] = 0; | |
| } | |
| inpath = end; | |
| } | |
| else if (dir) dir[0] = 0; | |
| /* look for extension: what's after the last dot */ | |
| end = NULL; | |
| for (p = inpath; *p; p++) if (*p == '.') end = p; | |
| if (!end) end = p; /* there's no extension */ | |
| if (fname) | |
| { | |
| memcpy( fname, inpath, end - inpath ); | |
| fname[end - inpath] = 0; | |
| } | |
| if (ext) strcpy( ext, end ); | |
| } |