dlls/msvcrt/wcs.c

   1 /*
   2  * msvcrt.dll wide-char functions
   3  *
   4  * Copyright 1999 Alexandre Julliard
   5  * Copyright 2000 Jon Griffiths
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #define _NO_CRT_STDIO_INLINE
  23 #include <limits.h>
  24 #include <locale.h>
  25 #include <math.h>
  26 #include <assert.h>
  27 #include <wchar.h>
  28 #include <wctype.h>
  29 #include "msvcrt.h"
  30 #include "winnls.h"
  31 #include "wtypes.h"
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  35
  36 typedef struct
  37 {
  38     enum { LEN_DEFAULT, LEN_SHORT, LEN_LONG } IntegerLength;
  39     BOOLEAN IntegerDouble, IntegerNative, LeftAlign, Alternate, PadZero;
  40     BOOLEAN WideString, NaturalString;
  41     int FieldLength, Precision;
  42     char Sign, Format;
  43 } pf_flags;
  44
  45 static BOOL n_format_enabled = TRUE;
  46
  47 #include "printf.h"
  48 #define PRINTF_WIDE
  49 #include "printf.h"
  50 #undef PRINTF_WIDE
  51
  52 #if _MSVCR_VER>=80
  53
  54 /*********************************************************************
  55  *              _get_printf_count_output (MSVCR80.@)
  56  */
  57 int CDECL _get_printf_count_output( void )
  58 {
  59     return n_format_enabled ? 1 : 0;
  60 }
  61
  62 /*********************************************************************
  63  *              _set_printf_count_output (MSVCR80.@)
  64  */
  65 int CDECL _set_printf_count_output( int enable )
  66 {
  67     BOOL old = n_format_enabled;
  68     n_format_enabled = enable != 0;
  69     return old ? 1 : 0;
  70 }
  71
  72 #endif /* _MSVCR_VER>=80 */
  73
  74 /*********************************************************************
  75  *              _wcsdup (MSVCRT.@)
  76  */
  77 wchar_t* CDECL _wcsdup( const wchar_t* str )
  78 {
  79   wchar_t* ret = NULL;
  80   if (str)
  81   {
  82     int size = (wcslen(str) + 1) * sizeof(wchar_t);
  83     ret = malloc( size );
  84     if (ret) memcpy( ret, str, size );
  85   }
  86   return ret;
  87 }
  88
  89 /*********************************************************************
  90  *              _towlower_l (MSVCRT.@)
  91  */
  92 wint_t CDECL _towlower_l(wint_t c, _locale_t locale)
  93 {
  94     pthreadlocinfo locinfo;
  95     wchar_t ret;
  96
  97     if(!locale)
  98         locinfo = get_locinfo();
  99     else
 100         locinfo = locale->locinfo;
 101
 102     if(!locinfo->lc_handle[LC_CTYPE]) {
 103         if(c >= 'A' && c <= 'Z')
 104             return c + 'a' - 'A';
 105         return c;
 106     }
 107
 108     if(!LCMapStringW(locinfo->lc_handle[LC_CTYPE], LCMAP_LOWERCASE, &c, 1, &ret, 1))
 109         return c;
 110     return ret;
 111 }
 112
 113 /*********************************************************************
 114  *              towlower (MSVCRT.@)
 115  */
 116 wint_t CDECL towlower(wint_t c)
 117 {
 118     return _towlower_l(c, NULL);
 119 }
 120
 121 INT CDECL _wcsicmp_l(const wchar_t *str1, const wchar_t *str2, _locale_t locale)
 122 {
 123     _locale_tstruct tmp = {0};
 124     wchar_t c1, c2;
 125
 126     if(!MSVCRT_CHECK_PMT(str1 != NULL) || !MSVCRT_CHECK_PMT(str2 != NULL))
 127         return _NLSCMPERROR;
 128
 129     if(!locale)
 130         locale = get_current_locale_noalloc(&tmp);
 131
 132     do
 133     {
 134         c1 = _towlower_l(*str1++, locale);
 135         c2 = _towlower_l(*str2++, locale);
 136     } while(c1 && (c1 == c2));
 137
 138     free_locale_noalloc(&tmp);
 139     return c1 - c2;
 140 }
 141
 142 /*********************************************************************
 143  *      towctrans (MSVCR120.@)
 144  */
 145 wint_t CDECL towctrans(wint_t c, wctrans_t category)
 146 {
 147     if(category == 1)
 148         return _towupper_l(c, NULL);
 149     return _towlower_l(c, NULL);
 150 }
 151
 152 /*********************************************************************
 153  *              _wcsicmp (MSVCRT.@)
 154  */
 155 INT CDECL _wcsicmp( const wchar_t* str1, const wchar_t* str2 )
 156 {
 157     return _wcsicmp_l(str1, str2, NULL);
 158 }
 159
 160 /*********************************************************************
 161  *              _wcsnicmp_l (MSVCRT.@)
 162  */
 163 INT CDECL _wcsnicmp_l(const wchar_t *str1, const wchar_t *str2,
 164         size_t n, _locale_t locale)
 165 {
 166     _locale_tstruct tmp = {0};
 167     wchar_t c1, c2;
 168
 169     if (!n)
 170         return 0;
 171
 172     if(!MSVCRT_CHECK_PMT(str1 != NULL) || !MSVCRT_CHECK_PMT(str2 != NULL))
 173         return _NLSCMPERROR;
 174
 175     if(!locale)
 176         locale = get_current_locale_noalloc(&tmp);
 177
 178     do
 179     {
 180         c1 = _towlower_l(*str1++, locale);
 181         c2 = _towlower_l(*str2++, locale);
 182     } while(--n && c1 && (c1 == c2));
 183
 184     free_locale_noalloc(&tmp);
 185     return c1 - c2;
 186 }
 187
 188 /*********************************************************************
 189  *              _wcsnicmp (MSVCRT.@)
 190  */
 191 INT CDECL _wcsnicmp(const wchar_t *str1, const wchar_t *str2, size_t n)
 192 {
 193     return _wcsnicmp_l(str1, str2, n, NULL);
 194 }
 195
 196 /*********************************************************************
 197  *              _wcsicoll_l (MSVCRT.@)
 198  */
 199 int CDECL _wcsicoll_l(const wchar_t* str1, const wchar_t* str2, _locale_t locale)
 200 {
 201     pthreadlocinfo locinfo;
 202
 203     if(!locale)
 204         locinfo = get_locinfo();
 205     else
 206         locinfo = locale->locinfo;
 207
 208     if(!locinfo->lc_handle[LC_COLLATE])
 209     {
 210         wchar_t c1, c2;
 211
 212         do
 213         {
 214             c1 = *str1++;
 215             if (c1 >= 'A' && c1 <= 'Z')
 216                 c1 += 'a' - 'A';
 217
 218             c2 = *str2++;
 219             if (c2 >= 'A' && c2 <= 'Z')
 220                 c2 += 'a' - 'A';
 221         } while(c1 && (c1 == c2));
 222         return c1 - c2;
 223     }
 224
 225     return CompareStringW(locinfo->lc_handle[LC_COLLATE], NORM_IGNORECASE,
 226                           str1, -1, str2, -1)-CSTR_EQUAL;
 227 }
 228
 229 /*********************************************************************
 230  *              _wcsicoll (MSVCRT.@)
 231  */
 232 INT CDECL _wcsicoll( const wchar_t* str1, const wchar_t* str2 )
 233 {
 234     return _wcsicoll_l(str1, str2, NULL);
 235 }
 236
 237 /*********************************************************************
 238  *              _wcsnicoll_l (MSVCRT.@)
 239  */
 240 int CDECL _wcsnicoll_l(const wchar_t* str1, const wchar_t* str2,
 241                               size_t count, _locale_t locale)
 242 {
 243     pthreadlocinfo locinfo;
 244
 245     if(!locale)
 246         locinfo = get_locinfo();
 247     else
 248         locinfo = locale->locinfo;
 249
 250     if(!locinfo->lc_handle[LC_COLLATE])
 251     {
 252         wchar_t c1, c2;
 253
 254         if (!count)
 255             return 0;
 256
 257         do
 258         {
 259             c1 = *str1++;
 260             if (c1 >= 'A' && c1 <= 'Z')
 261                 c1 += 'a' - 'A';
 262
 263             c2 = *str2++;
 264             if (c2 >= 'A' && c2 <= 'Z')
 265                 c2 += 'a' - 'A';
 266         } while(--count && c1 && (c1 == c2));
 267         return c1 - c2;
 268     }
 269
 270     return CompareStringW(locinfo->lc_handle[LC_COLLATE], NORM_IGNORECASE,
 271                           str1, wcsnlen(str1, count),
 272                           str2, wcsnlen(str2, count))-CSTR_EQUAL;
 273 }
 274
 275 /*********************************************************************
 276  *              _wcsnicoll (MSVCRT.@)
 277  */
 278 INT CDECL _wcsnicoll( const wchar_t* str1, const wchar_t* str2, size_t count )
 279 {
 280     return _wcsnicoll_l(str1, str2, count, NULL);
 281 }
 282
 283 /*********************************************************************
 284  *              _wcsnset (MSVCRT.@)
 285  */
 286 wchar_t* CDECL _wcsnset( wchar_t* str, wchar_t c, size_t n )
 287 {
 288   wchar_t* ret = str;
 289   while ((n-- > 0) && *str) *str++ = c;
 290   return ret;
 291 }
 292
 293 /*********************************************************************
 294  *              _wcsnset_s (MSVCRT.@)
 295  */
 296 int CDECL _wcsnset_s( wchar_t *str, size_t size, wchar_t c, size_t count )
 297 {
 298     size_t i;
 299
 300     if(!str && !size && !count) return 0;
 301     if(!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
 302     if(!MSVCRT_CHECK_PMT(size > 0)) return EINVAL;
 303
 304     for(i=0; i<size-1 && i<count; i++) {
 305         if(!str[i]) return 0;
 306         str[i] = c;
 307     }
 308     for(; i<size; i++)
 309         if(!str[i]) return 0;
 310
 311     str[0] = 0;
 312     _invalid_parameter(NULL, NULL, NULL, 0, 0);
 313     *_errno() = EINVAL;
 314     return EINVAL;
 315 }
 316
 317 /*********************************************************************
 318  *              _wcsrev (MSVCRT.@)
 319  */
 320 wchar_t* CDECL _wcsrev( wchar_t* str )
 321 {
 322   wchar_t* ret = str;
 323   wchar_t* end = str + wcslen(str) - 1;
 324   while (end > str)
 325   {
 326     wchar_t t = *end;
 327     *end--  = *str;
 328     *str++  = t;
 329   }
 330   return ret;
 331 }
 332
 333 /*********************************************************************
 334  *              _wcsset_s (MSVCRT.@)
 335  */
 336 int CDECL _wcsset_s( wchar_t *str, size_t n, wchar_t c )
 337 {
 338     wchar_t *p = str;
 339
 340     if(!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
 341     if(!MSVCRT_CHECK_PMT(n)) return EINVAL;
 342
 343     while(*p && --n) *p++ = c;
 344     if(!n) {
 345         str[0] = 0;
 346         _invalid_parameter(NULL, NULL, NULL, 0, 0);
 347         *_errno() = EINVAL;
 348         return EINVAL;
 349     }
 350     return 0;
 351 }
 352
 353 /*********************************************************************
 354  *              _wcsset (MSVCRT.@)
 355  */
 356 wchar_t* CDECL _wcsset( wchar_t* str, wchar_t c )
 357 {
 358   wchar_t* ret = str;
 359   while (*str) *str++ = c;
 360   return ret;
 361 }
 362
 363 /******************************************************************
 364  *              _wcsupr_s_l (MSVCRT.@)
 365  */
 366 int CDECL _wcsupr_s_l( wchar_t* str, size_t n, _locale_t locale )
 367 {
 368   _locale_tstruct tmp = {0};
 369   wchar_t* ptr = str;
 370
 371   if (!str || !n)
 372   {
 373     if (str) *str = '\0';
 374     *_errno() = EINVAL;
 375     return EINVAL;
 376   }
 377
 378   if(!locale)
 379     locale = get_current_locale_noalloc(&tmp);
 380
 381   while (n--)
 382   {
 383     if (!*ptr)
 384     {
 385       free_locale_noalloc(&tmp);
 386       return 0;
 387     }
 388     *ptr = _towupper_l(*ptr, locale);
 389     ptr++;
 390   }
 391
 392   free_locale_noalloc(&tmp);
 393
 394   /* MSDN claims that the function should return and set errno to
 395    * ERANGE, which doesn't seem to be true based on the tests. */
 396   *str = '\0';
 397   *_errno() = EINVAL;
 398   return EINVAL;
 399 }
 400
 401 /******************************************************************
 402  *              _wcsupr_s (MSVCRT.@)
 403  *
 404  */
 405 INT CDECL _wcsupr_s( wchar_t* str, size_t n )
 406 {
 407   return _wcsupr_s_l( str, n, NULL );
 408 }
 409
 410 /******************************************************************
 411  *              _wcsupr_l (MSVCRT.@)
 412  */
 413 wchar_t* CDECL _wcsupr_l( wchar_t *str, _locale_t locale )
 414 {
 415     _wcsupr_s_l( str, -1, locale);
 416     return str;
 417 }
 418
 419 /******************************************************************
 420  *              _wcsupr (MSVCRT.@)
 421  */
 422 wchar_t* CDECL _wcsupr( wchar_t *str )
 423 {
 424     return _wcsupr_l(str, NULL);
 425 }
 426
 427 /******************************************************************
 428  *              _wcslwr_s_l (MSVCRT.@)
 429  */
 430 int CDECL _wcslwr_s_l( wchar_t* str, size_t n, _locale_t locale )
 431 {
 432   _locale_tstruct tmp = {0};
 433   wchar_t* ptr = str;
 434
 435   if (!str || !n)
 436   {
 437     if (str) *str = '\0';
 438     *_errno() = EINVAL;
 439     return EINVAL;
 440   }
 441
 442   if(!locale)
 443     locale = get_current_locale_noalloc(&tmp);
 444
 445   while (n--)
 446   {
 447     if (!*ptr)
 448     {
 449       free_locale_noalloc(&tmp);
 450       return 0;
 451     }
 452     *ptr = _towlower_l(*ptr, locale);
 453     ptr++;
 454   }
 455
 456   free_locale_noalloc(&tmp);
 457
 458   /* MSDN claims that the function should return and set errno to
 459    * ERANGE, which doesn't seem to be true based on the tests. */
 460   *str = '\0';
 461   *_errno() = EINVAL;
 462   return EINVAL;
 463 }
 464
 465 /******************************************************************
 466  *              _wcslwr_s (MSVCRT.@)
 467  */
 468 int CDECL _wcslwr_s( wchar_t* str, size_t n )
 469 {
 470     return _wcslwr_s_l(str, n, NULL);
 471 }
 472
 473 /******************************************************************
 474  *              _wcslwr_l (MSVCRT.@)
 475  */
 476 wchar_t* CDECL _wcslwr_l( wchar_t* str, _locale_t locale )
 477 {
 478     _wcslwr_s_l(str, -1, locale);
 479     return str;
 480 }
 481
 482 /******************************************************************
 483  *              _wcslwr (MSVCRT.@)
 484  */
 485 wchar_t* CDECL _wcslwr( wchar_t* str )
 486 {
 487     _wcslwr_s_l(str, -1, NULL);
 488     return str;
 489 }
 490
 491 /*********************************************************************
 492  *           wcscspn    (MSVCRT.@)
 493  */
 494 size_t __cdecl wcscspn(const wchar_t *str, const wchar_t *reject)
 495 {
 496     const wchar_t *ptr;
 497     for (ptr = str; *ptr; ptr++) if (wcschr( reject, *ptr )) break;
 498     return ptr - str;
 499 }
 500
 501 /*********************************************************************
 502  *           wcsspn    (MSVCRT.@)
 503  */
 504 size_t __cdecl wcsspn(const wchar_t *str, const wchar_t *accept)
 505 {
 506     const wchar_t *ptr;
 507     for (ptr = str; *ptr; ptr++) if (!wcschr( accept, *ptr )) break;
 508     return ptr - str;
 509 }
 510
 511 /*********************************************************************
 512  *           wcsncmp    (MSVCRT.@)
 513  */
 514 int CDECL wcsncmp(const wchar_t *str1, const wchar_t *str2, size_t n)
 515 {
 516     if (!n)
 517         return 0;
 518     while(--n && *str1 && (*str1 == *str2))
 519     {
 520         str1++;
 521         str2++;
 522     }
 523     return *str1 - *str2;
 524 }
 525
 526 /*********************************************************************
 527  *              _wcsncoll_l (MSVCRT.@)
 528  */
 529 int CDECL _wcsncoll_l(const wchar_t* str1, const wchar_t* str2,
 530                               size_t count, _locale_t locale)
 531 {
 532     pthreadlocinfo locinfo;
 533
 534     if(!locale)
 535         locinfo = get_locinfo();
 536     else
 537         locinfo = locale->locinfo;
 538
 539     if(!locinfo->lc_handle[LC_COLLATE])
 540         return wcsncmp(str1, str2, count);
 541     return CompareStringW(locinfo->lc_handle[LC_COLLATE], 0,
 542               str1, wcsnlen(str1, count),
 543               str2, wcsnlen(str2, count))-CSTR_EQUAL;
 544 }
 545
 546 /*********************************************************************
 547  *              _wcsncoll (MSVCRT.@)
 548  */
 549 int CDECL _wcsncoll(const wchar_t* str1, const wchar_t* str2, size_t count)
 550 {
 551     return _wcsncoll_l(str1, str2, count, NULL);
 552 }
 553
 554 static wchar_t strtod_wstr_get(void *ctx)
 555 {
 556     const wchar_t **p = ctx;
 557     if (!**p) return WEOF;
 558     return *(*p)++;
 559 }
 560
 561 static void strtod_wstr_unget(void *ctx)
 562 {
 563     const wchar_t **p = ctx;
 564     (*p)--;
 565 }
 566
 567 /*********************************************************************
 568  *              _wcstod_l (MSVCRT.@)
 569  */
 570 double CDECL _wcstod_l(const wchar_t* str, wchar_t** end,
 571         _locale_t locale)
 572 {
 573     pthreadlocinfo locinfo;
 574     const wchar_t *beg, *p;
 575     struct fpnum fp;
 576     double ret;
 577     int err;
 578
 579     if (!MSVCRT_CHECK_PMT(str != NULL)) {
 580         if (end) *end = NULL;
 581         return 0;
 582     }
 583
 584     if (!locale)
 585         locinfo = get_locinfo();
 586     else
 587         locinfo = locale->locinfo;
 588
 589     p = str;
 590     while(_iswspace_l(*p, locale))
 591         p++;
 592     beg = p;
 593
 594     fp = fpnum_parse(strtod_wstr_get, strtod_wstr_unget, &p, locinfo, FALSE);
 595     if (end) *end = (p == beg ? (wchar_t*)str : (wchar_t*)p);
 596
 597     err = fpnum_double(&fp, &ret);
 598     if(err) *_errno() = err;
 599     return ret;
 600 }
 601
 602 /*********************************************************************
 603  * wcsrtombs_l (INTERNAL)
 604  */
 605 static size_t wcsrtombs_l(char *mbstr, const wchar_t **wcstr,
 606         size_t count, _locale_t locale)
 607 {
 608     pthreadlocinfo locinfo;
 609     size_t tmp = 0;
 610     BOOL used_default = FALSE;
 611     BOOL *pused_default;
 612
 613     if(!locale)
 614         locinfo = get_locinfo();
 615     else
 616         locinfo = locale->locinfo;
 617
 618     if(!locinfo->lc_codepage) {
 619         size_t i;
 620
 621         if(!mbstr)
 622             return wcslen(*wcstr);
 623
 624         for(i=0; i<count; i++) {
 625             if((*wcstr)[i] > 255) {
 626                 *_errno() = EILSEQ;
 627                 return -1;
 628             }
 629
 630             mbstr[i] = (*wcstr)[i];
 631             if(!(*wcstr)[i]) break;
 632         }
 633
 634         if(i < count) *wcstr = NULL;
 635         else *wcstr += i;
 636         return i;
 637     }
 638
 639     pused_default = (locinfo->lc_codepage != CP_UTF8 ? &used_default : NULL);
 640
 641     if(!mbstr) {
 642         tmp = WideCharToMultiByte(locinfo->lc_codepage, WC_NO_BEST_FIT_CHARS,
 643                 *wcstr, -1, NULL, 0, NULL, pused_default);
 644         if(!tmp || used_default) {
 645             *_errno() = EILSEQ;
 646             return -1;
 647         }
 648         return tmp-1;
 649     }
 650
 651     while(**wcstr) {
 652         char buf[3];
 653         size_t i, size;
 654
 655         size = WideCharToMultiByte(locinfo->lc_codepage, WC_NO_BEST_FIT_CHARS,
 656                 *wcstr, 1, buf, 3, NULL, pused_default);
 657         if(!size || used_default) {
 658             *_errno() = EILSEQ;
 659             return -1;
 660         }
 661         if(tmp+size > count)
 662             return tmp;
 663
 664         for(i=0; i<size; i++)
 665             mbstr[tmp++] = buf[i];
 666         (*wcstr)++;
 667     }
 668
 669     if(tmp < count) {
 670         mbstr[tmp] = '\0';
 671         *wcstr = NULL;
 672     }
 673     return tmp;
 674 }
 675
 676 /*********************************************************************
 677  *              _wcstombs_l (MSVCRT.@)
 678  */
 679 size_t CDECL _wcstombs_l(char *mbstr, const wchar_t *wcstr,
 680         size_t count, _locale_t locale)
 681 {
 682     return wcsrtombs_l(mbstr, &wcstr, count, locale);
 683 }
 684
 685 /*********************************************************************
 686  *              wcstombs (MSVCRT.@)
 687  */
 688 size_t CDECL wcstombs(char *mbstr, const wchar_t *wcstr,
 689         size_t count)
 690 {
 691     return wcsrtombs_l(mbstr, &wcstr, count, NULL);
 692 }
 693
 694 /*********************************************************************
 695  *              wcsrtombs (MSVCRT.@)
 696  */
 697 size_t CDECL wcsrtombs(char *mbstr, const wchar_t **wcstr,
 698         size_t count, mbstate_t *mbstate)
 699 {
 700     if(mbstate)
 701         *mbstate = 0;
 702
 703     return wcsrtombs_l(mbstr, wcstr, count, NULL);
 704 }
 705
 706 /*********************************************************************
 707  * wcsrtombs_s_l (INTERNAL)
 708  */
 709 static int wcsrtombs_s_l(size_t *ret, char *mbstr, size_t size,
 710         const wchar_t **wcstr, size_t count, _locale_t locale)
 711 {
 712     size_t conv;
 713     int err;
 714
 715     if(!mbstr && !size && wcstr) {
 716         conv = wcsrtombs_l(NULL, wcstr, 0, locale);
 717         if(ret)
 718             *ret = conv+1;
 719         if(conv == -1)
 720             return *_errno();
 721         return 0;
 722     }
 723
 724     if (!MSVCRT_CHECK_PMT(mbstr != NULL)) return EINVAL;
 725     if (size) mbstr[0] = '\0';
 726     if (!MSVCRT_CHECK_PMT(wcstr != NULL)) return EINVAL;
 727     if (!MSVCRT_CHECK_PMT(*wcstr != NULL)) return EINVAL;
 728
 729     if(count==_TRUNCATE || size<count)
 730         conv = size;
 731     else
 732         conv = count;
 733
 734     err = 0;
 735     conv = wcsrtombs_l(mbstr, wcstr, conv, locale);
 736     if(conv == -1) {
 737         conv = 0;
 738         if(size)
 739             mbstr[0] = '\0';
 740         err = *_errno();
 741     }else if(conv < size)
 742         mbstr[conv++] = '\0';
 743     else if(conv==size && (count==_TRUNCATE || mbstr[conv-1]=='\0')) {
 744         mbstr[conv-1] = '\0';
 745         if(count==_TRUNCATE)
 746             err = STRUNCATE;
 747     }else {
 748         MSVCRT_INVALID_PMT("mbstr[size] is too small", ERANGE);
 749         conv = 0;
 750         if(size)
 751             mbstr[0] = '\0';
 752         err = ERANGE;
 753     }
 754
 755     if(ret)
 756         *ret = conv;
 757     return err;
 758 }
 759
 760 /*********************************************************************
 761  *              _wcstombs_s_l (MSVCRT.@)
 762  */
 763 int CDECL _wcstombs_s_l(size_t *ret, char *mbstr, size_t size,
 764         const wchar_t *wcstr, size_t count, _locale_t locale)
 765 {
 766     return wcsrtombs_s_l(ret, mbstr, size, &wcstr,count, locale);
 767 }
 768
 769 /*********************************************************************
 770  *              wcstombs_s (MSVCRT.@)
 771  */
 772 int CDECL wcstombs_s(size_t *ret, char *mbstr, size_t size,
 773         const wchar_t *wcstr, size_t count)
 774 {
 775     return wcsrtombs_s_l(ret, mbstr, size, &wcstr, count, NULL);
 776 }
 777
 778 /*********************************************************************
 779  *              wcsrtombs_s (MSVCRT.@)
 780  */
 781 int CDECL wcsrtombs_s(size_t *ret, char *mbstr, size_t size,
 782         const wchar_t **wcstr, size_t count, mbstate_t *mbstate)
 783 {
 784     if(mbstate)
 785         *mbstate = 0;
 786
 787     return wcsrtombs_s_l(ret, mbstr, size, wcstr, count, NULL);
 788 }
 789
 790 /*********************************************************************
 791  *              wcstod (MSVCRT.@)
 792  */
 793 double CDECL wcstod(const wchar_t* lpszStr, wchar_t** end)
 794 {
 795     return _wcstod_l(lpszStr, end, NULL);
 796 }
 797
 798 /*********************************************************************
 799  *              _wtof (MSVCRT.@)
 800  */
 801 double CDECL _wtof(const wchar_t *str)
 802 {
 803     return _wcstod_l(str, NULL, NULL);
 804 }
 805
 806 /*********************************************************************
 807  *              _wtof_l (MSVCRT.@)
 808  */
 809 double CDECL _wtof_l(const wchar_t *str, _locale_t locale)
 810 {
 811     return _wcstod_l(str, NULL, locale);
 812 }
 813
 814 #if _MSVCR_VER>=120
 815
 816 /*********************************************************************
 817  *              _wcstof_l  (MSVCR120.@)
 818  */
 819 float CDECL _wcstof_l( const wchar_t *str, wchar_t **end, _locale_t locale )
 820 {
 821     double ret = _wcstod_l(str, end, locale);
 822     if (ret && isfinite(ret)) {
 823         float f = ret;
 824         if (!f || !isfinite(f))
 825             *_errno() = ERANGE;
 826     }
 827     return ret;
 828 }
 829
 830 /*********************************************************************
 831  *              wcstof  (MSVCR120.@)
 832  */
 833 float CDECL wcstof( const wchar_t *str, wchar_t **end )
 834 {
 835     return _wcstof_l(str, end, NULL);
 836 }
 837
 838 #endif /* _MSVCR_VER>=120 */
 839
 840 /*********************************************************************
 841  * arg_clbk_valist (INTERNAL)
 842  */
 843 printf_arg arg_clbk_valist(void *ctx, int arg_pos, int type, va_list *valist)
 844 {
 845     printf_arg ret;
 846
 847     if(type == VT_I8)
 848         ret.get_longlong = va_arg(*valist, LONGLONG);
 849     else if(type == VT_INT)
 850         ret.get_int = va_arg(*valist, int);
 851     else if(type == VT_R8)
 852         ret.get_double = va_arg(*valist, double);
 853     else if(type == VT_PTR)
 854         ret.get_ptr = va_arg(*valist, void*);
 855     else {
 856         ERR("Incorrect type\n");
 857         ret.get_int = 0;
 858     }
 859
 860     return ret;
 861 }
 862
 863 /*********************************************************************
 864  * arg_clbk_positional (INTERNAL)
 865  */
 866 printf_arg arg_clbk_positional(void *ctx, int pos, int type, va_list *valist)
 867 {
 868     printf_arg *args = ctx;
 869     return args[pos];
 870 }
 871
 872 #if _MSVCR_VER < 140
 873
 874 /*********************************************************************
 875  *              _vsnprintf (MSVCRT.@)
 876  */
 877 int CDECL _vsnprintf( char *str, size_t len, const char *format, va_list valist )
 878 {
 879     static const char nullbyte = '\0';
 880     struct _str_ctx_a ctx = {len, str};
 881     int ret;
 882
 883     ret = pf_printf_a(puts_clbk_str_a, &ctx, format, NULL, 0,
 884             arg_clbk_valist, NULL, &valist);
 885     puts_clbk_str_a(&ctx, 1, &nullbyte);
 886     return ret;
 887 }
 888
 889 #else
 890
 891 static int puts_clbk_str_c99_a(void *ctx, int len, const char *str)
 892 {
 893     struct _str_ctx_a *out = ctx;
 894
 895     if(!out->buf)
 896         return len;
 897
 898     if(out->len < len) {
 899         memmove(out->buf, str, out->len);
 900         out->buf += out->len;
 901         out->len = 0;
 902         return len;
 903     }
 904
 905     memmove(out->buf, str, len);
 906     out->buf += len;
 907     out->len -= len;
 908     return len;
 909 }
 910
 911 /*********************************************************************
 912  *              __stdio_common_vsprintf (UCRTBASE.@)
 913  */
 914 int CDECL __stdio_common_vsprintf( unsigned __int64 options, char *str, size_t len, const char *format,
 915                                    _locale_t locale, va_list valist )
 916 {
 917     static const char nullbyte = '\0';
 918     struct _str_ctx_a ctx = {len, str};
 919     int ret;
 920
 921     if (options & ~UCRTBASE_PRINTF_MASK)
 922         FIXME("options %#I64x not handled\n", options);
 923     ret = pf_printf_a(puts_clbk_str_c99_a,
 924             &ctx, format, (_locale_t)locale, options & UCRTBASE_PRINTF_MASK, arg_clbk_valist, NULL, &valist);
 925     puts_clbk_str_a(&ctx, 1, &nullbyte);
 926
 927     if(!str)
 928         return ret;
 929     if(options & _CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION)
 930         return ret>len ? -1 : ret;
 931     if(ret>=len) {
 932         if(len) str[len-1] = 0;
 933         if(options & _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR)
 934             return ret;
 935         return len > 0 ? -2 : -1;
 936     }
 937     return ret;
 938 }
 939
 940 #endif /* _MSVCR_VER>=140 */
 941
 942 /*********************************************************************
 943  *              _vsnprintf_l (MSVCRT.@)
 944  */
 945 int CDECL _vsnprintf_l( char *str, size_t len, const char *format,
 946                             _locale_t locale, va_list valist )
 947 {
 948     static const char nullbyte = '\0';
 949     struct _str_ctx_a ctx = {len, str};
 950     int ret;
 951
 952     ret = pf_printf_a(puts_clbk_str_a, &ctx, format, locale, 0,
 953             arg_clbk_valist, NULL, &valist);
 954     puts_clbk_str_a(&ctx, 1, &nullbyte);
 955     return ret;
 956 }
 957
 958 /*********************************************************************
 959  *              _vsprintf_l (MSVCRT.@)
 960  */
 961 int CDECL _vsprintf_l( char *str, const char *format,
 962                             _locale_t locale, va_list valist )
 963 {
 964     return _vsnprintf_l(str, INT_MAX, format, locale, valist);
 965 }
 966
 967 /*********************************************************************
 968  *              _sprintf_l (MSVCRT.@)
 969  */
 970 int WINAPIV _sprintf_l(char *str, const char *format,
 971                            _locale_t locale, ...)
 972 {
 973     int retval;
 974     va_list valist;
 975     va_start(valist, locale);
 976     retval = _vsnprintf_l(str, INT_MAX, format, locale, valist);
 977     va_end(valist);
 978     return retval;
 979 }
 980
 981 static int CDECL vsnprintf_s_l_opt( char *str, size_t sizeOfBuffer,
 982         size_t count, const char *format, DWORD options,
 983         _locale_t locale, va_list valist )
 984 {
 985     static const char nullbyte = '\0';
 986     struct _str_ctx_a ctx;
 987     int len, ret;
 988
 989     if(sizeOfBuffer<count+1 || count==-1)
 990         len = sizeOfBuffer;
 991     else
 992         len = count+1;
 993
 994     ctx.len = len;
 995     ctx.buf = str;
 996     ret = pf_printf_a(puts_clbk_str_a, &ctx, format, locale, MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER | options,
 997             arg_clbk_valist, NULL, &valist);
 998     puts_clbk_str_a(&ctx, 1, &nullbyte);
 999
1000     if(ret<0 || ret==len) {
1001         if(count!=_TRUNCATE && count>sizeOfBuffer) {
1002             MSVCRT_INVALID_PMT("str[sizeOfBuffer] is too small", ERANGE);
1003             memset(str, 0, sizeOfBuffer);
1004         } else
1005             str[len-1] = '\0';
1006
1007         return -1;
1008     }
1009
1010     return ret;
1011 }
1012
1013 static int vsnwprintf_s_l_opt( wchar_t *str, size_t sizeOfBuffer,
1014         size_t count, const wchar_t *format, DWORD options,
1015         _locale_t locale, va_list valist)
1016 {
1017     struct _str_ctx_w ctx;
1018     int len, ret;
1019
1020     len = sizeOfBuffer;
1021     if(count!=-1 && len>count+1)
1022         len = count+1;
1023
1024     ctx.len = len;
1025     ctx.buf = str;
1026     ret = pf_printf_w(puts_clbk_str_w, &ctx, format, locale, MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER | options,
1027             arg_clbk_valist, NULL, &valist);
1028     puts_clbk_str_w(&ctx, 1, L"");
1029
1030     if(ret<0 || ret==len) {
1031         if(count!=_TRUNCATE && count>sizeOfBuffer) {
1032             MSVCRT_INVALID_PMT("str[sizeOfBuffer] is too small", ERANGE);
1033             memset(str, 0, sizeOfBuffer*sizeof(wchar_t));
1034         } else
1035             str[len-1] = '\0';
1036
1037         return -1;
1038     }
1039
1040     return ret;
1041 }
1042
1043 /*********************************************************************
1044  *              _vsnprintf_s_l (MSVCRT.@)
1045  */
1046 int CDECL _vsnprintf_s_l( char *str, size_t sizeOfBuffer,
1047         size_t count, const char *format,
1048         _locale_t locale, va_list valist )
1049 {
1050     return vsnprintf_s_l_opt(str, sizeOfBuffer, count, format, 0, locale, valist);
1051 }
1052
1053 /*********************************************************************
1054  *              _vsprintf_s_l (MSVCRT.@)
1055  */
1056 int CDECL _vsprintf_s_l( char *str, size_t count, const char *format,
1057                                _locale_t locale, va_list valist )
1058 {
1059     return _vsnprintf_s_l(str, INT_MAX, count, format, locale, valist);
1060 }
1061
1062 /*********************************************************************
1063  *              _sprintf_s_l (MSVCRT.@)
1064  */
1065 int WINAPIV _sprintf_s_l( char *str, size_t count, const char *format,
1066                                 _locale_t locale, ...)
1067 {
1068     int retval;
1069     va_list valist;
1070     va_start(valist, locale);
1071     retval = _vsnprintf_s_l(str, INT_MAX, count, format, locale, valist);
1072     va_end(valist);
1073     return retval;
1074 }
1075
1076 /*********************************************************************
1077  *              _vsnprintf_s (MSVCRT.@)
1078  */
1079 int CDECL _vsnprintf_s( char *str, size_t sizeOfBuffer,
1080         size_t count, const char *format, va_list valist )
1081 {
1082     return _vsnprintf_s_l(str,sizeOfBuffer, count, format, NULL, valist);
1083 }
1084
1085 /*********************************************************************
1086  *              _vsnprintf_c_l (MSVCRT.@)
1087  */
1088 int CDECL _vsnprintf_c_l(char *str, size_t len, const char *format,
1089         _locale_t locale, va_list valist)
1090 {
1091     return vsnprintf_s_l_opt(str, len, len, format, 0, locale, valist);
1092 }
1093
1094 /*********************************************************************
1095  *              _vsnprintf_c (MSVCRT.@)
1096  */
1097 int CDECL _vsnprintf_c(char *str, size_t len,
1098         const char *format, va_list valist)
1099 {
1100     return _vsnprintf_c_l(str, len, format, NULL, valist);
1101 }
1102
1103 #if _MSVCR_VER>=140
1104
1105 /*********************************************************************
1106  *              __stdio_common_vsnprintf_s (UCRTBASE.@)
1107  */
1108 int CDECL __stdio_common_vsnprintf_s( unsigned __int64 options,
1109         char *str, size_t sizeOfBuffer, size_t count,
1110         const char *format, _locale_t locale, va_list valist )
1111 {
1112     if (options & ~UCRTBASE_PRINTF_MASK)
1113         FIXME("options %#I64x not handled\n", options);
1114     return vsnprintf_s_l_opt(str, sizeOfBuffer, count, format, options & UCRTBASE_PRINTF_MASK, locale, valist);
1115 }
1116
1117 /*********************************************************************
1118  *              __stdio_common_vsnwprintf_s (UCRTBASE.@)
1119  */
1120 int CDECL __stdio_common_vsnwprintf_s( unsigned __int64 options,
1121         wchar_t *str, size_t sizeOfBuffer, size_t count,
1122         const wchar_t *format, _locale_t locale, va_list valist )
1123 {
1124     if (options & ~UCRTBASE_PRINTF_MASK)
1125         FIXME("options %#I64x not handled\n", options);
1126     return vsnwprintf_s_l_opt(str, sizeOfBuffer, count, format, options & UCRTBASE_PRINTF_MASK, locale, valist);
1127 }
1128
1129 /*********************************************************************
1130  *              __stdio_common_vswprintf_s (UCRTBASE.@)
1131  */
1132 int CDECL __stdio_common_vswprintf_s( unsigned __int64 options,
1133         wchar_t *str, size_t count, const wchar_t *format,
1134         _locale_t locale, va_list valist )
1135 {
1136     return __stdio_common_vsnwprintf_s(options, str, INT_MAX, count, format, locale, valist);
1137 }
1138
1139 /*********************************************************************
1140  *              __stdio_common_vsprintf_s (UCRTBASE.@)
1141  */
1142 int CDECL __stdio_common_vsprintf_s( unsigned __int64 options,
1143         char *str, size_t count, const char *format,
1144         _locale_t locale, va_list valist )
1145 {
1146     if (options & ~UCRTBASE_PRINTF_MASK)
1147         FIXME("options %#I64x not handled\n", options);
1148     return vsnprintf_s_l_opt(str, INT_MAX, count, format, options & UCRTBASE_PRINTF_MASK, locale, valist);
1149 }
1150
1151 #endif /* _MSVCR_VER>=140 */
1152
1153 /*********************************************************************
1154  *              vsprintf (MSVCRT.@)
1155  */
1156 int CDECL vsprintf( char *str, const char *format, va_list valist)
1157 {
1158     return vsnprintf(str, INT_MAX, format, valist);
1159 }
1160
1161 /*********************************************************************
1162  *              vsprintf_s (MSVCRT.@)
1163  */
1164 int CDECL vsprintf_s( char *str, size_t num, const char *format, va_list valist)
1165 {
1166     return vsnprintf(str, num, format, valist);
1167 }
1168
1169 /*********************************************************************
1170  *              _vscprintf (MSVCRT.@)
1171  */
1172 int CDECL _vscprintf( const char *format, va_list valist )
1173 {
1174     return _vsnprintf_l( NULL, INT_MAX, format, NULL, valist );
1175 }
1176
1177 /*********************************************************************
1178  *              _vscprintf_l (MSVCRT.@)
1179  */
1180 int CDECL _vscprintf_l(const char *format,
1181         _locale_t locale, va_list valist)
1182 {
1183     return _vsnprintf_l(NULL, INT_MAX, format, locale, valist);
1184 }
1185
1186 /*********************************************************************
1187  *              _vscprintf_p_l (MSVCRT.@)
1188  */
1189 int CDECL _vscprintf_p_l(const char *format,
1190         _locale_t locale, va_list args)
1191 {
1192     printf_arg args_ctx[_ARGMAX+1];
1193     struct _str_ctx_a puts_ctx = {INT_MAX, NULL};
1194     int ret;
1195
1196     memset(args_ctx, 0, sizeof(args_ctx));
1197
1198     ret = create_positional_ctx_a(args_ctx, format, args);
1199     if(ret < 0)  {
1200         _invalid_parameter(NULL, NULL, NULL, 0, 0);
1201         *_errno() = EINVAL;
1202         return ret;
1203     } else if(ret == 0) {
1204         ret = pf_printf_a(puts_clbk_str_a, &puts_ctx, format, locale,
1205                 MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER,
1206                 arg_clbk_valist, NULL, &args);
1207     } else {
1208         ret = pf_printf_a(puts_clbk_str_a, &puts_ctx, format, locale,
1209                 MSVCRT_PRINTF_POSITIONAL_PARAMS | MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER,
1210                 arg_clbk_positional, args_ctx, NULL);
1211     }
1212
1213     return ret;
1214 }
1215
1216 /*********************************************************************
1217  *              _vscprintf_p (MSVCR80.@)
1218  */
1219 int CDECL _vscprintf_p(const char *format, va_list argptr)
1220 {
1221     return _vscprintf_p_l(format, NULL, argptr);
1222 }
1223
1224 /*********************************************************************
1225  *              _snprintf (MSVCRT.@)
1226  */
1227 int WINAPIV _snprintf(char *str, size_t len, const char *format, ...)
1228 {
1229     int retval;
1230     va_list valist;
1231     va_start(valist, format);
1232     retval = vsnprintf(str, len, format, valist);
1233     va_end(valist);
1234     return retval;
1235 }
1236
1237 /*********************************************************************
1238  *              _snprintf_l (MSVCRT.@)
1239  */
1240 int WINAPIV _snprintf_l(char *str, size_t count, const char *format,
1241         _locale_t locale, ...)
1242 {
1243     int retval;
1244     va_list valist;
1245     va_start(valist, locale);
1246     retval = _vsnprintf_l(str, count, format, locale, valist);
1247     va_end(valist);
1248     return retval;
1249 }
1250
1251 /*********************************************************************
1252  *              _snprintf_c_l (MSVCRT.@)
1253  */
1254 int WINAPIV _snprintf_c_l(char *str, size_t count, const char *format,
1255         _locale_t locale, ...)
1256 {
1257     int retval;
1258     va_list valist;
1259     va_start(valist, locale);
1260     retval = _vsnprintf_c_l(str, count, format, locale, valist);
1261     va_end(valist);
1262     return retval;
1263 }
1264
1265 /*********************************************************************
1266  *              _snprintf_c (MSVCRT.@)
1267  */
1268 int WINAPIV _snprintf_c(char *str, size_t count, const char *format, ...)
1269 {
1270     int retval;
1271     va_list valist;
1272     va_start(valist, format);
1273     retval = _vsnprintf_c(str, count, format, valist);
1274     va_end(valist);
1275     return retval;
1276 }
1277
1278 /*********************************************************************
1279  *              _snprintf_s_l (MSVCRT.@)
1280  */
1281 int WINAPIV _snprintf_s_l(char *str, size_t len, size_t count,
1282         const char *format, _locale_t locale, ...)
1283 {
1284     int retval;
1285     va_list valist;
1286     va_start(valist, locale);
1287     retval = _vsnprintf_s_l(str, len, count, format, locale, valist);
1288     va_end(valist);
1289     return retval;
1290 }
1291
1292 /*********************************************************************
1293  *              _snprintf_s (MSVCRT.@)
1294  */
1295 int WINAPIV _snprintf_s(char *str, size_t len, size_t count,
1296     const char *format, ...)
1297 {
1298     int retval;
1299     va_list valist;
1300     va_start(valist, format);
1301     retval = _vsnprintf_s_l(str, len, count, format, NULL, valist);
1302     va_end(valist);
1303     return retval;
1304 }
1305
1306 /*********************************************************************
1307  *              _scprintf (MSVCRT.@)
1308  */
1309 int WINAPIV _scprintf(const char *format, ...)
1310 {
1311     int retval;
1312     va_list valist;
1313     va_start(valist, format);
1314     retval = _vscprintf(format, valist);
1315     va_end(valist);
1316     return retval;
1317 }
1318
1319 /*********************************************************************
1320  *              _vsnwprintf (MSVCRT.@)
1321  */
1322 int CDECL _vsnwprintf(wchar_t *str, size_t len,
1323         const wchar_t *format, va_list valist)
1324 {
1325     struct _str_ctx_w ctx = {len, str};
1326     int ret;
1327
1328     ret = pf_printf_w(puts_clbk_str_w, &ctx, format, NULL, 0,
1329             arg_clbk_valist, NULL, &valist);
1330     puts_clbk_str_w(&ctx, 1, L"");
1331     return ret;
1332 }
1333
1334 /*********************************************************************
1335  *              _vsnwprintf_l (MSVCRT.@)
1336  */
1337 int CDECL _vsnwprintf_l(wchar_t *str, size_t len, const wchar_t *format,
1338         _locale_t locale, va_list valist)
1339 {
1340     struct _str_ctx_w ctx = {len, str};
1341     int ret;
1342
1343     ret = pf_printf_w(puts_clbk_str_w, &ctx, format, locale, 0,
1344             arg_clbk_valist, NULL, &valist);
1345     puts_clbk_str_w(&ctx, 1, L"");
1346     return ret;
1347 }
1348
1349 /*********************************************************************
1350  *              _vswprintf_c_l (MSVCRT.@)
1351  */
1352 int CDECL _vswprintf_c_l(wchar_t *str, size_t len, const wchar_t *format,
1353         _locale_t locale, va_list valist)
1354 {
1355     return vsnwprintf_s_l_opt(str, len, len, format, 0, locale, valist);
1356 }
1357
1358 /*********************************************************************
1359  *              _vswprintf_c (MSVCRT.@)
1360  */
1361 int CDECL _vswprintf_c(wchar_t *str, size_t len,
1362         const wchar_t *format, va_list valist)
1363 {
1364     return _vswprintf_c_l(str, len, format, NULL, valist);
1365 }
1366
1367 static int vswprintf_p_l_opt(wchar_t *buffer, size_t length,
1368         const wchar_t *format, DWORD options, _locale_t locale, va_list args)
1369 {
1370     printf_arg args_ctx[_ARGMAX+1];
1371     struct _str_ctx_w puts_ctx = {length, buffer};
1372     int ret;
1373
1374     memset(args_ctx, 0, sizeof(args_ctx));
1375
1376     ret = create_positional_ctx_w(args_ctx, format, args);
1377     if(ret < 0)  {
1378         _invalid_parameter(NULL, NULL, NULL, 0, 0);
1379         *_errno() = EINVAL;
1380         return ret;
1381     } else if(ret == 0)
1382         ret = pf_printf_w(puts_clbk_str_w, &puts_ctx, format, locale, MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER | options,
1383                 arg_clbk_valist, NULL, &args);
1384     else
1385         ret = pf_printf_w(puts_clbk_str_w, &puts_ctx, format, locale,
1386                 MSVCRT_PRINTF_POSITIONAL_PARAMS | MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER | options,
1387                 arg_clbk_positional, args_ctx, NULL);
1388
1389     puts_clbk_str_w(&puts_ctx, 1, L"");
1390     return ret;
1391 }
1392
1393 /*********************************************************************
1394  *              _vswprintf_p_l (MSVCRT.@)
1395  */
1396 int CDECL _vswprintf_p_l(wchar_t *buffer, size_t length,
1397         const wchar_t *format, _locale_t locale, va_list args)
1398 {
1399     return vswprintf_p_l_opt(buffer, length, format, 0, locale, args);
1400 }
1401
1402 #if _MSVCR_VER>=80
1403 /*********************************************************************
1404  * _vswprintf_p (MSVCR80.@)
1405  */
1406 int CDECL _vswprintf_p(wchar_t *buffer, size_t length,
1407         const wchar_t *format, va_list args)
1408 {
1409     return vswprintf_p_l_opt(buffer, length, format, 0, NULL, args);
1410 }
1411 #endif
1412
1413 #if _MSVCR_VER>=140
1414 /*********************************************************************
1415  *              __stdio_common_vswprintf_p (UCRTBASE.@)
1416  */
1417 int CDECL __stdio_common_vswprintf_p( unsigned __int64 options,
1418         wchar_t *str, size_t count, const wchar_t *format,
1419         _locale_t locale, va_list valist )
1420 {
1421     if (options & ~UCRTBASE_PRINTF_MASK)
1422         FIXME("options %#I64x not handled\n", options);
1423     return vswprintf_p_l_opt(str, count, format, options & UCRTBASE_PRINTF_MASK, locale, valist);
1424 }
1425 #endif
1426
1427 /*********************************************************************
1428  *              _vsnwprintf_s_l (MSVCRT.@)
1429  */
1430 int CDECL _vsnwprintf_s_l( wchar_t *str, size_t sizeOfBuffer,
1431         size_t count, const wchar_t *format,
1432         _locale_t locale, va_list valist)
1433 {
1434     return vsnwprintf_s_l_opt(str, sizeOfBuffer, count, format, 0, locale, valist);
1435 }
1436
1437 /*********************************************************************
1438  *              _vsnwprintf_s (MSVCRT.@)
1439  */
1440 int CDECL _vsnwprintf_s(wchar_t *str, size_t sizeOfBuffer,
1441         size_t count, const wchar_t *format, va_list valist)
1442 {
1443     return _vsnwprintf_s_l(str, sizeOfBuffer, count,
1444             format, NULL, valist);
1445 }
1446
1447 /*********************************************************************
1448  *              _snwprintf (MSVCRT.@)
1449  */
1450 int WINAPIV _snwprintf( wchar_t *str, size_t len, const wchar_t *format, ...)
1451 {
1452     int retval;
1453     va_list valist;
1454     va_start(valist, format);
1455     retval = _vsnwprintf(str, len, format, valist);
1456     va_end(valist);
1457     return retval;
1458 }
1459
1460 /*********************************************************************
1461  *              _snwprintf_l (MSVCRT.@)
1462  */
1463 int WINAPIV _snwprintf_l( wchar_t *str, size_t len, const wchar_t *format,
1464         _locale_t locale, ...)
1465 {
1466     int retval;
1467     va_list valist;
1468     va_start(valist, locale);
1469     retval = _vsnwprintf_l(str, len, format, locale, valist);
1470     va_end(valist);
1471     return retval;
1472 }
1473
1474 /*********************************************************************
1475  *              _snwprintf_s (MSVCRT.@)
1476  */
1477 int WINAPIV _snwprintf_s( wchar_t *str, size_t len, size_t count,
1478     const wchar_t *format, ...)
1479 {
1480     int retval;
1481     va_list valist;
1482     va_start(valist, format);
1483     retval = _vsnwprintf_s_l(str, len, count, format, NULL, valist);
1484     va_end(valist);
1485     return retval;
1486 }
1487
1488 /*********************************************************************
1489  *              _snwprintf_s_l (MSVCRT.@)
1490  */
1491 int WINAPIV _snwprintf_s_l( wchar_t *str, size_t len, size_t count,
1492         const wchar_t *format, _locale_t locale, ... )
1493 {
1494     int retval;
1495     va_list valist;
1496     va_start(valist, locale);
1497     retval = _vsnwprintf_s_l(str, len, count, format, locale, valist);
1498     va_end(valist);
1499     return retval;
1500 }
1501
1502 #if _MSVCR_VER>=140
1503
1504 static int puts_clbk_str_c99_w(void *ctx, int len, const wchar_t *str)
1505 {
1506     struct _str_ctx_w *out = ctx;
1507
1508     if(!out->buf)
1509         return len;
1510
1511     if(out->len < len) {
1512         memcpy(out->buf, str, out->len*sizeof(wchar_t));
1513         out->buf += out->len;
1514         out->len = 0;
1515         return len;
1516     }
1517
1518     memcpy(out->buf, str, len*sizeof(wchar_t));
1519     out->buf += len;
1520     out->len -= len;
1521     return len;
1522 }
1523
1524 /*********************************************************************
1525  *              __stdio_common_vswprintf (UCRTBASE.@)
1526  */
1527 int CDECL __stdio_common_vswprintf( unsigned __int64 options,
1528         wchar_t *str, size_t len, const wchar_t *format,
1529         _locale_t locale, va_list valist )
1530 {
1531     struct _str_ctx_w ctx = {len, str};
1532     int ret;
1533
1534     if (options & ~UCRTBASE_PRINTF_MASK)
1535         FIXME("options %#I64x not handled\n", options);
1536     ret = pf_printf_w(puts_clbk_str_c99_w,
1537             &ctx, format, locale, options & UCRTBASE_PRINTF_MASK, arg_clbk_valist, NULL, &valist);
1538     puts_clbk_str_w(&ctx, 1, L"");
1539
1540     if(!str)
1541         return ret;
1542     if(options & _CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION)
1543         return ret>len ? -1 : ret;
1544     if(ret>=len) {
1545         if(len) str[len-1] = 0;
1546         if(options & _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR)
1547             return ret;
1548         return len > 0 ? -2 : -1;
1549     }
1550     return ret;
1551 }
1552
1553 #endif /* _MSVCR_VER>=140 */
1554
1555 /*********************************************************************
1556  *              sprintf (MSVCRT.@)
1557  */
1558 int WINAPIV sprintf( char *str, const char *format, ... )
1559 {
1560     va_list ap;
1561     int r;
1562
1563     va_start( ap, format );
1564     r = vsnprintf( str, INT_MAX, format, ap );
1565     va_end( ap );
1566     return r;
1567 }
1568
1569 /*********************************************************************
1570  *              sprintf_s (MSVCRT.@)
1571  */
1572 int WINAPIV sprintf_s( char *str, size_t num, const char *format, ... )
1573 {
1574     va_list ap;
1575     int r;
1576
1577     va_start( ap, format );
1578     r = vsnprintf( str, num, format, ap );
1579     va_end( ap );
1580     return r;
1581 }
1582
1583 /*********************************************************************
1584  *              _scwprintf (MSVCRT.@)
1585  */
1586 int WINAPIV _scwprintf( const wchar_t *format, ... )
1587 {
1588     va_list ap;
1589     int r;
1590
1591     va_start( ap, format );
1592     r = _vsnwprintf( NULL, INT_MAX, format, ap );
1593     va_end( ap );
1594     return r;
1595 }
1596
1597 /*********************************************************************
1598  *              swprintf (MSVCRT.@)
1599  */
1600 int WINAPIV _swprintf( wchar_t *str, const wchar_t *format, ... )
1601 {
1602     va_list ap;
1603     int r;
1604
1605     va_start( ap, format );
1606     r = _vsnwprintf( str, INT_MAX, format, ap );
1607     va_end( ap );
1608     return r;
1609 }
1610
1611 /*********************************************************************
1612  *              swprintf_s (MSVCRT.@)
1613  */
1614 int WINAPIV swprintf_s(wchar_t *str, size_t numberOfElements,
1615         const wchar_t *format, ... )
1616 {
1617     va_list ap;
1618     int r;
1619
1620     va_start(ap, format);
1621     r = _vsnwprintf_s(str, numberOfElements, INT_MAX, format, ap);
1622     va_end(ap);
1623
1624     return r;
1625 }
1626
1627 /*********************************************************************
1628  *              _swprintf_s_l (MSVCRT.@)
1629  */
1630 int WINAPIV _swprintf_s_l(wchar_t *str, size_t numberOfElements,
1631         const wchar_t *format, _locale_t locale, ... )
1632 {
1633     va_list ap;
1634     int r;
1635
1636     va_start(ap, locale);
1637     r = _vsnwprintf_s_l(str, numberOfElements, INT_MAX, format, locale, ap);
1638     va_end(ap);
1639
1640     return r;
1641 }
1642
1643 /*********************************************************************
1644  *              _swprintf_c_l (MSVCRT.@)
1645  */
1646 int WINAPIV _swprintf_c_l(wchar_t *str, size_t len,
1647         const wchar_t *format, _locale_t locale, ... )
1648 {
1649     va_list ap;
1650     int r;
1651
1652     va_start(ap, locale);
1653     r = _vswprintf_c_l(str, len, format, locale, ap);
1654     va_end(ap);
1655
1656     return r;
1657 }
1658
1659 /*********************************************************************
1660  *              _swprintf_c (MSVCRT.@)
1661  */
1662 int WINAPIV _swprintf_c(wchar_t *str, size_t len,
1663         const wchar_t *format, ... )
1664 {
1665     va_list ap;
1666     int r;
1667
1668     va_start(ap, format);
1669     r = _vswprintf_c(str, len, format, ap);
1670     va_end(ap);
1671
1672     return r;
1673 }
1674
1675 /*********************************************************************
1676  *              _vswprintf (MSVCRT.@)
1677  */
1678 int CDECL _vswprintf( wchar_t* str, const wchar_t* format, va_list args )
1679 {
1680     return _vsnwprintf( str, INT_MAX, format, args );
1681 }
1682
1683 /*********************************************************************
1684  *              _vswprintf (MSVCRT.@)
1685  */
1686 int CDECL _vswprintf_l( wchar_t* str, const wchar_t* format,
1687         _locale_t locale, va_list args )
1688 {
1689     return _vsnwprintf_l( str, INT_MAX, format, locale, args );
1690 }
1691
1692 /*********************************************************************
1693  *              _vscwprintf (MSVCRT.@)
1694  */
1695 int CDECL _vscwprintf( const wchar_t *format, va_list args )
1696 {
1697     return _vsnwprintf( NULL, INT_MAX, format, args );
1698 }
1699
1700 /*********************************************************************
1701  *              _vscwprintf_l (MSVCRT.@)
1702  */
1703 int CDECL _vscwprintf_l( const wchar_t *format, _locale_t locale, va_list args )
1704 {
1705     return _vsnwprintf_l( NULL, INT_MAX, format, locale, args );
1706 }
1707
1708 /*********************************************************************
1709  *              _vscwprintf_p_l (MSVCRT.@)
1710  */
1711 int CDECL _vscwprintf_p_l( const wchar_t *format, _locale_t locale, va_list args )
1712 {
1713     return vswprintf_p_l_opt( NULL, INT_MAX, format, 0, locale, args );
1714 }
1715
1716 #if _MSVCR_VER>=80
1717 /*********************************************************************
1718  * _vscwprintf_p (MSVCR80.@)
1719  */
1720 int CDECL _vscwprintf_p(const wchar_t *format, va_list args)
1721 {
1722     return vswprintf_p_l_opt(NULL, INT_MAX, format, 0, NULL, args);
1723 }
1724 #endif
1725
1726 /*********************************************************************
1727  *              vswprintf_s (MSVCRT.@)
1728  */
1729 int CDECL vswprintf_s(wchar_t* str, size_t numberOfElements,
1730         const wchar_t* format, va_list args)
1731 {
1732     return _vsnwprintf_s(str, numberOfElements, INT_MAX, format, args );
1733 }
1734
1735 /*********************************************************************
1736  *              _vswprintf_s_l (MSVCRT.@)
1737  */
1738 int CDECL _vswprintf_s_l(wchar_t* str, size_t numberOfElements,
1739         const wchar_t* format, _locale_t locale, va_list args)
1740 {
1741     return _vsnwprintf_s_l(str, numberOfElements, INT_MAX,
1742             format, locale, args );
1743 }
1744
1745 static int vsprintf_p_l_opt(char *buffer, size_t length, const char *format,
1746         DWORD options, _locale_t locale, va_list args)
1747 {
1748     static const char nullbyte = '\0';
1749     printf_arg args_ctx[_ARGMAX+1];
1750     struct _str_ctx_a puts_ctx = {length, buffer};
1751     int ret;
1752
1753     memset(args_ctx, 0, sizeof(args_ctx));
1754
1755     ret = create_positional_ctx_a(args_ctx, format, args);
1756     if(ret < 0) {
1757         _invalid_parameter(NULL, NULL, NULL, 0, 0);
1758         *_errno() = EINVAL;
1759         return ret;
1760     } else if(ret == 0)
1761         ret = pf_printf_a(puts_clbk_str_a, &puts_ctx, format, locale,
1762                 MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER | options, arg_clbk_valist, NULL, &args);
1763     else
1764         ret = pf_printf_a(puts_clbk_str_a, &puts_ctx, format, locale,
1765                 MSVCRT_PRINTF_POSITIONAL_PARAMS | MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER | options,
1766                 arg_clbk_positional, args_ctx, NULL);
1767
1768     puts_clbk_str_a(&puts_ctx, 1, &nullbyte);
1769     return ret;
1770 }
1771
1772 /*********************************************************************
1773  *              _vsprintf_p_l (MSVCRT.@)
1774  */
1775 int CDECL _vsprintf_p_l(char *buffer, size_t length, const char *format,
1776         _locale_t locale, va_list args)
1777 {
1778     return vsprintf_p_l_opt(buffer, length, format, 0, locale, args);
1779 }
1780
1781 /*********************************************************************
1782  *              _vsprintf_p (MSVCRT.@)
1783  */
1784 int CDECL _vsprintf_p(char *buffer, size_t length,
1785         const char *format, va_list args)
1786 {
1787     return _vsprintf_p_l(buffer, length, format, NULL, args);
1788 }
1789
1790 #if _MSVCR_VER>=140
1791 /*********************************************************************
1792  *              __stdio_common_vsprintf_p (UCRTBASE.@)
1793  */
1794 int CDECL __stdio_common_vsprintf_p(unsigned __int64 options, char *buffer, size_t length,
1795         const char *format, _locale_t locale, va_list args)
1796 {
1797     if (options & ~UCRTBASE_PRINTF_MASK)
1798         FIXME("options %#I64x not handled\n", options);
1799     return vsprintf_p_l_opt(buffer, length, format, options & UCRTBASE_PRINTF_MASK, locale, args);
1800 }
1801 #endif
1802
1803 /*********************************************************************
1804  *              _sprintf_p_l (MSVCRT.@)
1805  */
1806 int WINAPIV _sprintf_p_l(char *buffer, size_t length,
1807         const char *format, _locale_t locale, ...)
1808 {
1809     va_list valist;
1810     int r;
1811
1812     va_start(valist, locale);
1813     r = _vsprintf_p_l(buffer, length, format, locale, valist);
1814     va_end(valist);
1815
1816     return r;
1817 }
1818
1819 /*********************************************************************
1820  *              __swprintf_l (MSVCRT.@)
1821  */
1822 int WINAPIV __swprintf_l( wchar_t *str, const wchar_t *format,
1823         _locale_t locale, ...)
1824 {
1825     int retval;
1826     va_list valist;
1827     va_start(valist, locale);
1828     retval = _vswprintf_l(str, format, locale, valist);
1829     va_end(valist);
1830     return retval;
1831 }
1832
1833 #if _MSVCR_VER>=80
1834 /*********************************************************************
1835  * _sprintf_p (MSVCR80.@)
1836  */
1837 int WINAPIV _sprintf_p(char *buffer, size_t length, const char *format, ...)
1838 {
1839     va_list valist;
1840     int r;
1841
1842     va_start(valist, format);
1843     r = _vsprintf_p_l(buffer, length, format, NULL, valist);
1844     va_end(valist);
1845
1846     return r;
1847 }
1848 #endif
1849
1850 /*********************************************************************
1851  *              _swprintf_p_l (MSVCRT.@)
1852  */
1853 int WINAPIV _swprintf_p_l(wchar_t *buffer, size_t length,
1854         const wchar_t *format, _locale_t locale, ...)
1855 {
1856     va_list valist;
1857     int r;
1858
1859     va_start(valist, locale);
1860     r = vswprintf_p_l_opt(buffer, length, format, 0, locale, valist);
1861     va_end(valist);
1862
1863     return r;
1864 }
1865
1866 /*********************************************************************
1867  *              wcscmp (MSVCRT.@)
1868  */
1869 int CDECL wcscmp(const wchar_t *str1, const wchar_t *str2)
1870 {
1871     while (*str1 && (*str1 == *str2))
1872     {
1873         str1++;
1874         str2++;
1875     }
1876
1877     if (*str1 < *str2)
1878         return -1;
1879     if (*str1 > *str2)
1880         return 1;
1881     return 0;
1882 }
1883
1884 /*********************************************************************
1885  *              _wcscoll_l (MSVCRT.@)
1886  */
1887 int CDECL _wcscoll_l(const wchar_t* str1, const wchar_t* str2, _locale_t locale)
1888 {
1889     pthreadlocinfo locinfo;
1890
1891     if(!locale)
1892         locinfo = get_locinfo();
1893     else
1894         locinfo = locale->locinfo;
1895
1896     if(!locinfo->lc_handle[LC_COLLATE])
1897         return wcscmp(str1, str2);
1898     return CompareStringW(locinfo->lc_handle[LC_COLLATE], 0, str1, -1, str2, -1)-CSTR_EQUAL;
1899 }
1900
1901 /*********************************************************************
1902  *              wcscoll (MSVCRT.@)
1903  */
1904 int CDECL wcscoll( const wchar_t* str1, const wchar_t* str2 )
1905 {
1906     return _wcscoll_l(str1, str2, NULL);
1907 }
1908
1909 /*********************************************************************
1910  *              wcspbrk (MSVCRT.@)
1911  */
1912 wchar_t* CDECL wcspbrk( const wchar_t* str, const wchar_t* accept )
1913 {
1914     const wchar_t* p;
1915
1916     while (*str)
1917     {
1918         for (p = accept; *p; p++) if (*p == *str) return (wchar_t*)str;
1919         str++;
1920     }
1921     return NULL;
1922 }
1923
1924 /*********************************************************************
1925  *              wcstok_s  (MSVCRT.@)
1926  */
1927 wchar_t * CDECL wcstok_s( wchar_t *str, const wchar_t *delim,
1928                                  wchar_t **next_token )
1929 {
1930     wchar_t *ret;
1931
1932     if (!MSVCRT_CHECK_PMT(delim != NULL)) return NULL;
1933     if (!MSVCRT_CHECK_PMT(next_token != NULL)) return NULL;
1934     if (!MSVCRT_CHECK_PMT(str != NULL || *next_token != NULL)) return NULL;
1935
1936     if (!str) str = *next_token;
1937
1938     while (*str && wcschr( delim, *str )) str++;
1939     if (!*str) ret = NULL;
1940     else
1941     {
1942         ret = str++;
1943         while (*str && !wcschr( delim, *str )) str++;
1944         if (*str) *str++ = 0;
1945     }
1946     *next_token = str;
1947     return ret;
1948 }
1949
1950 /*********************************************************************
1951  *              wcstok  (MSVCRT.@)
1952  */
1953 #if _MSVCR_VER>=140
1954 wchar_t * CDECL wcstok( wchar_t *str, const wchar_t *delim, wchar_t **ctx )
1955 {
1956     if (!ctx)
1957         ctx = &msvcrt_get_thread_data()->wcstok_next;
1958     return wcstok_s(str, delim, ctx);
1959 }
1960 #else
1961 wchar_t * CDECL wcstok( wchar_t *str, const wchar_t *delim )
1962 {
1963     return wcstok_s(str, delim, &msvcrt_get_thread_data()->wcstok_next);
1964 }
1965 #endif
1966
1967 /*********************************************************************
1968  *              _wctomb_s_l (MSVCRT.@)
1969  */
1970 int CDECL _wctomb_s_l(int *len, char *mbchar, size_t size,
1971         wchar_t wch, _locale_t locale)
1972 {
1973     pthreadlocinfo locinfo;
1974     BOOL error = FALSE;
1975     BOOL *perror;
1976     int mblen;
1977
1978     if(!mbchar && size>0) {
1979         if(len)
1980             *len = 0;
1981         return 0;
1982     }
1983
1984     if(len)
1985         *len = -1;
1986
1987     if(!MSVCRT_CHECK_PMT(size <= INT_MAX))
1988         return EINVAL;
1989
1990     if(!locale)
1991         locinfo = get_locinfo();
1992     else
1993         locinfo = locale->locinfo;
1994
1995     if(!locinfo->lc_codepage) {
1996         if(wch > 0xff) {
1997             if(mbchar && size>0)
1998                 memset(mbchar, 0, size);
1999             *_errno() = EILSEQ;
2000             return EILSEQ;
2001         }
2002
2003         if(!MSVCRT_CHECK_PMT_ERR(size >= 1, ERANGE))
2004             return ERANGE;
2005
2006         *mbchar = wch;
2007         if(len)
2008             *len = 1;
2009         return 0;
2010     }
2011
2012     perror = (locinfo->lc_codepage != CP_UTF8 ? &error : NULL);
2013     mblen = WideCharToMultiByte(locinfo->lc_codepage, 0, &wch, 1, mbchar, size, NULL, perror);
2014     if(!mblen || error) {
2015         if(!mblen && GetLastError()==ERROR_INSUFFICIENT_BUFFER) {
2016             if(mbchar && size>0)
2017                 memset(mbchar, 0, size);
2018
2019             MSVCRT_INVALID_PMT("insufficient buffer size", ERANGE);
2020             return ERANGE;
2021         }
2022
2023         *_errno() = EILSEQ;
2024         return EILSEQ;
2025     }
2026
2027     if(len)
2028         *len = mblen;
2029     return 0;
2030 }
2031
2032 /*********************************************************************
2033  *              wctomb_s (MSVCRT.@)
2034  */
2035 int CDECL wctomb_s(int *len, char *mbchar, size_t size, wchar_t wch)
2036 {
2037     return _wctomb_s_l(len, mbchar, size, wch, NULL);
2038 }
2039
2040 /*********************************************************************
2041  *              _wctomb_l (MSVCRT.@)
2042  */
2043 int CDECL _wctomb_l(char *dst, wchar_t ch, _locale_t locale)
2044 {
2045     int len;
2046
2047     _wctomb_s_l(&len, dst, dst ? MB_LEN_MAX : 0, ch, locale);
2048     return len;
2049 }
2050
2051 /*********************************************************************
2052  *              wctomb (MSVCRT.@)
2053  */
2054 INT CDECL wctomb( char *dst, wchar_t ch )
2055 {
2056     return _wctomb_l(dst, ch, NULL);
2057 }
2058
2059 /*********************************************************************
2060  *              wctob (MSVCRT.@)
2061  */
2062 INT CDECL wctob( wint_t wchar )
2063 {
2064     char out;
2065     BOOL error = FALSE;
2066     BOOL *perror;
2067     UINT codepage = get_locinfo()->lc_codepage;
2068
2069     perror = (codepage != CP_UTF8 ? &error : NULL);
2070
2071     if(!codepage) {
2072         if (wchar < 0xff)
2073             return (signed char)wchar;
2074         else
2075             return EOF;
2076     } else if(WideCharToMultiByte( codepage, 0, &wchar, 1, &out, 1, NULL, perror ) && !error)
2077         return (INT)out;
2078     return EOF;
2079 }
2080
2081 /*********************************************************************
2082  *              wcrtomb_s (MSVCRT.@)
2083  */
2084 INT CDECL wcrtomb_s(size_t *len, char *mbchar,
2085         size_t size, wchar_t wch, mbstate_t *s)
2086 {
2087     int ilen, ret;
2088
2089     if (s) *s = 0;
2090     ret = wctomb_s(&ilen, mbchar, size, wch);
2091     if (len) *len = ilen;
2092     return ret;
2093 }
2094
2095 /*********************************************************************
2096  *              wcrtomb (MSVCRT.@)
2097  */
2098 size_t CDECL wcrtomb( char *dst, wchar_t ch, mbstate_t *s)
2099 {
2100     if(s)
2101         *s = 0;
2102     return wctomb(dst, ch);
2103 }
2104
2105 /*********************************************************************
2106  *              _iswctype_l (MSVCRT.@)
2107  */
2108 INT CDECL _iswctype_l( wchar_t wc, wctype_t type, _locale_t locale )
2109 {
2110     WORD ct;
2111
2112     if (wc == WEOF) return 0;
2113     if (wc < 256) return MSVCRT__pwctype[wc] & type;
2114
2115     if (!GetStringTypeW(CT_CTYPE1, &wc, 1, &ct))
2116     {
2117         ERR("GetStringTypeW failed for %x\n", wc);
2118         return 0;
2119     }
2120     return ct & type;
2121 }
2122
2123 /*********************************************************************
2124  *              iswctype    (MSVCRT.@)
2125  */
2126 INT CDECL iswctype( wchar_t wc, wctype_t type )
2127 {
2128     return _iswctype_l( wc, type, NULL );
2129 }
2130
2131 /*********************************************************************
2132  *              _iswalnum_l (MSVCRT.@)
2133  */
2134 int CDECL _iswalnum_l( wchar_t wc, _locale_t locale )
2135 {
2136     return _iswctype_l( wc, _ALPHA | _DIGIT, locale );
2137 }
2138
2139 /*********************************************************************
2140  *              iswalnum (MSVCRT.@)
2141  */
2142 INT CDECL iswalnum( wchar_t wc )
2143 {
2144     return _iswalnum_l( wc, NULL );
2145 }
2146
2147 /*********************************************************************
2148  *              iswalpha_l (MSVCRT.@)
2149  */
2150 INT CDECL _iswalpha_l( wchar_t wc, _locale_t locale )
2151 {
2152     return _iswctype_l( wc, _ALPHA, locale );
2153 }
2154
2155 /*********************************************************************
2156  *              iswalpha (MSVCRT.@)
2157  */
2158 INT CDECL iswalpha( wchar_t wc )
2159 {
2160     return _iswalpha_l( wc, NULL );
2161 }
2162
2163 /*********************************************************************
2164  *              _iswcntrl_l (MSVCRT.@)
2165  */
2166 int CDECL _iswcntrl_l( wchar_t wc, _locale_t locale )
2167 {
2168     return _iswctype_l( wc, _CONTROL, locale );
2169 }
2170
2171 /*********************************************************************
2172  *              iswcntrl (MSVCRT.@)
2173  */
2174 INT CDECL iswcntrl( wchar_t wc )
2175 {
2176     return _iswcntrl_l( wc, NULL );
2177 }
2178
2179 /*********************************************************************
2180  *              _iswdigit_l (MSVCRT.@)
2181  */
2182 INT CDECL _iswdigit_l( wchar_t wc, _locale_t locale )
2183 {
2184     return _iswctype_l( wc, _DIGIT, locale );
2185 }
2186
2187 /*********************************************************************
2188  *              iswdigit (MSVCRT.@)
2189  */
2190 INT CDECL iswdigit( wchar_t wc )
2191 {
2192     return _iswdigit_l( wc, NULL );
2193 }
2194
2195 /*********************************************************************
2196  *              _iswgraph_l (MSVCRT.@)
2197  */
2198 int CDECL _iswgraph_l( wchar_t wc, _locale_t locale )
2199 {
2200     return _iswctype_l( wc, _ALPHA | _DIGIT | _PUNCT, locale );
2201 }
2202
2203 /*********************************************************************
2204  *              iswgraph (MSVCRT.@)
2205  */
2206 INT CDECL iswgraph( wchar_t wc )
2207 {
2208     return _iswgraph_l( wc, NULL );
2209 }
2210
2211 /*********************************************************************
2212  *              _iswlower_l (MSVCRT.@)
2213  */
2214 int CDECL _iswlower_l( wchar_t wc, _locale_t locale )
2215 {
2216     return _iswctype_l( wc, _LOWER, locale );
2217 }
2218
2219 /*********************************************************************
2220  *              iswlower (MSVCRT.@)
2221  */
2222 INT CDECL iswlower( wchar_t wc )
2223 {
2224     return _iswlower_l( wc, NULL );
2225 }
2226
2227 /*********************************************************************
2228  *              _iswprint_l (MSVCRT.@)
2229  */
2230 int CDECL _iswprint_l( wchar_t wc, _locale_t locale )
2231 {
2232     return _iswctype_l( wc, _ALPHA | _BLANK | _DIGIT | _PUNCT, locale );
2233 }
2234
2235 /*********************************************************************
2236  *              iswprint (MSVCRT.@)
2237  */
2238 INT CDECL iswprint( wchar_t wc )
2239 {
2240     return _iswprint_l( wc, NULL );
2241 }
2242
2243 /*********************************************************************
2244  *              _iswpunct_l (MSVCRT.@)
2245  */
2246 INT CDECL _iswpunct_l( wchar_t wc, _locale_t locale )
2247 {
2248     return _iswctype_l( wc, _PUNCT, locale );
2249 }
2250
2251 /*********************************************************************
2252  *              iswpunct (MSVCRT.@)
2253  */
2254 INT CDECL iswpunct( wchar_t wc )
2255 {
2256     return _iswpunct_l( wc, NULL );
2257 }
2258
2259 /*********************************************************************
2260  *              _iswspace_l (MSVCRT.@)
2261  */
2262 INT CDECL _iswspace_l( wchar_t wc, _locale_t locale )
2263 {
2264     return _iswctype_l( wc, _SPACE, locale );
2265 }
2266
2267 /*********************************************************************
2268  *              iswspace (MSVCRT.@)
2269  */
2270 INT CDECL iswspace( wchar_t wc )
2271 {
2272     return _iswspace_l( wc, NULL );
2273 }
2274
2275 /*********************************************************************
2276  *              _iswupper_l (MSVCRT.@)
2277  */
2278 int CDECL _iswupper_l( wchar_t wc, _locale_t locale )
2279 {
2280     return _iswctype_l( wc, _UPPER, locale );
2281 }
2282
2283 /*********************************************************************
2284  *              iswupper (MSVCRT.@)
2285  */
2286 INT CDECL iswupper( wchar_t wc )
2287 {
2288     return _iswupper_l( wc, NULL );
2289 }
2290
2291 /*********************************************************************
2292  *              _iswxdigit_l (MSVCRT.@)
2293  */
2294 int CDECL _iswxdigit_l( wchar_t wc, _locale_t locale )
2295 {
2296     return _iswctype_l( wc, _HEX, locale );
2297 }
2298
2299 /*********************************************************************
2300  *              iswxdigit (MSVCRT.@)
2301  */
2302 INT CDECL iswxdigit( wchar_t wc )
2303 {
2304     return _iswxdigit_l( wc, NULL );
2305 }
2306
2307 /*********************************************************************
2308  *              _iswblank_l (MSVCRT.@)
2309  */
2310 INT CDECL _iswblank_l( wchar_t wc, _locale_t locale )
2311 {
2312     return wc == '\t' || _iswctype_l( wc, _BLANK, locale );
2313 }
2314
2315 /*********************************************************************
2316  *              iswblank (MSVCRT.@)
2317  */
2318 INT CDECL iswblank( wchar_t wc )
2319 {
2320     return wc == '\t' || _iswctype_l( wc, _BLANK, NULL );
2321 }
2322
2323 /*********************************************************************
2324  *              wcscpy_s (MSVCRT.@)
2325  */
2326 INT CDECL wcscpy_s( wchar_t* wcDest, size_t numElement, const  wchar_t *wcSrc)
2327 {
2328     size_t size = 0;
2329
2330     if(!MSVCRT_CHECK_PMT(wcDest)) return EINVAL;
2331     if(!MSVCRT_CHECK_PMT(numElement)) return EINVAL;
2332
2333     if(!MSVCRT_CHECK_PMT(wcSrc))
2334     {
2335         wcDest[0] = 0;
2336         return EINVAL;
2337     }
2338
2339     size = wcslen(wcSrc) + 1;
2340
2341     if(!MSVCRT_CHECK_PMT_ERR(size <= numElement, ERANGE))
2342     {
2343         wcDest[0] = 0;
2344         return ERANGE;
2345     }
2346
2347     memmove( wcDest, wcSrc, size*sizeof(WCHAR) );
2348
2349     return 0;
2350 }
2351
2352 /***********************************************************************
2353  *             wcscpy (MSVCRT.@)
2354  */
2355 wchar_t* __cdecl wcscpy( wchar_t *dst, const wchar_t *src )
2356 {
2357     WCHAR *p = dst;
2358     while ((*p++ = *src++));
2359     return dst;
2360 }
2361
2362 /******************************************************************
2363  *              wcsncpy (MSVCRT.@)
2364  */
2365 wchar_t* __cdecl wcsncpy( wchar_t* s1, const wchar_t *s2, size_t n )
2366 {
2367     size_t i;
2368
2369     for(i=0; i<n; i++)
2370         if(!(s1[i] = s2[i])) break;
2371     for(; i<n; i++)
2372         s1[i] = 0;
2373     return s1;
2374 }
2375
2376 /******************************************************************
2377  *              wcsncpy_s (MSVCRT.@)
2378  */
2379 INT CDECL wcsncpy_s( wchar_t* wcDest, size_t numElement, const wchar_t *wcSrc,
2380                             size_t count )
2381 {
2382     WCHAR *p = wcDest;
2383     BOOL truncate = (count == _TRUNCATE);
2384
2385     if(!wcDest && !numElement && !count)
2386         return 0;
2387
2388     if (!wcDest || !numElement)
2389         return EINVAL;
2390
2391     if (!wcSrc)
2392     {
2393         *wcDest = 0;
2394         return count ? EINVAL : 0;
2395     }
2396
2397     while (numElement && count && *wcSrc)
2398     {
2399         *p++ = *wcSrc++;
2400         numElement--;
2401         count--;
2402     }
2403     if (!numElement && truncate)
2404     {
2405         *(p-1) = 0;
2406         return STRUNCATE;
2407     }
2408     else if (!numElement)
2409     {
2410         *wcDest = 0;
2411         return ERANGE;
2412     }
2413
2414     *p = 0;
2415     return 0;
2416 }
2417
2418 /******************************************************************
2419  *              wcscat_s (MSVCRT.@)
2420  *
2421  */
2422 INT CDECL wcscat_s(wchar_t* dst, size_t elem, const wchar_t* src)
2423 {
2424     wchar_t* ptr = dst;
2425
2426     if (!dst || elem == 0) return EINVAL;
2427     if (!src)
2428     {
2429         dst[0] = '\0';
2430         return EINVAL;
2431     }
2432
2433     /* seek to end of dst string (or elem if no end of string is found */
2434     while (ptr < dst + elem && *ptr != '\0') ptr++;
2435     while (ptr < dst + elem)
2436     {
2437         if ((*ptr++ = *src++) == '\0') return 0;
2438     }
2439     /* not enough space */
2440     dst[0] = '\0';
2441     return ERANGE;
2442 }
2443
2444 /***********************************************************************
2445  *           wcscat (MSVCRT.@)
2446  */
2447 wchar_t* __cdecl wcscat( wchar_t *dst, const wchar_t *src )
2448 {
2449     wcscpy( dst + wcslen(dst), src );
2450     return dst;
2451 }
2452
2453 /*********************************************************************
2454  *  wcsncat_s (MSVCRT.@)
2455  *
2456  */
2457 INT CDECL wcsncat_s(wchar_t *dst, size_t elem,
2458         const wchar_t *src, size_t count)
2459 {
2460     size_t srclen;
2461     wchar_t dststart;
2462     INT ret = 0;
2463
2464     if (!MSVCRT_CHECK_PMT(dst != NULL)) return EINVAL;
2465     if (!MSVCRT_CHECK_PMT(elem > 0)) return EINVAL;
2466     if (!MSVCRT_CHECK_PMT(src != NULL || count == 0)) return EINVAL;
2467
2468     if (count == 0)
2469         return 0;
2470
2471     for (dststart = 0; dststart < elem; dststart++)
2472     {
2473         if (dst[dststart] == '\0')
2474             break;
2475     }
2476     if (dststart == elem)
2477     {
2478         MSVCRT_INVALID_PMT("dst[elem] is not NULL terminated\n", EINVAL);
2479         return EINVAL;
2480     }
2481
2482     if (count == _TRUNCATE)
2483     {
2484         srclen = wcslen(src);
2485         if (srclen >= (elem - dststart))
2486         {
2487             srclen = elem - dststart - 1;
2488             ret = STRUNCATE;
2489         }
2490     }
2491     else
2492         srclen = min(wcslen(src), count);
2493     if (srclen < (elem - dststart))
2494     {
2495         memcpy(&dst[dststart], src, srclen*sizeof(wchar_t));
2496         dst[dststart+srclen] = '\0';
2497         return ret;
2498     }
2499     MSVCRT_INVALID_PMT("dst[elem] is too small", ERANGE);
2500     dst[0] = '\0';
2501     return ERANGE;
2502 }
2503
2504 /*********************************************************************
2505  *           wcsncat    (NTDLL.@)
2506  */
2507 wchar_t * __cdecl wcsncat(wchar_t *s1, const wchar_t *s2, size_t n)
2508 {
2509     wchar_t *ret = s1;
2510     while (*s1) s1++;
2511     while (n-- > 0) if (!(*s1++ = *s2++)) return ret;
2512     *s1 = 0;
2513     return ret;
2514 }
2515
2516 /*********************************************************************
2517  * wctoint (INTERNAL)
2518  */
2519 static int wctoint(WCHAR c, int base)
2520 {
2521     int v = -1;
2522     if ('0' <= c && c <= '9')
2523         v = c - '0';
2524     else if ('A' <= c && c <= 'Z')
2525         v = c - 'A' + 10;
2526     else if ('a' <= c && c <= 'z')
2527         v = c - 'a' + 10;
2528     else {
2529         /* NOTE: wine_fold_string(MAP_FOLDDIGITS) supports too many things. */
2530         /* Unicode points that contain digits 0-9; keep this sorted! */
2531         static const WCHAR zeros[] = {
2532             0x660, 0x6f0, 0x966, 0x9e6, 0xa66, 0xae6, 0xb66, 0xc66, 0xce6,
2533             0xd66, 0xe50, 0xed0, 0xf20, 0x1040, 0x17e0, 0x1810, 0xff10
2534         };
2535         int i;
2536         for (i = 0; i < ARRAY_SIZE(zeros) && c >= zeros[i]; ++i) {
2537             if (zeros[i] <= c && c <= zeros[i] + 9) {
2538                 v = c - zeros[i];
2539                 break;
2540             }
2541         }
2542     }
2543     return v < base ? v : -1;
2544 }
2545
2546 /*********************************************************************
2547  *  _wcstoi64_l (MSVCRT.@)
2548  */
2549 __int64 CDECL _wcstoi64_l(const wchar_t *nptr,
2550         wchar_t **endptr, int base, _locale_t locale)
2551 {
2552     BOOL negative = FALSE, empty = TRUE;
2553     __int64 ret = 0;
2554
2555     TRACE("(%s %p %d %p)\n", debugstr_w(nptr), endptr, base, locale);
2556
2557     if (!MSVCRT_CHECK_PMT(nptr != NULL)) return 0;
2558     if (!MSVCRT_CHECK_PMT(base == 0 || base >= 2)) return 0;
2559     if (!MSVCRT_CHECK_PMT(base <= 36)) return 0;
2560
2561     if(endptr)
2562         *endptr = (wchar_t*)nptr;
2563
2564     while(_iswspace_l(*nptr, locale)) nptr++;
2565
2566     if(*nptr == '-') {
2567         negative = TRUE;
2568         nptr++;
2569     } else if(*nptr == '+')
2570         nptr++;
2571
2572     if((base==0 || base==16) && wctoint(*nptr, 1)==0 && (nptr[1]=='x' || nptr[1]=='X')) {
2573         base = 16;
2574         nptr += 2;
2575     }
2576
2577     if(base == 0) {
2578         if(wctoint(*nptr, 1)==0)
2579             base = 8;
2580         else
2581             base = 10;
2582     }
2583
2584     while(*nptr) {
2585         int v = wctoint(*nptr, base);
2586         if(v<0)
2587             break;
2588
2589         if(negative)
2590             v = -v;
2591
2592         nptr++;
2593         empty = FALSE;
2594
2595         if(!negative && (ret>I64_MAX/base || ret*base>I64_MAX-v)) {
2596             ret = I64_MAX;
2597             *_errno() = ERANGE;
2598         } else if(negative && (ret<I64_MIN/base || ret*base<I64_MIN-v)) {
2599             ret = I64_MIN;
2600             *_errno() = ERANGE;
2601         } else
2602             ret = ret*base + v;
2603     }
2604
2605     if(endptr && !empty)
2606         *endptr = (wchar_t*)nptr;
2607
2608     return ret;
2609 }
2610
2611 /*********************************************************************
2612  *  _wcstoi64 (MSVCRT.@)
2613  */
2614 __int64 CDECL _wcstoi64(const wchar_t *nptr,
2615         wchar_t **endptr, int base)
2616 {
2617     return _wcstoi64_l(nptr, endptr, base, NULL);
2618 }
2619
2620 /*********************************************************************
2621  *  _wcstol_l (MSVCRT.@)
2622  */
2623 __msvcrt_long CDECL _wcstol_l(const wchar_t *s,
2624         wchar_t **end, int base, _locale_t locale)
2625 {
2626     __int64 ret = _wcstoi64_l(s, end, base, locale);
2627
2628     if(ret > LONG_MAX) {
2629         ret = LONG_MAX;
2630         *_errno() = ERANGE;
2631     }else if(ret < LONG_MIN) {
2632         ret = LONG_MIN;
2633         *_errno() = ERANGE;
2634     }
2635     return ret;
2636 }
2637
2638 /*********************************************************************
2639  *  wcstol (MSVCRT.@)
2640  */
2641 __msvcrt_long CDECL wcstol(const wchar_t *s,
2642         wchar_t **end, int base)
2643 {
2644     return _wcstol_l(s, end, base, NULL);
2645 }
2646
2647 /*********************************************************************
2648  *  _wtoi_l (MSVCRT.@)
2649  */
2650 int __cdecl _wtoi_l(const wchar_t *str, _locale_t locale)
2651 {
2652     __int64 ret = _wcstoi64_l(str, NULL, 10, locale);
2653
2654     if(ret > INT_MAX) {
2655         ret = INT_MAX;
2656         *_errno() = ERANGE;
2657     } else if(ret < INT_MIN) {
2658         ret = INT_MIN;
2659         *_errno() = ERANGE;
2660     }
2661     return ret;
2662 }
2663
2664 /*********************************************************************
2665  *  _wtoi (MSVCRT.@)
2666  */
2667 int __cdecl _wtoi(const wchar_t *str)
2668 {
2669     return _wtoi_l(str, NULL);
2670 }
2671
2672 /*********************************************************************
2673  *  _wtol_l (MSVCRT.@)
2674  */
2675 __msvcrt_long __cdecl _wtol_l(const wchar_t *str, _locale_t locale)
2676 {
2677     __int64 ret = _wcstoi64_l(str, NULL, 10, locale);
2678
2679     if(ret > LONG_MAX) {
2680         ret = LONG_MAX;
2681         *_errno() = ERANGE;
2682     } else if(ret < LONG_MIN) {
2683         ret = LONG_MIN;
2684         *_errno() = ERANGE;
2685     }
2686     return ret;
2687 }
2688
2689 /*********************************************************************
2690  *  _wtol (MSVCRT.@)
2691  */
2692 __msvcrt_long __cdecl _wtol(const wchar_t *str)
2693 {
2694     return _wtol_l(str, NULL);
2695 }
2696
2697 #if _MSVCR_VER>=120
2698
2699 /*********************************************************************
2700  *  _wtoll_l (MSVCR120.@)
2701  */
2702 __int64 __cdecl _wtoll_l(const wchar_t *str, _locale_t locale)
2703 {
2704     return _wcstoi64_l(str, NULL, 10, locale);
2705 }
2706
2707 /*********************************************************************
2708  *  _wtoll (MSVCR120.@)
2709  */
2710 __int64 __cdecl _wtoll(const wchar_t *str)
2711 {
2712     return _wtoll_l(str, NULL);
2713 }
2714
2715 #endif /* _MSVCR_VER>=120 */
2716
2717 /*********************************************************************
2718  *  _wcstoui64_l (MSVCRT.@)
2719  */
2720 unsigned __int64 CDECL _wcstoui64_l(const wchar_t *nptr,
2721         wchar_t **endptr, int base, _locale_t locale)
2722 {
2723     BOOL negative = FALSE, empty = TRUE;
2724     unsigned __int64 ret = 0;
2725
2726     TRACE("(%s %p %d %p)\n", debugstr_w(nptr), endptr, base, locale);
2727
2728     if (!MSVCRT_CHECK_PMT(nptr != NULL)) return 0;
2729     if (!MSVCRT_CHECK_PMT(base == 0 || base >= 2)) return 0;
2730     if (!MSVCRT_CHECK_PMT(base <= 36)) return 0;
2731
2732     if(endptr)
2733         *endptr = (wchar_t*)nptr;
2734
2735     while(_iswspace_l(*nptr, locale)) nptr++;
2736
2737     if(*nptr == '-') {
2738         negative = TRUE;
2739         nptr++;
2740     } else if(*nptr == '+')
2741         nptr++;
2742
2743     if((base==0 || base==16) && wctoint(*nptr, 1)==0 && (nptr[1]=='x' || nptr[1]=='X')) {
2744         base = 16;
2745         nptr += 2;
2746     }
2747
2748     if(base == 0) {
2749         if(wctoint(*nptr, 1)==0)
2750             base = 8;
2751         else
2752             base = 10;
2753     }
2754
2755     while(*nptr) {
2756         int v = wctoint(*nptr, base);
2757         if(v<0)
2758             break;
2759
2760         nptr++;
2761         empty = FALSE;
2762
2763         if(ret>UI64_MAX/base || ret*base>UI64_MAX-v) {
2764             ret = UI64_MAX;
2765             *_errno() = ERANGE;
2766         } else
2767             ret = ret*base + v;
2768     }
2769
2770     if(endptr && !empty)
2771         *endptr = (wchar_t*)nptr;
2772
2773     return negative ? -ret : ret;
2774 }
2775
2776 /*********************************************************************
2777  *  _wcstoui64 (MSVCRT.@)
2778  */
2779 unsigned __int64 CDECL _wcstoui64(const wchar_t *nptr,
2780         wchar_t **endptr, int base)
2781 {
2782     return _wcstoui64_l(nptr, endptr, base, NULL);
2783 }
2784
2785 /*********************************************************************
2786  *  _wcstoul_l (MSVCRT.@)
2787  */
2788 __msvcrt_ulong __cdecl _wcstoul_l(const wchar_t *s,
2789         wchar_t **end, int base, _locale_t locale)
2790 {
2791     __int64 ret = _wcstoi64_l(s, end, base, locale);
2792
2793     if(ret > ULONG_MAX) {
2794         ret = ULONG_MAX;
2795         *_errno() = ERANGE;
2796     }else if(ret < -(__int64)ULONG_MAX) {
2797         ret = 1;
2798         *_errno() = ERANGE;
2799     }
2800     return ret;
2801 }
2802
2803 /*********************************************************************
2804    *  wcstoul (MSVCRT.@)
2805     */
2806 __msvcrt_ulong __cdecl wcstoul(const wchar_t *s, wchar_t **end, int base)
2807 {
2808     return _wcstoul_l(s, end, base, NULL);
2809 }
2810
2811 /******************************************************************
2812  *  wcsnlen (MSVCRT.@)
2813  */
2814 size_t CDECL wcsnlen(const wchar_t *s, size_t maxlen)
2815 {
2816     size_t i;
2817
2818     for (i = 0; i < maxlen; i++)
2819         if (!s[i]) break;
2820     return i;
2821 }
2822
2823 /*********************************************************************
2824  *              _towupper_l (MSVCRT.@)
2825  */
2826 wint_t CDECL _towupper_l(wint_t c, _locale_t locale)
2827 {
2828     pthreadlocinfo locinfo;
2829     wchar_t ret;
2830
2831     if(!locale)
2832         locinfo = get_locinfo();
2833     else
2834         locinfo = locale->locinfo;
2835
2836     if(!locinfo->lc_handle[LC_CTYPE]) {
2837         if(c >= 'a' && c <= 'z')
2838             return c + 'A' - 'a';
2839         return c;
2840     }
2841
2842     if(!LCMapStringW(locinfo->lc_handle[LC_CTYPE], LCMAP_UPPERCASE, &c, 1, &ret, 1))
2843         return c;
2844     return ret;
2845 }
2846
2847 /*********************************************************************
2848  *              towupper (MSVCRT.@)
2849  */
2850 wint_t CDECL towupper(wint_t c)
2851 {
2852     return _towupper_l(c, NULL);
2853 }
2854
2855 /*********************************************************************
2856  *              wcschr (MSVCRT.@)
2857  */
2858 wchar_t* CDECL wcschr(const wchar_t *str, wchar_t ch)
2859 {
2860     do { if (*str == ch) return (WCHAR *)(ULONG_PTR)str; } while (*str++);
2861     return NULL;
2862 }
2863
2864 /*********************************************************************
2865  *              wcsrchr (MSVCRT.@)
2866  */
2867 wchar_t* CDECL wcsrchr(const wchar_t *str, wchar_t ch)
2868 {
2869     WCHAR *ret = NULL;
2870     do { if (*str == ch) ret = (WCHAR *)(ULONG_PTR)str; } while (*str++);
2871     return ret;
2872 }
2873
2874 /***********************************************************************
2875  *              wcslen (MSVCRT.@)
2876  */
2877 size_t CDECL wcslen(const wchar_t *str)
2878 {
2879     const wchar_t *s = str;
2880     while (*s) s++;
2881     return s - str;
2882 }
2883
2884 /*********************************************************************
2885  *              wcsstr (MSVCRT.@)
2886  */
2887 wchar_t* CDECL wcsstr(const wchar_t *str, const wchar_t *sub)
2888 {
2889     while(*str)
2890     {
2891         const wchar_t *p1 = str, *p2 = sub;
2892         while(*p1 && *p2 && *p1 == *p2)
2893         {
2894             p1++;
2895             p2++;
2896         }
2897         if(!*p2)
2898             return (wchar_t*)str;
2899         str++;
2900     }
2901     return NULL;
2902 }
2903
2904 /*********************************************************************
2905  *              _wtoi64_l (MSVCRT.@)
2906  */
2907 __int64 CDECL _wtoi64_l(const wchar_t *str, _locale_t locale)
2908 {
2909     ULONGLONG RunningTotal = 0;
2910     BOOL bMinus = FALSE;
2911
2912     while (_iswspace_l(*str, locale)) {
2913         str++;
2914     } /* while */
2915
2916     if (*str == '+') {
2917         str++;
2918     } else if (*str == '-') {
2919         bMinus = TRUE;
2920         str++;
2921     } /* if */
2922
2923     while (*str >= '0' && *str <= '9') {
2924         RunningTotal = RunningTotal * 10 + *str - '0';
2925         str++;
2926     } /* while */
2927
2928     return bMinus ? -RunningTotal : RunningTotal;
2929 }
2930
2931 /*********************************************************************
2932  *              _wtoi64 (MSVCRT.@)
2933  */
2934 __int64 CDECL _wtoi64(const wchar_t *str)
2935 {
2936     return _wtoi64_l(str, NULL);
2937 }
2938
2939 /*********************************************************************
2940  *              _wcsxfrm_l (MSVCRT.@)
2941  */
2942 size_t CDECL _wcsxfrm_l(wchar_t *dest, const wchar_t *src,
2943         size_t len, _locale_t locale)
2944 {
2945     pthreadlocinfo locinfo;
2946     int i, ret;
2947
2948     if(!MSVCRT_CHECK_PMT(src)) return INT_MAX;
2949     if(!MSVCRT_CHECK_PMT(dest || !len)) return INT_MAX;
2950
2951     if(len > INT_MAX) {
2952         FIXME("len > INT_MAX not supported\n");
2953         len = INT_MAX;
2954     }
2955
2956     if(!locale)
2957         locinfo = get_locinfo();
2958     else
2959         locinfo = locale->locinfo;
2960
2961     if(!locinfo->lc_handle[LC_COLLATE]) {
2962         wcsncpy(dest, src, len);
2963         return wcslen(src);
2964     }
2965
2966     ret = LCMapStringW(locinfo->lc_handle[LC_COLLATE],
2967             LCMAP_SORTKEY, src, -1, NULL, 0);
2968     if(!ret) {
2969         if(len) dest[0] = 0;
2970         *_errno() = EILSEQ;
2971         return INT_MAX;
2972     }
2973     if(!len) return ret-1;
2974
2975     if(ret > len) {
2976         dest[0] = 0;
2977         *_errno() = ERANGE;
2978         return ret-1;
2979     }
2980
2981     ret = LCMapStringW(locinfo->lc_handle[LC_COLLATE],
2982             LCMAP_SORTKEY, src, -1, dest, len) - 1;
2983     for(i=ret; i>=0; i--)
2984         dest[i] = ((unsigned char*)dest)[i];
2985     return ret;
2986 }
2987
2988 /*********************************************************************
2989  *              wcsxfrm (MSVCRT.@)
2990  */
2991 size_t CDECL wcsxfrm(wchar_t *dest, const wchar_t *src, size_t len)
2992 {
2993     return _wcsxfrm_l(dest, src, len, NULL);
2994 }