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  *              _vscprintf_p_l (MSVCRT.@)
 829  */
 830 int CDECL MSVCRT__vscprintf_p_l(const char *format,
 831         MSVCRT__locale_t locale, __ms_va_list args)
 832 {
 833     printf_arg args_ctx[MSVCRT__ARGMAX+1];
 834     struct _str_ctx_a puts_ctx = {INT_MAX, NULL};
 835     int ret;
 836
 837     memset(args_ctx, 0, sizeof(args_ctx));
 838
 839     ret = create_positional_ctx_a(args_ctx, format, args);
 840     if(ret < 0)  {
 841         MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
 842         *MSVCRT__errno() = MSVCRT_EINVAL;
 843         return ret;
 844     } else if(ret == 0) {
 845         ret = pf_printf_a(puts_clbk_str_a, &puts_ctx, format, locale, FALSE, TRUE,
 846                 arg_clbk_valist, NULL, &args);
 847     } else {
 848         ret = pf_printf_a(puts_clbk_str_a, &puts_ctx, format, locale, TRUE, TRUE,
 849                 arg_clbk_positional, args_ctx, NULL);
 850     }
 851
 852     return ret;
 853 }
 854
 855 /*********************************************************************
 856  *              _vscprintf_p (MSVCR80.@)
 857  */
 858 int CDECL MSVCRT__vscprintf_p(const char *format, __ms_va_list argptr)
 859 {
 860     return MSVCRT__vscprintf_p_l(format, NULL, argptr);
 861 }
 862
 863 /*********************************************************************
 864  *              _snprintf (MSVCRT.@)
 865  */
 866 int CDECL MSVCRT__snprintf(char *str, unsigned int len, const char *format, ...)
 867 {
 868     int retval;
 869     __ms_va_list valist;
 870     __ms_va_start(valist, format);
 871     retval = MSVCRT_vsnprintf(str, len, format, valist);
 872     __ms_va_end(valist);
 873     return retval;
 874 }
 875
 876 /*********************************************************************
 877  *              _snprintf_l (MSVCRT.@)
 878  */
 879 int CDECL MSVCRT__snprintf_l(char *str, unsigned int count, MSVCRT__locale_t locale,
 880     const char *format, ...)
 881 {
 882     int retval;
 883     __ms_va_list valist;
 884     __ms_va_start(valist, format);
 885     retval = MSVCRT_vsnprintf_l(str, count, format, locale, valist);
 886     __ms_va_end(valist);
 887     return retval;
 888 }
 889
 890 /*********************************************************************
 891  *              _snprintf_s (MSVCRT.@)
 892  */
 893 int CDECL MSVCRT__snprintf_s(char *str, unsigned int len, unsigned int count,
 894     const char *format, ...)
 895 {
 896     int retval;
 897     __ms_va_list valist;
 898     __ms_va_start(valist, format);
 899     retval = MSVCRT_vsnprintf_s_l(str, len, count, format, NULL, valist);
 900     __ms_va_end(valist);
 901     return retval;
 902 }
 903
 904 /*********************************************************************
 905  *              _scprintf (MSVCRT.@)
 906  */
 907 int CDECL MSVCRT__scprintf(const char *format, ...)
 908 {
 909     int retval;
 910     __ms_va_list valist;
 911     __ms_va_start(valist, format);
 912     retval = MSVCRT__vscprintf(format, valist);
 913     __ms_va_end(valist);
 914     return retval;
 915 }
 916
 917 /*********************************************************************
 918  *              _vsnwprintf (MSVCRT.@)
 919  */
 920 int CDECL MSVCRT_vsnwprintf(MSVCRT_wchar_t *str, MSVCRT_size_t len,
 921         const MSVCRT_wchar_t *format, __ms_va_list valist)
 922 {
 923     static const MSVCRT_wchar_t nullbyte = '\0';
 924     struct _str_ctx_w ctx = {len, str};
 925     int ret;
 926
 927     ret = pf_printf_w(puts_clbk_str_w, &ctx, format, NULL, FALSE, FALSE,
 928             arg_clbk_valist, NULL, &valist);
 929     puts_clbk_str_w(&ctx, 1, &nullbyte);
 930     return ret;
 931 }
 932
 933 /*********************************************************************
 934  *              _vsnwprintf_l (MSVCRT.@)
 935  */
 936 int CDECL MSVCRT_vsnwprintf_l(MSVCRT_wchar_t *str, MSVCRT_size_t len,
 937         const MSVCRT_wchar_t *format, MSVCRT__locale_t locale,
 938         __ms_va_list valist)
 939 {
 940     static const MSVCRT_wchar_t nullbyte = '\0';
 941     struct _str_ctx_w ctx = {len, str};
 942     int ret;
 943
 944     ret = pf_printf_w(puts_clbk_str_w, &ctx, format, locale, FALSE, FALSE,
 945             arg_clbk_valist, NULL, &valist);
 946     puts_clbk_str_w(&ctx, 1, &nullbyte);
 947     return ret;
 948 }
 949
 950 /*********************************************************************
 951  *              _vswprintf_p_l (MSVCRT.@)
 952  */
 953 int CDECL MSVCRT_vswprintf_p_l(MSVCRT_wchar_t *buffer, MSVCRT_size_t length,
 954         const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, __ms_va_list args)
 955 {
 956     static const MSVCRT_wchar_t nullbyte = '\0';
 957     printf_arg args_ctx[MSVCRT__ARGMAX+1];
 958     struct _str_ctx_w puts_ctx = {length, buffer};
 959     int ret;
 960
 961     memset(args_ctx, 0, sizeof(args_ctx));
 962
 963     ret = create_positional_ctx_w(args_ctx, format, args);
 964     if(ret < 0)  {
 965         MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
 966         *MSVCRT__errno() = MSVCRT_EINVAL;
 967         return ret;
 968     } else if(ret == 0)
 969         ret = pf_printf_w(puts_clbk_str_w, &puts_ctx, format, locale, FALSE, TRUE,
 970                 arg_clbk_valist, NULL, &args);
 971     else
 972         ret = pf_printf_w(puts_clbk_str_w, &puts_ctx, format, locale, TRUE, TRUE,
 973                 arg_clbk_positional, args_ctx, NULL);
 974
 975     puts_clbk_str_w(&puts_ctx, 1, &nullbyte);
 976     return ret;
 977 }
 978
 979 /*********************************************************************
 980  * _vswprintf_p (MSVCR100.@)
 981  */
 982 int CDECL MSVCRT__vswprintf_p(MSVCRT_wchar_t *buffer, MSVCRT_size_t length,
 983         const MSVCRT_wchar_t *format, __ms_va_list args)
 984 {
 985     return MSVCRT_vswprintf_p_l(buffer, length, format, NULL, args);
 986 }
 987
 988 /*********************************************************************
 989  *              _vsnwprintf_s_l (MSVCRT.@)
 990  */
 991 int CDECL MSVCRT_vsnwprintf_s_l( MSVCRT_wchar_t *str, MSVCRT_size_t sizeOfBuffer,
 992         MSVCRT_size_t count, const MSVCRT_wchar_t *format,
 993         MSVCRT__locale_t locale, __ms_va_list valist)
 994 {
 995     static const MSVCRT_wchar_t nullbyte = '\0';
 996     struct _str_ctx_w ctx;
 997     int len, ret;
 998
 999     len = sizeOfBuffer;
1000     if(count!=-1 && len>count+1)
1001         len = count+1;
1002
1003     ctx.len = len;
1004     ctx.buf = str;
1005     ret = pf_printf_w(puts_clbk_str_w, &ctx, format, locale, FALSE, TRUE,
1006             arg_clbk_valist, NULL, &valist);
1007     puts_clbk_str_w(&ctx, 1, &nullbyte);
1008
1009     if(ret<0 || ret==len) {
1010         if(count!=MSVCRT__TRUNCATE && count>sizeOfBuffer) {
1011             MSVCRT_INVALID_PMT("str[sizeOfBuffer] is too small", MSVCRT_ERANGE);
1012             memset(str, 0, sizeOfBuffer*sizeof(MSVCRT_wchar_t));
1013         } else
1014             str[len-1] = '\0';
1015
1016         return -1;
1017     }
1018
1019     return ret;
1020 }
1021
1022 /*********************************************************************
1023  *              _vsnwprintf_s (MSVCRT.@)
1024  */
1025 int CDECL MSVCRT_vsnwprintf_s(MSVCRT_wchar_t *str, MSVCRT_size_t sizeOfBuffer,
1026         MSVCRT_size_t count, const MSVCRT_wchar_t *format, __ms_va_list valist)
1027 {
1028     return MSVCRT_vsnwprintf_s_l(str, sizeOfBuffer, count,
1029             format, NULL, valist);
1030 }
1031
1032 /*********************************************************************
1033  *              _snwprintf (MSVCRT.@)
1034  */
1035 int CDECL MSVCRT__snwprintf( MSVCRT_wchar_t *str, unsigned int len, const MSVCRT_wchar_t *format, ...)
1036 {
1037     int retval;
1038     __ms_va_list valist;
1039     __ms_va_start(valist, format);
1040     retval = MSVCRT_vsnwprintf(str, len, format, valist);
1041     __ms_va_end(valist);
1042     return retval;
1043 }
1044
1045 /*********************************************************************
1046  *              _snwprintf_l (MSVCRT.@)
1047  */
1048 int CDECL MSVCRT__snwprintf_l( MSVCRT_wchar_t *str, unsigned int len, const MSVCRT_wchar_t *format,
1049         MSVCRT__locale_t locale, ...)
1050 {
1051     int retval;
1052     __ms_va_list valist;
1053     __ms_va_start(valist, locale);
1054     retval = MSVCRT_vsnwprintf_l(str, len, format, locale, valist);
1055     __ms_va_end(valist);
1056     return retval;
1057 }
1058
1059 /*********************************************************************
1060  *              _snwprintf_s (MSVCRT.@)
1061  */
1062 int CDECL MSVCRT__snwprintf_s( MSVCRT_wchar_t *str, unsigned int len, unsigned int count,
1063     const MSVCRT_wchar_t *format, ...)
1064 {
1065     int retval;
1066     __ms_va_list valist;
1067     __ms_va_start(valist, format);
1068     retval = MSVCRT_vsnwprintf_s_l(str, len, count, format, NULL, valist);
1069     __ms_va_end(valist);
1070     return retval;
1071 }
1072
1073 /*********************************************************************
1074  *              _snwprintf_s_l (MSVCRT.@)
1075  */
1076 int CDECL MSVCRT__snwprintf_s_l( MSVCRT_wchar_t *str, unsigned int len, unsigned int count,
1077         const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, ... )
1078 {
1079     int retval;
1080     __ms_va_list valist;
1081     __ms_va_start(valist, locale);
1082     retval = MSVCRT_vsnwprintf_s_l(str, len, count, format, locale, valist);
1083     __ms_va_end(valist);
1084     return retval;
1085 }
1086
1087 /*********************************************************************
1088  *              sprintf (MSVCRT.@)
1089  */
1090 int CDECL MSVCRT_sprintf( char *str, const char *format, ... )
1091 {
1092     __ms_va_list ap;
1093     int r;
1094
1095     __ms_va_start( ap, format );
1096     r = MSVCRT_vsnprintf( str, INT_MAX, format, ap );
1097     __ms_va_end( ap );
1098     return r;
1099 }
1100
1101 /*********************************************************************
1102  *              sprintf_s (MSVCRT.@)
1103  */
1104 int CDECL MSVCRT_sprintf_s( char *str, MSVCRT_size_t num, const char *format, ... )
1105 {
1106     __ms_va_list ap;
1107     int r;
1108
1109     __ms_va_start( ap, format );
1110     r = MSVCRT_vsnprintf( str, num, format, ap );
1111     __ms_va_end( ap );
1112     return r;
1113 }
1114
1115 /*********************************************************************
1116  *              _scwprintf (MSVCRT.@)
1117  */
1118 int CDECL MSVCRT__scwprintf( const MSVCRT_wchar_t *format, ... )
1119 {
1120     __ms_va_list ap;
1121     int r;
1122
1123     __ms_va_start( ap, format );
1124     r = MSVCRT_vsnwprintf( NULL, INT_MAX, format, ap );
1125     __ms_va_end( ap );
1126     return r;
1127 }
1128
1129 /*********************************************************************
1130  *              swprintf (MSVCRT.@)
1131  */
1132 int CDECL MSVCRT_swprintf( MSVCRT_wchar_t *str, const MSVCRT_wchar_t *format, ... )
1133 {
1134     __ms_va_list ap;
1135     int r;
1136
1137     __ms_va_start( ap, format );
1138     r = MSVCRT_vsnwprintf( str, INT_MAX, format, ap );
1139     __ms_va_end( ap );
1140     return r;
1141 }
1142
1143 /*********************************************************************
1144  *              swprintf_s (MSVCRT.@)
1145  */
1146 int CDECL MSVCRT_swprintf_s(MSVCRT_wchar_t *str, MSVCRT_size_t numberOfElements,
1147         const MSVCRT_wchar_t *format, ... )
1148 {
1149     __ms_va_list ap;
1150     int r;
1151
1152     __ms_va_start(ap, format);
1153     r = MSVCRT_vsnwprintf_s(str, numberOfElements, INT_MAX, format, ap);
1154     __ms_va_end(ap);
1155
1156     return r;
1157 }
1158
1159 /*********************************************************************
1160  *              _swprintf_s_l (MSVCRT.@)
1161  */
1162 int CDECL MSVCRT__swprintf_s_l(MSVCRT_wchar_t *str, MSVCRT_size_t numberOfElements,
1163         const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, ... )
1164 {
1165     __ms_va_list ap;
1166     int r;
1167
1168     __ms_va_start(ap, locale);
1169     r = MSVCRT_vsnwprintf_s_l(str, numberOfElements, INT_MAX, format, locale, ap);
1170     __ms_va_end(ap);
1171
1172     return r;
1173 }
1174
1175 /*********************************************************************
1176  *              _vswprintf (MSVCRT.@)
1177  */
1178 int CDECL MSVCRT_vswprintf( MSVCRT_wchar_t* str, const MSVCRT_wchar_t* format, __ms_va_list args )
1179 {
1180     return MSVCRT_vsnwprintf( str, INT_MAX, format, args );
1181 }
1182
1183 /*********************************************************************
1184  *              _vswprintf (MSVCRT.@)
1185  */
1186 int CDECL MSVCRT_vswprintf_l( MSVCRT_wchar_t* str, const MSVCRT_wchar_t* format,
1187         MSVCRT__locale_t locale, __ms_va_list args )
1188 {
1189     return MSVCRT_vsnwprintf_l( str, INT_MAX, format, locale, args );
1190 }
1191
1192 /*********************************************************************
1193  *              _vscwprintf (MSVCRT.@)
1194  */
1195 int CDECL MSVCRT__vscwprintf( const MSVCRT_wchar_t *format, __ms_va_list args )
1196 {
1197     return MSVCRT_vsnwprintf( NULL, INT_MAX, format, args );
1198 }
1199
1200 /*********************************************************************
1201  *              _vscwprintf_l (MSVCRT.@)
1202  */
1203 int CDECL MSVCRT__vscwprintf_l( const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, __ms_va_list args )
1204 {
1205     return MSVCRT_vsnwprintf_l( NULL, INT_MAX, format, locale, args );
1206 }
1207
1208 /*********************************************************************
1209  *              _vscwprintf_p_l (MSVCRT.@)
1210  */
1211 int CDECL MSVCRT__vscwprintf_p_l( const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, __ms_va_list args )
1212 {
1213     return MSVCRT_vswprintf_p_l( NULL, INT_MAX, format, locale, args );
1214 }
1215
1216 /*********************************************************************
1217  * _vscwprintf_p (MSVCR100.@)
1218  */
1219 int CDECL MSVCRT__vscwprintf_p(const MSVCRT_wchar_t *format, __ms_va_list args)
1220 {
1221     return MSVCRT_vswprintf_p_l(NULL, INT_MAX, format, NULL, args);
1222 }
1223
1224 /*********************************************************************
1225  *              vswprintf_s (MSVCRT.@)
1226  */
1227 int CDECL MSVCRT_vswprintf_s(MSVCRT_wchar_t* str, MSVCRT_size_t numberOfElements,
1228         const MSVCRT_wchar_t* format, __ms_va_list args)
1229 {
1230     return MSVCRT_vsnwprintf_s(str, numberOfElements, INT_MAX, format, args );
1231 }
1232
1233 /*********************************************************************
1234  *              _vswprintf_s_l (MSVCRT.@)
1235  */
1236 int CDECL MSVCRT_vswprintf_s_l(MSVCRT_wchar_t* str, MSVCRT_size_t numberOfElements,
1237         const MSVCRT_wchar_t* format, MSVCRT__locale_t locale, __ms_va_list args)
1238 {
1239     return MSVCRT_vsnwprintf_s_l(str, numberOfElements, INT_MAX,
1240             format, locale, args );
1241 }
1242
1243 /*********************************************************************
1244  *              _vsprintf_p_l (MSVCRT.@)
1245  */
1246 int CDECL MSVCRT_vsprintf_p_l(char *buffer, MSVCRT_size_t length, const char *format,
1247         MSVCRT__locale_t locale, __ms_va_list args)
1248 {
1249     static const char nullbyte = '\0';
1250     printf_arg args_ctx[MSVCRT__ARGMAX+1];
1251     struct _str_ctx_a puts_ctx = {length, buffer};
1252     int ret;
1253
1254     memset(args_ctx, 0, sizeof(args_ctx));
1255
1256     ret = create_positional_ctx_a(args_ctx, format, args);
1257     if(ret < 0) {
1258         MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
1259         *MSVCRT__errno() = MSVCRT_EINVAL;
1260         return ret;
1261     } else if(ret == 0)
1262         ret = pf_printf_a(puts_clbk_str_a, &puts_ctx, format, locale, FALSE, TRUE,
1263                 arg_clbk_valist, NULL, &args);
1264     else
1265         ret = pf_printf_a(puts_clbk_str_a, &puts_ctx, format, locale, TRUE, TRUE,
1266                 arg_clbk_positional, args_ctx, NULL);
1267
1268     puts_clbk_str_a(&puts_ctx, 1, &nullbyte);
1269     return ret;
1270 }
1271
1272 /*********************************************************************
1273  *              _vsprintf_p (MSVCRT.@)
1274  */
1275 int CDECL MSVCRT_vsprintf_p(char *buffer, MSVCRT_size_t length,
1276         const char *format, __ms_va_list args)
1277 {
1278     return MSVCRT_vsprintf_p_l(buffer, length, format, NULL, args);
1279 }
1280
1281 /*********************************************************************
1282  *              _sprintf_p_l (MSVCRT.@)
1283  */
1284 int CDECL MSVCRT_sprintf_p_l(char *buffer, MSVCRT_size_t length,
1285         const char *format, MSVCRT__locale_t locale, ...)
1286 {
1287     __ms_va_list valist;
1288     int r;
1289
1290     __ms_va_start(valist, locale);
1291     r = MSVCRT_vsprintf_p_l(buffer, length, format, locale, valist);
1292     __ms_va_end(valist);
1293
1294     return r;
1295 }
1296
1297 /*********************************************************************
1298  *              __swprintf_l (MSVCRT.@)
1299  */
1300 int CDECL MSVCRT___swprintf_l( MSVCRT_wchar_t *str, const MSVCRT_wchar_t *format,
1301         MSVCRT__locale_t locale, ...)
1302 {
1303     int retval;
1304     __ms_va_list valist;
1305     __ms_va_start(valist, locale);
1306     retval = MSVCRT_vswprintf_l(str, format, locale, valist);
1307     __ms_va_end(valist);
1308     return retval;
1309 }
1310
1311 /*********************************************************************
1312  * _sprintf_p (MSVCR100.@)
1313  */
1314 int CDECL MSVCRT__sprintf_p(char *buffer, MSVCRT_size_t length, const char *format, ...)
1315 {
1316     __ms_va_list valist;
1317     int r;
1318
1319     __ms_va_start(valist, format);
1320     r = MSVCRT_vsprintf_p_l(buffer, length, format, NULL, valist);
1321     __ms_va_end(valist);
1322
1323     return r;
1324 }
1325
1326 /*********************************************************************
1327  *              _swprintf_p_l (MSVCRT.@)
1328  */
1329 int CDECL MSVCRT_swprintf_p_l(MSVCRT_wchar_t *buffer, MSVCRT_size_t length,
1330         const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, ...)
1331 {
1332     __ms_va_list valist;
1333     int r;
1334
1335     __ms_va_start(valist, locale);
1336     r = MSVCRT_vswprintf_p_l(buffer, length, format, locale, valist);
1337     __ms_va_end(valist);
1338
1339     return r;
1340 }
1341
1342 /*********************************************************************
1343  *              _wcscoll_l (MSVCRT.@)
1344  */
1345 int CDECL MSVCRT__wcscoll_l(const MSVCRT_wchar_t* str1, const MSVCRT_wchar_t* str2, MSVCRT__locale_t locale)
1346 {
1347     MSVCRT_pthreadlocinfo locinfo;
1348
1349     if(!locale)
1350         locinfo = get_locinfo();
1351     else
1352         locinfo = locale->locinfo;
1353
1354     if(!locinfo->lc_handle[MSVCRT_LC_COLLATE])
1355         return strcmpW(str1, str2);
1356     return CompareStringW(locinfo->lc_handle[MSVCRT_LC_COLLATE], 0, str1, -1, str2, -1)-CSTR_EQUAL;
1357 }
1358
1359 /*********************************************************************
1360  *              wcscoll (MSVCRT.@)
1361  */
1362 int CDECL MSVCRT_wcscoll( const MSVCRT_wchar_t* str1, const MSVCRT_wchar_t* str2 )
1363 {
1364     return MSVCRT__wcscoll_l(str1, str2, NULL);
1365 }
1366
1367 /*********************************************************************
1368  *              wcspbrk (MSVCRT.@)
1369  */
1370 MSVCRT_wchar_t* CDECL MSVCRT_wcspbrk( const MSVCRT_wchar_t* str, const MSVCRT_wchar_t* accept )
1371 {
1372     const MSVCRT_wchar_t* p;
1373
1374     while (*str)
1375     {
1376         for (p = accept; *p; p++) if (*p == *str) return (MSVCRT_wchar_t*)str;
1377         str++;
1378     }
1379     return NULL;
1380 }
1381
1382 /*********************************************************************
1383  *              wcstok_s  (MSVCRT.@)
1384  */
1385 MSVCRT_wchar_t * CDECL MSVCRT_wcstok_s( MSVCRT_wchar_t *str, const MSVCRT_wchar_t *delim,
1386                                  MSVCRT_wchar_t **next_token )
1387 {
1388     MSVCRT_wchar_t *ret;
1389
1390     if (!MSVCRT_CHECK_PMT(delim != NULL)) return NULL;
1391     if (!MSVCRT_CHECK_PMT(next_token != NULL)) return NULL;
1392     if (!MSVCRT_CHECK_PMT(str != NULL || *next_token != NULL)) return NULL;
1393
1394     if (!str) str = *next_token;
1395
1396     while (*str && strchrW( delim, *str )) str++;
1397     if (!*str) return NULL;
1398     ret = str++;
1399     while (*str && !strchrW( delim, *str )) str++;
1400     if (*str) *str++ = 0;
1401     *next_token = str;
1402     return ret;
1403 }
1404
1405 /*********************************************************************
1406  *              wcstok  (MSVCRT.@)
1407  */
1408 MSVCRT_wchar_t * CDECL MSVCRT_wcstok( MSVCRT_wchar_t *str, const MSVCRT_wchar_t *delim )
1409 {
1410     return MSVCRT_wcstok_s(str, delim, &msvcrt_get_thread_data()->wcstok_next);
1411 }
1412
1413 /*********************************************************************
1414  *              _wctomb_s_l (MSVCRT.@)
1415  */
1416 int CDECL MSVCRT__wctomb_s_l(int *len, char *mbchar, MSVCRT_size_t size,
1417         MSVCRT_wchar_t wch, MSVCRT__locale_t locale)
1418 {
1419     MSVCRT_pthreadlocinfo locinfo;
1420     BOOL error;
1421     int mblen;
1422
1423     if(!mbchar && size>0) {
1424         if(len)
1425             *len = 0;
1426         return 0;
1427     }
1428
1429     if(len)
1430         *len = -1;
1431
1432     if(!MSVCRT_CHECK_PMT(size <= INT_MAX))
1433         return MSVCRT_EINVAL;
1434
1435     if(!locale)
1436         locinfo = get_locinfo();
1437     else
1438         locinfo = locale->locinfo;
1439
1440     if(!locinfo->lc_codepage) {
1441         if(wch > 0xff) {
1442             if(mbchar && size>0)
1443                 memset(mbchar, 0, size);
1444             *MSVCRT__errno() = MSVCRT_EILSEQ;
1445             return MSVCRT_EILSEQ;
1446         }
1447
1448         if(!MSVCRT_CHECK_PMT_ERR(size >= 1, MSVCRT_ERANGE))
1449             return MSVCRT_ERANGE;
1450
1451         *mbchar = wch;
1452         if(len)
1453             *len = 1;
1454         return 0;
1455     }
1456
1457     mblen = WideCharToMultiByte(locinfo->lc_codepage, 0, &wch, 1, mbchar, size, NULL, &error);
1458     if(!mblen || error) {
1459         if(!mblen && GetLastError()==ERROR_INSUFFICIENT_BUFFER) {
1460             if(mbchar && size>0)
1461                 memset(mbchar, 0, size);
1462
1463             MSVCRT_INVALID_PMT("insufficient buffer size", MSVCRT_ERANGE);
1464             return MSVCRT_ERANGE;
1465         }
1466
1467         *MSVCRT__errno() = MSVCRT_EILSEQ;
1468         return MSVCRT_EILSEQ;
1469     }
1470
1471     if(len)
1472         *len = mblen;
1473     return 0;
1474 }
1475
1476 /*********************************************************************
1477  *              wctomb_s (MSVCRT.@)
1478  */
1479 int CDECL MSVCRT_wctomb_s(int *len, char *mbchar, MSVCRT_size_t size, MSVCRT_wchar_t wch)
1480 {
1481     return MSVCRT__wctomb_s_l(len, mbchar, size, wch, NULL);
1482 }
1483
1484 /*********************************************************************
1485  *              _wctomb_l (MSVCRT.@)
1486  */
1487 int CDECL MSVCRT__wctomb_l(char *dst, MSVCRT_wchar_t ch, MSVCRT__locale_t locale)
1488 {
1489     int len;
1490
1491     MSVCRT__wctomb_s_l(&len, dst, dst ? MSVCRT_MB_LEN_MAX : 0, ch, locale);
1492     return len;
1493 }
1494
1495 /*********************************************************************
1496  *              wctomb (MSVCRT.@)
1497  */
1498 INT CDECL MSVCRT_wctomb( char *dst, MSVCRT_wchar_t ch )
1499 {
1500     return MSVCRT__wctomb_l(dst, ch, NULL);
1501 }
1502
1503 /*********************************************************************
1504  *              wctob (MSVCRT.@)
1505  */
1506 INT CDECL MSVCRT_wctob( MSVCRT_wint_t wchar )
1507 {
1508     char out;
1509     BOOL error;
1510     UINT codepage = get_locinfo()->lc_codepage;
1511
1512     if(!codepage) {
1513         if (wchar < 0xff)
1514             return (signed char)wchar;
1515         else
1516             return MSVCRT_EOF;
1517     } else if(WideCharToMultiByte( codepage, 0, &wchar, 1, &out, 1, NULL, &error ) && !error)
1518         return (INT)out;
1519     return MSVCRT_EOF;
1520 }
1521
1522 /*********************************************************************
1523  *              wcrtomb (MSVCRT.@)
1524  */
1525 MSVCRT_size_t CDECL MSVCRT_wcrtomb( char *dst, MSVCRT_wchar_t ch, MSVCRT_mbstate_t *s)
1526 {
1527     if(s)
1528         *s = 0;
1529     return MSVCRT_wctomb(dst, ch);
1530 }
1531
1532 /*********************************************************************
1533  *              iswalnum (MSVCRT.@)
1534  */
1535 INT CDECL MSVCRT_iswalnum( MSVCRT_wchar_t wc )
1536 {
1537     return isalnumW( wc );
1538 }
1539
1540 /*********************************************************************
1541  *              iswalpha (MSVCRT.@)
1542  */
1543 INT CDECL MSVCRT_iswalpha( MSVCRT_wchar_t wc )
1544 {
1545     return isalphaW( wc );
1546 }
1547
1548 /*********************************************************************
1549  *              iswalpha_l (MSVCRT.@)
1550  */
1551 INT CDECL MSVCRT__iswalpha_l( MSVCRT_wchar_t wc, MSVCRT__locale_t locale )
1552 {
1553     return isalphaW( wc );
1554 }
1555
1556 /*********************************************************************
1557  *              iswcntrl (MSVCRT.@)
1558  */
1559 INT CDECL MSVCRT_iswcntrl( MSVCRT_wchar_t wc )
1560 {
1561     return iscntrlW( wc );
1562 }
1563
1564 /*********************************************************************
1565  *              iswdigit (MSVCRT.@)
1566  */
1567 INT CDECL MSVCRT_iswdigit( MSVCRT_wchar_t wc )
1568 {
1569     return isdigitW( wc );
1570 }
1571
1572 /*********************************************************************
1573  *              _iswdigit_l (MSVCRT.@)
1574  */
1575 INT CDECL MSVCRT__iswdigit_l( MSVCRT_wchar_t wc, MSVCRT__locale_t locale )
1576 {
1577     return isdigitW( wc );
1578 }
1579
1580 /*********************************************************************
1581  *              iswgraph (MSVCRT.@)
1582  */
1583 INT CDECL MSVCRT_iswgraph( MSVCRT_wchar_t wc )
1584 {
1585     return isgraphW( wc );
1586 }
1587
1588 /*********************************************************************
1589  *              iswlower (MSVCRT.@)
1590  */
1591 INT CDECL MSVCRT_iswlower( MSVCRT_wchar_t wc )
1592 {
1593     return islowerW( wc );
1594 }
1595
1596 /*********************************************************************
1597  *              iswprint (MSVCRT.@)
1598  */
1599 INT CDECL MSVCRT_iswprint( MSVCRT_wchar_t wc )
1600 {
1601     return isprintW( wc );
1602 }
1603
1604 /*********************************************************************
1605  *              _iswpunct_l (MSVCRT.@)
1606  */
1607 INT CDECL MSVCRT__iswpunct_l( MSVCRT_wchar_t wc, MSVCRT__locale_t locale )
1608 {
1609     return ispunctW( wc );
1610 }
1611
1612 /*********************************************************************
1613  *              iswpunct (MSVCRT.@)
1614  */
1615 INT CDECL MSVCRT_iswpunct( MSVCRT_wchar_t wc )
1616 {
1617     return ispunctW( wc );
1618 }
1619
1620 /*********************************************************************
1621  *              _iswspace_l (MSVCRT.@)
1622  */
1623 INT CDECL MSVCRT__iswspace_l( MSVCRT_wchar_t wc, MSVCRT__locale_t locale )
1624 {
1625     return isspaceW( wc );
1626 }
1627
1628 /*********************************************************************
1629  *              iswspace (MSVCRT.@)
1630  */
1631 INT CDECL MSVCRT_iswspace( MSVCRT_wchar_t wc )
1632 {
1633     return isspaceW( wc );
1634 }
1635
1636 /*********************************************************************
1637  *              iswupper (MSVCRT.@)
1638  */
1639 INT CDECL MSVCRT_iswupper( MSVCRT_wchar_t wc )
1640 {
1641     return isupperW( wc );
1642 }
1643
1644 /*********************************************************************
1645  *              iswxdigit (MSVCRT.@)
1646  */
1647 INT CDECL MSVCRT_iswxdigit( MSVCRT_wchar_t wc )
1648 {
1649     return isxdigitW( wc );
1650 }
1651
1652 /*********************************************************************
1653  *              wcscpy_s (MSVCRT.@)
1654  */
1655 INT CDECL MSVCRT_wcscpy_s( MSVCRT_wchar_t* wcDest, MSVCRT_size_t numElement, const  MSVCRT_wchar_t *wcSrc)
1656 {
1657     MSVCRT_size_t size = 0;
1658
1659     if(!MSVCRT_CHECK_PMT(wcDest)) return MSVCRT_EINVAL;
1660     if(!MSVCRT_CHECK_PMT(numElement)) return MSVCRT_EINVAL;
1661
1662     wcDest[0] = 0;
1663
1664     if(!MSVCRT_CHECK_PMT(wcSrc)) return MSVCRT_EINVAL;
1665
1666     size = strlenW(wcSrc) + 1;
1667
1668     if(!MSVCRT_CHECK_PMT_ERR(size <= numElement, MSVCRT_ERANGE))
1669         return MSVCRT_ERANGE;
1670
1671     memcpy( wcDest, wcSrc, size*sizeof(WCHAR) );
1672
1673     return 0;
1674 }
1675
1676 /******************************************************************
1677  *              wcsncpy (MSVCRT.@)
1678  */
1679 MSVCRT_wchar_t* __cdecl MSVCRT_wcsncpy( MSVCRT_wchar_t* s1,
1680         const MSVCRT_wchar_t *s2, MSVCRT_size_t n )
1681 {
1682     MSVCRT_size_t i;
1683
1684     for(i=0; i<n; i++)
1685         if(!(s1[i] = s2[i])) break;
1686     for(; i<n; i++)
1687         s1[i] = 0;
1688     return s1;
1689 }
1690
1691 /******************************************************************
1692  *              wcsncpy_s (MSVCRT.@)
1693  */
1694 INT CDECL MSVCRT_wcsncpy_s( MSVCRT_wchar_t* wcDest, MSVCRT_size_t numElement, const MSVCRT_wchar_t *wcSrc,
1695                             MSVCRT_size_t count )
1696 {
1697     WCHAR *p = wcDest;
1698     BOOL truncate = (count == MSVCRT__TRUNCATE);
1699
1700     if(!wcDest && !numElement && !count)
1701         return 0;
1702
1703     if (!wcDest || !numElement)
1704         return MSVCRT_EINVAL;
1705
1706     if (!wcSrc)
1707     {
1708         *wcDest = 0;
1709         return count ? MSVCRT_EINVAL : 0;
1710     }
1711
1712     while (numElement && count && *wcSrc)
1713     {
1714         *p++ = *wcSrc++;
1715         numElement--;
1716         count--;
1717     }
1718     if (!numElement && truncate)
1719     {
1720         *(p-1) = 0;
1721         return MSVCRT_STRUNCATE;
1722     }
1723     else if (!numElement)
1724     {
1725         *wcDest = 0;
1726         return MSVCRT_ERANGE;
1727     }
1728
1729     *p = 0;
1730     return 0;
1731 }
1732
1733 /******************************************************************
1734  *              wcscat_s (MSVCRT.@)
1735  *
1736  */
1737 INT CDECL MSVCRT_wcscat_s(MSVCRT_wchar_t* dst, MSVCRT_size_t elem, const MSVCRT_wchar_t* src)
1738 {
1739     MSVCRT_wchar_t* ptr = dst;
1740
1741     if (!dst || elem == 0) return MSVCRT_EINVAL;
1742     if (!src)
1743     {
1744         dst[0] = '\0';
1745         return MSVCRT_EINVAL;
1746     }
1747
1748     /* seek to end of dst string (or elem if no end of string is found */
1749     while (ptr < dst + elem && *ptr != '\0') ptr++;
1750     while (ptr < dst + elem)
1751     {
1752         if ((*ptr++ = *src++) == '\0') return 0;
1753     }
1754     /* not enough space */
1755     dst[0] = '\0';
1756     return MSVCRT_ERANGE;
1757 }
1758
1759 /*********************************************************************
1760  *  wcsncat_s (MSVCRT.@)
1761  *
1762  */
1763 INT CDECL MSVCRT_wcsncat_s(MSVCRT_wchar_t *dst, MSVCRT_size_t elem,
1764         const MSVCRT_wchar_t *src, MSVCRT_size_t count)
1765 {
1766     MSVCRT_size_t srclen;
1767     MSVCRT_wchar_t dststart;
1768     INT ret = 0;
1769
1770     if (!MSVCRT_CHECK_PMT(dst != NULL)) return MSVCRT_EINVAL;
1771     if (!MSVCRT_CHECK_PMT(elem > 0)) return MSVCRT_EINVAL;
1772     if (!MSVCRT_CHECK_PMT(src != NULL || count == 0)) return MSVCRT_EINVAL;
1773
1774     if (count == 0)
1775         return 0;
1776
1777     for (dststart = 0; dststart < elem; dststart++)
1778     {
1779         if (dst[dststart] == '\0')
1780             break;
1781     }
1782     if (dststart == elem)
1783     {
1784         MSVCRT_INVALID_PMT("dst[elem] is not NULL terminated\n", MSVCRT_EINVAL);
1785         return MSVCRT_EINVAL;
1786     }
1787
1788     if (count == MSVCRT__TRUNCATE)
1789     {
1790         srclen = strlenW(src);
1791         if (srclen >= (elem - dststart))
1792         {
1793             srclen = elem - dststart - 1;
1794             ret = MSVCRT_STRUNCATE;
1795         }
1796     }
1797     else
1798         srclen = min(strlenW(src), count);
1799     if (srclen < (elem - dststart))
1800     {
1801         memcpy(&dst[dststart], src, srclen*sizeof(MSVCRT_wchar_t));
1802         dst[dststart+srclen] = '\0';
1803         return ret;
1804     }
1805     MSVCRT_INVALID_PMT("dst[elem] is too small", MSVCRT_ERANGE);
1806     dst[0] = '\0';
1807     return MSVCRT_ERANGE;
1808 }
1809
1810 /*********************************************************************
1811  *  _wcstoi64_l (MSVCRT.@)
1812  *
1813  * FIXME: locale parameter is ignored
1814  */
1815 __int64 CDECL MSVCRT__wcstoi64_l(const MSVCRT_wchar_t *nptr,
1816         MSVCRT_wchar_t **endptr, int base, MSVCRT__locale_t locale)
1817 {
1818     BOOL negative = FALSE;
1819     __int64 ret = 0;
1820
1821     TRACE("(%s %p %d %p)\n", debugstr_w(nptr), endptr, base, locale);
1822
1823     if (!MSVCRT_CHECK_PMT(nptr != NULL)) return 0;
1824     if (!MSVCRT_CHECK_PMT(base == 0 || base >= 2)) return 0;
1825     if (!MSVCRT_CHECK_PMT(base <= 36)) return 0;
1826
1827     while(isspaceW(*nptr)) nptr++;
1828
1829     if(*nptr == '-') {
1830         negative = TRUE;
1831         nptr++;
1832     } else if(*nptr == '+')
1833         nptr++;
1834
1835     if((base==0 || base==16) && *nptr=='0' && tolowerW(*(nptr+1))=='x') {
1836         base = 16;
1837         nptr += 2;
1838     }
1839
1840     if(base == 0) {
1841         if(*nptr=='0')
1842             base = 8;
1843         else
1844             base = 10;
1845     }
1846
1847     while(*nptr) {
1848         MSVCRT_wchar_t cur = tolowerW(*nptr);
1849         int v;
1850
1851         if(isdigitW(cur)) {
1852             if(cur >= '0'+base)
1853                 break;
1854             v = cur-'0';
1855         } else {
1856             if(cur<'a' || cur>='a'+base-10)
1857                 break;
1858             v = cur-'a'+10;
1859         }
1860
1861         if(negative)
1862             v = -v;
1863
1864         nptr++;
1865
1866         if(!negative && (ret>MSVCRT_I64_MAX/base || ret*base>MSVCRT_I64_MAX-v)) {
1867             ret = MSVCRT_I64_MAX;
1868             *MSVCRT__errno() = MSVCRT_ERANGE;
1869         } else if(negative && (ret<MSVCRT_I64_MIN/base || ret*base<MSVCRT_I64_MIN-v)) {
1870             ret = MSVCRT_I64_MIN;
1871             *MSVCRT__errno() = MSVCRT_ERANGE;
1872         } else
1873             ret = ret*base + v;
1874     }
1875
1876     if(endptr)
1877         *endptr = (MSVCRT_wchar_t*)nptr;
1878
1879     return ret;
1880 }
1881
1882 /*********************************************************************
1883  *  _wcstoi64 (MSVCRT.@)
1884  */
1885 __int64 CDECL MSVCRT__wcstoi64(const MSVCRT_wchar_t *nptr,
1886         MSVCRT_wchar_t **endptr, int base)
1887 {
1888     return MSVCRT__wcstoi64_l(nptr, endptr, base, NULL);
1889 }
1890
1891 /*********************************************************************
1892  *  _wcstol_l (MSVCRT.@)
1893  */
1894 MSVCRT_long CDECL MSVCRT__wcstol_l(const MSVCRT_wchar_t *s,
1895         MSVCRT_wchar_t **end, int base, MSVCRT__locale_t locale)
1896 {
1897     __int64 ret = MSVCRT__wcstoi64_l(s, end, base, locale);
1898
1899     if(ret > MSVCRT_LONG_MAX) {
1900         ret = MSVCRT_LONG_MAX;
1901         *MSVCRT__errno() = MSVCRT_ERANGE;
1902     }else if(ret < MSVCRT_LONG_MIN) {
1903         ret = MSVCRT_LONG_MIN;
1904         *MSVCRT__errno() = MSVCRT_ERANGE;
1905     }
1906     return ret;
1907 }
1908
1909 /*********************************************************************
1910  *  _wtoi_l (MSVCRT.@)
1911  */
1912 int __cdecl MSVCRT__wtoi_l(const MSVCRT_wchar_t *str, MSVCRT__locale_t locale)
1913 {
1914     __int64 ret = MSVCRT__wcstoi64_l(str, NULL, 10, locale);
1915
1916     if(ret > INT_MAX) {
1917         ret = INT_MAX;
1918         *MSVCRT__errno() = MSVCRT_ERANGE;
1919     } else if(ret < INT_MIN) {
1920         ret = INT_MIN;
1921         *MSVCRT__errno() = MSVCRT_ERANGE;
1922     }
1923     return ret;
1924 }
1925
1926 /*********************************************************************
1927  *  _wtoi (MSVCRT.@)
1928  */
1929 int __cdecl MSVCRT__wtoi(const MSVCRT_wchar_t *str)
1930 {
1931     return MSVCRT__wtoi_l(str, NULL);
1932 }
1933
1934 /*********************************************************************
1935  *  _wtol_l (MSVCRT.@)
1936  */
1937 MSVCRT_long __cdecl MSVCRT__wtol_l(const MSVCRT_wchar_t *str, MSVCRT__locale_t locale)
1938 {
1939     __int64 ret = MSVCRT__wcstoi64_l(str, NULL, 10, locale);
1940
1941     if(ret > MSVCRT_LONG_MAX) {
1942         ret = MSVCRT_LONG_MAX;
1943         *MSVCRT__errno() = MSVCRT_ERANGE;
1944     } else if(ret < MSVCRT_LONG_MIN) {
1945         ret = MSVCRT_LONG_MIN;
1946         *MSVCRT__errno() = MSVCRT_ERANGE;
1947     }
1948     return ret;
1949 }
1950
1951 /*********************************************************************
1952  *  _wtol (MSVCRT.@)
1953  */
1954 MSVCRT_long __cdecl MSVCRT__wtol(const MSVCRT_wchar_t *str)
1955 {
1956     return MSVCRT__wtol_l(str, NULL);
1957 }
1958
1959 /*********************************************************************
1960  *  _wcstoui64_l (MSVCRT.@)
1961  *
1962  * FIXME: locale parameter is ignored
1963  */
1964 unsigned __int64 CDECL MSVCRT__wcstoui64_l(const MSVCRT_wchar_t *nptr,
1965         MSVCRT_wchar_t **endptr, int base, MSVCRT__locale_t locale)
1966 {
1967     BOOL negative = FALSE;
1968     unsigned __int64 ret = 0;
1969
1970     TRACE("(%s %p %d %p)\n", debugstr_w(nptr), endptr, base, locale);
1971
1972     if (!MSVCRT_CHECK_PMT(nptr != NULL)) return 0;
1973     if (!MSVCRT_CHECK_PMT(base == 0 || base >= 2)) return 0;
1974     if (!MSVCRT_CHECK_PMT(base <= 36)) return 0;
1975
1976     while(isspaceW(*nptr)) nptr++;
1977
1978     if(*nptr == '-') {
1979         negative = TRUE;
1980         nptr++;
1981     } else if(*nptr == '+')
1982         nptr++;
1983
1984     if((base==0 || base==16) && *nptr=='0' && tolowerW(*(nptr+1))=='x') {
1985         base = 16;
1986         nptr += 2;
1987     }
1988
1989     if(base == 0) {
1990         if(*nptr=='0')
1991             base = 8;
1992         else
1993             base = 10;
1994     }
1995
1996     while(*nptr) {
1997         MSVCRT_wchar_t cur = tolowerW(*nptr);
1998         int v;
1999
2000         if(isdigitW(cur)) {
2001             if(cur >= '0'+base)
2002                 break;
2003             v = *nptr-'0';
2004         } else {
2005             if(cur<'a' || cur>='a'+base-10)
2006                 break;
2007             v = cur-'a'+10;
2008         }
2009
2010         nptr++;
2011
2012         if(ret>MSVCRT_UI64_MAX/base || ret*base>MSVCRT_UI64_MAX-v) {
2013             ret = MSVCRT_UI64_MAX;
2014             *MSVCRT__errno() = MSVCRT_ERANGE;
2015         } else
2016             ret = ret*base + v;
2017     }
2018
2019     if(endptr)
2020         *endptr = (MSVCRT_wchar_t*)nptr;
2021
2022     return negative ? -ret : ret;
2023 }
2024
2025 /*********************************************************************
2026  *  _wcstoui64 (MSVCRT.@)
2027  */
2028 unsigned __int64 CDECL MSVCRT__wcstoui64(const MSVCRT_wchar_t *nptr,
2029         MSVCRT_wchar_t **endptr, int base)
2030 {
2031     return MSVCRT__wcstoui64_l(nptr, endptr, base, NULL);
2032 }
2033
2034 /*********************************************************************
2035  *  _wcstoul_l (MSVCRT.@)
2036  */
2037 MSVCRT_ulong __cdecl MSVCRT__wcstoul_l(const MSVCRT_wchar_t *s,
2038         MSVCRT_wchar_t **end, int base, MSVCRT__locale_t locale)
2039 {
2040     __int64 ret = MSVCRT__wcstoui64_l(s, end, base, locale);
2041
2042     if(ret > MSVCRT_ULONG_MAX) {
2043         ret = MSVCRT_ULONG_MAX;
2044         *MSVCRT__errno() = MSVCRT_ERANGE;
2045     }
2046     return ret;
2047 }
2048
2049 /*********************************************************************
2050    *  wcstoul (MSVCRT.@)
2051     */
2052 MSVCRT_ulong __cdecl MSVCRT_wcstoul(const MSVCRT_wchar_t *s, MSVCRT_wchar_t **end, int base)
2053 {
2054     return MSVCRT__wcstoul_l(s, end, base, NULL);
2055 }
2056
2057 /******************************************************************
2058  *  wcsnlen (MSVCRT.@)
2059  */
2060 MSVCRT_size_t CDECL MSVCRT_wcsnlen(const MSVCRT_wchar_t *s, MSVCRT_size_t maxlen)
2061 {
2062     MSVCRT_size_t i;
2063
2064     for (i = 0; i < maxlen; i++)
2065         if (!s[i]) break;
2066     return i;
2067 }
2068
2069 /*********************************************************************
2070  *              _towupper_l (MSVCRT.@)
2071  */
2072 int CDECL MSVCRT__towupper_l(MSVCRT_wint_t c, MSVCRT__locale_t locale)
2073 {
2074     return toupperW(c);
2075 }
2076
2077 /*********************************************************************
2078  *              towupper (MSVCRT.@)
2079  */
2080 int CDECL MSVCRT_towupper(MSVCRT_wint_t c)
2081 {
2082     return MSVCRT__towupper_l(c, NULL);
2083 }
2084
2085 /*********************************************************************
2086  *              _towlower_l (MSVCRT.@)
2087  */
2088 int CDECL MSVCRT__towlower_l(MSVCRT_wint_t c, MSVCRT__locale_t locale)
2089 {
2090     return tolowerW(c);
2091 }
2092
2093 /*********************************************************************
2094  *              towlower (MSVCRT.@)
2095  */
2096 int CDECL MSVCRT_towlower(MSVCRT_wint_t c)
2097 {
2098     return MSVCRT__towlower_l(c, NULL);
2099 }
2100
2101 /*********************************************************************
2102  *              wcschr (MSVCRT.@)
2103  */
2104 MSVCRT_wchar_t* CDECL MSVCRT_wcschr(const MSVCRT_wchar_t *str, MSVCRT_wchar_t ch)
2105 {
2106     return strchrW(str, ch);
2107 }
2108
2109 /***********************************************************************
2110  *              wcslen (MSVCRT.@)
2111  */
2112 int CDECL MSVCRT_wcslen(const MSVCRT_wchar_t *str)
2113 {
2114     return strlenW(str);
2115 }
2116
2117 /*********************************************************************
2118  *              wcsstr (MSVCRT.@)
2119  */
2120 MSVCRT_wchar_t* CDECL MSVCRT_wcsstr(const MSVCRT_wchar_t *str, const MSVCRT_wchar_t *sub)
2121 {
2122     return strstrW(str, sub);
2123 }
2124
2125 /*********************************************************************
2126  *              _wtoi64_l (MSVCRT.@)
2127  */
2128 __int64 CDECL MSVCRT__wtoi64_l(const MSVCRT_wchar_t *str, MSVCRT__locale_t locale)
2129 {
2130     ULONGLONG RunningTotal = 0;
2131     BOOL bMinus = FALSE;
2132
2133     while (isspaceW(*str)) {
2134         str++;
2135     } /* while */
2136
2137     if (*str == '+') {
2138         str++;
2139     } else if (*str == '-') {
2140         bMinus = TRUE;
2141         str++;
2142     } /* if */
2143
2144     while (*str >= '0' && *str <= '9') {
2145         RunningTotal = RunningTotal * 10 + *str - '0';
2146         str++;
2147     } /* while */
2148
2149     return bMinus ? -RunningTotal : RunningTotal;
2150 }
2151
2152 /*********************************************************************
2153  *              _wtoi64 (MSVCRT.@)
2154  */
2155 __int64 CDECL MSVCRT__wtoi64(const MSVCRT_wchar_t *str)
2156 {
2157     return MSVCRT__wtoi64_l(str, NULL);
2158 }
2159
2160 /*********************************************************************
2161  *           wcsncmp    (MSVCRT.@)
2162  */
2163 int CDECL MSVCRT_wcsncmp(const MSVCRT_wchar_t *str1, const MSVCRT_wchar_t *str2, int n)
2164 {
2165     return strncmpW(str1, str2, n);
2166 }
2167
2168 /*********************************************************************
2169  *              _wcsxfrm_l (MSVCRT.@)
2170  */
2171 MSVCRT_size_t CDECL MSVCRT__wcsxfrm_l(MSVCRT_wchar_t *dest, const MSVCRT_wchar_t *src,
2172         MSVCRT_size_t len, MSVCRT__locale_t locale)
2173 {
2174     MSVCRT_pthreadlocinfo locinfo;
2175     int i, ret;
2176
2177     if(!MSVCRT_CHECK_PMT(src)) return INT_MAX;
2178     if(!MSVCRT_CHECK_PMT(dest || !len)) return INT_MAX;
2179
2180     if(len > INT_MAX) {
2181         FIXME("len > INT_MAX not supported\n");
2182         len = INT_MAX;
2183     }
2184
2185     if(!locale)
2186         locinfo = get_locinfo();
2187     else
2188         locinfo = locale->locinfo;
2189
2190     if(!locinfo->lc_handle[MSVCRT_LC_COLLATE]) {
2191         MSVCRT_wcsncpy(dest, src, len);
2192         return strlenW(src);
2193     }
2194
2195     ret = LCMapStringW(locinfo->lc_handle[MSVCRT_LC_COLLATE],
2196             LCMAP_SORTKEY, src, -1, NULL, 0);
2197     if(!ret) {
2198         if(len) dest[0] = 0;
2199         *MSVCRT__errno() = MSVCRT_EILSEQ;
2200         return INT_MAX;
2201     }
2202     if(!len) return ret-1;
2203
2204     if(ret > len) {
2205         dest[0] = 0;
2206         *MSVCRT__errno() = MSVCRT_ERANGE;
2207         return ret-1;
2208     }
2209
2210     ret = LCMapStringW(locinfo->lc_handle[MSVCRT_LC_COLLATE],
2211             LCMAP_SORTKEY, src, -1, dest, len) - 1;
2212     for(i=ret; i>=0; i--)
2213         dest[i] = ((unsigned char*)dest)[i];
2214     return ret;
2215 }
2216
2217 /*********************************************************************
2218  *              wcsxfrm (MSVCRT.@)
2219  */
2220 MSVCRT_size_t CDECL MSVCRT_wcsxfrm(MSVCRT_wchar_t *dest,
2221         const MSVCRT_wchar_t *src, MSVCRT_size_t len)
2222 {
2223     return MSVCRT__wcsxfrm_l(dest, src, len, NULL);
2224 }