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 <limits.h>
  22 #include <stdio.h>
  23 #include <math.h>
  24 #include <assert.h>
  25 #include "msvcrt.h"
  26 #include "winnls.h"
  27 #include "wine/unicode.h"
  28 #include "wine/debug.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  31
  32
  33 /*********************************************************************
  34  *              _wcsdup (MSVCRT.@)
  35  */
  36 MSVCRT_wchar_t* CDECL _wcsdup( const MSVCRT_wchar_t* str )
  37 {
  38   MSVCRT_wchar_t* ret = NULL;
  39   if (str)
  40   {
  41     int size = (strlenW(str) + 1) * sizeof(MSVCRT_wchar_t);
  42     ret = MSVCRT_malloc( size );
  43     if (ret) memcpy( ret, str, size );
  44   }
  45   return ret;
  46 }
  47
  48 /*********************************************************************
  49  *              _wcsicoll (MSVCRT.@)
  50  */
  51 INT CDECL _wcsicoll( const MSVCRT_wchar_t* str1, const MSVCRT_wchar_t* str2 )
  52 {
  53   /* FIXME: handle collates */
  54   return strcmpiW( str1, str2 );
  55 }
  56
  57 /*********************************************************************
  58  *              _wcsnset (MSVCRT.@)
  59  */
  60 MSVCRT_wchar_t* CDECL _wcsnset( MSVCRT_wchar_t* str, MSVCRT_wchar_t c, MSVCRT_size_t n )
  61 {
  62   MSVCRT_wchar_t* ret = str;
  63   while ((n-- > 0) && *str) *str++ = c;
  64   return ret;
  65 }
  66
  67 /*********************************************************************
  68  *              _wcsrev (MSVCRT.@)
  69  */
  70 MSVCRT_wchar_t* CDECL _wcsrev( MSVCRT_wchar_t* str )
  71 {
  72   MSVCRT_wchar_t* ret = str;
  73   MSVCRT_wchar_t* end = str + strlenW(str) - 1;
  74   while (end > str)
  75   {
  76     MSVCRT_wchar_t t = *end;
  77     *end--  = *str;
  78     *str++  = t;
  79   }
  80   return ret;
  81 }
  82
  83 /*********************************************************************
  84  *              _wcsset (MSVCRT.@)
  85  */
  86 MSVCRT_wchar_t* CDECL _wcsset( MSVCRT_wchar_t* str, MSVCRT_wchar_t c )
  87 {
  88   MSVCRT_wchar_t* ret = str;
  89   while (*str) *str++ = c;
  90   return ret;
  91 }
  92
  93 /*********************************************************************
  94  *              wcstod (MSVCRT.@)
  95  */
  96 double CDECL MSVCRT_wcstod(const MSVCRT_wchar_t* lpszStr, MSVCRT_wchar_t** end)
  97 {
  98   const MSVCRT_wchar_t* str = lpszStr;
  99   int negative = 0;
 100   double ret = 0, divisor = 10.0;
 101
 102   TRACE("(%s,%p) semi-stub\n", debugstr_w(lpszStr), end);
 103
 104   /* FIXME:
 105    * - Should set errno on failure
 106    * - Should fail on overflow
 107    * - Need to check which input formats are allowed
 108    */
 109   while (isspaceW(*str))
 110     str++;
 111
 112   if (*str == '-')
 113   {
 114     negative = 1;
 115     str++;
 116   }
 117
 118   while (isdigitW(*str))
 119   {
 120     ret = ret * 10.0 + (*str - '0');
 121     str++;
 122   }
 123   if (*str == '.')
 124     str++;
 125   while (isdigitW(*str))
 126   {
 127     ret = ret + (*str - '0') / divisor;
 128     divisor *= 10;
 129     str++;
 130   }
 131
 132   if (*str == 'E' || *str == 'e' || *str == 'D' || *str == 'd')
 133   {
 134     int negativeExponent = 0;
 135     int exponent = 0;
 136     if (*(++str) == '-')
 137     {
 138       negativeExponent = 1;
 139       str++;
 140     }
 141     while (isdigitW(*str))
 142     {
 143       exponent = exponent * 10 + (*str - '0');
 144       str++;
 145     }
 146     if (exponent != 0)
 147     {
 148       if (negativeExponent)
 149         ret = ret / pow(10.0, exponent);
 150       else
 151         ret = ret * pow(10.0, exponent);
 152     }
 153   }
 154
 155   if (negative)
 156     ret = -ret;
 157
 158   if (end)
 159     *end = (MSVCRT_wchar_t*)str;
 160
 161   TRACE("returning %g\n", ret);
 162   return ret;
 163 }
 164
 165
 166 typedef struct pf_output_t
 167 {
 168     int used;
 169     int len;
 170     BOOL unicode;
 171     union {
 172         LPWSTR W;
 173         LPSTR  A;
 174     } buf;
 175 } pf_output;
 176
 177 typedef struct pf_flags_t
 178 {
 179     char Sign, LeftAlign, Alternate, PadZero;
 180     int FieldLength, Precision;
 181     char IntegerLength, IntegerDouble;
 182     char WideString;
 183     char Format;
 184 } pf_flags;
 185
 186 /*
 187  * writes a string of characters to the output
 188  * returns -1 if the string doesn't fit in the output buffer
 189  * return the length of the string if all characters were written
 190  */
 191 static inline int pf_output_stringW( pf_output *out, LPCWSTR str, int len )
 192 {
 193     int space = out->len - out->used;
 194
 195     if( len < 0 )
 196         len = strlenW( str );
 197     if( out->unicode )
 198     {
 199         LPWSTR p = out->buf.W + out->used;
 200
 201         if( space >= len )
 202         {
 203             memcpy( p, str, len*sizeof(WCHAR) );
 204             out->used += len;
 205             return len;
 206         }
 207         if( space > 0 )
 208             memcpy( p, str, space*sizeof(WCHAR) );
 209         out->used += len;
 210     }
 211     else
 212     {
 213         int n = WideCharToMultiByte( CP_ACP, 0, str, len, NULL, 0, NULL, NULL );
 214         LPSTR p = out->buf.A + out->used;
 215
 216         if( space >= n )
 217         {
 218             WideCharToMultiByte( CP_ACP, 0, str, len, p, n, NULL, NULL );
 219             out->used += n;
 220             return len;
 221         }
 222         if( space > 0 )
 223             WideCharToMultiByte( CP_ACP, 0, str, len, p, space, NULL, NULL );
 224         out->used += n;
 225     }
 226     return -1;
 227 }
 228
 229 static inline int pf_output_stringA( pf_output *out, LPCSTR str, int len )
 230 {
 231     int space = out->len - out->used;
 232
 233     if( len < 0 )
 234         len = strlen( str );
 235     if( !out->unicode )
 236     {
 237         LPSTR p = out->buf.A + out->used;
 238
 239         if( space >= len )
 240         {
 241             memcpy( p, str, len );
 242             out->used += len;
 243             return len;
 244         }
 245         if( space > 0 )
 246             memcpy( p, str, space );
 247         out->used += len;
 248     }
 249     else
 250     {
 251         int n = MultiByteToWideChar( CP_ACP, 0, str, len, NULL, 0 );
 252         LPWSTR p = out->buf.W + out->used;
 253
 254         if( space >= n )
 255         {
 256             MultiByteToWideChar( CP_ACP, 0, str, len, p, n );
 257             out->used += n;
 258             return len;
 259         }
 260         if( space > 0 )
 261             MultiByteToWideChar( CP_ACP, 0, str, len, p, space );
 262         out->used += n;
 263     }
 264     return -1;
 265 }
 266
 267 /* pf_fill: takes care of signs, alignment, zero and field padding */
 268 static inline int pf_fill( pf_output *out, int len, pf_flags *flags, char left )
 269 {
 270     int i, r = 0;
 271
 272     if( flags->Sign && !( flags->Format == 'd' || flags->Format == 'i' ) )
 273         flags->Sign = 0;
 274
 275     if( left && flags->Sign )
 276     {
 277         flags->FieldLength--;
 278         if( flags->PadZero )
 279             r = pf_output_stringA( out, &flags->Sign, 1 );
 280     }
 281
 282     if( ( !left &&  flags->LeftAlign ) ||
 283         (  left && !flags->LeftAlign ))
 284     {
 285         for( i=0; (i<(flags->FieldLength-len)) && (r>=0); i++ )
 286         {
 287             if( left && flags->PadZero )
 288                 r = pf_output_stringA( out, "0", 1 );
 289             else
 290                 r = pf_output_stringA( out, " ", 1 );
 291         }
 292     }
 293
 294     if( left && flags->Sign && !flags->PadZero )
 295         r = pf_output_stringA( out, &flags->Sign, 1 );
 296
 297     return r;
 298 }
 299
 300 static inline int pf_output_format_W( pf_output *out, LPCWSTR str,
 301                                       int len, pf_flags *flags )
 302 {
 303     int r = 0;
 304
 305     if( len < 0 )
 306         len = strlenW( str );
 307
 308     if (flags->Precision >= 0 && flags->Precision < len)
 309         len = flags->Precision;
 310
 311     r = pf_fill( out, len, flags, 1 );
 312
 313     if( r>=0 )
 314         r = pf_output_stringW( out, str, len );
 315
 316     if( r>=0 )
 317         r = pf_fill( out, len, flags, 0 );
 318
 319     return r;
 320 }
 321
 322 static inline int pf_output_format_A( pf_output *out, LPCSTR str,
 323                                       int len, pf_flags *flags )
 324 {
 325     int r = 0;
 326
 327     if( len < 0 )
 328         len = strlen( str );
 329
 330     if (flags->Precision >= 0 && flags->Precision < len)
 331         len = flags->Precision;
 332
 333     r = pf_fill( out, len, flags, 1 );
 334
 335     if( r>=0 )
 336         r = pf_output_stringA( out, str, len );
 337
 338     if( r>=0 )
 339         r = pf_fill( out, len, flags, 0 );
 340
 341     return r;
 342 }
 343
 344 static int pf_handle_string_format( pf_output *out, const void* str, int len,
 345                              pf_flags *flags, BOOL capital_letter)
 346 {
 347      if(str == NULL)  /* catch NULL pointer */
 348         return pf_output_format_A( out, "(null)", -1, flags);
 349
 350      /* prefixes take priority over %c,%s vs. %C,%S, so we handle them first */
 351     if(flags->WideString || flags->IntegerLength == 'l')
 352         return pf_output_format_W( out, str, len, flags);
 353     if(flags->IntegerLength == 'h')
 354         return pf_output_format_A( out, str, len, flags);
 355
 356     /* %s,%c ->  chars in ansi functions & wchars in unicode
 357      * %S,%C -> wchars in ansi functions &  chars in unicode */
 358     if( capital_letter == out->unicode) /* either both TRUE or both FALSE */
 359         return pf_output_format_A( out, str, len, flags);
 360     else
 361         return pf_output_format_W( out, str, len, flags);
 362 }
 363
 364 static inline BOOL pf_is_integer_format( char fmt )
 365 {
 366     static const char float_fmts[] = "diouxX";
 367     if (!fmt)
 368         return FALSE;
 369     return strchr( float_fmts, fmt ) ? TRUE : FALSE;
 370 }
 371
 372 static inline BOOL pf_is_double_format( char fmt )
 373 {
 374     static const char float_fmts[] = "aeEfgG";
 375     if (!fmt)
 376         return FALSE;
 377     return strchr( float_fmts, fmt ) ? TRUE : FALSE;
 378 }
 379
 380 static inline BOOL pf_is_valid_format( char fmt )
 381 {
 382     static const char float_fmts[] = "acCdeEfgGinouxX";
 383     if (!fmt)
 384         return FALSE;
 385     return strchr( float_fmts, fmt ) ? TRUE : FALSE;
 386 }
 387
 388 static void pf_rebuild_format_string( char *p, pf_flags *flags )
 389 {
 390     *p++ = '%';
 391     if( flags->Sign )
 392         *p++ = flags->Sign;
 393     if( flags->LeftAlign )
 394         *p++ = flags->LeftAlign;
 395     if( flags->Alternate )
 396         *p++ = flags->Alternate;
 397     if( flags->PadZero )
 398         *p++ = flags->PadZero;
 399     if( flags->FieldLength )
 400     {
 401         sprintf(p, "%d", flags->FieldLength);
 402         p += strlen(p);
 403     }
 404     if( flags->Precision >= 0 )
 405     {
 406         sprintf(p, ".%d", flags->Precision);
 407         p += strlen(p);
 408     }
 409     *p++ = flags->Format;
 410     *p++ = 0;
 411 }
 412
 413 /* pf_integer_conv:  prints x to buf, including alternate formats and
 414    additional precision digits, but not field characters or the sign */
 415 static void pf_integer_conv( char *buf, int buf_len, pf_flags *flags,
 416                              LONGLONG x )
 417 {
 418     unsigned int base;
 419     const char *digits;
 420
 421     int i, j, k;
 422     char number[40], *tmp = number;
 423
 424     if( buf_len > sizeof number )
 425         tmp = HeapAlloc( GetProcessHeap(), 0, buf_len );
 426
 427     base = 10;
 428     if( flags->Format == 'o' )
 429         base = 8;
 430     else if( flags->Format == 'x' || flags->Format == 'X' )
 431         base = 16;
 432
 433     if( flags->Format == 'X' )
 434         digits = "0123456789ABCDEFX";
 435     else
 436         digits = "0123456789abcdefx";
 437
 438     if( x < 0 && ( flags->Format == 'd' || flags->Format == 'i' ) )
 439     {
 440         x = -x;
 441         flags->Sign = '-';
 442     }
 443
 444     /* Do conversion (backwards) */
 445     i = 0;
 446     if( x == 0 && flags->Precision )
 447         tmp[i++] = '0';
 448     else
 449         while( x != 0 )
 450         {
 451             j = (ULONGLONG) x % base;
 452             x = (ULONGLONG) x / base;
 453             tmp[i++] = digits[j];
 454         }
 455     k = flags->Precision - i;
 456     while( k-- > 0 )
 457         tmp[i++] = '0';
 458     if( flags->Alternate )
 459     {
 460         if( base == 16 )
 461         {
 462             tmp[i++] = digits[16];
 463             tmp[i++] = '0';
 464         }
 465         else if( base == 8 && tmp[i-1] != '0' )
 466             tmp[i++] = '0';
 467     }
 468
 469     /* Reverse for buf */
 470     j = 0;
 471     while( i-- > 0 )
 472         buf[j++] = tmp[i];
 473     buf[j] = '\0';
 474
 475     /* Adjust precision so pf_fill won't truncate the number later */
 476     flags->Precision = strlen( buf );
 477
 478     if( tmp != number )
 479         HeapFree( GetProcessHeap(), 0, tmp );
 480
 481     return;
 482 }
 483
 484 /*********************************************************************
 485  *  pf_vsnprintf  (INTERNAL)
 486  *
 487  *  implements both A and W vsnprintf functions
 488  */
 489 static int pf_vsnprintf( pf_output *out, const WCHAR *format, va_list valist )
 490 {
 491     int r;
 492     LPCWSTR q, p = format;
 493     pf_flags flags;
 494
 495     TRACE("format is %s\n",debugstr_w(format));
 496     while (*p)
 497     {
 498         q = strchrW( p, '%' );
 499
 500         /* there's no % characters left, output the rest of the string */
 501         if( !q )
 502         {
 503             r = pf_output_stringW(out, p, -1);
 504             if( r<0 )
 505                 return r;
 506             p += r;
 507             continue;
 508         }
 509
 510         /* there's characters before the %, output them */
 511         if( q != p )
 512         {
 513             r = pf_output_stringW(out, p, q - p);
 514             if( r<0 )
 515                 return r;
 516             p = q;
 517         }
 518
 519         /* we must be at a % now, skip over it */
 520         assert( *p == '%' );
 521         p++;
 522
 523         /* output a single % character */
 524         if( *p == '%' )
 525         {
 526             r = pf_output_stringW(out, p++, 1);
 527             if( r<0 )
 528                 return r;
 529             continue;
 530         }
 531
 532         /* parse the flags */
 533         memset( &flags, 0, sizeof flags );
 534         while (*p)
 535         {
 536             if( *p == '+' || *p == ' ' )
 537             {
 538                 if ( flags.Sign != '+' )
 539                     flags.Sign = *p;
 540             }
 541             else if( *p == '-' )
 542                 flags.LeftAlign = *p;
 543             else if( *p == '0' )
 544                 flags.PadZero = *p;
 545             else if( *p == '#' )
 546                 flags.Alternate = *p;
 547             else
 548                 break;
 549             p++;
 550         }
 551
 552         /* deal with the field width specifier */
 553         flags.FieldLength = 0;
 554         if( *p == '*' )
 555         {
 556             flags.FieldLength = va_arg( valist, int );
 557             if (flags.FieldLength < 0)
 558             {
 559                 flags.LeftAlign = '-';
 560                 flags.FieldLength = -flags.FieldLength;
 561             }
 562             p++;
 563         }
 564         else while( isdigit(*p) )
 565         {
 566             flags.FieldLength *= 10;
 567             flags.FieldLength += *p++ - '0';
 568         }
 569
 570         /* deal with precision */
 571         flags.Precision = -1;
 572         if( *p == '.' )
 573         {
 574             flags.Precision = 0;
 575             p++;
 576             if( *p == '*' )
 577             {
 578                 flags.Precision = va_arg( valist, int );
 579                 p++;
 580             }
 581             else while( isdigit(*p) )
 582             {
 583                 flags.Precision *= 10;
 584                 flags.Precision += *p++ - '0';
 585             }
 586         }
 587
 588         /* deal with integer width modifier */
 589         while( *p )
 590         {
 591             if( *p == 'h' || *p == 'l' || *p == 'L' )
 592             {
 593                 flags.IntegerLength = *p;
 594                 p++;
 595             }
 596             else if( *p == 'I' )
 597             {
 598                 if( *(p+1) == '6' && *(p+2) == '4' )
 599                 {
 600                     flags.IntegerDouble++;
 601                     p += 3;
 602                 }
 603                 else if( *(p+1) == '3' && *(p+2) == '2' )
 604                     p += 3;
 605                 else if( isdigit(*(p+1)) || *(p+1) == 0 )
 606                     break;
 607                 else
 608                     p++;
 609             }
 610             else if( *p == 'w' )
 611                 flags.WideString = *p++;
 612             else if( *p == 'F' )
 613                 p++; /* ignore */
 614             else
 615                 break;
 616         }
 617
 618         flags.Format = *p;
 619         r = 0;
 620
 621         /* output a string */
 622         if(  flags.Format == 's' || flags.Format == 'S' )
 623             r = pf_handle_string_format( out, va_arg(valist, const void*), -1,
 624                                          &flags, (flags.Format == 'S') );
 625
 626         /* output a single character */
 627         else if( flags.Format == 'c' || flags.Format == 'C' )
 628         {
 629             INT ch = va_arg( valist, int );
 630
 631             r = pf_handle_string_format( out, &ch, 1, &flags, (flags.Format == 'C') );
 632         }
 633
 634         /* output a pointer */
 635         else if( flags.Format == 'p' )
 636         {
 637             char pointer[11];
 638
 639             flags.PadZero = 0;
 640             if( flags.Alternate )
 641                 sprintf(pointer, "0X%08lX", va_arg(valist, long));
 642             else
 643                 sprintf(pointer, "%08lX", va_arg(valist, long));
 644             r = pf_output_format_A( out, pointer, -1, &flags );
 645         }
 646
 647         /* deal with %n */
 648         else if( flags.Format == 'n' )
 649         {
 650             int *x = va_arg(valist, int *);
 651             *x = out->used;
 652         }
 653
 654         /* deal with 64-bit integers */
 655         else if( pf_is_integer_format( flags.Format ) && flags.IntegerDouble )
 656         {
 657             char number[40], *x = number;
 658
 659             /* Estimate largest possible required buffer size:
 660                * Chooses the larger of the field or precision
 661                * Includes extra bytes: 1 byte for null, 1 byte for sign,
 662                  4 bytes for exponent, 2 bytes for alternate formats, 1 byte
 663                  for a decimal, and 1 byte for an additional float digit. */
 664             int x_len = ((flags.FieldLength > flags.Precision) ?
 665                         flags.FieldLength : flags.Precision) + 10;
 666
 667             if( x_len >= sizeof number)
 668                 x = HeapAlloc( GetProcessHeap(), 0, x_len );
 669
 670             pf_integer_conv( x, x_len, &flags, va_arg(valist, LONGLONG) );
 671
 672             r = pf_output_format_A( out, x, -1, &flags );
 673             if( x != number )
 674                 HeapFree( GetProcessHeap(), 0, x );
 675         }
 676
 677         /* deal with integers and floats using libc's printf */
 678         else if( pf_is_valid_format( flags.Format ) )
 679         {
 680             char fmt[20], number[40], *x = number;
 681
 682             /* Estimate largest possible required buffer size:
 683                * Chooses the larger of the field or precision
 684                * Includes extra bytes: 1 byte for null, 1 byte for sign,
 685                  4 bytes for exponent, 2 bytes for alternate formats, 1 byte
 686                  for a decimal, and 1 byte for an additional float digit. */
 687             int x_len = ((flags.FieldLength > flags.Precision) ?
 688                         flags.FieldLength : flags.Precision) + 10;
 689
 690             if( x_len >= sizeof number)
 691                 x = HeapAlloc( GetProcessHeap(), 0, x_len );
 692
 693             pf_rebuild_format_string( fmt, &flags );
 694
 695             if( pf_is_double_format( flags.Format ) )
 696                 sprintf( x, fmt, va_arg(valist, double) );
 697             else
 698                 sprintf( x, fmt, va_arg(valist, int) );
 699
 700             r = pf_output_stringA( out, x, -1 );
 701             if( x != number )
 702                 HeapFree( GetProcessHeap(), 0, x );
 703         }
 704         else
 705             continue;
 706
 707         if( r<0 )
 708             return r;
 709         p++;
 710     }
 711
 712     /* check we reached the end, and null terminate the string */
 713     assert( *p == 0 );
 714     pf_output_stringW( out, p, 1 );
 715
 716     return out->used - 1;
 717 }
 718
 719 /*********************************************************************
 720  *              _vsnprintf (MSVCRT.@)
 721  */
 722 int CDECL MSVCRT_vsnprintf( char *str, unsigned int len,
 723                             const char *format, va_list valist )
 724 {
 725     DWORD sz;
 726     LPWSTR formatW = NULL;
 727     pf_output out;
 728     int r;
 729
 730     out.unicode = FALSE;
 731     out.buf.A = str;
 732     out.used = 0;
 733     out.len = len;
 734
 735     if( format )
 736     {
 737         sz = MultiByteToWideChar( CP_ACP, 0, format, -1, NULL, 0 );
 738         formatW = HeapAlloc( GetProcessHeap(), 0, sz*sizeof(WCHAR) );
 739         MultiByteToWideChar( CP_ACP, 0, format, -1, formatW, sz );
 740     }
 741
 742     r = pf_vsnprintf( &out, formatW, valist );
 743
 744     HeapFree( GetProcessHeap(), 0, formatW );
 745
 746     return r;
 747 }
 748
 749 /*********************************************************************
 750  *              vsprintf (MSVCRT.@)
 751  */
 752 int CDECL MSVCRT_vsprintf( char *str, const char *format, va_list valist)
 753 {
 754     return MSVCRT_vsnprintf(str, INT_MAX, format, valist);
 755 }
 756
 757 /*********************************************************************
 758  *              _snprintf (MSVCRT.@)
 759  */
 760 int CDECL MSVCRT__snprintf(char *str, unsigned int len, const char *format, ...)
 761 {
 762     int retval;
 763     va_list valist;
 764     va_start(valist, format);
 765     retval = MSVCRT_vsnprintf(str, len, format, valist);
 766     va_end(valist);
 767     return retval;
 768 }
 769
 770 /*********************************************************************
 771  *              _vsnwsprintf (MSVCRT.@)
 772  */
 773 int CDECL MSVCRT_vsnwprintf( MSVCRT_wchar_t *str, unsigned int len,
 774                              const MSVCRT_wchar_t *format, va_list valist )
 775 {
 776     pf_output out;
 777
 778     out.unicode = TRUE;
 779     out.buf.W = str;
 780     out.used = 0;
 781     out.len = len;
 782
 783     return pf_vsnprintf( &out, format, valist );
 784 }
 785
 786 /*********************************************************************
 787  *              _snwprintf (MSVCRT.@)
 788  */
 789 int CDECL MSVCRT__snwprintf( MSVCRT_wchar_t *str, unsigned int len, const MSVCRT_wchar_t *format, ...)
 790 {
 791     int retval;
 792     va_list valist;
 793     va_start(valist, format);
 794     retval = MSVCRT_vsnwprintf(str, len, format, valist);
 795     va_end(valist);
 796     return retval;
 797 }
 798
 799 /*********************************************************************
 800  *              sprintf (MSVCRT.@)
 801  */
 802 int CDECL MSVCRT_sprintf( char *str, const char *format, ... )
 803 {
 804     va_list ap;
 805     int r;
 806
 807     va_start( ap, format );
 808     r = MSVCRT_vsnprintf( str, INT_MAX, format, ap );
 809     va_end( ap );
 810     return r;
 811 }
 812
 813 /*********************************************************************
 814  *              swprintf (MSVCRT.@)
 815  */
 816 int CDECL MSVCRT_swprintf( MSVCRT_wchar_t *str, const MSVCRT_wchar_t *format, ... )
 817 {
 818     va_list ap;
 819     int r;
 820
 821     va_start( ap, format );
 822     r = MSVCRT_vsnwprintf( str, INT_MAX, format, ap );
 823     va_end( ap );
 824     return r;
 825 }
 826
 827 /*********************************************************************
 828  *              vswprintf (MSVCRT.@)
 829  */
 830 int CDECL MSVCRT_vswprintf( MSVCRT_wchar_t* str, const MSVCRT_wchar_t* format, va_list args )
 831 {
 832     return MSVCRT_vsnwprintf( str, INT_MAX, format, args );
 833 }
 834
 835 /*********************************************************************
 836  *              wcscoll (MSVCRT.@)
 837  */
 838 int CDECL MSVCRT_wcscoll( const MSVCRT_wchar_t* str1, const MSVCRT_wchar_t* str2 )
 839 {
 840   /* FIXME: handle collates */
 841   return strcmpW( str1, str2 );
 842 }
 843
 844 /*********************************************************************
 845  *              wcspbrk (MSVCRT.@)
 846  */
 847 MSVCRT_wchar_t* CDECL MSVCRT_wcspbrk( const MSVCRT_wchar_t* str, const MSVCRT_wchar_t* accept )
 848 {
 849   const MSVCRT_wchar_t* p;
 850   while (*str)
 851   {
 852     for (p = accept; *p; p++) if (*p == *str) return (MSVCRT_wchar_t*)str;
 853       str++;
 854   }
 855   return NULL;
 856 }
 857
 858 /*********************************************************************
 859  *              wcstok  (MSVCRT.@)
 860  */
 861 MSVCRT_wchar_t * CDECL MSVCRT_wcstok( MSVCRT_wchar_t *str, const MSVCRT_wchar_t *delim )
 862 {
 863     thread_data_t *data = msvcrt_get_thread_data();
 864     MSVCRT_wchar_t *ret;
 865
 866     if (!str)
 867         if (!(str = data->wcstok_next)) return NULL;
 868
 869     while (*str && strchrW( delim, *str )) str++;
 870     if (!*str) return NULL;
 871     ret = str++;
 872     while (*str && !strchrW( delim, *str )) str++;
 873     if (*str) *str++ = 0;
 874     data->wcstok_next = str;
 875     return ret;
 876 }
 877
 878
 879 /*********************************************************************
 880  *              wctomb (MSVCRT.@)
 881  */
 882 INT CDECL MSVCRT_wctomb( char *dst, MSVCRT_wchar_t ch )
 883 {
 884   return WideCharToMultiByte( CP_ACP, 0, &ch, 1, dst, 6, NULL, NULL );
 885 }
 886
 887 /*********************************************************************
 888  *              iswalnum (MSVCRT.@)
 889  */
 890 INT CDECL MSVCRT_iswalnum( MSVCRT_wchar_t wc )
 891 {
 892     return isalnumW( wc );
 893 }
 894
 895 /*********************************************************************
 896  *              iswalpha (MSVCRT.@)
 897  */
 898 INT CDECL MSVCRT_iswalpha( MSVCRT_wchar_t wc )
 899 {
 900     return isalphaW( wc );
 901 }
 902
 903 /*********************************************************************
 904  *              iswcntrl (MSVCRT.@)
 905  */
 906 INT CDECL MSVCRT_iswcntrl( MSVCRT_wchar_t wc )
 907 {
 908     return iscntrlW( wc );
 909 }
 910
 911 /*********************************************************************
 912  *              iswdigit (MSVCRT.@)
 913  */
 914 INT CDECL MSVCRT_iswdigit( MSVCRT_wchar_t wc )
 915 {
 916     return isdigitW( wc );
 917 }
 918
 919 /*********************************************************************
 920  *              iswgraph (MSVCRT.@)
 921  */
 922 INT CDECL MSVCRT_iswgraph( MSVCRT_wchar_t wc )
 923 {
 924     return isgraphW( wc );
 925 }
 926
 927 /*********************************************************************
 928  *              iswlower (MSVCRT.@)
 929  */
 930 INT CDECL MSVCRT_iswlower( MSVCRT_wchar_t wc )
 931 {
 932     return islowerW( wc );
 933 }
 934
 935 /*********************************************************************
 936  *              iswprint (MSVCRT.@)
 937  */
 938 INT CDECL MSVCRT_iswprint( MSVCRT_wchar_t wc )
 939 {
 940     return isprintW( wc );
 941 }
 942
 943 /*********************************************************************
 944  *              iswpunct (MSVCRT.@)
 945  */
 946 INT CDECL MSVCRT_iswpunct( MSVCRT_wchar_t wc )
 947 {
 948     return ispunctW( wc );
 949 }
 950
 951 /*********************************************************************
 952  *              iswspace (MSVCRT.@)
 953  */
 954 INT CDECL MSVCRT_iswspace( MSVCRT_wchar_t wc )
 955 {
 956     return isspaceW( wc );
 957 }
 958
 959 /*********************************************************************
 960  *              iswupper (MSVCRT.@)
 961  */
 962 INT CDECL MSVCRT_iswupper( MSVCRT_wchar_t wc )
 963 {
 964     return isupperW( wc );
 965 }
 966
 967 /*********************************************************************
 968  *              iswxdigit (MSVCRT.@)
 969  */
 970 INT CDECL MSVCRT_iswxdigit( MSVCRT_wchar_t wc )
 971 {
 972     return isxdigitW( wc );
 973 }
 974
 975 /*********************************************************************
 976  *              wcscpy_s (MSVCRT.@)
 977  */
 978 INT CDECL MSVCRT_wcscpy_s( MSVCRT_wchar_t* wcDest, MSVCRT_size_t numElement, const  MSVCRT_wchar_t *wcSrc)
 979 {
 980     INT size = 0;
 981
 982     if(!wcDest || !numElement)
 983         return MSVCRT_EINVAL;
 984
 985     wcDest[0] = 0;
 986
 987     if(!wcSrc)
 988     {
 989         return MSVCRT_EINVAL;
 990     }
 991
 992     size = strlenW(wcSrc) + 1;
 993
 994     if(size > numElement)
 995     {
 996         return MSVCRT_ERANGE;
 997     }
 998
 999     if(size > numElement)
1000         size = numElement;
1001
1002     memcpy( wcDest, wcSrc, size*sizeof(WCHAR) );
1003
1004     return 0;
1005 }