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