2 * NTDLL wide-char functions
4 * Copyright 2000 Alexandre Julliard
5 * Copyright 2000 Jon Griffiths
6 * Copyright 2003 Thomas Mertes
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
33 #include "ntdll_misc.h"
35 static const unsigned short wctypes
[256] =
38 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
39 0x0020, 0x0068, 0x0028, 0x0028, 0x0028, 0x0028, 0x0020, 0x0020,
41 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
42 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
44 0x0048, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
45 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
47 0x0084, 0x0084, 0x0084, 0x0084, 0x0084, 0x0084, 0x0084, 0x0084,
48 0x0084, 0x0084, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
50 0x0010, 0x0181, 0x0181, 0x0181, 0x0181, 0x0181, 0x0181, 0x0101,
51 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
53 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
54 0x0101, 0x0101, 0x0101, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
56 0x0010, 0x0182, 0x0182, 0x0182, 0x0182, 0x0182, 0x0182, 0x0102,
57 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102,
59 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102,
60 0x0102, 0x0102, 0x0102, 0x0010, 0x0010, 0x0010, 0x0010, 0x0020,
62 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
63 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
65 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
66 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
68 0x0048, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
69 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
71 0x0010, 0x0010, 0x0014, 0x0014, 0x0010, 0x0010, 0x0010, 0x0010,
72 0x0010, 0x0014, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
74 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
75 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
77 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0010,
78 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0102,
80 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102,
81 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102,
83 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0010,
84 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102
88 /*********************************************************************
91 int __cdecl
_wcsicmp( LPCWSTR str1
, LPCWSTR str2
)
95 WCHAR ch1
= (*str1
>= 'A' && *str1
<= 'Z') ? *str1
+ 32 : *str1
;
96 WCHAR ch2
= (*str2
>= 'A' && *str2
<= 'Z') ? *str2
+ 32 : *str2
;
97 if (ch1
!= ch2
|| !*str1
) return ch1
- ch2
;
104 /*********************************************************************
107 LPWSTR __cdecl
_wcslwr( LPWSTR str
)
114 if (ch
>= 'A' && ch
<= 'Z') ch
+= 32;
121 /*********************************************************************
122 * _wcsnicmp (NTDLL.@)
124 int __cdecl
_wcsnicmp( LPCWSTR str1
, LPCWSTR str2
, size_t n
)
127 for ( ; n
> 0; n
--, str1
++, str2
++)
129 WCHAR ch1
= (*str1
>= 'A' && *str1
<= 'Z') ? *str1
+ 32 : *str1
;
130 WCHAR ch2
= (*str2
>= 'A' && *str2
<= 'Z') ? *str2
+ 32 : *str2
;
131 if ((ret
= ch1
- ch2
) || !*str1
) break;
137 /*********************************************************************
140 LPWSTR __cdecl
_wcsupr( LPWSTR str
)
147 if (ch
>= 'a' && ch
<= 'z') ch
-= 32;
154 /***********************************************************************
157 LPWSTR __cdecl
wcscpy( LPWSTR dst
, LPCWSTR src
)
160 while ((*p
++ = *src
++));
165 /***********************************************************************
168 size_t __cdecl
wcslen( LPCWSTR str
)
170 const WCHAR
*s
= str
;
176 /***********************************************************************
179 LPWSTR __cdecl
wcscat( LPWSTR dst
, LPCWSTR src
)
181 wcscpy( dst
+ wcslen(dst
), src
);
186 /*********************************************************************
189 LPWSTR __cdecl
wcschr( LPCWSTR str
, WCHAR ch
)
191 do { if (*str
== ch
) return (WCHAR
*)(ULONG_PTR
)str
; } while (*str
++);
196 /*********************************************************************
199 int __cdecl
wcscmp( LPCWSTR str1
, LPCWSTR str2
)
201 while (*str1
&& (*str1
== *str2
)) { str1
++; str2
++; }
202 return *str1
- *str2
;
206 /*********************************************************************
209 size_t __cdecl
wcscspn( LPCWSTR str
, LPCWSTR reject
)
212 for (ptr
= str
; *ptr
; ptr
++) if (wcschr( reject
, *ptr
)) break;
217 /*********************************************************************
220 LPWSTR __cdecl
wcsncat( LPWSTR s1
, LPCWSTR s2
, size_t n
)
224 while (n
-- > 0) if (!(*s1
++ = *s2
++)) return ret
;
230 /*********************************************************************
233 int __cdecl
wcsncmp( LPCWSTR str1
, LPCWSTR str2
, size_t n
)
235 if (n
<= 0) return 0;
236 while ((--n
> 0) && *str1
&& (*str1
== *str2
)) { str1
++; str2
++; }
237 return *str1
- *str2
;
241 /*********************************************************************
245 LPWSTR __cdecl
wcsncpy( LPWSTR s1
, LPCWSTR s2
, size_t n
)
248 for ( ; n
; n
--) if (!(*s1
++ = *s2
++)) break;
249 for ( ; n
; n
--) *s1
++ = 0;
254 /*********************************************************************
257 LPWSTR __cdecl
wcspbrk( LPCWSTR str
, LPCWSTR accept
)
259 for ( ; *str
; str
++) if (wcschr( accept
, *str
)) return (WCHAR
*)(ULONG_PTR
)str
;
264 /*********************************************************************
267 LPWSTR __cdecl
wcsrchr( LPCWSTR str
, WCHAR ch
)
270 do { if (*str
== ch
) ret
= (WCHAR
*)(ULONG_PTR
)str
; } while (*str
++);
275 /*********************************************************************
278 size_t __cdecl
wcsspn( LPCWSTR str
, LPCWSTR accept
)
281 for (ptr
= str
; *ptr
; ptr
++) if (!wcschr( accept
, *ptr
)) break;
286 /*********************************************************************
289 LPWSTR __cdecl
wcsstr( LPCWSTR str
, LPCWSTR sub
)
293 const WCHAR
*p1
= str
, *p2
= sub
;
294 while (*p1
&& *p2
&& *p1
== *p2
) { p1
++; p2
++; }
295 if (!*p2
) return (WCHAR
*)str
;
302 /*********************************************************************
305 LPWSTR __cdecl
wcstok( LPWSTR str
, LPCWSTR delim
)
307 static LPWSTR next
= NULL
;
311 if (!(str
= next
)) return NULL
;
313 while (*str
&& wcschr( delim
, *str
)) str
++;
314 if (!*str
) return NULL
;
316 while (*str
&& !wcschr( delim
, *str
)) str
++;
317 if (*str
) *str
++ = 0;
323 /*********************************************************************
326 size_t __cdecl
wcstombs( char *dst
, const WCHAR
*src
, size_t n
)
332 RtlUnicodeToMultiByteSize( &len
, src
, wcslen(src
) * sizeof(WCHAR
) );
337 if (n
<= 0) return 0;
338 RtlUnicodeToMultiByteN( dst
, n
, &len
, src
, wcslen(src
) * sizeof(WCHAR
) );
339 if (len
< n
) dst
[len
] = 0;
345 /*********************************************************************
348 size_t __cdecl
mbstowcs( WCHAR
*dst
, const char *src
, size_t n
)
354 RtlMultiByteToUnicodeSize( &len
, src
, strlen(src
) );
358 if (n
<= 0) return 0;
359 RtlMultiByteToUnicodeN( dst
, n
*sizeof(WCHAR
), &len
, src
, strlen(src
) );
360 if (len
/ sizeof(WCHAR
) < n
) dst
[len
/ sizeof(WCHAR
)] = 0;
362 return len
/ sizeof(WCHAR
);
366 /*********************************************************************
369 INT __cdecl
iswctype( WCHAR wc
, unsigned short type
)
371 if (wc
>= 256) return 0;
372 return wctypes
[wc
] & type
;
376 /*********************************************************************
379 INT __cdecl
iswalpha( WCHAR wc
)
381 if (wc
>= 256) return 0;
382 return wctypes
[wc
] & (C1_ALPHA
| C1_UPPER
| C1_LOWER
);
386 /*********************************************************************
389 * Checks if a unicode char wc is a digit
392 * TRUE: The unicode char wc is a digit.
395 INT __cdecl
iswdigit( WCHAR wc
)
397 if (wc
>= 256) return 0;
398 return wctypes
[wc
] & C1_DIGIT
;
402 /*********************************************************************
405 * Checks if a unicode char wc is a lower case letter
408 * TRUE: The unicode char wc is a lower case letter.
411 INT __cdecl
iswlower( WCHAR wc
)
413 if (wc
>= 256) return 0;
414 return wctypes
[wc
] & C1_LOWER
;
418 /*********************************************************************
421 * Checks if a unicode char wc is a white space character
424 * TRUE: The unicode char wc is a white space character.
427 INT __cdecl
iswspace( WCHAR wc
)
429 if (wc
>= 256) return 0;
430 return wctypes
[wc
] & C1_SPACE
;
434 /*********************************************************************
435 * iswxdigit (NTDLL.@)
437 * Checks if a unicode char wc is an extended digit
440 * TRUE: The unicode char wc is an extended digit.
443 INT __cdecl
iswxdigit( WCHAR wc
)
445 if (wc
>= 256) return 0;
446 return wctypes
[wc
] & C1_XDIGIT
;
450 static int wctoint( WCHAR c
)
452 /* NOTE: MAP_FOLDDIGITS supports too many things. */
453 /* Unicode points that contain digits 0-9; keep this sorted! */
454 static const WCHAR zeros
[] =
456 0x0660, 0x06f0, 0x0966, 0x09e6, 0x0a66, 0x0ae6, 0x0b66, 0x0c66, 0x0ce6,
457 0x0d66, 0x0e50, 0x0ed0, 0x0f20, 0x1040, 0x17e0, 0x1810, 0xff10
461 if ('0' <= c
&& c
<= '9') return c
- '0';
462 if ('A' <= c
&& c
<= 'Z') return c
- 'A' + 10;
463 if ('a' <= c
&& c
<= 'z') return c
- 'a' + 10;
464 for (i
= 0; i
< ARRAY_SIZE(zeros
) && c
>= zeros
[i
]; i
++)
465 if (zeros
[i
] <= c
&& c
<= zeros
[i
] + 9) return c
- zeros
[i
];
470 /*********************************************************************
473 __msvcrt_long __cdecl
wcstol(LPCWSTR s
, LPWSTR
*end
, INT base
)
475 BOOL negative
= FALSE
, empty
= TRUE
;
478 if (base
< 0 || base
== 1 || base
> 36) return 0;
479 if (end
) *end
= (WCHAR
*)s
;
480 while (iswspace(*s
)) s
++;
487 else if (*s
== '+') s
++;
489 if ((base
== 0 || base
== 16) && !wctoint( *s
) && (s
[1] == 'x' || s
[1] == 'X'))
494 if (base
== 0) base
= wctoint( *s
) ? 10 : 8;
498 int v
= wctoint( *s
);
499 if (v
< 0 || v
>= base
) break;
500 if (negative
) v
= -v
;
504 if (!negative
&& (ret
> MAXLONG
/ base
|| ret
* base
> MAXLONG
- v
))
506 else if (negative
&& (ret
< (LONG
)MINLONG
/ base
|| ret
* base
< (LONG
)(MINLONG
- v
)))
509 ret
= ret
* base
+ v
;
512 if (end
&& !empty
) *end
= (WCHAR
*)s
;
517 /*********************************************************************
520 __msvcrt_ulong __cdecl
wcstoul(LPCWSTR s
, LPWSTR
*end
, INT base
)
522 BOOL negative
= FALSE
, empty
= TRUE
;
525 if (base
< 0 || base
== 1 || base
> 36) return 0;
526 if (end
) *end
= (WCHAR
*)s
;
527 while (iswspace(*s
)) s
++;
534 else if (*s
== '+') s
++;
536 if ((base
== 0 || base
== 16) && !wctoint( *s
) && (s
[1] == 'x' || s
[1] == 'X'))
541 if (base
== 0) base
= wctoint( *s
) ? 10 : 8;
545 int v
= wctoint( *s
);
546 if (v
< 0 || v
>= base
) break;
550 if (ret
> MAXDWORD
/ base
|| ret
* base
> MAXDWORD
- v
)
553 ret
= ret
* base
+ v
;
556 if (end
&& !empty
) *end
= (WCHAR
*)s
;
557 return negative
? -ret
: ret
;
561 /*********************************************************************
564 * Converts an unsigned long integer to a unicode string.
567 * Always returns str.
570 * Converts value to a '\0' terminated wstring which is copied to str.
571 * The maximum length of the copied str is 33 bytes.
572 * Does not check if radix is in the range of 2 to 36.
573 * If str is NULL it just returns NULL.
575 LPWSTR __cdecl
_ultow( __msvcrt_ulong value
, LPWSTR str
, INT radix
)
585 digit
= value
% radix
;
586 value
= value
/ radix
;
588 *--pos
= '0' + digit
;
590 *--pos
= 'a' + digit
- 10;
592 } while (value
!= 0L);
595 memcpy(str
, pos
, (&buffer
[32] - pos
+ 1) * sizeof(WCHAR
));
601 /*********************************************************************
604 * Converts a long integer to a unicode string.
607 * Always returns str.
610 * Converts value to a '\0' terminated wstring which is copied to str.
611 * The maximum length of the copied str is 33 bytes. If radix
612 * is 10 and value is negative, the value is converted with sign.
613 * Does not check if radix is in the range of 2 to 36.
614 * If str is NULL it just returns NULL.
616 LPWSTR __cdecl
_ltow( __msvcrt_long value
, LPWSTR str
, INT radix
)
624 if (value
< 0 && radix
== 10) {
639 *--pos
= '0' + digit
;
641 *--pos
= 'a' + digit
- 10;
650 memcpy(str
, pos
, (&buffer
[32] - pos
+ 1) * sizeof(WCHAR
));
656 /*********************************************************************
659 * Converts an integer to a unicode string.
662 * Always returns str.
665 * Converts value to a '\0' terminated wstring which is copied to str.
666 * The maximum length of the copied str is 33 bytes. If radix
667 * is 10 and value is negative, the value is converted with sign.
668 * Does not check if radix is in the range of 2 to 36.
669 * If str is NULL it just returns NULL.
672 * - The native function crashes when the string is longer than 19 chars.
673 * This function does not have this bug.
675 LPWSTR __cdecl
_itow(
676 int value
, /* [I] Value to be converted */
677 LPWSTR str
, /* [O] Destination for the converted value */
678 INT radix
) /* [I] Number base for conversion */
680 return _ltow(value
, str
, radix
);
684 /*********************************************************************
687 * Converts a large unsigned integer to a unicode string.
690 * Always returns str.
693 * Converts value to a '\0' terminated wstring which is copied to str.
694 * The maximum length of the copied str is 33 bytes.
695 * Does not check if radix is in the range of 2 to 36.
696 * If str is NULL it just returns NULL.
699 * - This function does not exist in the native DLL (but in msvcrt).
700 * But since the maintenance of all these functions is better done
701 * in one place we implement it here.
703 LPWSTR __cdecl
_ui64tow(
704 ULONGLONG value
, /* [I] Value to be converted */
705 LPWSTR str
, /* [O] Destination for the converted value */
706 INT radix
) /* [I] Number base for conversion */
716 digit
= value
% radix
;
717 value
= value
/ radix
;
719 *--pos
= '0' + digit
;
721 *--pos
= 'a' + digit
- 10;
723 } while (value
!= 0L);
726 memcpy(str
, pos
, (&buffer
[64] - pos
+ 1) * sizeof(WCHAR
));
732 /*********************************************************************
735 * Converts a large integer to a unicode string.
738 * Always returns str.
741 * Converts value to a '\0' terminated wstring which is copied to str.
742 * The maximum length of the copied str is 33 bytes. If radix
743 * is 10 and value is negative, the value is converted with sign.
744 * Does not check if radix is in the range of 2 to 36.
745 * If str is NULL it just returns NULL.
748 * - The native DLL converts negative values (for base 10) wrong:
749 * -1 is converted to -18446744073709551615
750 * -2 is converted to -18446744073709551614
751 * -9223372036854775807 is converted to -9223372036854775809
752 * -9223372036854775808 is converted to -9223372036854775808
753 * The native msvcrt _i64tow function and our ntdll function do
756 LPWSTR __cdecl
_i64tow(
757 LONGLONG value
, /* [I] Value to be converted */
758 LPWSTR str
, /* [O] Destination for the converted value */
759 INT radix
) /* [I] Number base for conversion */
767 if (value
< 0 && radix
== 10) {
782 *--pos
= '0' + digit
;
784 *--pos
= 'a' + digit
- 10;
793 memcpy(str
, pos
, (&buffer
[64] - pos
+ 1) * sizeof(WCHAR
));
799 /*********************************************************************
802 * Converts a unicode string to a long integer.
805 * str [I] Wstring to be converted
808 * On success it returns the integer value otherwise it returns 0.
811 * Accepts: {whitespace} [+|-] {digits}
812 * No check is made for value overflow, only the lower 32 bits are assigned.
813 * If str is NULL it crashes, as the native function does.
815 __msvcrt_long __cdecl
_wtol( LPCWSTR str
)
817 ULONG RunningTotal
= 0;
820 while (iswspace(*str
)) str
++;
824 } else if (*str
== '-') {
829 while (*str
>= '0' && *str
<= '9') {
830 RunningTotal
= RunningTotal
* 10 + *str
- '0';
834 return bMinus
? -RunningTotal
: RunningTotal
;
838 /*********************************************************************
841 * Converts a unicode string to an integer.
844 * str [I] Wstring to be converted
847 * On success it returns the integer value otherwise it returns 0.
850 * Accepts: {whitespace} [+|-] {digits}
851 * No check is made for value overflow, only the lower 32 bits are assigned.
852 * If str is NULL it crashes, as the native function does.
854 int __cdecl
_wtoi( LPCWSTR str
)
860 /*********************************************************************
863 * Converts a unicode string to a large integer.
866 * str [I] Wstring to be converted
869 * On success it returns the integer value otherwise it returns 0.
872 * Accepts: {whitespace} [+|-] {digits}
873 * No check is made for value overflow, only the lower 64 bits are assigned.
874 * If str is NULL it crashes, as the native function does.
876 LONGLONG __cdecl
_wtoi64( LPCWSTR str
)
878 ULONGLONG RunningTotal
= 0;
881 while (iswspace(*str
)) str
++;
885 } else if (*str
== '-') {
890 while (*str
>= '0' && *str
<= '9') {
891 RunningTotal
= RunningTotal
* 10 + *str
- '0';
895 return bMinus
? -RunningTotal
: RunningTotal
;