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