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(isdigitW(*p)) {
 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(isdigitW(*p)) {
 387         exp++;
 388         p++;
 389     }
 390     if(*p == *locinfo->lconv->decimal_point)
 391         p++;
 392
 393     while(isdigitW(*p)) {
 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(isdigitW(*p))
 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(isdigitW(*p)) {
 422             while(isdigitW(*p)) {
 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(!mbstr) {
 481         tmp = WideCharToMultiByte(locinfo->lc_codepage, WC_NO_BEST_FIT_CHARS,
 482                 *wcstr, -1, NULL, 0, NULL, &used_default)-1;
 483         if(!tmp || used_default) {
 484             *MSVCRT__errno() = MSVCRT_EILSEQ;
 485             return -1;
 486         }
 487         return tmp;
 488     }
 489
 490     while(**wcstr) {
 491         char buf[3];
 492         MSVCRT_size_t i, size;
 493
 494         size = WideCharToMultiByte(locinfo->lc_codepage, WC_NO_BEST_FIT_CHARS,
 495                 *wcstr, 1, buf, 3, NULL, &used_default);
 496         if(!size || used_default) {
 497             *MSVCRT__errno() = MSVCRT_EILSEQ;
 498             return -1;
 499         }
 500         if(tmp+size > count)
 501             return tmp;
 502
 503         for(i=0; i<size; i++)
 504             mbstr[tmp++] = buf[i];
 505         (*wcstr)++;
 506     }
 507
 508     if(tmp < count) {
 509         mbstr[tmp] = '\0';
 510         *wcstr = NULL;
 511     }
 512     return tmp;
 513 }
 514
 515 /*********************************************************************
 516  *              _wcstombs_l (MSVCRT.@)
 517  */
 518 MSVCRT_size_t CDECL MSVCRT__wcstombs_l(char *mbstr, const MSVCRT_wchar_t *wcstr,
 519         MSVCRT_size_t count, MSVCRT__locale_t locale)
 520 {
 521     return MSVCRT_wcsrtombs_l(mbstr, &wcstr, count, locale);
 522 }
 523
 524 /*********************************************************************
 525  *              wcstombs (MSVCRT.@)
 526  */
 527 MSVCRT_size_t CDECL MSVCRT_wcstombs(char *mbstr, const MSVCRT_wchar_t *wcstr,
 528         MSVCRT_size_t count)
 529 {
 530     return MSVCRT_wcsrtombs_l(mbstr, &wcstr, count, NULL);
 531 }
 532
 533 /*********************************************************************
 534  *              wcsrtombs (MSVCRT.@)
 535  */
 536 MSVCRT_size_t CDECL MSVCRT_wcsrtombs(char *mbstr, const MSVCRT_wchar_t **wcstr,
 537         MSVCRT_size_t count, MSVCRT_mbstate_t *mbstate)
 538 {
 539     if(mbstate)
 540         *mbstate = 0;
 541
 542     return MSVCRT_wcsrtombs_l(mbstr, wcstr, count, NULL);
 543 }
 544
 545 /*********************************************************************
 546  * MSVCRT_wcsrtombs_s_l (INTERNAL)
 547  */
 548 static int MSVCRT_wcsrtombs_s_l(MSVCRT_size_t *ret, char *mbstr,
 549         MSVCRT_size_t size, const MSVCRT_wchar_t **wcstr,
 550         MSVCRT_size_t count, MSVCRT__locale_t locale)
 551 {
 552     MSVCRT_size_t conv;
 553
 554     if(!mbstr && !size && wcstr) {
 555         conv = MSVCRT_wcsrtombs_l(NULL, wcstr, 0, locale);
 556         if(conv == -1)
 557             return *MSVCRT__errno();
 558         if(ret)
 559             *ret = conv+1;
 560         return 0;
 561     }
 562
 563     if (!MSVCRT_CHECK_PMT(mbstr != NULL)) return MSVCRT_EINVAL;
 564     if (size) mbstr[0] = '\0';
 565     if (!MSVCRT_CHECK_PMT(wcstr != NULL)) return MSVCRT_EINVAL;
 566     if (!MSVCRT_CHECK_PMT(*wcstr != NULL)) return MSVCRT_EINVAL;
 567
 568     if(count==MSVCRT__TRUNCATE || size<count)
 569         conv = size;
 570     else
 571         conv = count;
 572
 573     conv = MSVCRT_wcsrtombs_l(mbstr, wcstr, conv, locale);
 574     if(conv == -1) {
 575         if(size)
 576             mbstr[0] = '\0';
 577         return *MSVCRT__errno();
 578     }else if(conv < size)
 579         mbstr[conv++] = '\0';
 580     else if(conv==size && (count==MSVCRT__TRUNCATE || mbstr[conv-1]=='\0'))
 581         mbstr[conv-1] = '\0';
 582     else {
 583         MSVCRT_INVALID_PMT("mbstr[size] is too small", MSVCRT_ERANGE);
 584         if(size)
 585             mbstr[0] = '\0';
 586         return MSVCRT_ERANGE;
 587     }
 588
 589     if(ret)
 590         *ret = conv;
 591     return 0;
 592 }
 593
 594 /*********************************************************************
 595  *              _wcstombs_s_l (MSVCRT.@)
 596  */
 597 int CDECL MSVCRT__wcstombs_s_l(MSVCRT_size_t *ret, char *mbstr,
 598         MSVCRT_size_t size, const MSVCRT_wchar_t *wcstr,
 599         MSVCRT_size_t count, MSVCRT__locale_t locale)
 600 {
 601     return MSVCRT_wcsrtombs_s_l(ret, mbstr, size, &wcstr,count, locale);
 602 }
 603
 604 /*********************************************************************
 605  *              wcstombs_s (MSVCRT.@)
 606  */
 607 int CDECL MSVCRT_wcstombs_s(MSVCRT_size_t *ret, char *mbstr,
 608         MSVCRT_size_t size, const MSVCRT_wchar_t *wcstr, MSVCRT_size_t count)
 609 {
 610     return MSVCRT_wcsrtombs_s_l(ret, mbstr, size, &wcstr, count, NULL);
 611 }
 612
 613 /*********************************************************************
 614  *              wcsrtombs_s (MSVCRT.@)
 615  */
 616 int CDECL MSVCRT_wcsrtombs_s(MSVCRT_size_t *ret, char *mbstr, MSVCRT_size_t size,
 617         const MSVCRT_wchar_t **wcstr, MSVCRT_size_t count, MSVCRT_mbstate_t *mbstate)
 618 {
 619     if(mbstate)
 620         *mbstate = 0;
 621
 622     return MSVCRT_wcsrtombs_s_l(ret, mbstr, size, wcstr, count, NULL);
 623 }
 624
 625 /*********************************************************************
 626  *              wcstod (MSVCRT.@)
 627  */
 628 double CDECL MSVCRT_wcstod(const MSVCRT_wchar_t* lpszStr, MSVCRT_wchar_t** end)
 629 {
 630     return MSVCRT__wcstod_l(lpszStr, end, NULL);
 631 }
 632
 633 /*********************************************************************
 634  *              _wtof (MSVCRT.@)
 635  */
 636 double CDECL MSVCRT__wtof(const MSVCRT_wchar_t *str)
 637 {
 638     return MSVCRT__wcstod_l(str, NULL, NULL);
 639 }
 640
 641 /*********************************************************************
 642  *              _wtof_l (MSVCRT.@)
 643  */
 644 double CDECL MSVCRT__wtof_l(const MSVCRT_wchar_t *str, MSVCRT__locale_t locale)
 645 {
 646     return MSVCRT__wcstod_l(str, NULL, locale);
 647 }
 648
 649 /*********************************************************************
 650  * arg_clbk_valist (INTERNAL)
 651  */
 652 printf_arg arg_clbk_valist(void *ctx, int arg_pos, int type, __ms_va_list *valist)
 653 {
 654     printf_arg ret;
 655
 656     if(type == VT_I8)
 657         ret.get_longlong = va_arg(*valist, LONGLONG);
 658     else if(type == VT_INT)
 659         ret.get_int = va_arg(*valist, int);
 660     else if(type == VT_R8)
 661         ret.get_double = va_arg(*valist, double);
 662     else if(type == VT_PTR)
 663         ret.get_ptr = va_arg(*valist, void*);
 664     else {
 665         ERR("Incorrect type\n");
 666         ret.get_int = 0;
 667     }
 668
 669     return ret;
 670 }
 671
 672 /*********************************************************************
 673  * arg_clbk_positional (INTERNAL)
 674  */
 675 static printf_arg arg_clbk_positional(void *ctx, int pos, int type, __ms_va_list *valist)
 676 {
 677     printf_arg *args = ctx;
 678     return args[pos];
 679 }
 680
 681 /*********************************************************************
 682  *              _vsnprintf (MSVCRT.@)
 683  */
 684 int CDECL MSVCRT_vsnprintf( char *str, MSVCRT_size_t len,
 685                             const char *format, __ms_va_list valist )
 686 {
 687     static const char nullbyte = '\0';
 688     struct _str_ctx_a ctx = {len, str};
 689     int ret;
 690
 691     ret = pf_printf_a(puts_clbk_str_a, &ctx, format, NULL, FALSE, FALSE,
 692             arg_clbk_valist, NULL, &valist);
 693     puts_clbk_str_a(&ctx, 1, &nullbyte);
 694     return ret;
 695 }
 696
 697 /*********************************************************************
 698  *              _vsnprintf_l (MSVCRT.@)
 699  */
 700 int CDECL MSVCRT_vsnprintf_l( char *str, MSVCRT_size_t len, const char *format,
 701                             MSVCRT__locale_t locale, __ms_va_list valist )
 702 {
 703     static const char nullbyte = '\0';
 704     struct _str_ctx_a ctx = {len, str};
 705     int ret;
 706
 707     ret = pf_printf_a(puts_clbk_str_a, &ctx, format, locale, FALSE, FALSE,
 708             arg_clbk_valist, NULL, &valist);
 709     puts_clbk_str_a(&ctx, 1, &nullbyte);
 710     return ret;
 711 }
 712
 713 /*********************************************************************
 714  *              _vsprintf_l (MSVCRT.@)
 715  */
 716 int CDECL MSVCRT_vsprintf_l( char *str, const char *format,
 717                             MSVCRT__locale_t locale, __ms_va_list valist )
 718 {
 719     return MSVCRT_vsnprintf_l(str, INT_MAX, format, locale, valist);
 720 }
 721
 722 /*********************************************************************
 723  *              _sprintf_l (MSVCRT.@)
 724  */
 725 int CDECL MSVCRT_sprintf_l(char *str, const char *format,
 726                            MSVCRT__locale_t locale, ...)
 727 {
 728     int retval;
 729     __ms_va_list valist;
 730     __ms_va_start(valist, locale);
 731     retval = MSVCRT_vsnprintf_l(str, INT_MAX, format, locale, valist);
 732     __ms_va_end(valist);
 733     return retval;
 734 }
 735
 736 /*********************************************************************
 737  *              _vsnprintf_s_l (MSVCRT.@)
 738  */
 739 int CDECL MSVCRT_vsnprintf_s_l( char *str, MSVCRT_size_t sizeOfBuffer,
 740         MSVCRT_size_t count, const char *format,
 741         MSVCRT__locale_t locale, __ms_va_list valist )
 742 {
 743     static const char nullbyte = '\0';
 744     struct _str_ctx_a ctx;
 745     int len, ret;
 746
 747     if(sizeOfBuffer<count+1 || count==-1)
 748         len = sizeOfBuffer;
 749     else
 750         len = count+1;
 751
 752     ctx.len = len;
 753     ctx.buf = str;
 754     ret = pf_printf_a(puts_clbk_str_a, &ctx, format, locale, FALSE, TRUE,
 755             arg_clbk_valist, NULL, &valist);
 756     puts_clbk_str_a(&ctx, 1, &nullbyte);
 757
 758     if(ret<0 || ret==len) {
 759         if(count!=MSVCRT__TRUNCATE && count>sizeOfBuffer) {
 760             MSVCRT_INVALID_PMT("str[sizeOfBuffer] is too small", MSVCRT_ERANGE);
 761             memset(str, 0, sizeOfBuffer);
 762         } else
 763             str[len-1] = '\0';
 764
 765         return -1;
 766     }
 767
 768     return ret;
 769 }
 770
 771 /*********************************************************************
 772  *              _vsprintf_s_l (MSVCRT.@)
 773  */
 774 int CDECL MSVCRT_vsprintf_s_l( char *str, MSVCRT_size_t count, const char *format,
 775                                MSVCRT__locale_t locale, __ms_va_list valist )
 776 {
 777     return MSVCRT_vsnprintf_s_l(str, INT_MAX, count, format, locale, valist);
 778 }
 779
 780 /*********************************************************************
 781  *              _sprintf_s_l (MSVCRT.@)
 782  */
 783 int CDECL MSVCRT_sprintf_s_l( char *str, MSVCRT_size_t count, const char *format,
 784                               MSVCRT__locale_t locale, ...)
 785 {
 786     int retval;
 787     __ms_va_list valist;
 788     __ms_va_start(valist, locale);
 789     retval = MSVCRT_vsnprintf_s_l(str, INT_MAX, count, format, locale, valist);
 790     __ms_va_end(valist);
 791     return retval;
 792 }
 793
 794 /*********************************************************************
 795  *              _vsnprintf_s (MSVCRT.@)
 796  */
 797 int CDECL MSVCRT_vsnprintf_s( char *str, MSVCRT_size_t sizeOfBuffer,
 798         MSVCRT_size_t count, const char *format, __ms_va_list valist )
 799 {
 800     return MSVCRT_vsnprintf_s_l(str,sizeOfBuffer, count, format, NULL, valist);
 801 }
 802
 803 /*********************************************************************
 804  *              vsprintf (MSVCRT.@)
 805  */
 806 int CDECL MSVCRT_vsprintf( char *str, const char *format, __ms_va_list valist)
 807 {
 808     return MSVCRT_vsnprintf(str, INT_MAX, format, valist);
 809 }
 810
 811 /*********************************************************************
 812  *              vsprintf_s (MSVCRT.@)
 813  */
 814 int CDECL MSVCRT_vsprintf_s( char *str, MSVCRT_size_t num, const char *format, __ms_va_list valist)
 815 {
 816     return MSVCRT_vsnprintf(str, num, format, valist);
 817 }
 818
 819 /*********************************************************************
 820  *              _vscprintf (MSVCRT.@)
 821  */
 822 int CDECL MSVCRT__vscprintf( const char *format, __ms_va_list valist )
 823 {
 824     return MSVCRT_vsnprintf( NULL, INT_MAX, format, valist );
 825 }
 826
 827 /*********************************************************************
 828  *              _snprintf (MSVCRT.@)
 829  */
 830 int CDECL MSVCRT__snprintf(char *str, unsigned int len, const char *format, ...)
 831 {
 832     int retval;
 833     __ms_va_list valist;
 834     __ms_va_start(valist, format);
 835     retval = MSVCRT_vsnprintf(str, len, format, valist);
 836     __ms_va_end(valist);
 837     return retval;
 838 }
 839
 840 /*********************************************************************
 841  *              _snprintf_l (MSVCRT.@)
 842  */
 843 int CDECL MSVCRT__snprintf_l(char *str, unsigned int count, MSVCRT__locale_t locale,
 844     const char *format, ...)
 845 {
 846     int retval;
 847     __ms_va_list valist;
 848     __ms_va_start(valist, format);
 849     retval = MSVCRT_vsnprintf_l(str, count, format, locale, valist);
 850     __ms_va_end(valist);
 851     return retval;
 852 }
 853
 854 /*********************************************************************
 855  *              _snprintf_s (MSVCRT.@)
 856  */
 857 int CDECL MSVCRT__snprintf_s(char *str, unsigned int len, unsigned int count,
 858     const char *format, ...)
 859 {
 860     int retval;
 861     __ms_va_list valist;
 862     __ms_va_start(valist, format);
 863     retval = MSVCRT_vsnprintf_s_l(str, len, count, format, NULL, valist);
 864     __ms_va_end(valist);
 865     return retval;
 866 }
 867
 868 /*********************************************************************
 869  *              _scprintf (MSVCRT.@)
 870  */
 871 int CDECL MSVCRT__scprintf(const char *format, ...)
 872 {
 873     int retval;
 874     __ms_va_list valist;
 875     __ms_va_start(valist, format);
 876     retval = MSVCRT__vscprintf(format, valist);
 877     __ms_va_end(valist);
 878     return retval;
 879 }
 880
 881 /*********************************************************************
 882  *              _vsnwprintf (MSVCRT.@)
 883  */
 884 int CDECL MSVCRT_vsnwprintf(MSVCRT_wchar_t *str, MSVCRT_size_t len,
 885         const MSVCRT_wchar_t *format, __ms_va_list valist)
 886 {
 887     static const MSVCRT_wchar_t nullbyte = '\0';
 888     struct _str_ctx_w ctx = {len, str};
 889     int ret;
 890
 891     ret = pf_printf_w(puts_clbk_str_w, &ctx, format, NULL, FALSE, FALSE,
 892             arg_clbk_valist, NULL, &valist);
 893     puts_clbk_str_w(&ctx, 1, &nullbyte);
 894     return ret;
 895 }
 896
 897 /*********************************************************************
 898  *              _vsnwprintf_l (MSVCRT.@)
 899  */
 900 int CDECL MSVCRT_vsnwprintf_l(MSVCRT_wchar_t *str, MSVCRT_size_t len,
 901         const MSVCRT_wchar_t *format, MSVCRT__locale_t locale,
 902         __ms_va_list valist)
 903 {
 904     static const MSVCRT_wchar_t nullbyte = '\0';
 905     struct _str_ctx_w ctx = {len, str};
 906     int ret;
 907
 908     ret = pf_printf_w(puts_clbk_str_w, &ctx, format, locale, FALSE, FALSE,
 909             arg_clbk_valist, NULL, &valist);
 910     puts_clbk_str_w(&ctx, 1, &nullbyte);
 911     return ret;
 912 }
 913
 914 /*********************************************************************
 915  *              _vswprintf_p_l (MSVCRT.@)
 916  */
 917 int CDECL MSVCRT_vswprintf_p_l(MSVCRT_wchar_t *buffer, MSVCRT_size_t length,
 918         const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, __ms_va_list args)
 919 {
 920     static const MSVCRT_wchar_t nullbyte = '\0';
 921     printf_arg args_ctx[MSVCRT__ARGMAX+1];
 922     struct _str_ctx_w puts_ctx = {length, buffer};
 923     int ret;
 924
 925     memset(args_ctx, 0, sizeof(args_ctx));
 926
 927     ret = create_positional_ctx_w(args_ctx, format, args);
 928     if(ret < 0)  {
 929         MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
 930         *MSVCRT__errno() = MSVCRT_EINVAL;
 931         return ret;
 932     } else if(ret == 0)
 933         ret = pf_printf_w(puts_clbk_str_w, &puts_ctx, format, locale, FALSE, TRUE,
 934                 arg_clbk_valist, NULL, &args);
 935     else
 936         ret = pf_printf_w(puts_clbk_str_w, &puts_ctx, format, locale, TRUE, TRUE,
 937                 arg_clbk_positional, args_ctx, NULL);
 938
 939     puts_clbk_str_w(&puts_ctx, 1, &nullbyte);
 940     return ret;
 941 }
 942
 943 /*********************************************************************
 944  * _vswprintf_p (MSVCR100.@)
 945  */
 946 int CDECL MSVCRT__vswprintf_p(MSVCRT_wchar_t *buffer, MSVCRT_size_t length,
 947         const MSVCRT_wchar_t *format, __ms_va_list args)
 948 {
 949     return MSVCRT_vswprintf_p_l(buffer, length, format, NULL, args);
 950 }
 951
 952 /*********************************************************************
 953  *              _vsnwprintf_s_l (MSVCRT.@)
 954  */
 955 int CDECL MSVCRT_vsnwprintf_s_l( MSVCRT_wchar_t *str, MSVCRT_size_t sizeOfBuffer,
 956         MSVCRT_size_t count, const MSVCRT_wchar_t *format,
 957         MSVCRT__locale_t locale, __ms_va_list valist)
 958 {
 959     static const MSVCRT_wchar_t nullbyte = '\0';
 960     struct _str_ctx_w ctx;
 961     int len, ret;
 962
 963     len = sizeOfBuffer;
 964     if(count!=-1 && len>count+1)
 965         len = count+1;
 966
 967     ctx.len = len;
 968     ctx.buf = str;
 969     ret = pf_printf_w(puts_clbk_str_w, &ctx, format, locale, FALSE, TRUE,
 970             arg_clbk_valist, NULL, &valist);
 971     puts_clbk_str_w(&ctx, 1, &nullbyte);
 972
 973     if(ret<0 || ret==len) {
 974         if(count!=MSVCRT__TRUNCATE && count>sizeOfBuffer) {
 975             MSVCRT_INVALID_PMT("str[sizeOfBuffer] is too small", MSVCRT_ERANGE);
 976             memset(str, 0, sizeOfBuffer*sizeof(MSVCRT_wchar_t));
 977         } else
 978             str[len-1] = '\0';
 979
 980         return -1;
 981     }
 982
 983     return ret;
 984 }
 985
 986 /*********************************************************************
 987  *              _vsnwprintf_s (MSVCRT.@)
 988  */
 989 int CDECL MSVCRT_vsnwprintf_s(MSVCRT_wchar_t *str, MSVCRT_size_t sizeOfBuffer,
 990         MSVCRT_size_t count, const MSVCRT_wchar_t *format, __ms_va_list valist)
 991 {
 992     return MSVCRT_vsnwprintf_s_l(str, sizeOfBuffer, count,
 993             format, NULL, valist);
 994 }
 995
 996 /*********************************************************************
 997  *              _snwprintf (MSVCRT.@)
 998  */
 999 int CDECL MSVCRT__snwprintf( MSVCRT_wchar_t *str, unsigned int len, const MSVCRT_wchar_t *format, ...)
1000 {
1001     int retval;
1002     __ms_va_list valist;
1003     __ms_va_start(valist, format);
1004     retval = MSVCRT_vsnwprintf(str, len, format, valist);
1005     __ms_va_end(valist);
1006     return retval;
1007 }
1008
1009 /*********************************************************************
1010  *              _snwprintf_l (MSVCRT.@)
1011  */
1012 int CDECL MSVCRT__snwprintf_l( MSVCRT_wchar_t *str, unsigned int len, const MSVCRT_wchar_t *format,
1013         MSVCRT__locale_t locale, ...)
1014 {
1015     int retval;
1016     __ms_va_list valist;
1017     __ms_va_start(valist, locale);
1018     retval = MSVCRT_vsnwprintf_l(str, len, format, locale, valist);
1019     __ms_va_end(valist);
1020     return retval;
1021 }
1022
1023 /*********************************************************************
1024  *              _snwprintf_s (MSVCRT.@)
1025  */
1026 int CDECL MSVCRT__snwprintf_s( MSVCRT_wchar_t *str, unsigned int len, unsigned int count,
1027     const MSVCRT_wchar_t *format, ...)
1028 {
1029     int retval;
1030     __ms_va_list valist;
1031     __ms_va_start(valist, format);
1032     retval = MSVCRT_vsnwprintf_s_l(str, len, count, format, NULL, valist);
1033     __ms_va_end(valist);
1034     return retval;
1035 }
1036
1037 /*********************************************************************
1038  *              _snwprintf_s_l (MSVCRT.@)
1039  */
1040 int CDECL MSVCRT__snwprintf_s_l( MSVCRT_wchar_t *str, unsigned int len, unsigned int count,
1041         const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, ... )
1042 {
1043     int retval;
1044     __ms_va_list valist;
1045     __ms_va_start(valist, locale);
1046     retval = MSVCRT_vsnwprintf_s_l(str, len, count, format, locale, valist);
1047     __ms_va_end(valist);
1048     return retval;
1049 }
1050
1051 /*********************************************************************
1052  *              sprintf (MSVCRT.@)
1053  */
1054 int CDECL MSVCRT_sprintf( char *str, const char *format, ... )
1055 {
1056     __ms_va_list ap;
1057     int r;
1058
1059     __ms_va_start( ap, format );
1060     r = MSVCRT_vsnprintf( str, INT_MAX, format, ap );
1061     __ms_va_end( ap );
1062     return r;
1063 }
1064
1065 /*********************************************************************
1066  *              sprintf_s (MSVCRT.@)
1067  */
1068 int CDECL MSVCRT_sprintf_s( char *str, MSVCRT_size_t num, const char *format, ... )
1069 {
1070     __ms_va_list ap;
1071     int r;
1072
1073     __ms_va_start( ap, format );
1074     r = MSVCRT_vsnprintf( str, num, format, ap );
1075     __ms_va_end( ap );
1076     return r;
1077 }
1078
1079 /*********************************************************************
1080  *              _scwprintf (MSVCRT.@)
1081  */
1082 int CDECL MSVCRT__scwprintf( const MSVCRT_wchar_t *format, ... )
1083 {
1084     __ms_va_list ap;
1085     int r;
1086
1087     __ms_va_start( ap, format );
1088     r = MSVCRT_vsnwprintf( NULL, INT_MAX, format, ap );
1089     __ms_va_end( ap );
1090     return r;
1091 }
1092
1093 /*********************************************************************
1094  *              swprintf (MSVCRT.@)
1095  */
1096 int CDECL MSVCRT_swprintf( MSVCRT_wchar_t *str, const MSVCRT_wchar_t *format, ... )
1097 {
1098     __ms_va_list ap;
1099     int r;
1100
1101     __ms_va_start( ap, format );
1102     r = MSVCRT_vsnwprintf( str, INT_MAX, format, ap );
1103     __ms_va_end( ap );
1104     return r;
1105 }
1106
1107 /*********************************************************************
1108  *              swprintf_s (MSVCRT.@)
1109  */
1110 int CDECL MSVCRT_swprintf_s(MSVCRT_wchar_t *str, MSVCRT_size_t numberOfElements,
1111         const MSVCRT_wchar_t *format, ... )
1112 {
1113     __ms_va_list ap;
1114     int r;
1115
1116     __ms_va_start(ap, format);
1117     r = MSVCRT_vsnwprintf_s(str, numberOfElements, INT_MAX, format, ap);
1118     __ms_va_end(ap);
1119
1120     return r;
1121 }
1122
1123 /*********************************************************************
1124  *              _swprintf_s_l (MSVCRT.@)
1125  */
1126 int CDECL MSVCRT__swprintf_s_l(MSVCRT_wchar_t *str, MSVCRT_size_t numberOfElements,
1127         const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, ... )
1128 {
1129     __ms_va_list ap;
1130     int r;
1131
1132     __ms_va_start(ap, locale);
1133     r = MSVCRT_vsnwprintf_s_l(str, numberOfElements, INT_MAX, format, locale, ap);
1134     __ms_va_end(ap);
1135
1136     return r;
1137 }
1138
1139 /*********************************************************************
1140  *              _vswprintf (MSVCRT.@)
1141  */
1142 int CDECL MSVCRT_vswprintf( MSVCRT_wchar_t* str, const MSVCRT_wchar_t* format, __ms_va_list args )
1143 {
1144     return MSVCRT_vsnwprintf( str, INT_MAX, format, args );
1145 }
1146
1147 /*********************************************************************
1148  *              _vswprintf (MSVCRT.@)
1149  */
1150 int CDECL MSVCRT_vswprintf_l( MSVCRT_wchar_t* str, const MSVCRT_wchar_t* format,
1151         MSVCRT__locale_t locale, __ms_va_list args )
1152 {
1153     return MSVCRT_vsnwprintf_l( str, INT_MAX, format, locale, args );
1154 }
1155
1156 /*********************************************************************
1157  *              _vscwprintf (MSVCRT.@)
1158  */
1159 int CDECL MSVCRT__vscwprintf( const MSVCRT_wchar_t *format, __ms_va_list args )
1160 {
1161     return MSVCRT_vsnwprintf( NULL, INT_MAX, format, args );
1162 }
1163
1164 /*********************************************************************
1165  *              _vscwprintf_l (MSVCRT.@)
1166  */
1167 int CDECL MSVCRT__vscwprintf_l( const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, __ms_va_list args )
1168 {
1169     return MSVCRT_vsnwprintf_l( NULL, INT_MAX, format, locale, args );
1170 }
1171
1172 /*********************************************************************
1173  *              _vscwprintf_p_l (MSVCRT.@)
1174  */
1175 int CDECL MSVCRT__vscwprintf_p_l( const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, __ms_va_list args )
1176 {
1177     return MSVCRT_vswprintf_p_l( NULL, INT_MAX, format, locale, args );
1178 }
1179
1180 /*********************************************************************
1181  * _vscwprintf_p (MSVCR100.@)
1182  */
1183 int CDECL MSVCRT__vscwprintf_p(const MSVCRT_wchar_t *format, __ms_va_list args)
1184 {
1185     return MSVCRT_vswprintf_p_l(NULL, INT_MAX, format, NULL, args);
1186 }
1187
1188 /*********************************************************************
1189  *              vswprintf_s (MSVCRT.@)
1190  */
1191 int CDECL MSVCRT_vswprintf_s(MSVCRT_wchar_t* str, MSVCRT_size_t numberOfElements,
1192         const MSVCRT_wchar_t* format, __ms_va_list args)
1193 {
1194     return MSVCRT_vsnwprintf_s(str, numberOfElements, INT_MAX, format, args );
1195 }
1196
1197 /*********************************************************************
1198  *              _vswprintf_s_l (MSVCRT.@)
1199  */
1200 int CDECL MSVCRT_vswprintf_s_l(MSVCRT_wchar_t* str, MSVCRT_size_t numberOfElements,
1201         const MSVCRT_wchar_t* format, MSVCRT__locale_t locale, __ms_va_list args)
1202 {
1203     return MSVCRT_vsnwprintf_s_l(str, numberOfElements, INT_MAX,
1204             format, locale, args );
1205 }
1206
1207 /*********************************************************************
1208  *              _vsprintf_p_l (MSVCRT.@)
1209  */
1210 int CDECL MSVCRT_vsprintf_p_l(char *buffer, MSVCRT_size_t length, const char *format,
1211         MSVCRT__locale_t locale, __ms_va_list args)
1212 {
1213     static const char nullbyte = '\0';
1214     printf_arg args_ctx[MSVCRT__ARGMAX+1];
1215     struct _str_ctx_a puts_ctx = {length, buffer};
1216     int ret;
1217
1218     memset(args_ctx, 0, sizeof(args_ctx));
1219
1220     ret = create_positional_ctx_a(args_ctx, format, args);
1221     if(ret < 0) {
1222         MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
1223         *MSVCRT__errno() = MSVCRT_EINVAL;
1224         return ret;
1225     } else if(ret == 0)
1226         ret = pf_printf_a(puts_clbk_str_a, &puts_ctx, format, locale, FALSE, TRUE,
1227                 arg_clbk_valist, NULL, &args);
1228     else
1229         ret = pf_printf_a(puts_clbk_str_a, &puts_ctx, format, locale, TRUE, TRUE,
1230                 arg_clbk_positional, args_ctx, NULL);
1231
1232     puts_clbk_str_a(&puts_ctx, 1, &nullbyte);
1233     return ret;
1234 }
1235
1236 /*********************************************************************
1237  *              _vsprintf_p (MSVCRT.@)
1238  */
1239 int CDECL MSVCRT_vsprintf_p(char *buffer, MSVCRT_size_t length,
1240         const char *format, __ms_va_list args)
1241 {
1242     return MSVCRT_vsprintf_p_l(buffer, length, format, NULL, args);
1243 }
1244
1245 /*********************************************************************
1246  *              _sprintf_p_l (MSVCRT.@)
1247  */
1248 int CDECL MSVCRT_sprintf_p_l(char *buffer, MSVCRT_size_t length,
1249         const char *format, MSVCRT__locale_t locale, ...)
1250 {
1251     __ms_va_list valist;
1252     int r;
1253
1254     __ms_va_start(valist, locale);
1255     r = MSVCRT_vsprintf_p_l(buffer, length, format, locale, valist);
1256     __ms_va_end(valist);
1257
1258     return r;
1259 }
1260
1261 /*********************************************************************
1262  * _sprintf_p (MSVCR100.@)
1263  */
1264 int CDECL MSVCRT__sprintf_p(char *buffer, MSVCRT_size_t length, const char *format, ...)
1265 {
1266     __ms_va_list valist;
1267     int r;
1268
1269     __ms_va_start(valist, format);
1270     r = MSVCRT_vsprintf_p_l(buffer, length, format, NULL, valist);
1271     __ms_va_end(valist);
1272
1273     return r;
1274 }
1275
1276 /*********************************************************************
1277  *              _swprintf_p_l (MSVCRT.@)
1278  */
1279 int CDECL MSVCRT_swprintf_p_l(MSVCRT_wchar_t *buffer, MSVCRT_size_t length,
1280         const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, ...)
1281 {
1282     __ms_va_list valist;
1283     int r;
1284
1285     __ms_va_start(valist, locale);
1286     r = MSVCRT_vswprintf_p_l(buffer, length, format, locale, valist);
1287     __ms_va_end(valist);
1288
1289     return r;
1290 }
1291
1292 /*********************************************************************
1293  *              _wcscoll_l (MSVCRT.@)
1294  */
1295 int CDECL MSVCRT__wcscoll_l(const MSVCRT_wchar_t* str1, const MSVCRT_wchar_t* str2, MSVCRT__locale_t locale)
1296 {
1297     MSVCRT_pthreadlocinfo locinfo;
1298
1299     if(!locale)
1300         locinfo = get_locinfo();
1301     else
1302         locinfo = locale->locinfo;
1303
1304     if(!locinfo->lc_handle[MSVCRT_LC_COLLATE])
1305         return strcmpW(str1, str2);
1306     return CompareStringW(locinfo->lc_handle[MSVCRT_LC_COLLATE], 0, str1, -1, str2, -1)-CSTR_EQUAL;
1307 }
1308
1309 /*********************************************************************
1310  *              wcscoll (MSVCRT.@)
1311  */
1312 int CDECL MSVCRT_wcscoll( const MSVCRT_wchar_t* str1, const MSVCRT_wchar_t* str2 )
1313 {
1314     return MSVCRT__wcscoll_l(str1, str2, NULL);
1315 }
1316
1317 /*********************************************************************
1318  *              wcspbrk (MSVCRT.@)
1319  */
1320 MSVCRT_wchar_t* CDECL MSVCRT_wcspbrk( const MSVCRT_wchar_t* str, const MSVCRT_wchar_t* accept )
1321 {
1322     const MSVCRT_wchar_t* p;
1323
1324     while (*str)
1325     {
1326         for (p = accept; *p; p++) if (*p == *str) return (MSVCRT_wchar_t*)str;
1327         str++;
1328     }
1329     return NULL;
1330 }
1331
1332 /*********************************************************************
1333  *              wcstok_s  (MSVCRT.@)
1334  */
1335 MSVCRT_wchar_t * CDECL MSVCRT_wcstok_s( MSVCRT_wchar_t *str, const MSVCRT_wchar_t *delim,
1336                                  MSVCRT_wchar_t **next_token )
1337 {
1338     MSVCRT_wchar_t *ret;
1339
1340     if (!MSVCRT_CHECK_PMT(delim != NULL)) return NULL;
1341     if (!MSVCRT_CHECK_PMT(next_token != NULL)) return NULL;
1342     if (!MSVCRT_CHECK_PMT(str != NULL || *next_token != NULL)) return NULL;
1343
1344     if (!str) str = *next_token;
1345
1346     while (*str && strchrW( delim, *str )) str++;
1347     if (!*str) return NULL;
1348     ret = str++;
1349     while (*str && !strchrW( delim, *str )) str++;
1350     if (*str) *str++ = 0;
1351     *next_token = str;
1352     return ret;
1353 }
1354
1355 /*********************************************************************
1356  *              wcstok  (MSVCRT.@)
1357  */
1358 MSVCRT_wchar_t * CDECL MSVCRT_wcstok( MSVCRT_wchar_t *str, const MSVCRT_wchar_t *delim )
1359 {
1360     return MSVCRT_wcstok_s(str, delim, &msvcrt_get_thread_data()->wcstok_next);
1361 }
1362
1363 /*********************************************************************
1364  *              _wctomb_s_l (MSVCRT.@)
1365  */
1366 int CDECL MSVCRT__wctomb_s_l(int *len, char *mbchar, MSVCRT_size_t size,
1367         MSVCRT_wchar_t wch, MSVCRT__locale_t locale)
1368 {
1369     MSVCRT_pthreadlocinfo locinfo;
1370     BOOL error;
1371     int mblen;
1372
1373     if(!mbchar && size>0) {
1374         if(len)
1375             *len = 0;
1376         return 0;
1377     }
1378
1379     if(len)
1380         *len = -1;
1381
1382     if(!MSVCRT_CHECK_PMT(size <= INT_MAX))
1383         return MSVCRT_EINVAL;
1384
1385     if(!locale)
1386         locinfo = get_locinfo();
1387     else
1388         locinfo = locale->locinfo;
1389
1390     if(!locinfo->lc_codepage) {
1391         if(wch > 0xff) {
1392             if(mbchar && size>0)
1393                 memset(mbchar, 0, size);
1394             *MSVCRT__errno() = MSVCRT_EILSEQ;
1395             return MSVCRT_EILSEQ;
1396         }
1397
1398         if(!MSVCRT_CHECK_PMT_ERR(size >= 1, MSVCRT_ERANGE))
1399             return MSVCRT_ERANGE;
1400
1401         *mbchar = wch;
1402         if(len)
1403             *len = 1;
1404         return 0;
1405     }
1406
1407     mblen = WideCharToMultiByte(locinfo->lc_codepage, 0, &wch, 1, mbchar, size, NULL, &error);
1408     if(!mblen || error) {
1409         if(!mblen && GetLastError()==ERROR_INSUFFICIENT_BUFFER) {
1410             if(mbchar && size>0)
1411                 memset(mbchar, 0, size);
1412
1413             MSVCRT_INVALID_PMT("insufficient buffer size", MSVCRT_ERANGE);
1414             return MSVCRT_ERANGE;
1415         }
1416
1417         *MSVCRT__errno() = MSVCRT_EILSEQ;
1418         return MSVCRT_EILSEQ;
1419     }
1420
1421     if(len)
1422         *len = mblen;
1423     return 0;
1424 }
1425
1426 /*********************************************************************
1427  *              wctomb_s (MSVCRT.@)
1428  */
1429 int CDECL MSVCRT_wctomb_s(int *len, char *mbchar, MSVCRT_size_t size, MSVCRT_wchar_t wch)
1430 {
1431     return MSVCRT__wctomb_s_l(len, mbchar, size, wch, NULL);
1432 }
1433
1434 /*********************************************************************
1435  *              _wctomb_l (MSVCRT.@)
1436  */
1437 int CDECL MSVCRT__wctomb_l(char *dst, MSVCRT_wchar_t ch, MSVCRT__locale_t locale)
1438 {
1439     int len;
1440
1441     MSVCRT__wctomb_s_l(&len, dst, dst ? 6 : 0, ch, locale);
1442     return len;
1443 }
1444
1445 /*********************************************************************
1446  *              wctomb (MSVCRT.@)
1447  */
1448 INT CDECL MSVCRT_wctomb( char *dst, MSVCRT_wchar_t ch )
1449 {
1450     return MSVCRT__wctomb_l(dst, ch, NULL);
1451 }
1452
1453 /*********************************************************************
1454  *              wctob (MSVCRT.@)
1455  */
1456 INT CDECL MSVCRT_wctob( MSVCRT_wint_t wchar )
1457 {
1458     char out;
1459     BOOL error;
1460     UINT codepage = get_locinfo()->lc_codepage;
1461
1462     if(!codepage) {
1463         if (wchar < 0xff)
1464             return (signed char)wchar;
1465         else
1466             return MSVCRT_EOF;
1467     } else if(WideCharToMultiByte( codepage, 0, &wchar, 1, &out, 1, NULL, &error ) && !error)
1468         return (INT)out;
1469     return MSVCRT_EOF;
1470 }
1471
1472 /*********************************************************************
1473  *              wcrtomb (MSVCRT.@)
1474  */
1475 MSVCRT_size_t CDECL MSVCRT_wcrtomb( char *dst, MSVCRT_wchar_t ch, MSVCRT_mbstate_t *s)
1476 {
1477     if(s)
1478         *s = 0;
1479     return MSVCRT_wctomb(dst, ch);
1480 }
1481
1482 /*********************************************************************
1483  *              iswalnum (MSVCRT.@)
1484  */
1485 INT CDECL MSVCRT_iswalnum( MSVCRT_wchar_t wc )
1486 {
1487     return isalnumW( wc );
1488 }
1489
1490 /*********************************************************************
1491  *              iswalpha (MSVCRT.@)
1492  */
1493 INT CDECL MSVCRT_iswalpha( MSVCRT_wchar_t wc )
1494 {
1495     return isalphaW( wc );
1496 }
1497
1498 /*********************************************************************
1499  *              iswalpha_l (MSVCRT.@)
1500  */
1501 INT CDECL MSVCRT__iswalpha_l( MSVCRT_wchar_t wc, MSVCRT__locale_t locale )
1502 {
1503     return isalphaW( wc );
1504 }
1505
1506 /*********************************************************************
1507  *              iswcntrl (MSVCRT.@)
1508  */
1509 INT CDECL MSVCRT_iswcntrl( MSVCRT_wchar_t wc )
1510 {
1511     return iscntrlW( wc );
1512 }
1513
1514 /*********************************************************************
1515  *              iswdigit (MSVCRT.@)
1516  */
1517 INT CDECL MSVCRT_iswdigit( MSVCRT_wchar_t wc )
1518 {
1519     return isdigitW( wc );
1520 }
1521
1522 /*********************************************************************
1523  *              _iswdigit_l (MSVCRT.@)
1524  */
1525 INT CDECL MSVCRT__iswdigit_l( MSVCRT_wchar_t wc, MSVCRT__locale_t locale )
1526 {
1527     return isdigitW( wc );
1528 }
1529
1530 /*********************************************************************
1531  *              iswgraph (MSVCRT.@)
1532  */
1533 INT CDECL MSVCRT_iswgraph( MSVCRT_wchar_t wc )
1534 {
1535     return isgraphW( wc );
1536 }
1537
1538 /*********************************************************************
1539  *              iswlower (MSVCRT.@)
1540  */
1541 INT CDECL MSVCRT_iswlower( MSVCRT_wchar_t wc )
1542 {
1543     return islowerW( wc );
1544 }
1545
1546 /*********************************************************************
1547  *              iswprint (MSVCRT.@)
1548  */
1549 INT CDECL MSVCRT_iswprint( MSVCRT_wchar_t wc )
1550 {
1551     return isprintW( wc );
1552 }
1553
1554 /*********************************************************************
1555  *              iswpunct (MSVCRT.@)
1556  */
1557 INT CDECL MSVCRT_iswpunct( MSVCRT_wchar_t wc )
1558 {
1559     return ispunctW( wc );
1560 }
1561
1562 /*********************************************************************
1563  *              iswspace (MSVCRT.@)
1564  */
1565 INT CDECL MSVCRT_iswspace( MSVCRT_wchar_t wc )
1566 {
1567     return isspaceW( wc );
1568 }
1569
1570 /*********************************************************************
1571  *              iswupper (MSVCRT.@)
1572  */
1573 INT CDECL MSVCRT_iswupper( MSVCRT_wchar_t wc )
1574 {
1575     return isupperW( wc );
1576 }
1577
1578 /*********************************************************************
1579  *              iswxdigit (MSVCRT.@)
1580  */
1581 INT CDECL MSVCRT_iswxdigit( MSVCRT_wchar_t wc )
1582 {
1583     return isxdigitW( wc );
1584 }
1585
1586 /*********************************************************************
1587  *              wcscpy_s (MSVCRT.@)
1588  */
1589 INT CDECL MSVCRT_wcscpy_s( MSVCRT_wchar_t* wcDest, MSVCRT_size_t numElement, const  MSVCRT_wchar_t *wcSrc)
1590 {
1591     MSVCRT_size_t size = 0;
1592
1593     if(!MSVCRT_CHECK_PMT(wcDest)) return MSVCRT_EINVAL;
1594     if(!MSVCRT_CHECK_PMT(numElement)) return MSVCRT_EINVAL;
1595
1596     wcDest[0] = 0;
1597
1598     if(!MSVCRT_CHECK_PMT(wcSrc)) return MSVCRT_EINVAL;
1599
1600     size = strlenW(wcSrc) + 1;
1601
1602     if(!MSVCRT_CHECK_PMT_ERR(size <= numElement, MSVCRT_ERANGE))
1603         return MSVCRT_ERANGE;
1604
1605     memcpy( wcDest, wcSrc, size*sizeof(WCHAR) );
1606
1607     return 0;
1608 }
1609
1610 /******************************************************************
1611  *              wcsncpy (MSVCRT.@)
1612  */
1613 MSVCRT_wchar_t* __cdecl MSVCRT_wcsncpy( MSVCRT_wchar_t* s1,
1614         const MSVCRT_wchar_t *s2, MSVCRT_size_t n )
1615 {
1616     MSVCRT_size_t i;
1617
1618     for(i=0; i<n; i++)
1619         if(!(s1[i] = s2[i])) break;
1620     for(; i<n; i++)
1621         s1[i] = 0;
1622     return s1;
1623 }
1624
1625 /******************************************************************
1626  *              wcsncpy_s (MSVCRT.@)
1627  */
1628 INT CDECL MSVCRT_wcsncpy_s( MSVCRT_wchar_t* wcDest, MSVCRT_size_t numElement, const MSVCRT_wchar_t *wcSrc,
1629                             MSVCRT_size_t count )
1630 {
1631     WCHAR *p = wcDest;
1632     BOOL truncate = (count == MSVCRT__TRUNCATE);
1633
1634     if(!wcDest && !numElement && !count)
1635         return 0;
1636
1637     if (!wcDest || !numElement)
1638         return MSVCRT_EINVAL;
1639
1640     if (!wcSrc)
1641     {
1642         *wcDest = 0;
1643         return count ? MSVCRT_EINVAL : 0;
1644     }
1645
1646     while (numElement && count && *wcSrc)
1647     {
1648         *p++ = *wcSrc++;
1649         numElement--;
1650         count--;
1651     }
1652     if (!numElement && truncate)
1653     {
1654         *(p-1) = 0;
1655         return MSVCRT_STRUNCATE;
1656     }
1657     else if (!numElement)
1658     {
1659         *wcDest = 0;
1660         return MSVCRT_ERANGE;
1661     }
1662
1663     *p = 0;
1664     return 0;
1665 }
1666
1667 /******************************************************************
1668  *              wcscat_s (MSVCRT.@)
1669  *
1670  */
1671 INT CDECL MSVCRT_wcscat_s(MSVCRT_wchar_t* dst, MSVCRT_size_t elem, const MSVCRT_wchar_t* src)
1672 {
1673     MSVCRT_wchar_t* ptr = dst;
1674
1675     if (!dst || elem == 0) return MSVCRT_EINVAL;
1676     if (!src)
1677     {
1678         dst[0] = '\0';
1679         return MSVCRT_EINVAL;
1680     }
1681
1682     /* seek to end of dst string (or elem if no end of string is found */
1683     while (ptr < dst + elem && *ptr != '\0') ptr++;
1684     while (ptr < dst + elem)
1685     {
1686         if ((*ptr++ = *src++) == '\0') return 0;
1687     }
1688     /* not enough space */
1689     dst[0] = '\0';
1690     return MSVCRT_ERANGE;
1691 }
1692
1693 /*********************************************************************
1694  *  wcsncat_s (MSVCRT.@)
1695  *
1696  */
1697 INT CDECL MSVCRT_wcsncat_s(MSVCRT_wchar_t *dst, MSVCRT_size_t elem,
1698         const MSVCRT_wchar_t *src, MSVCRT_size_t count)
1699 {
1700     MSVCRT_size_t srclen;
1701     MSVCRT_wchar_t dststart;
1702     INT ret = 0;
1703
1704     if (!MSVCRT_CHECK_PMT(dst != NULL)) return MSVCRT_EINVAL;
1705     if (!MSVCRT_CHECK_PMT(elem > 0)) return MSVCRT_EINVAL;
1706     if (!MSVCRT_CHECK_PMT(src != NULL || count == 0)) return MSVCRT_EINVAL;
1707
1708     if (count == 0)
1709         return 0;
1710
1711     for (dststart = 0; dststart < elem; dststart++)
1712     {
1713         if (dst[dststart] == '\0')
1714             break;
1715     }
1716     if (dststart == elem)
1717     {
1718         MSVCRT_INVALID_PMT("dst[elem] is not NULL terminated\n", MSVCRT_EINVAL);
1719         return MSVCRT_EINVAL;
1720     }
1721
1722     if (count == MSVCRT__TRUNCATE)
1723     {
1724         srclen = strlenW(src);
1725         if (srclen >= (elem - dststart))
1726         {
1727             srclen = elem - dststart - 1;
1728             ret = MSVCRT_STRUNCATE;
1729         }
1730     }
1731     else
1732         srclen = min(strlenW(src), count);
1733     if (srclen < (elem - dststart))
1734     {
1735         memcpy(&dst[dststart], src, srclen*sizeof(MSVCRT_wchar_t));
1736         dst[dststart+srclen] = '\0';
1737         return ret;
1738     }
1739     MSVCRT_INVALID_PMT("dst[elem] is too small", MSVCRT_ERANGE);
1740     dst[0] = '\0';
1741     return MSVCRT_ERANGE;
1742 }
1743
1744 /*********************************************************************
1745  *  _wcstoi64_l (MSVCRT.@)
1746  *
1747  * FIXME: locale parameter is ignored
1748  */
1749 __int64 CDECL MSVCRT__wcstoi64_l(const MSVCRT_wchar_t *nptr,
1750         MSVCRT_wchar_t **endptr, int base, MSVCRT__locale_t locale)
1751 {
1752     BOOL negative = FALSE;
1753     __int64 ret = 0;
1754
1755     TRACE("(%s %p %d %p)\n", debugstr_w(nptr), endptr, base, locale);
1756
1757     if (!MSVCRT_CHECK_PMT(nptr != NULL)) return 0;
1758     if (!MSVCRT_CHECK_PMT(base == 0 || base >= 2)) return 0;
1759     if (!MSVCRT_CHECK_PMT(base <= 36)) return 0;
1760
1761     while(isspaceW(*nptr)) nptr++;
1762
1763     if(*nptr == '-') {
1764         negative = TRUE;
1765         nptr++;
1766     } else if(*nptr == '+')
1767         nptr++;
1768
1769     if((base==0 || base==16) && *nptr=='0' && tolowerW(*(nptr+1))=='x') {
1770         base = 16;
1771         nptr += 2;
1772     }
1773
1774     if(base == 0) {
1775         if(*nptr=='0')
1776             base = 8;
1777         else
1778             base = 10;
1779     }
1780
1781     while(*nptr) {
1782         MSVCRT_wchar_t cur = tolowerW(*nptr);
1783         int v;
1784
1785         if(isdigitW(cur)) {
1786             if(cur >= '0'+base)
1787                 break;
1788             v = cur-'0';
1789         } else {
1790             if(cur<'a' || cur>='a'+base-10)
1791                 break;
1792             v = cur-'a'+10;
1793         }
1794
1795         if(negative)
1796             v = -v;
1797
1798         nptr++;
1799
1800         if(!negative && (ret>MSVCRT_I64_MAX/base || ret*base>MSVCRT_I64_MAX-v)) {
1801             ret = MSVCRT_I64_MAX;
1802             *MSVCRT__errno() = MSVCRT_ERANGE;
1803         } else if(negative && (ret<MSVCRT_I64_MIN/base || ret*base<MSVCRT_I64_MIN-v)) {
1804             ret = MSVCRT_I64_MIN;
1805             *MSVCRT__errno() = MSVCRT_ERANGE;
1806         } else
1807             ret = ret*base + v;
1808     }
1809
1810     if(endptr)
1811         *endptr = (MSVCRT_wchar_t*)nptr;
1812
1813     return ret;
1814 }
1815
1816 /*********************************************************************
1817  *  _wcstoi64 (MSVCRT.@)
1818  */
1819 __int64 CDECL MSVCRT__wcstoi64(const MSVCRT_wchar_t *nptr,
1820         MSVCRT_wchar_t **endptr, int base)
1821 {
1822     return MSVCRT__wcstoi64_l(nptr, endptr, base, NULL);
1823 }
1824
1825 /*********************************************************************
1826  *  _wcstol_l (MSVCRT.@)
1827  */
1828 MSVCRT_long CDECL MSVCRT__wcstol_l(const MSVCRT_wchar_t *s,
1829         MSVCRT_wchar_t **end, int base, MSVCRT__locale_t locale)
1830 {
1831     __int64 ret = MSVCRT__wcstoi64_l(s, end, base, locale);
1832
1833     if(ret > MSVCRT_LONG_MAX) {
1834         ret = MSVCRT_LONG_MAX;
1835         *MSVCRT__errno() = MSVCRT_ERANGE;
1836     }else if(ret < MSVCRT_LONG_MIN) {
1837         ret = MSVCRT_LONG_MIN;
1838         *MSVCRT__errno() = MSVCRT_ERANGE;
1839     }
1840     return ret;
1841 }
1842
1843 /*********************************************************************
1844  *  _wtoi_l (MSVCRT.@)
1845  */
1846 int __cdecl MSVCRT__wtoi_l(const MSVCRT_wchar_t *str, MSVCRT__locale_t locale)
1847 {
1848     __int64 ret = MSVCRT__wcstoi64_l(str, NULL, 10, locale);
1849
1850     if(ret > INT_MAX) {
1851         ret = INT_MAX;
1852         *MSVCRT__errno() = MSVCRT_ERANGE;
1853     } else if(ret < INT_MIN) {
1854         ret = INT_MIN;
1855         *MSVCRT__errno() = MSVCRT_ERANGE;
1856     }
1857     return ret;
1858 }
1859
1860 /*********************************************************************
1861  *  _wtoi (MSVCRT.@)
1862  */
1863 int __cdecl MSVCRT__wtoi(const MSVCRT_wchar_t *str)
1864 {
1865     return MSVCRT__wtoi_l(str, NULL);
1866 }
1867
1868 /*********************************************************************
1869  *  _wtol_l (MSVCRT.@)
1870  */
1871 MSVCRT_long __cdecl MSVCRT__wtol_l(const MSVCRT_wchar_t *str, MSVCRT__locale_t locale)
1872 {
1873     __int64 ret = MSVCRT__wcstoi64_l(str, NULL, 10, locale);
1874
1875     if(ret > MSVCRT_LONG_MAX) {
1876         ret = MSVCRT_LONG_MAX;
1877         *MSVCRT__errno() = MSVCRT_ERANGE;
1878     } else if(ret < MSVCRT_LONG_MIN) {
1879         ret = MSVCRT_LONG_MIN;
1880         *MSVCRT__errno() = MSVCRT_ERANGE;
1881     }
1882     return ret;
1883 }
1884
1885 /*********************************************************************
1886  *  _wtol (MSVCRT.@)
1887  */
1888 MSVCRT_long __cdecl MSVCRT__wtol(const MSVCRT_wchar_t *str)
1889 {
1890     return MSVCRT__wtol_l(str, NULL);
1891 }
1892
1893 /*********************************************************************
1894  *  _wcstoui64_l (MSVCRT.@)
1895  *
1896  * FIXME: locale parameter is ignored
1897  */
1898 unsigned __int64 CDECL MSVCRT__wcstoui64_l(const MSVCRT_wchar_t *nptr,
1899         MSVCRT_wchar_t **endptr, int base, MSVCRT__locale_t locale)
1900 {
1901     BOOL negative = FALSE;
1902     unsigned __int64 ret = 0;
1903
1904     TRACE("(%s %p %d %p)\n", debugstr_w(nptr), endptr, base, locale);
1905
1906     if (!MSVCRT_CHECK_PMT(nptr != NULL)) return 0;
1907     if (!MSVCRT_CHECK_PMT(base == 0 || base >= 2)) return 0;
1908     if (!MSVCRT_CHECK_PMT(base <= 36)) return 0;
1909
1910     while(isspaceW(*nptr)) nptr++;
1911
1912     if(*nptr == '-') {
1913         negative = TRUE;
1914         nptr++;
1915     } else if(*nptr == '+')
1916         nptr++;
1917
1918     if((base==0 || base==16) && *nptr=='0' && tolowerW(*(nptr+1))=='x') {
1919         base = 16;
1920         nptr += 2;
1921     }
1922
1923     if(base == 0) {
1924         if(*nptr=='0')
1925             base = 8;
1926         else
1927             base = 10;
1928     }
1929
1930     while(*nptr) {
1931         MSVCRT_wchar_t cur = tolowerW(*nptr);
1932         int v;
1933
1934         if(isdigitW(cur)) {
1935             if(cur >= '0'+base)
1936                 break;
1937             v = *nptr-'0';
1938         } else {
1939             if(cur<'a' || cur>='a'+base-10)
1940                 break;
1941             v = cur-'a'+10;
1942         }
1943
1944         nptr++;
1945
1946         if(ret>MSVCRT_UI64_MAX/base || ret*base>MSVCRT_UI64_MAX-v) {
1947             ret = MSVCRT_UI64_MAX;
1948             *MSVCRT__errno() = MSVCRT_ERANGE;
1949         } else
1950             ret = ret*base + v;
1951     }
1952
1953     if(endptr)
1954         *endptr = (MSVCRT_wchar_t*)nptr;
1955
1956     return negative ? -ret : ret;
1957 }
1958
1959 /*********************************************************************
1960  *  _wcstoui64 (MSVCRT.@)
1961  */
1962 unsigned __int64 CDECL MSVCRT__wcstoui64(const MSVCRT_wchar_t *nptr,
1963         MSVCRT_wchar_t **endptr, int base)
1964 {
1965     return MSVCRT__wcstoui64_l(nptr, endptr, base, NULL);
1966 }
1967
1968 /*********************************************************************
1969  *  _wcstoul_l (MSVCRT.@)
1970  */
1971 MSVCRT_ulong __cdecl MSVCRT__wcstoul_l(const MSVCRT_wchar_t *s,
1972         MSVCRT_wchar_t **end, int base, MSVCRT__locale_t locale)
1973 {
1974     __int64 ret = MSVCRT__wcstoui64_l(s, end, base, locale);
1975
1976     if(ret > MSVCRT_ULONG_MAX) {
1977         ret = MSVCRT_ULONG_MAX;
1978         *MSVCRT__errno() = MSVCRT_ERANGE;
1979     }
1980     return ret;
1981 }
1982
1983 /*********************************************************************
1984    *  wcstoul (MSVCRT.@)
1985     */
1986 MSVCRT_ulong __cdecl MSVCRT_wcstoul(const MSVCRT_wchar_t *s, MSVCRT_wchar_t **end, int base)
1987 {
1988     return MSVCRT__wcstoul_l(s, end, base, NULL);
1989 }
1990
1991 /******************************************************************
1992  *  wcsnlen (MSVCRT.@)
1993  */
1994 MSVCRT_size_t CDECL MSVCRT_wcsnlen(const MSVCRT_wchar_t *s, MSVCRT_size_t maxlen)
1995 {
1996     MSVCRT_size_t i;
1997
1998     for (i = 0; i < maxlen; i++)
1999         if (!s[i]) break;
2000     return i;
2001 }
2002
2003 /*********************************************************************
2004  *              _towupper_l (MSVCRT.@)
2005  */
2006 int CDECL MSVCRT__towupper_l(MSVCRT_wint_t c, MSVCRT__locale_t locale)
2007 {
2008     return toupperW(c);
2009 }
2010
2011 /*********************************************************************
2012  *              towupper (MSVCRT.@)
2013  */
2014 int CDECL MSVCRT_towupper(MSVCRT_wint_t c)
2015 {
2016     return MSVCRT__towupper_l(c, NULL);
2017 }
2018
2019 /*********************************************************************
2020  *              _towlower_l (MSVCRT.@)
2021  */
2022 int CDECL MSVCRT__towlower_l(MSVCRT_wint_t c, MSVCRT__locale_t locale)
2023 {
2024     return tolowerW(c);
2025 }
2026
2027 /*********************************************************************
2028  *              towlower (MSVCRT.@)
2029  */
2030 int CDECL MSVCRT_towlower(MSVCRT_wint_t c)
2031 {
2032     return MSVCRT__towlower_l(c, NULL);
2033 }
2034
2035 /*********************************************************************
2036  *              wcschr (MSVCRT.@)
2037  */
2038 MSVCRT_wchar_t* CDECL MSVCRT_wcschr(const MSVCRT_wchar_t *str, MSVCRT_wchar_t ch)
2039 {
2040     return strchrW(str, ch);
2041 }
2042
2043 /***********************************************************************
2044  *              wcslen (MSVCRT.@)
2045  */
2046 int CDECL MSVCRT_wcslen(const MSVCRT_wchar_t *str)
2047 {
2048     return strlenW(str);
2049 }
2050
2051 /*********************************************************************
2052  *              wcsstr (MSVCRT.@)
2053  */
2054 MSVCRT_wchar_t* CDECL MSVCRT_wcsstr(const MSVCRT_wchar_t *str, const MSVCRT_wchar_t *sub)
2055 {
2056     return strstrW(str, sub);
2057 }
2058
2059 /*********************************************************************
2060  *              _wtoi64_l (MSVCRT.@)
2061  */
2062 __int64 CDECL MSVCRT__wtoi64_l(const MSVCRT_wchar_t *str, MSVCRT__locale_t locale)
2063 {
2064     ULONGLONG RunningTotal = 0;
2065     BOOL bMinus = FALSE;
2066
2067     while (isspaceW(*str)) {
2068         str++;
2069     } /* while */
2070
2071     if (*str == '+') {
2072         str++;
2073     } else if (*str == '-') {
2074         bMinus = TRUE;
2075         str++;
2076     } /* if */
2077
2078     while (*str >= '0' && *str <= '9') {
2079         RunningTotal = RunningTotal * 10 + *str - '0';
2080         str++;
2081     } /* while */
2082
2083     return bMinus ? -RunningTotal : RunningTotal;
2084 }
2085
2086 /*********************************************************************
2087  *              _wtoi64 (MSVCRT.@)
2088  */
2089 __int64 CDECL MSVCRT__wtoi64(const MSVCRT_wchar_t *str)
2090 {
2091     return MSVCRT__wtoi64_l(str, NULL);
2092 }
2093
2094 /*********************************************************************
2095  *           wcsncmp    (MSVCRT.@)
2096  */
2097 int CDECL MSVCRT_wcsncmp(const MSVCRT_wchar_t *str1, const MSVCRT_wchar_t *str2, int n)
2098 {
2099     return strncmpW(str1, str2, n);
2100 }
2101
2102 /*********************************************************************
2103  *              _wcsxfrm_l (MSVCRT.@)
2104  */
2105 MSVCRT_size_t CDECL MSVCRT__wcsxfrm_l(MSVCRT_wchar_t *dest, const MSVCRT_wchar_t *src,
2106         MSVCRT_size_t len, MSVCRT__locale_t locale)
2107 {
2108     MSVCRT_pthreadlocinfo locinfo;
2109     int i, ret;
2110
2111     if(!MSVCRT_CHECK_PMT(src)) return INT_MAX;
2112     if(!MSVCRT_CHECK_PMT(dest || !len)) return INT_MAX;
2113
2114     if(len > INT_MAX) {
2115         FIXME("len > INT_MAX not supported\n");
2116         len = INT_MAX;
2117     }
2118
2119     if(!locale)
2120         locinfo = get_locinfo();
2121     else
2122         locinfo = locale->locinfo;
2123
2124     if(!locinfo->lc_handle[MSVCRT_LC_COLLATE]) {
2125         MSVCRT_wcsncpy(dest, src, len);
2126         return strlenW(src);
2127     }
2128
2129     ret = LCMapStringW(locinfo->lc_handle[MSVCRT_LC_COLLATE],
2130             LCMAP_SORTKEY, src, -1, NULL, 0);
2131     if(!ret) {
2132         if(len) dest[0] = 0;
2133         *MSVCRT__errno() = MSVCRT_EILSEQ;
2134         return INT_MAX;
2135     }
2136     if(!len) return ret-1;
2137
2138     if(ret > len) {
2139         dest[0] = 0;
2140         *MSVCRT__errno() = MSVCRT_ERANGE;
2141         return ret-1;
2142     }
2143
2144     ret = LCMapStringW(locinfo->lc_handle[MSVCRT_LC_COLLATE],
2145             LCMAP_SORTKEY, src, -1, dest, len) - 1;
2146     for(i=ret; i>=0; i--)
2147         dest[i] = ((unsigned char*)dest)[i];
2148     return ret;
2149 }
2150
2151 /*********************************************************************
2152  *              wcsxfrm (MSVCRT.@)
2153  */
2154 MSVCRT_size_t CDECL MSVCRT_wcsxfrm(MSVCRT_wchar_t *dest,
2155         const MSVCRT_wchar_t *src, MSVCRT_size_t len)
2156 {
2157     return MSVCRT__wcsxfrm_l(dest, src, len, NULL);
2158 }