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