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