| /* |
| * 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 ); |
| } |