| /* |
| * Unicode string manipulation functions |
| * |
| * Copyright 2000 Alexandre Julliard |
| * |
| * 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 <limits.h> |
| #include <stdio.h> |
| |
| #include "wine/unicode.h" |
| |
| extern const WCHAR wine_casemap_lower[]; |
| extern const WCHAR wine_casemap_upper[]; |
| extern const unsigned short wine_wctype_table[]; |
| |
| int wine_is_dbcs_leadbyte( const union cptable *table, unsigned char ch ) |
| { |
| return (table->info.char_size == 2) && (table->dbcs.cp2uni_leadbytes[ch]); |
| } |
| |
| WCHAR tolowerW( WCHAR ch ) |
| { |
| return ch + wine_casemap_lower[wine_casemap_lower[ch >> 8] + (ch & 0xff)]; |
| } |
| |
| WCHAR toupperW( WCHAR ch ) |
| { |
| return ch + wine_casemap_upper[wine_casemap_upper[ch >> 8] + (ch & 0xff)]; |
| } |
| |
| /* the character type contains the C1_* flags in the low 12 bits */ |
| /* and the C2_* type in the high 4 bits */ |
| unsigned short get_char_typeW( WCHAR ch ) |
| { |
| return wine_wctype_table[wine_wctype_table[ch >> 8] + (ch & 0xff)]; |
| } |
| |
| int iscntrlW( WCHAR wc ) |
| { |
| return get_char_typeW(wc) & C1_CNTRL; |
| } |
| |
| int ispunctW( WCHAR wc ) |
| { |
| return get_char_typeW(wc) & C1_PUNCT; |
| } |
| |
| int isspaceW( WCHAR wc ) |
| { |
| return get_char_typeW(wc) & C1_SPACE; |
| } |
| |
| int isdigitW( WCHAR wc ) |
| { |
| return get_char_typeW(wc) & C1_DIGIT; |
| } |
| |
| int isxdigitW( WCHAR wc ) |
| { |
| return get_char_typeW(wc) & C1_XDIGIT; |
| } |
| |
| int islowerW( WCHAR wc ) |
| { |
| return get_char_typeW(wc) & C1_LOWER; |
| } |
| |
| int isupperW( WCHAR wc ) |
| { |
| return get_char_typeW(wc) & C1_UPPER; |
| } |
| |
| int isalnumW( WCHAR wc ) |
| { |
| return get_char_typeW(wc) & (C1_ALPHA|C1_DIGIT|C1_LOWER|C1_UPPER); |
| } |
| |
| int isalphaW( WCHAR wc ) |
| { |
| return get_char_typeW(wc) & (C1_ALPHA|C1_LOWER|C1_UPPER); |
| } |
| |
| int isgraphW( WCHAR wc ) |
| { |
| return get_char_typeW(wc) & (C1_ALPHA|C1_PUNCT|C1_DIGIT|C1_LOWER|C1_UPPER); |
| } |
| |
| int isprintW( WCHAR wc ) |
| { |
| return get_char_typeW(wc) & (C1_ALPHA|C1_BLANK|C1_PUNCT|C1_DIGIT|C1_LOWER|C1_UPPER); |
| } |
| |
| unsigned int strlenW( const WCHAR *str ) |
| { |
| const WCHAR *s = str; |
| while (*s) s++; |
| return s - str; |
| } |
| |
| WCHAR *strcpyW( WCHAR *dst, const WCHAR *src ) |
| { |
| WCHAR *p = dst; |
| while ((*p++ = *src++)); |
| return dst; |
| } |
| |
| int strcmpW( const WCHAR *str1, const WCHAR *str2 ) |
| { |
| while (*str1 && (*str1 == *str2)) { str1++; str2++; } |
| return *str1 - *str2; |
| } |
| |
| int strncmpW( const WCHAR *str1, const WCHAR *str2, int n ) |
| { |
| if (n <= 0) return 0; |
| while ((--n > 0) && *str1 && (*str1 == *str2)) { str1++; str2++; } |
| return *str1 - *str2; |
| } |
| |
| WCHAR *strcatW( WCHAR *dst, const WCHAR *src ) |
| { |
| strcpyW( dst + strlenW(dst), src ); |
| return dst; |
| } |
| |
| WCHAR *strchrW( const WCHAR *str, WCHAR ch ) |
| { |
| do { if (*str == ch) return (WCHAR *)str; } while (*str++); |
| return NULL; |
| } |
| |
| WCHAR *strrchrW( const WCHAR *str, WCHAR ch ) |
| { |
| WCHAR *ret = NULL; |
| do { if (*str == ch) ret = (WCHAR *)str; } while (*str++); |
| return ret; |
| } |
| |
| WCHAR *strpbrkW( const WCHAR *str, const WCHAR *accept ) |
| { |
| for ( ; *str; str++) if (strchrW( accept, *str )) return (WCHAR *)str; |
| return NULL; |
| } |
| |
| size_t strspnW( const WCHAR *str, const WCHAR *accept ) |
| { |
| const WCHAR *ptr; |
| for (ptr = str; *ptr; ptr++) if (!strchrW( accept, *ptr )) break; |
| return ptr - str; |
| } |
| |
| size_t strcspnW( const WCHAR *str, const WCHAR *reject ) |
| { |
| const WCHAR *ptr; |
| for (ptr = str; *ptr; ptr++) if (strchrW( reject, *ptr )) break; |
| return ptr - str; |
| } |
| |
| WCHAR *strlwrW( WCHAR *str ) |
| { |
| WCHAR *ret = str; |
| while ((*str = tolowerW(*str))) str++; |
| return ret; |
| } |
| |
| WCHAR *struprW( WCHAR *str ) |
| { |
| WCHAR *ret = str; |
| while ((*str = toupperW(*str))) str++; |
| return ret; |
| } |
| |
| WCHAR *memchrW( const WCHAR *ptr, WCHAR ch, size_t n ) |
| { |
| const WCHAR *end; |
| for (end = ptr + n; ptr < end; ptr++) if (*ptr == ch) return (WCHAR *)ptr; |
| return NULL; |
| } |
| |
| WCHAR *memrchrW( const WCHAR *ptr, WCHAR ch, size_t n ) |
| { |
| const WCHAR *end, *ret = NULL; |
| for (end = ptr + n; ptr < end; ptr++) if (*ptr == ch) ret = ptr; |
| return (WCHAR *)ret; |
| } |
| |
| long int atolW( const WCHAR *str ) |
| { |
| return strtolW( str, (WCHAR **)0, 10 ); |
| } |
| |
| int atoiW( const WCHAR *str ) |
| { |
| return (int)atolW( str ); |
| } |
| |
| int strcmpiW( const WCHAR *str1, const WCHAR *str2 ) |
| { |
| for (;;) |
| { |
| int ret = tolowerW(*str1) - tolowerW(*str2); |
| if (ret || !*str1) return ret; |
| str1++; |
| str2++; |
| } |
| } |
| |
| int strncmpiW( const WCHAR *str1, const WCHAR *str2, int n ) |
| { |
| int ret = 0; |
| for ( ; n > 0; n--, str1++, str2++) |
| if ((ret = tolowerW(*str1) - tolowerW(*str2)) || !*str1) break; |
| return ret; |
| } |
| |
| int memicmpW( const WCHAR *str1, const WCHAR *str2, int n ) |
| { |
| int ret = 0; |
| for ( ; n > 0; n--, str1++, str2++) |
| if ((ret = tolowerW(*str1) - tolowerW(*str2))) break; |
| return ret; |
| } |
| |
| WCHAR *strstrW( const WCHAR *str, const WCHAR *sub ) |
| { |
| while (*str) |
| { |
| const WCHAR *p1 = str, *p2 = sub; |
| while (*p1 && *p2 && *p1 == *p2) { p1++; p2++; } |
| if (!*p2) return (WCHAR *)str; |
| str++; |
| } |
| return NULL; |
| } |
| |
| /* strtolW and strtoulW implementation based on the GNU C library code */ |
| /* Copyright (C) 1991,92,94,95,96,97,98,99,2000,2001 Free Software Foundation, Inc. */ |
| |
| long int strtolW( const WCHAR *nptr, WCHAR **endptr, int base ) |
| { |
| int negative; |
| register unsigned long int cutoff; |
| register unsigned int cutlim; |
| register unsigned long int i; |
| register const WCHAR *s; |
| register WCHAR c; |
| const WCHAR *save, *end; |
| int overflow; |
| |
| if (base < 0 || base == 1 || base > 36) return 0; |
| |
| save = s = nptr; |
| |
| /* Skip white space. */ |
| while (isspaceW (*s)) |
| ++s; |
| if (!*s) goto noconv; |
| |
| /* Check for a sign. */ |
| negative = 0; |
| if (*s == '-') |
| { |
| negative = 1; |
| ++s; |
| } |
| else if (*s == '+') |
| ++s; |
| |
| /* Recognize number prefix and if BASE is zero, figure it out ourselves. */ |
| if (*s == '0') |
| { |
| if ((base == 0 || base == 16) && toupperW(s[1]) == 'X') |
| { |
| s += 2; |
| base = 16; |
| } |
| else if (base == 0) |
| base = 8; |
| } |
| else if (base == 0) |
| base = 10; |
| |
| /* Save the pointer so we can check later if anything happened. */ |
| save = s; |
| end = NULL; |
| |
| cutoff = ULONG_MAX / (unsigned long int) base; |
| cutlim = ULONG_MAX % (unsigned long int) base; |
| |
| overflow = 0; |
| i = 0; |
| c = *s; |
| for (;c != '\0'; c = *++s) |
| { |
| if (s == end) |
| break; |
| if (c >= '0' && c <= '9') |
| c -= '0'; |
| else if (isalphaW (c)) |
| c = toupperW (c) - 'A' + 10; |
| else |
| break; |
| if ((int) c >= base) |
| break; |
| /* Check for overflow. */ |
| if (i > cutoff || (i == cutoff && c > cutlim)) |
| overflow = 1; |
| else |
| { |
| i *= (unsigned long int) base; |
| i += c; |
| } |
| } |
| |
| /* Check if anything actually happened. */ |
| if (s == save) |
| goto noconv; |
| |
| /* Store in ENDPTR the address of one character |
| past the last character we converted. */ |
| if (endptr != NULL) |
| *endptr = (WCHAR *)s; |
| |
| /* Check for a value that is within the range of |
| `unsigned LONG int', but outside the range of `LONG int'. */ |
| if (overflow == 0 |
| && i > (negative |
| ? -((unsigned long int) (LONG_MIN + 1)) + 1 |
| : (unsigned long int) LONG_MAX)) |
| overflow = 1; |
| |
| if (overflow) |
| { |
| return negative ? LONG_MIN : LONG_MAX; |
| } |
| |
| /* Return the result of the appropriate sign. */ |
| return negative ? -i : i; |
| |
| noconv: |
| /* We must handle a special case here: the base is 0 or 16 and the |
| first two characters are '0' and 'x', but the rest are not |
| hexadecimal digits. This is no error case. We return 0 and |
| ENDPTR points to the `x`. */ |
| if (endptr != NULL) |
| { |
| if (save - nptr >= 2 && toupperW (save[-1]) == 'X' |
| && save[-2] == '0') |
| *endptr = (WCHAR *)&save[-1]; |
| else |
| /* There was no number to convert. */ |
| *endptr = (WCHAR *)nptr; |
| } |
| |
| return 0L; |
| } |
| |
| |
| unsigned long int strtoulW( const WCHAR *nptr, WCHAR **endptr, int base ) |
| { |
| int negative; |
| register unsigned long int cutoff; |
| register unsigned int cutlim; |
| register unsigned long int i; |
| register const WCHAR *s; |
| register WCHAR c; |
| const WCHAR *save, *end; |
| int overflow; |
| |
| if (base < 0 || base == 1 || base > 36) return 0; |
| |
| save = s = nptr; |
| |
| /* Skip white space. */ |
| while (isspaceW (*s)) |
| ++s; |
| if (!*s) goto noconv; |
| |
| /* Check for a sign. */ |
| negative = 0; |
| if (*s == '-') |
| { |
| negative = 1; |
| ++s; |
| } |
| else if (*s == '+') |
| ++s; |
| |
| /* Recognize number prefix and if BASE is zero, figure it out ourselves. */ |
| if (*s == '0') |
| { |
| if ((base == 0 || base == 16) && toupperW(s[1]) == 'X') |
| { |
| s += 2; |
| base = 16; |
| } |
| else if (base == 0) |
| base = 8; |
| } |
| else if (base == 0) |
| base = 10; |
| |
| /* Save the pointer so we can check later if anything happened. */ |
| save = s; |
| end = NULL; |
| |
| cutoff = ULONG_MAX / (unsigned long int) base; |
| cutlim = ULONG_MAX % (unsigned long int) base; |
| |
| overflow = 0; |
| i = 0; |
| c = *s; |
| for (;c != '\0'; c = *++s) |
| { |
| if (s == end) |
| break; |
| if (c >= '0' && c <= '9') |
| c -= '0'; |
| else if (isalphaW (c)) |
| c = toupperW (c) - 'A' + 10; |
| else |
| break; |
| if ((int) c >= base) |
| break; |
| /* Check for overflow. */ |
| if (i > cutoff || (i == cutoff && c > cutlim)) |
| overflow = 1; |
| else |
| { |
| i *= (unsigned long int) base; |
| i += c; |
| } |
| } |
| |
| /* Check if anything actually happened. */ |
| if (s == save) |
| goto noconv; |
| |
| /* Store in ENDPTR the address of one character |
| past the last character we converted. */ |
| if (endptr != NULL) |
| *endptr = (WCHAR *)s; |
| |
| if (overflow) |
| { |
| return ULONG_MAX; |
| } |
| |
| /* Return the result of the appropriate sign. */ |
| return negative ? -i : i; |
| |
| noconv: |
| /* We must handle a special case here: the base is 0 or 16 and the |
| first two characters are '0' and 'x', but the rest are not |
| hexadecimal digits. This is no error case. We return 0 and |
| ENDPTR points to the `x`. */ |
| if (endptr != NULL) |
| { |
| if (save - nptr >= 2 && toupperW (save[-1]) == 'X' |
| && save[-2] == '0') |
| *endptr = (WCHAR *)&save[-1]; |
| else |
| /* There was no number to convert. */ |
| *endptr = (WCHAR *)nptr; |
| } |
| |
| return 0L; |
| } |
| |
| |
| int vsnprintfW(WCHAR *str, size_t len, const WCHAR *format, va_list valist) |
| { |
| unsigned int written = 0; |
| const WCHAR *iter = format; |
| char bufa[256], fmtbufa[64], *fmta; |
| |
| while (*iter) |
| { |
| while (*iter && *iter != '%') |
| { |
| if (written++ >= len) |
| return -1; |
| *str++ = *iter++; |
| } |
| if (*iter == '%') |
| { |
| if (iter[1] == '%') |
| { |
| if (written++ >= len) |
| return -1; |
| *str++ = '%'; /* "%%"->'%' */ |
| iter += 2; |
| continue; |
| } |
| |
| fmta = fmtbufa; |
| *fmta++ = *iter++; |
| while (*iter == '0' || |
| *iter == '+' || |
| *iter == '-' || |
| *iter == ' ' || |
| *iter == '*' || |
| *iter == '#') |
| { |
| if (*iter == '*') |
| { |
| char *buffiter = bufa; |
| int fieldlen = va_arg(valist, int); |
| sprintf(buffiter, "%d", fieldlen); |
| while (*buffiter) |
| *fmta++ = *buffiter++; |
| } |
| else |
| *fmta++ = *iter; |
| iter++; |
| } |
| |
| while (isdigit(*iter)) |
| *fmta++ = *iter++; |
| |
| if (*iter == '.') |
| { |
| *fmta++ = *iter++; |
| if (*iter == '*') |
| { |
| char *buffiter = bufa; |
| int fieldlen = va_arg(valist, int); |
| sprintf(buffiter, "%d", fieldlen); |
| while (*buffiter) |
| *fmta++ = *buffiter++; |
| } |
| else |
| while (isdigit(*iter)) |
| *fmta++ = *iter++; |
| } |
| if (*iter == 'h' || *iter == 'l') |
| *fmta++ = *iter++; |
| |
| switch (*iter) |
| { |
| case 's': |
| { |
| static const WCHAR none[] = { '(','n','u','l','l',')',0 }; |
| const WCHAR *wstr = va_arg(valist, const WCHAR *); |
| const WCHAR *striter = wstr ? wstr : none; |
| while (*striter) |
| { |
| if (written++ >= len) |
| return -1; |
| *str++ = *striter++; |
| } |
| iter++; |
| break; |
| } |
| |
| case 'c': |
| if (written++ >= len) |
| return -1; |
| *str++ = (WCHAR)va_arg(valist, int); |
| iter++; |
| break; |
| |
| default: |
| { |
| /* For non wc types, use system sprintf and append to wide char output */ |
| /* FIXME: for unrecognised types, should ignore % when printing */ |
| char *bufaiter = bufa; |
| if (*iter == 'p') |
| sprintf(bufaiter, "%08lX", va_arg(valist, long)); |
| else |
| { |
| *fmta++ = *iter; |
| *fmta = '\0'; |
| if (*iter == 'a' || *iter == 'A' || |
| *iter == 'e' || *iter == 'E' || |
| *iter == 'f' || *iter == 'F' || |
| *iter == 'g' || *iter == 'G') |
| sprintf(bufaiter, fmtbufa, va_arg(valist, double)); |
| else |
| { |
| /* FIXME: On 32 bit systems this doesn't handle int 64's. |
| * on 64 bit systems this doesn't work for 32 bit types |
| */ |
| sprintf(bufaiter, fmtbufa, va_arg(valist, void *)); |
| } |
| } |
| while (*bufaiter) |
| { |
| if (written++ >= len) |
| return -1; |
| *str++ = *bufaiter++; |
| } |
| iter++; |
| break; |
| } |
| } |
| } |
| } |
| if (written >= len) |
| return -1; |
| *str++ = 0; |
| return (int)written; |
| } |
| |
| int vsprintfW( WCHAR *str, const WCHAR *format, va_list valist ) |
| { |
| return vsnprintfW( str, INT_MAX, format, valist ); |
| } |
| |
| int snprintfW( WCHAR *str, size_t len, const WCHAR *format, ...) |
| { |
| int retval; |
| va_list valist; |
| va_start(valist, format); |
| retval = vsnprintfW(str, len, format, valist); |
| va_end(valist); |
| return retval; |
| } |
| |
| int sprintfW( WCHAR *str, const WCHAR *format, ...) |
| { |
| int retval; |
| va_list valist; |
| va_start(valist, format); |
| retval = vsnprintfW(str, INT_MAX, format, valist); |
| va_end(valist); |
| return retval; |
| } |
