Add Pacific Standard Time (PST) to TZ_INFO.
[wine] / dlls / ntdll / wcstring.c
1 /*
2  * NTDLL wide-char functions
3  *
4  * Copyright 2000 Alexandre Julliard
5  * Copyright 2000 Jon Griffiths
6  * Copyright 2003 Thomas Mertes
7  *
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.
12  *
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.
17  *
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  */
22
23 #include "config.h"
24
25 #include <ctype.h>
26 #include <limits.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <stdarg.h>
30 #include <stdio.h>
31
32 #include "ntstatus.h"
33 #include "windef.h"
34 #include "winbase.h"
35 #include "winreg.h"
36 #include "winternl.h"
37 #include "wine/unicode.h"
38 #include "wine/debug.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
41
42
43 /*********************************************************************
44  *           _wcsicmp    (NTDLL.@)
45  */
46 INT __cdecl NTDLL__wcsicmp( LPCWSTR str1, LPCWSTR str2 )
47 {
48     return strcmpiW( str1, str2 );
49 }
50
51
52 /*********************************************************************
53  *           _wcslwr    (NTDLL.@)
54  */
55 LPWSTR __cdecl NTDLL__wcslwr( LPWSTR str )
56 {
57     return strlwrW( str );
58 }
59
60
61 /*********************************************************************
62  *           _wcsnicmp    (NTDLL.@)
63  */
64 INT __cdecl NTDLL__wcsnicmp( LPCWSTR str1, LPCWSTR str2, INT n )
65 {
66     return strncmpiW( str1, str2, n );
67 }
68
69
70 /*********************************************************************
71  *           _wcsupr    (NTDLL.@)
72  */
73 LPWSTR __cdecl NTDLL__wcsupr( LPWSTR str )
74 {
75     return struprW( str );
76 }
77
78
79 /*********************************************************************
80  *           towlower    (NTDLL.@)
81  */
82 WCHAR __cdecl NTDLL_towlower( WCHAR ch )
83 {
84     return tolowerW(ch);
85 }
86
87
88 /*********************************************************************
89  *           towupper    (NTDLL.@)
90  */
91 WCHAR __cdecl NTDLL_towupper( WCHAR ch )
92 {
93     return toupperW(ch);
94 }
95
96
97 /***********************************************************************
98  *           wcscat    (NTDLL.@)
99  */
100 LPWSTR __cdecl NTDLL_wcscat( LPWSTR dst, LPCWSTR src )
101 {
102     return strcatW( dst, src );
103 }
104
105
106 /*********************************************************************
107  *           wcschr    (NTDLL.@)
108  */
109 LPWSTR __cdecl NTDLL_wcschr( LPCWSTR str, WCHAR ch )
110 {
111     return strchrW( str, ch );
112 }
113
114
115 /*********************************************************************
116  *           wcscmp    (NTDLL.@)
117  */
118 INT __cdecl NTDLL_wcscmp( LPCWSTR str1, LPCWSTR str2 )
119 {
120     return strcmpW( str1, str2 );
121 }
122
123
124 /***********************************************************************
125  *           wcscpy    (NTDLL.@)
126  */
127 LPWSTR __cdecl NTDLL_wcscpy( LPWSTR dst, LPCWSTR src )
128 {
129     return strcpyW( dst, src );
130 }
131
132
133 /*********************************************************************
134  *           wcscspn    (NTDLL.@)
135  */
136 INT __cdecl NTDLL_wcscspn( LPCWSTR str, LPCWSTR reject )
137 {
138     LPCWSTR start = str;
139     while (*str)
140     {
141         LPCWSTR p = reject;
142         while (*p && (*p != *str)) p++;
143         if (*p) break;
144         str++;
145     }
146     return str - start;
147 }
148
149
150 /***********************************************************************
151  *           wcslen    (NTDLL.@)
152  */
153 INT __cdecl NTDLL_wcslen( LPCWSTR str )
154 {
155     return strlenW( str );
156 }
157
158
159 /*********************************************************************
160  *           wcsncat    (NTDLL.@)
161  */
162 LPWSTR __cdecl NTDLL_wcsncat( LPWSTR s1, LPCWSTR s2, INT n )
163 {
164     LPWSTR ret = s1;
165     while (*s1) s1++;
166     while (n-- > 0) if (!(*s1++ = *s2++)) return ret;
167     *s1 = 0;
168     return ret;
169 }
170
171
172 /*********************************************************************
173  *           wcsncmp    (NTDLL.@)
174  */
175 INT __cdecl NTDLL_wcsncmp( LPCWSTR str1, LPCWSTR str2, INT n )
176 {
177     return strncmpW( str1, str2, n );
178 }
179
180
181 /*********************************************************************
182  *           wcsncpy    (NTDLL.@)
183  */
184 LPWSTR __cdecl NTDLL_wcsncpy( LPWSTR s1, LPCWSTR s2, INT n )
185 {
186     return strncpyW( s1, s2, n );
187 }
188
189
190 /*********************************************************************
191  *           wcspbrk    (NTDLL.@)
192  */
193 LPWSTR __cdecl NTDLL_wcspbrk( LPCWSTR str, LPCWSTR accept )
194 {
195     LPCWSTR p;
196     while (*str)
197     {
198         for (p = accept; *p; p++) if (*p == *str) return (LPWSTR)str;
199         str++;
200     }
201     return NULL;
202 }
203
204
205 /*********************************************************************
206  *           wcsrchr    (NTDLL.@)
207  */
208 LPWSTR __cdecl NTDLL_wcsrchr( LPWSTR str, WCHAR ch )
209 {
210     LPWSTR last = NULL;
211     while (*str)
212     {
213         if (*str == ch) last = str;
214         str++;
215     }
216     return last;
217 }
218
219
220 /*********************************************************************
221  *           wcsspn    (NTDLL.@)
222  */
223 INT __cdecl NTDLL_wcsspn( LPCWSTR str, LPCWSTR accept )
224 {
225     LPCWSTR start = str;
226     while (*str)
227     {
228         LPCWSTR p = accept;
229         while (*p && (*p != *str)) p++;
230         if (!*p) break;
231         str++;
232     }
233     return str - start;
234 }
235
236
237 /*********************************************************************
238  *           wcsstr    (NTDLL.@)
239  */
240 LPWSTR __cdecl NTDLL_wcsstr( LPCWSTR str, LPCWSTR sub )
241 {
242     return strstrW( str, sub );
243 }
244
245
246 /*********************************************************************
247  *           wcstok    (NTDLL.@)
248  */
249 LPWSTR __cdecl NTDLL_wcstok( LPWSTR str, LPCWSTR delim )
250 {
251     static LPWSTR next = NULL;
252     LPWSTR ret;
253
254     if (!str)
255         if (!(str = next)) return NULL;
256
257     while (*str && NTDLL_wcschr( delim, *str )) str++;
258     if (!*str) return NULL;
259     ret = str++;
260     while (*str && !NTDLL_wcschr( delim, *str )) str++;
261     if (*str) *str++ = 0;
262     next = str;
263     return ret;
264 }
265
266
267 /*********************************************************************
268  *           wcstombs    (NTDLL.@)
269  */
270 INT __cdecl NTDLL_wcstombs( LPSTR dst, LPCWSTR src, INT n )
271 {
272     DWORD len;
273
274     if (!dst)
275     {
276         RtlUnicodeToMultiByteSize( &len, src, strlenW(src)*sizeof(WCHAR) );
277         return len;
278     }
279     else
280     {
281         if (n <= 0) return 0;
282         RtlUnicodeToMultiByteN( dst, n, &len, src, strlenW(src)*sizeof(WCHAR) );
283         if (len < n) dst[len] = 0;
284     }
285     return len;
286 }
287
288
289 /*********************************************************************
290  *           mbstowcs    (NTDLL.@)
291  */
292 INT __cdecl NTDLL_mbstowcs( LPWSTR dst, LPCSTR src, INT n )
293 {
294     DWORD len;
295
296     if (!dst)
297     {
298         RtlMultiByteToUnicodeSize( &len, src, strlen(src) );
299     }
300     else
301     {
302         if (n <= 0) return 0;
303         RtlMultiByteToUnicodeN( dst, n*sizeof(WCHAR), &len, src, strlen(src) );
304         if (len / sizeof(WCHAR) < n) dst[len / sizeof(WCHAR)] = 0;
305     }
306     return len / sizeof(WCHAR);
307 }
308
309
310 /*********************************************************************
311  *                  wcstol  (NTDLL.@)
312  */
313 long __cdecl NTDLL_wcstol(LPCWSTR s,LPWSTR *end,INT base)
314 {
315     return strtolW( s, end, base );
316 }
317
318
319 /*********************************************************************
320  *                  wcstoul  (NTDLL.@)
321  */
322 unsigned long __cdecl NTDLL_wcstoul(LPCWSTR s,LPWSTR *end,INT base)
323 {
324     return strtoulW( s, end, base );
325 }
326
327
328 /*********************************************************************
329  *           iswctype    (NTDLL.@)
330  */
331 INT __cdecl NTDLL_iswctype( WCHAR wc, WCHAR wct )
332 {
333     return (get_char_typeW(wc) & 0xfff) & wct;
334 }
335
336
337 /*********************************************************************
338  *           iswalpha    (NTDLL.@)
339  *
340  * Checks if an unicode char wc is a letter
341  *
342  * RETURNS
343  *  TRUE: The unicode char wc is a letter.
344  *  FALSE: Otherwise
345  */
346 INT __cdecl NTDLL_iswalpha( WCHAR wc )
347 {
348     return isalphaW(wc);
349 }
350
351
352 /*********************************************************************
353  *              iswdigit (NTDLL.@)
354  *
355  * Checks if an unicode char wc is a digit
356  *
357  * RETURNS
358  *  TRUE: The unicode char wc is a digit.
359  *  FALSE: Otherwise
360  */
361 INT __cdecl NTDLL_iswdigit( WCHAR wc )
362 {
363     return isdigitW(wc);
364 }
365
366
367 /*********************************************************************
368  *              iswlower (NTDLL.@)
369  *
370  * Checks if an unicode char wc is a lower case letter
371  *
372  * RETURNS
373  *  TRUE: The unicode char wc is a lower case letter.
374  *  FALSE: Otherwise
375  */
376 INT __cdecl NTDLL_iswlower( WCHAR wc )
377 {
378     return islowerW(wc);
379 }
380
381
382 /*********************************************************************
383  *              iswspace (NTDLL.@)
384  *
385  * Checks if an unicode char wc is a white space character
386  *
387  * RETURNS
388  *  TRUE: The unicode char wc is a white space character.
389  *  FALSE: Otherwise
390  */
391 INT __cdecl NTDLL_iswspace( WCHAR wc )
392 {
393     return isspaceW(wc);
394 }
395
396
397 /*********************************************************************
398  *              iswxdigit (NTDLL.@)
399  *
400  * Checks if an unicode char wc is an extended digit
401  *
402  * RETURNS
403  *  TRUE: The unicode char wc is an extended digit.
404  *  FALSE: Otherwise
405  */
406 INT __cdecl NTDLL_iswxdigit( WCHAR wc )
407 {
408     return isxdigitW(wc);
409 }
410
411
412 /*********************************************************************
413  *      _ultow   (NTDLL.@)
414  *
415  * Converts an unsigned long integer to an unicode string.
416  *
417  * RETURNS
418  *  Always returns str.
419  *
420  * NOTES
421  *  Converts value to a '\0' terminated wstring which is copied to str.
422  *  The maximum length of the copied str is 33 bytes.
423  *  Does not check if radix is in the range of 2 to 36.
424  *  If str is NULL it just returns NULL.
425  */
426 LPWSTR __cdecl _ultow(
427     unsigned long value, /* [I] Value to be converted */
428     LPWSTR str,          /* [O] Destination for the converted value */
429     INT radix)           /* [I] Number base for conversion */
430 {
431     WCHAR buffer[33];
432     PWCHAR pos;
433     WCHAR digit;
434
435     pos = &buffer[32];
436     *pos = '\0';
437
438     do {
439         digit = value % radix;
440         value = value / radix;
441         if (digit < 10) {
442             *--pos = '0' + digit;
443         } else {
444             *--pos = 'a' + digit - 10;
445         } /* if */
446     } while (value != 0L);
447
448     if (str != NULL) {
449         memcpy(str, pos, (&buffer[32] - pos + 1) * sizeof(WCHAR));
450     } /* if */
451     return str;
452 }
453
454
455 /*********************************************************************
456  *      _ltow   (NTDLL.@)
457  *
458  * Converts a long integer to an unicode string.
459  *
460  * RETURNS
461  *  Always returns str.
462  *
463  * NOTES
464  *  Converts value to a '\0' terminated wstring which is copied to str.
465  *  The maximum length of the copied str is 33 bytes. If radix
466  *  is 10 and value is negative, the value is converted with sign.
467  *  Does not check if radix is in the range of 2 to 36.
468  *  If str is NULL it just returns NULL.
469  */
470 LPWSTR __cdecl _ltow(
471     long value, /* [I] Value to be converted */
472     LPWSTR str, /* [O] Destination for the converted value */
473     INT radix)  /* [I] Number base for conversion */
474 {
475     unsigned long val;
476     int negative;
477     WCHAR buffer[33];
478     PWCHAR pos;
479     WCHAR digit;
480
481     if (value < 0 && radix == 10) {
482         negative = 1;
483         val = -value;
484     } else {
485         negative = 0;
486         val = value;
487     } /* if */
488
489     pos = &buffer[32];
490     *pos = '\0';
491
492     do {
493         digit = val % radix;
494         val = val / radix;
495         if (digit < 10) {
496             *--pos = '0' + digit;
497         } else {
498             *--pos = 'a' + digit - 10;
499         } /* if */
500     } while (val != 0L);
501
502     if (negative) {
503         *--pos = '-';
504     } /* if */
505
506     if (str != NULL) {
507         memcpy(str, pos, (&buffer[32] - pos + 1) * sizeof(WCHAR));
508     } /* if */
509     return str;
510 }
511
512
513 /*********************************************************************
514  *      _itow    (NTDLL.@)
515  *
516  * Converts an integer to an unicode string.
517  *
518  * RETURNS
519  *  Always returns str.
520  *
521  * NOTES
522  *  Converts value to a '\0' terminated wstring which is copied to str.
523  *  The maximum length of the copied str is 33 bytes. If radix
524  *  is 10 and value is negative, the value is converted with sign.
525  *  Does not check if radix is in the range of 2 to 36.
526  *  If str is NULL it just returns NULL.
527  *
528  * DIFFERENCES
529  * - The native function crashes when the string is longer than 19 chars.
530  *   This function does not have this bug.
531  */
532 LPWSTR __cdecl _itow(
533     int value,  /* [I] Value to be converted */
534     LPWSTR str, /* [O] Destination for the converted value */
535     INT radix)  /* [I] Number base for conversion */
536 {
537     return _ltow(value, str, radix);
538 }
539
540
541 /*********************************************************************
542  *      _ui64tow   (NTDLL.@)
543  *
544  * Converts a large unsigned integer to an unicode string.
545  *
546  * RETURNS
547  *  Always returns str.
548  *
549  * NOTES
550  *  Converts value to a '\0' terminated wstring which is copied to str.
551  *  The maximum length of the copied str is 33 bytes.
552  *  Does not check if radix is in the range of 2 to 36.
553  *  If str is NULL it just returns NULL.
554  *
555  * DIFFERENCES
556  * - This function does not exist in the native DLL (but in msvcrt).
557  *   But since the maintenance of all these functions is better done
558  *   in one place we implement it here.
559  */
560 LPWSTR __cdecl _ui64tow(
561     ULONGLONG value, /* [I] Value to be converted */
562     LPWSTR str,      /* [O] Destination for the converted value */
563     INT radix)       /* [I] Number base for conversion */
564 {
565     WCHAR buffer[65];
566     PWCHAR pos;
567     WCHAR digit;
568
569     pos = &buffer[64];
570     *pos = '\0';
571
572     do {
573         digit = value % radix;
574         value = value / radix;
575         if (digit < 10) {
576             *--pos = '0' + digit;
577         } else {
578             *--pos = 'a' + digit - 10;
579         } /* if */
580     } while (value != 0L);
581
582     if (str != NULL) {
583         memcpy(str, pos, (&buffer[64] - pos + 1) * sizeof(WCHAR));
584     } /* if */
585     return str;
586 }
587
588
589 /*********************************************************************
590  *      _i64tow   (NTDLL.@)
591  *
592  * Converts a large integer to an unicode string.
593  *
594  * RETURNS
595  *  Always returns str.
596  *
597  * NOTES
598  *  Converts value to a '\0' terminated wstring which is copied to str.
599  *  The maximum length of the copied str is 33 bytes. If radix
600  *  is 10 and value is negative, the value is converted with sign.
601  *  Does not check if radix is in the range of 2 to 36.
602  *  If str is NULL it just returns NULL.
603  *
604  * DIFFERENCES
605  * - The native DLL converts negative values (for base 10) wrong:
606  *                     -1 is converted to -18446744073709551615
607  *                     -2 is converted to -18446744073709551614
608  *   -9223372036854775807 is converted to  -9223372036854775809
609  *   -9223372036854775808 is converted to  -9223372036854775808
610  *   The native msvcrt _i64tow function and our ntdll function do
611  *   not have this bug.
612  */
613 LPWSTR __cdecl _i64tow(
614     LONGLONG value, /* [I] Value to be converted */
615     LPWSTR str,     /* [O] Destination for the converted value */
616     INT radix)      /* [I] Number base for conversion */
617 {
618     ULONGLONG val;
619     int negative;
620     WCHAR buffer[65];
621     PWCHAR pos;
622     WCHAR digit;
623
624     if (value < 0 && radix == 10) {
625         negative = 1;
626         val = -value;
627     } else {
628         negative = 0;
629         val = value;
630     } /* if */
631
632     pos = &buffer[64];
633     *pos = '\0';
634
635     do {
636         digit = val % radix;
637         val = val / radix;
638         if (digit < 10) {
639             *--pos = '0' + digit;
640         } else {
641             *--pos = 'a' + digit - 10;
642         } /* if */
643     } while (val != 0L);
644
645     if (negative) {
646         *--pos = '-';
647     } /* if */
648
649     if (str != NULL) {
650         memcpy(str, pos, (&buffer[64] - pos + 1) * sizeof(WCHAR));
651     } /* if */
652     return str;
653 }
654
655
656 /*********************************************************************
657  *      _wtol    (NTDLL.@)
658  *
659  * Converts an unicode string to a long integer.
660  *
661  * PARAMS
662  *  str [I] Wstring to be converted
663  *
664  * RETURNS
665  *  On success it returns the integer value otherwise it returns 0.
666  *
667  * NOTES
668  *  Accepts: {whitespace} [+|-] {digits}
669  *  No check is made for value overflow, only the lower 32 bits are assigned.
670  *  If str is NULL it crashes, as the native function does.
671  */
672 LONG __cdecl _wtol( LPCWSTR str )
673 {
674     ULONG RunningTotal = 0;
675     char bMinus = 0;
676
677     while (isspaceW(*str)) {
678         str++;
679     } /* while */
680
681     if (*str == '+') {
682         str++;
683     } else if (*str == '-') {
684         bMinus = 1;
685         str++;
686     } /* if */
687
688     while (*str >= '0' && *str <= '9') {
689         RunningTotal = RunningTotal * 10 + *str - '0';
690         str++;
691     } /* while */
692
693     return bMinus ? -RunningTotal : RunningTotal;
694 }
695
696
697 /*********************************************************************
698  *      _wtoi    (NTDLL.@)
699  *
700  * Converts an unicode string to an integer.
701  *
702  * PARAMS
703  *  str [I] Wstring to be converted
704  *
705  * RETURNS
706  *  On success it returns the integer value otherwise it returns 0.
707  *
708  * NOTES
709  *  Accepts: {whitespace} [+|-] {digits}
710  *  No check is made for value overflow, only the lower 32 bits are assigned.
711  *  If str is NULL it crashes, as the native function does.
712  */
713 int __cdecl _wtoi( LPCWSTR str )
714 {
715     return _wtol(str);
716 }
717
718
719 /*********************************************************************
720  *      _wtoi64   (NTDLL.@)
721  *
722  * Converts an unicode string to a large integer.
723  *
724  * PARAMS
725  *  str [I] Wstring to be converted
726  *
727  * RETURNS
728  *  On success it returns the integer value otherwise it returns 0.
729  *
730  * NOTES
731  *  Accepts: {whitespace} [+|-] {digits}
732  *  No check is made for value overflow, only the lower 64 bits are assigned.
733  *  If str is NULL it crashes, as the native function does.
734  */
735 LONGLONG  __cdecl _wtoi64( LPCWSTR str )
736 {
737     ULONGLONG RunningTotal = 0;
738     char bMinus = 0;
739
740     while (isspaceW(*str)) {
741         str++;
742     } /* while */
743
744     if (*str == '+') {
745         str++;
746     } else if (*str == '-') {
747         bMinus = 1;
748         str++;
749     } /* if */
750
751     while (*str >= '0' && *str <= '9') {
752         RunningTotal = RunningTotal * 10 + *str - '0';
753         str++;
754     } /* while */
755
756     return bMinus ? -RunningTotal : RunningTotal;
757 }
758
759
760 /***********************************************************************
761  *        _snwprintf (NTDLL.@)
762  */
763 int __cdecl _snwprintf(WCHAR *str, unsigned int len, const WCHAR *format, ...)
764 {
765   int retval;
766   va_list valist;
767   va_start(valist, format);
768   retval = vsnprintfW(str, len, format, valist);
769   va_end(valist);
770   return retval;
771 }
772
773
774 /***********************************************************************
775  *        swprintf (NTDLL.@)
776  */
777 int __cdecl NTDLL_swprintf(WCHAR *str, const WCHAR *format, ...)
778 {
779   int retval;
780   va_list valist;
781   va_start(valist, format);
782   retval = vsnprintfW(str, INT_MAX, format, valist);
783   va_end(valist);
784   return retval;
785 }