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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "config.h"
  24
  25 #include <ctype.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <stdarg.h>
  29 #include <stdio.h>
  30
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "winnls.h"
  34 #include "winternl.h"
  35 #include "ntdll_misc.h"
  36
  37 static const unsigned short wctypes[256] =
  38 {
  39     /* 00 */
  40     0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
  41     0x0020, 0x0068, 0x0028, 0x0028, 0x0028, 0x0028, 0x0020, 0x0020,
  42     /* 10 */
  43     0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
  44     0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
  45     /* 20 */
  46     0x0048, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
  47     0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
  48     /* 30 */
  49     0x0084, 0x0084, 0x0084, 0x0084, 0x0084, 0x0084, 0x0084, 0x0084,
  50     0x0084, 0x0084, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
  51     /* 40 */
  52     0x0010, 0x0181, 0x0181, 0x0181, 0x0181, 0x0181, 0x0181, 0x0101,
  53     0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
  54     /* 50 */
  55     0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
  56     0x0101, 0x0101, 0x0101, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
  57     /* 60 */
  58     0x0010, 0x0182, 0x0182, 0x0182, 0x0182, 0x0182, 0x0182, 0x0102,
  59     0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102,
  60     /* 70 */
  61     0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102,
  62     0x0102, 0x0102, 0x0102, 0x0010, 0x0010, 0x0010, 0x0010, 0x0020,
  63     /* 80 */
  64     0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
  65     0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
  66     /* 90 */
  67     0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
  68     0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
  69     /* a0 */
  70     0x0048, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
  71     0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
  72     /* b0 */
  73     0x0010, 0x0010, 0x0014, 0x0014, 0x0010, 0x0010, 0x0010, 0x0010,
  74     0x0010, 0x0014, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
  75     /* c0 */
  76     0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
  77     0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
  78     /* d0 */
  79     0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0010,
  80     0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0102,
  81     /* e0 */
  82     0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102,
  83     0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102,
  84     /* f0 */
  85     0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0010,
  86     0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102
  87 };
  88
  89
  90 /*********************************************************************
  91  *           _wcsicmp    (NTDLL.@)
  92  */
  93 int __cdecl NTDLL__wcsicmp( LPCWSTR str1, LPCWSTR str2 )
  94 {
  95     for (;;)
  96     {
  97         WCHAR ch1 = (*str1 >= 'A' && *str1 <= 'Z') ? *str1 + 32 : *str1;
  98         WCHAR ch2 = (*str2 >= 'A' && *str2 <= 'Z') ? *str2 + 32 : *str2;
  99         if (ch1 != ch2 || !*str1) return ch1 - ch2;
 100         str1++;
 101         str2++;
 102     }
 103 }
 104
 105
 106 /*********************************************************************
 107  *           _wcslwr    (NTDLL.@)
 108  */
 109 LPWSTR __cdecl NTDLL__wcslwr( LPWSTR str )
 110 {
 111     WCHAR *ret = str;
 112
 113     while (*str)
 114     {
 115         WCHAR ch = *str;
 116         if (ch >= 'A' && ch <= 'Z') ch += 32;
 117         *str++ = ch;
 118     }
 119     return ret;
 120 }
 121
 122
 123 /*********************************************************************
 124  *           _wcsnicmp    (NTDLL.@)
 125  */
 126 int __cdecl NTDLL__wcsnicmp( LPCWSTR str1, LPCWSTR str2, size_t n )
 127 {
 128     int ret = 0;
 129     for ( ; n > 0; n--, str1++, str2++)
 130     {
 131         WCHAR ch1 = (*str1 >= 'A' && *str1 <= 'Z') ? *str1 + 32 : *str1;
 132         WCHAR ch2 = (*str2 >= 'A' && *str2 <= 'Z') ? *str2 + 32 : *str2;
 133         if ((ret = ch1 - ch2) ||  !*str1) break;
 134     }
 135     return ret;
 136 }
 137
 138
 139 /*********************************************************************
 140  *           _wcsupr    (NTDLL.@)
 141  */
 142 LPWSTR __cdecl NTDLL__wcsupr( LPWSTR str )
 143 {
 144     WCHAR *ret = str;
 145
 146     while (*str)
 147     {
 148         WCHAR ch = *str;
 149         if (ch >= 'a' && ch <= 'z') ch -= 32;
 150         *str++ = ch;
 151     }
 152     return ret;
 153 }
 154
 155
 156 /***********************************************************************
 157  *           wcscpy    (NTDLL.@)
 158  */
 159 LPWSTR __cdecl NTDLL_wcscpy( LPWSTR dst, LPCWSTR src )
 160 {
 161     WCHAR *p = dst;
 162     while ((*p++ = *src++));
 163     return dst;
 164 }
 165
 166
 167 /***********************************************************************
 168  *           wcslen    (NTDLL.@)
 169  */
 170 size_t __cdecl NTDLL_wcslen( LPCWSTR str )
 171 {
 172     const WCHAR *s = str;
 173     while (*s) s++;
 174     return s - str;
 175 }
 176
 177
 178 /***********************************************************************
 179  *           wcscat    (NTDLL.@)
 180  */
 181 LPWSTR __cdecl NTDLL_wcscat( LPWSTR dst, LPCWSTR src )
 182 {
 183     NTDLL_wcscpy( dst + NTDLL_wcslen(dst), src );
 184     return dst;
 185 }
 186
 187
 188 /*********************************************************************
 189  *           wcschr    (NTDLL.@)
 190  */
 191 LPWSTR __cdecl NTDLL_wcschr( LPCWSTR str, WCHAR ch )
 192 {
 193     do { if (*str == ch) return (WCHAR *)(ULONG_PTR)str; } while (*str++);
 194     return NULL;
 195 }
 196
 197
 198 /*********************************************************************
 199  *           wcscmp    (NTDLL.@)
 200  */
 201 int __cdecl NTDLL_wcscmp( LPCWSTR str1, LPCWSTR str2 )
 202 {
 203     while (*str1 && (*str1 == *str2)) { str1++; str2++; }
 204     return *str1 - *str2;
 205 }
 206
 207
 208 /*********************************************************************
 209  *           wcscspn    (NTDLL.@)
 210  */
 211 size_t __cdecl NTDLL_wcscspn( LPCWSTR str, LPCWSTR reject )
 212 {
 213     const WCHAR *ptr;
 214     for (ptr = str; *ptr; ptr++) if (NTDLL_wcschr( reject, *ptr )) break;
 215     return ptr - str;
 216 }
 217
 218
 219 /*********************************************************************
 220  *           wcsncat    (NTDLL.@)
 221  */
 222 LPWSTR __cdecl NTDLL_wcsncat( LPWSTR s1, LPCWSTR s2, size_t n )
 223 {
 224     LPWSTR ret = s1;
 225     while (*s1) s1++;
 226     while (n-- > 0) if (!(*s1++ = *s2++)) return ret;
 227     *s1 = 0;
 228     return ret;
 229 }
 230
 231
 232 /*********************************************************************
 233  *           wcsncmp    (NTDLL.@)
 234  */
 235 int __cdecl NTDLL_wcsncmp( LPCWSTR str1, LPCWSTR str2, size_t n )
 236 {
 237     if (n <= 0) return 0;
 238     while ((--n > 0) && *str1 && (*str1 == *str2)) { str1++; str2++; }
 239     return *str1 - *str2;
 240 }
 241
 242
 243 /*********************************************************************
 244  *           wcsncpy    (NTDLL.@)
 245  */
 246 LPWSTR __cdecl NTDLL_wcsncpy( LPWSTR s1, LPCWSTR s2, size_t n )
 247 {
 248     WCHAR *ret = s1;
 249     while (n-- > 0) if (!(*s1++ = *s2++)) break;
 250     while (n-- > 0) *s1++ = 0;
 251     return ret;
 252 }
 253
 254
 255 /*********************************************************************
 256  *           wcspbrk    (NTDLL.@)
 257  */
 258 LPWSTR __cdecl NTDLL_wcspbrk( LPCWSTR str, LPCWSTR accept )
 259 {
 260     for ( ; *str; str++) if (NTDLL_wcschr( accept, *str )) return (WCHAR *)(ULONG_PTR)str;
 261     return NULL;
 262 }
 263
 264
 265 /*********************************************************************
 266  *           wcsrchr    (NTDLL.@)
 267  */
 268 LPWSTR __cdecl NTDLL_wcsrchr( LPCWSTR str, WCHAR ch )
 269 {
 270     WCHAR *ret = NULL;
 271     do { if (*str == ch) ret = (WCHAR *)(ULONG_PTR)str; } while (*str++);
 272     return ret;
 273 }
 274
 275
 276 /*********************************************************************
 277  *           wcsspn    (NTDLL.@)
 278  */
 279 size_t __cdecl NTDLL_wcsspn( LPCWSTR str, LPCWSTR accept )
 280 {
 281     const WCHAR *ptr;
 282     for (ptr = str; *ptr; ptr++) if (!NTDLL_wcschr( accept, *ptr )) break;
 283     return ptr - str;
 284 }
 285
 286
 287 /*********************************************************************
 288  *           wcsstr    (NTDLL.@)
 289  */
 290 LPWSTR __cdecl NTDLL_wcsstr( LPCWSTR str, LPCWSTR sub )
 291 {
 292     while (*str)
 293     {
 294         const WCHAR *p1 = str, *p2 = sub;
 295         while (*p1 && *p2 && *p1 == *p2) { p1++; p2++; }
 296         if (!*p2) return (WCHAR *)str;
 297         str++;
 298     }
 299     return NULL;
 300 }
 301
 302
 303 /*********************************************************************
 304  *           wcstok    (NTDLL.@)
 305  */
 306 LPWSTR __cdecl NTDLL_wcstok( LPWSTR str, LPCWSTR delim )
 307 {
 308     static LPWSTR next = NULL;
 309     LPWSTR ret;
 310
 311     if (!str)
 312         if (!(str = next)) return NULL;
 313
 314     while (*str && NTDLL_wcschr( delim, *str )) str++;
 315     if (!*str) return NULL;
 316     ret = str++;
 317     while (*str && !NTDLL_wcschr( delim, *str )) str++;
 318     if (*str) *str++ = 0;
 319     next = str;
 320     return ret;
 321 }
 322
 323
 324 /*********************************************************************
 325  *           wcstombs    (NTDLL.@)
 326  */
 327 INT __cdecl NTDLL_wcstombs( LPSTR dst, LPCWSTR src, INT n )
 328 {
 329     DWORD len;
 330
 331     if (!dst)
 332     {
 333         RtlUnicodeToMultiByteSize( &len, src, NTDLL_wcslen(src) * sizeof(WCHAR) );
 334         return len;
 335     }
 336     else
 337     {
 338         if (n <= 0) return 0;
 339         RtlUnicodeToMultiByteN( dst, n, &len, src, NTDLL_wcslen(src) * sizeof(WCHAR) );
 340         if (len < n) dst[len] = 0;
 341     }
 342     return len;
 343 }
 344
 345
 346 /*********************************************************************
 347  *           mbstowcs    (NTDLL.@)
 348  */
 349 INT __cdecl NTDLL_mbstowcs( LPWSTR dst, LPCSTR src, INT n )
 350 {
 351     DWORD len;
 352
 353     if (!dst)
 354     {
 355         RtlMultiByteToUnicodeSize( &len, src, strlen(src) );
 356     }
 357     else
 358     {
 359         if (n <= 0) return 0;
 360         RtlMultiByteToUnicodeN( dst, n*sizeof(WCHAR), &len, src, strlen(src) );
 361         if (len / sizeof(WCHAR) < n) dst[len / sizeof(WCHAR)] = 0;
 362     }
 363     return len / sizeof(WCHAR);
 364 }
 365
 366
 367 /*********************************************************************
 368  *           iswctype    (NTDLL.@)
 369  */
 370 INT __cdecl NTDLL_iswctype( WCHAR wc, unsigned short type )
 371 {
 372     if (wc >= 256) return 0;
 373     return wctypes[wc] & type;
 374 }
 375
 376
 377 /*********************************************************************
 378  *           iswalpha    (NTDLL.@)
 379  */
 380 INT __cdecl NTDLL_iswalpha( WCHAR wc )
 381 {
 382     if (wc >= 256) return 0;
 383     return wctypes[wc] & (C1_ALPHA | C1_UPPER | C1_LOWER);
 384 }
 385
 386
 387 /*********************************************************************
 388  *              iswdigit (NTDLL.@)
 389  *
 390  * Checks if a unicode char wc is a digit
 391  *
 392  * RETURNS
 393  *  TRUE: The unicode char wc is a digit.
 394  *  FALSE: Otherwise
 395  */
 396 INT __cdecl NTDLL_iswdigit( WCHAR wc )
 397 {
 398     if (wc >= 256) return 0;
 399     return wctypes[wc] & C1_DIGIT;
 400 }
 401
 402
 403 /*********************************************************************
 404  *              iswlower (NTDLL.@)
 405  *
 406  * Checks if a unicode char wc is a lower case letter
 407  *
 408  * RETURNS
 409  *  TRUE: The unicode char wc is a lower case letter.
 410  *  FALSE: Otherwise
 411  */
 412 INT __cdecl NTDLL_iswlower( WCHAR wc )
 413 {
 414     if (wc >= 256) return 0;
 415     return wctypes[wc] & C1_LOWER;
 416 }
 417
 418
 419 /*********************************************************************
 420  *              iswspace (NTDLL.@)
 421  *
 422  * Checks if a unicode char wc is a white space character
 423  *
 424  * RETURNS
 425  *  TRUE: The unicode char wc is a white space character.
 426  *  FALSE: Otherwise
 427  */
 428 INT __cdecl NTDLL_iswspace( WCHAR wc )
 429 {
 430     if (wc >= 256) return 0;
 431     return wctypes[wc] & C1_SPACE;
 432 }
 433
 434
 435 /*********************************************************************
 436  *              iswxdigit (NTDLL.@)
 437  *
 438  * Checks if a unicode char wc is an extended digit
 439  *
 440  * RETURNS
 441  *  TRUE: The unicode char wc is an extended digit.
 442  *  FALSE: Otherwise
 443  */
 444 INT __cdecl NTDLL_iswxdigit( WCHAR wc )
 445 {
 446     if (wc >= 256) return 0;
 447     return wctypes[wc] & C1_XDIGIT;
 448 }
 449
 450
 451 static int wctoint( WCHAR c )
 452 {
 453     /* NOTE: MAP_FOLDDIGITS supports too many things. */
 454     /* Unicode points that contain digits 0-9; keep this sorted! */
 455     static const WCHAR zeros[] =
 456     {
 457         0x0660, 0x06f0, 0x0966, 0x09e6, 0x0a66, 0x0ae6, 0x0b66, 0x0c66, 0x0ce6,
 458         0x0d66, 0x0e50, 0x0ed0, 0x0f20, 0x1040, 0x17e0, 0x1810, 0xff10
 459     };
 460     int i;
 461
 462     if ('0' <= c && c <= '9') return c - '0';
 463     if ('A' <= c && c <= 'Z') return c - 'A' + 10;
 464     if ('a' <= c && c <= 'z') return c - 'a' + 10;
 465     for (i = 0; i < ARRAY_SIZE(zeros) && c >= zeros[i]; i++)
 466         if (zeros[i] <= c && c <= zeros[i] + 9) return c - zeros[i];
 467
 468     return -1;
 469 }
 470
 471 /*********************************************************************
 472  *                  wcstol  (NTDLL.@)
 473  */
 474 LONG __cdecl NTDLL_wcstol(LPCWSTR s, LPWSTR *end, INT base)
 475 {
 476     BOOL negative = FALSE, empty = TRUE;
 477     LONG ret = 0;
 478
 479     if (base < 0 || base == 1 || base > 36) return 0;
 480     if (end) *end = (WCHAR *)s;
 481     while (NTDLL_iswspace(*s)) s++;
 482
 483     if (*s == '-')
 484     {
 485         negative = TRUE;
 486         s++;
 487     }
 488     else if (*s == '+') s++;
 489
 490     if ((base == 0 || base == 16) && !wctoint( *s ) && (s[1] == 'x' || s[1] == 'X'))
 491     {
 492         base = 16;
 493         s += 2;
 494     }
 495     if (base == 0) base = wctoint( *s ) ? 10 : 8;
 496
 497     while (*s)
 498     {
 499         int v = wctoint( *s );
 500         if (v < 0 || v >= base) break;
 501         if (negative) v = -v;
 502         s++;
 503         empty = FALSE;
 504
 505         if (!negative && (ret > MAXLONG / base || ret * base > MAXLONG - v))
 506             ret = MAXLONG;
 507         else if (negative && (ret < (LONG)MINLONG / base || ret * base < (LONG)(MINLONG - v)))
 508             ret = MINLONG;
 509         else
 510             ret = ret * base + v;
 511     }
 512
 513     if (end && !empty) *end = (WCHAR *)s;
 514     return ret;
 515 }
 516
 517
 518 /*********************************************************************
 519  *                  wcstoul  (NTDLL.@)
 520  */
 521 ULONG __cdecl NTDLL_wcstoul(LPCWSTR s, LPWSTR *end, INT base)
 522 {
 523     BOOL negative = FALSE, empty = TRUE;
 524     ULONG ret = 0;
 525
 526     if (base < 0 || base == 1 || base > 36) return 0;
 527     if (end) *end = (WCHAR *)s;
 528     while (NTDLL_iswspace(*s)) s++;
 529
 530     if (*s == '-')
 531     {
 532         negative = TRUE;
 533         s++;
 534     }
 535     else if (*s == '+') s++;
 536
 537     if ((base == 0 || base == 16) && !wctoint( *s ) && (s[1] == 'x' || s[1] == 'X'))
 538     {
 539         base = 16;
 540         s += 2;
 541     }
 542     if (base == 0) base = wctoint( *s ) ? 10 : 8;
 543
 544     while (*s)
 545     {
 546         int v = wctoint( *s );
 547         if (v < 0 || v >= base) break;
 548         s++;
 549         empty = FALSE;
 550
 551         if (ret > MAXDWORD / base || ret * base > MAXDWORD - v)
 552             ret = MAXDWORD;
 553         else
 554             ret = ret * base + v;
 555     }
 556
 557     if (end && !empty) *end = (WCHAR *)s;
 558     return negative ? -ret : ret;
 559 }
 560
 561
 562 /*********************************************************************
 563  *      _ultow   (NTDLL.@)
 564  *
 565  * Converts an unsigned long integer to a unicode string.
 566  *
 567  * RETURNS
 568  *  Always returns str.
 569  *
 570  * NOTES
 571  *  Converts value to a '\0' terminated wstring which is copied to str.
 572  *  The maximum length of the copied str is 33 bytes.
 573  *  Does not check if radix is in the range of 2 to 36.
 574  *  If str is NULL it just returns NULL.
 575  */
 576 LPWSTR __cdecl _ultow(
 577     ULONG value,         /* [I] Value to be converted */
 578     LPWSTR str,          /* [O] Destination for the converted value */
 579     INT radix)           /* [I] Number base for conversion */
 580 {
 581     WCHAR buffer[33];
 582     PWCHAR pos;
 583     WCHAR digit;
 584
 585     pos = &buffer[32];
 586     *pos = '\0';
 587
 588     do {
 589         digit = value % radix;
 590         value = value / radix;
 591         if (digit < 10) {
 592             *--pos = '0' + digit;
 593         } else {
 594             *--pos = 'a' + digit - 10;
 595         } /* if */
 596     } while (value != 0L);
 597
 598     if (str != NULL) {
 599         memcpy(str, pos, (&buffer[32] - pos + 1) * sizeof(WCHAR));
 600     } /* if */
 601     return str;
 602 }
 603
 604
 605 /*********************************************************************
 606  *      _ltow   (NTDLL.@)
 607  *
 608  * Converts a long integer to a unicode string.
 609  *
 610  * RETURNS
 611  *  Always returns str.
 612  *
 613  * NOTES
 614  *  Converts value to a '\0' terminated wstring which is copied to str.
 615  *  The maximum length of the copied str is 33 bytes. If radix
 616  *  is 10 and value is negative, the value is converted with sign.
 617  *  Does not check if radix is in the range of 2 to 36.
 618  *  If str is NULL it just returns NULL.
 619  */
 620 LPWSTR __cdecl _ltow(
 621     LONG value, /* [I] Value to be converted */
 622     LPWSTR str, /* [O] Destination for the converted value */
 623     INT radix)  /* [I] Number base for conversion */
 624 {
 625     ULONG val;
 626     int negative;
 627     WCHAR buffer[33];
 628     PWCHAR pos;
 629     WCHAR digit;
 630
 631     if (value < 0 && radix == 10) {
 632         negative = 1;
 633         val = -value;
 634     } else {
 635         negative = 0;
 636         val = value;
 637     } /* if */
 638
 639     pos = &buffer[32];
 640     *pos = '\0';
 641
 642     do {
 643         digit = val % radix;
 644         val = val / radix;
 645         if (digit < 10) {
 646             *--pos = '0' + digit;
 647         } else {
 648             *--pos = 'a' + digit - 10;
 649         } /* if */
 650     } while (val != 0L);
 651
 652     if (negative) {
 653         *--pos = '-';
 654     } /* if */
 655
 656     if (str != NULL) {
 657         memcpy(str, pos, (&buffer[32] - pos + 1) * sizeof(WCHAR));
 658     } /* if */
 659     return str;
 660 }
 661
 662
 663 /*********************************************************************
 664  *      _itow    (NTDLL.@)
 665  *
 666  * Converts an integer to a unicode string.
 667  *
 668  * RETURNS
 669  *  Always returns str.
 670  *
 671  * NOTES
 672  *  Converts value to a '\0' terminated wstring which is copied to str.
 673  *  The maximum length of the copied str is 33 bytes. If radix
 674  *  is 10 and value is negative, the value is converted with sign.
 675  *  Does not check if radix is in the range of 2 to 36.
 676  *  If str is NULL it just returns NULL.
 677  *
 678  * DIFFERENCES
 679  * - The native function crashes when the string is longer than 19 chars.
 680  *   This function does not have this bug.
 681  */
 682 LPWSTR __cdecl _itow(
 683     int value,  /* [I] Value to be converted */
 684     LPWSTR str, /* [O] Destination for the converted value */
 685     INT radix)  /* [I] Number base for conversion */
 686 {
 687     return _ltow(value, str, radix);
 688 }
 689
 690
 691 /*********************************************************************
 692  *      _ui64tow   (NTDLL.@)
 693  *
 694  * Converts a large unsigned integer to a unicode string.
 695  *
 696  * RETURNS
 697  *  Always returns str.
 698  *
 699  * NOTES
 700  *  Converts value to a '\0' terminated wstring which is copied to str.
 701  *  The maximum length of the copied str is 33 bytes.
 702  *  Does not check if radix is in the range of 2 to 36.
 703  *  If str is NULL it just returns NULL.
 704  *
 705  * DIFFERENCES
 706  * - This function does not exist in the native DLL (but in msvcrt).
 707  *   But since the maintenance of all these functions is better done
 708  *   in one place we implement it here.
 709  */
 710 LPWSTR __cdecl _ui64tow(
 711     ULONGLONG value, /* [I] Value to be converted */
 712     LPWSTR str,      /* [O] Destination for the converted value */
 713     INT radix)       /* [I] Number base for conversion */
 714 {
 715     WCHAR buffer[65];
 716     PWCHAR pos;
 717     WCHAR digit;
 718
 719     pos = &buffer[64];
 720     *pos = '\0';
 721
 722     do {
 723         digit = value % radix;
 724         value = value / radix;
 725         if (digit < 10) {
 726             *--pos = '0' + digit;
 727         } else {
 728             *--pos = 'a' + digit - 10;
 729         } /* if */
 730     } while (value != 0L);
 731
 732     if (str != NULL) {
 733         memcpy(str, pos, (&buffer[64] - pos + 1) * sizeof(WCHAR));
 734     } /* if */
 735     return str;
 736 }
 737
 738
 739 /*********************************************************************
 740  *      _i64tow   (NTDLL.@)
 741  *
 742  * Converts a large integer to a unicode string.
 743  *
 744  * RETURNS
 745  *  Always returns str.
 746  *
 747  * NOTES
 748  *  Converts value to a '\0' terminated wstring which is copied to str.
 749  *  The maximum length of the copied str is 33 bytes. If radix
 750  *  is 10 and value is negative, the value is converted with sign.
 751  *  Does not check if radix is in the range of 2 to 36.
 752  *  If str is NULL it just returns NULL.
 753  *
 754  * DIFFERENCES
 755  * - The native DLL converts negative values (for base 10) wrong:
 756  *                     -1 is converted to -18446744073709551615
 757  *                     -2 is converted to -18446744073709551614
 758  *   -9223372036854775807 is converted to  -9223372036854775809
 759  *   -9223372036854775808 is converted to  -9223372036854775808
 760  *   The native msvcrt _i64tow function and our ntdll function do
 761  *   not have this bug.
 762  */
 763 LPWSTR __cdecl _i64tow(
 764     LONGLONG value, /* [I] Value to be converted */
 765     LPWSTR str,     /* [O] Destination for the converted value */
 766     INT radix)      /* [I] Number base for conversion */
 767 {
 768     ULONGLONG val;
 769     int negative;
 770     WCHAR buffer[65];
 771     PWCHAR pos;
 772     WCHAR digit;
 773
 774     if (value < 0 && radix == 10) {
 775         negative = 1;
 776         val = -value;
 777     } else {
 778         negative = 0;
 779         val = value;
 780     } /* if */
 781
 782     pos = &buffer[64];
 783     *pos = '\0';
 784
 785     do {
 786         digit = val % radix;
 787         val = val / radix;
 788         if (digit < 10) {
 789             *--pos = '0' + digit;
 790         } else {
 791             *--pos = 'a' + digit - 10;
 792         } /* if */
 793     } while (val != 0L);
 794
 795     if (negative) {
 796         *--pos = '-';
 797     } /* if */
 798
 799     if (str != NULL) {
 800         memcpy(str, pos, (&buffer[64] - pos + 1) * sizeof(WCHAR));
 801     } /* if */
 802     return str;
 803 }
 804
 805
 806 /*********************************************************************
 807  *      _wtol    (NTDLL.@)
 808  *
 809  * Converts a unicode string to a long integer.
 810  *
 811  * PARAMS
 812  *  str [I] Wstring to be converted
 813  *
 814  * RETURNS
 815  *  On success it returns the integer value otherwise it returns 0.
 816  *
 817  * NOTES
 818  *  Accepts: {whitespace} [+|-] {digits}
 819  *  No check is made for value overflow, only the lower 32 bits are assigned.
 820  *  If str is NULL it crashes, as the native function does.
 821  */
 822 LONG __cdecl _wtol( LPCWSTR str )
 823 {
 824     ULONG RunningTotal = 0;
 825     BOOL bMinus = FALSE;
 826
 827     while (NTDLL_iswspace(*str)) str++;
 828
 829     if (*str == '+') {
 830         str++;
 831     } else if (*str == '-') {
 832         bMinus = TRUE;
 833         str++;
 834     } /* if */
 835
 836     while (*str >= '0' && *str <= '9') {
 837         RunningTotal = RunningTotal * 10 + *str - '0';
 838         str++;
 839     } /* while */
 840
 841     return bMinus ? -RunningTotal : RunningTotal;
 842 }
 843
 844
 845 /*********************************************************************
 846  *      _wtoi    (NTDLL.@)
 847  *
 848  * Converts a unicode string to an integer.
 849  *
 850  * PARAMS
 851  *  str [I] Wstring to be converted
 852  *
 853  * RETURNS
 854  *  On success it returns the integer value otherwise it returns 0.
 855  *
 856  * NOTES
 857  *  Accepts: {whitespace} [+|-] {digits}
 858  *  No check is made for value overflow, only the lower 32 bits are assigned.
 859  *  If str is NULL it crashes, as the native function does.
 860  */
 861 int __cdecl _wtoi( LPCWSTR str )
 862 {
 863     return _wtol(str);
 864 }
 865
 866
 867 /*********************************************************************
 868  *      _wtoi64   (NTDLL.@)
 869  *
 870  * Converts a unicode string to a large integer.
 871  *
 872  * PARAMS
 873  *  str [I] Wstring to be converted
 874  *
 875  * RETURNS
 876  *  On success it returns the integer value otherwise it returns 0.
 877  *
 878  * NOTES
 879  *  Accepts: {whitespace} [+|-] {digits}
 880  *  No check is made for value overflow, only the lower 64 bits are assigned.
 881  *  If str is NULL it crashes, as the native function does.
 882  */
 883 LONGLONG  __cdecl _wtoi64( LPCWSTR str )
 884 {
 885     ULONGLONG RunningTotal = 0;
 886     BOOL bMinus = FALSE;
 887
 888     while (NTDLL_iswspace(*str)) str++;
 889
 890     if (*str == '+') {
 891         str++;
 892     } else if (*str == '-') {
 893         bMinus = TRUE;
 894         str++;
 895     } /* if */
 896
 897     while (*str >= '0' && *str <= '9') {
 898         RunningTotal = RunningTotal * 10 + *str - '0';
 899         str++;
 900     } /* while */
 901
 902     return bMinus ? -RunningTotal : RunningTotal;
 903 }