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