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