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