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 /* pf_fixup_exponent: convert a string containing a 2 digit exponent
 485    to 3 digits, accounting for padding, in place. Needed to match
 486    the native printf's which always use 3 digits. */
 487 static void pf_fixup_exponent( char *buf )
 488 {
 489     char* tmp = buf;
 490
 491     while (tmp[0] && toupper(tmp[0]) != 'E')
 492         tmp++;
 493
 494     if (tmp[0] && (tmp[1] == '+' || tmp[1] == '-') &&
 495         isdigit(tmp[2]) && isdigit(tmp[3]))
 496     {
 497         char final;
 498
 499         if (isdigit(tmp[4]))
 500             return; /* Exponent already 3 digits */
 501
 502         /* We have a 2 digit exponent. Prepend '0' to make it 3 */
 503         tmp += 2;
 504         final = tmp[2];
 505         tmp[2] = tmp[1];
 506         tmp[1] = tmp[0];
 507         tmp[0] = '0';
 508         if (final == '\0')
 509         {
 510             /* We didn't expand into trailing space, so this string isn't left
 511              * justified. Terminate the string and strip a ' ' at the start of
 512              * the string if there is one (as there may be if the string is
 513              * right justified).
 514              */
 515             tmp[3] = '\0';
 516             if (buf[0] == ' ')
 517                 memmove(buf, buf + 1, (tmp - buf) + 3);
 518         }
 519         /* Otherwise, we expanded into trailing space -> nothing to do */
 520     }
 521 }
 522
 523 /*********************************************************************
 524  *  pf_vsnprintf  (INTERNAL)
 525  *
 526  *  implements both A and W vsnprintf functions
 527  */
 528 static int pf_vsnprintf( pf_output *out, const WCHAR *format, va_list valist )
 529 {
 530     int r;
 531     LPCWSTR q, p = format;
 532     pf_flags flags;
 533
 534     TRACE("format is %s\n",debugstr_w(format));
 535     while (*p)
 536     {
 537         q = strchrW( p, '%' );
 538
 539         /* there's no % characters left, output the rest of the string */
 540         if( !q )
 541         {
 542             r = pf_output_stringW(out, p, -1);
 543             if( r<0 )
 544                 return r;
 545             p += r;
 546             continue;
 547         }
 548
 549         /* there's characters before the %, output them */
 550         if( q != p )
 551         {
 552             r = pf_output_stringW(out, p, q - p);
 553             if( r<0 )
 554                 return r;
 555             p = q;
 556         }
 557
 558         /* we must be at a % now, skip over it */
 559         assert( *p == '%' );
 560         p++;
 561
 562         /* output a single % character */
 563         if( *p == '%' )
 564         {
 565             r = pf_output_stringW(out, p++, 1);
 566             if( r<0 )
 567                 return r;
 568             continue;
 569         }
 570
 571         /* parse the flags */
 572         memset( &flags, 0, sizeof flags );
 573         while (*p)
 574         {
 575             if( *p == '+' || *p == ' ' )
 576             {
 577                 if ( flags.Sign != '+' )
 578                     flags.Sign = *p;
 579             }
 580             else if( *p == '-' )
 581                 flags.LeftAlign = *p;
 582             else if( *p == '0' )
 583                 flags.PadZero = *p;
 584             else if( *p == '#' )
 585                 flags.Alternate = *p;
 586             else
 587                 break;
 588             p++;
 589         }
 590
 591         /* deal with the field width specifier */
 592         flags.FieldLength = 0;
 593         if( *p == '*' )
 594         {
 595             flags.FieldLength = va_arg( valist, int );
 596             if (flags.FieldLength < 0)
 597             {
 598                 flags.LeftAlign = '-';
 599                 flags.FieldLength = -flags.FieldLength;
 600             }
 601             p++;
 602         }
 603         else while( isdigit(*p) )
 604         {
 605             flags.FieldLength *= 10;
 606             flags.FieldLength += *p++ - '0';
 607         }
 608
 609         /* deal with precision */
 610         flags.Precision = -1;
 611         if( *p == '.' )
 612         {
 613             flags.Precision = 0;
 614             p++;
 615             if( *p == '*' )
 616             {
 617                 flags.Precision = va_arg( valist, int );
 618                 p++;
 619             }
 620             else while( isdigit(*p) )
 621             {
 622                 flags.Precision *= 10;
 623                 flags.Precision += *p++ - '0';
 624             }
 625         }
 626
 627         /* deal with integer width modifier */
 628         while( *p )
 629         {
 630             if( *p == 'h' || *p == 'l' || *p == 'L' )
 631             {
 632                 flags.IntegerLength = *p;
 633                 p++;
 634             }
 635             else if( *p == 'I' )
 636             {
 637                 if( *(p+1) == '6' && *(p+2) == '4' )
 638                 {
 639                     flags.IntegerDouble++;
 640                     p += 3;
 641                 }
 642                 else if( *(p+1) == '3' && *(p+2) == '2' )
 643                     p += 3;
 644                 else if( isdigit(*(p+1)) || *(p+1) == 0 )
 645                     break;
 646                 else
 647                     p++;
 648             }
 649             else if( *p == 'w' )
 650                 flags.WideString = *p++;
 651             else if( *p == 'F' )
 652                 p++; /* ignore */
 653             else
 654                 break;
 655         }
 656
 657         flags.Format = *p;
 658         r = 0;
 659
 660         if (flags.Format == '$')
 661         {
 662             FIXME("Positional parameters are not supported (%s)\n", wine_dbgstr_w(format));
 663             return -1;
 664         }
 665         /* output a string */
 666         if(  flags.Format == 's' || flags.Format == 'S' )
 667             r = pf_handle_string_format( out, va_arg(valist, const void*), -1,
 668                                          &flags, (flags.Format == 'S') );
 669
 670         /* output a single character */
 671         else if( flags.Format == 'c' || flags.Format == 'C' )
 672         {
 673             INT ch = va_arg( valist, int );
 674
 675             r = pf_handle_string_format( out, &ch, 1, &flags, (flags.Format == 'C') );
 676         }
 677
 678         /* output a pointer */
 679         else if( flags.Format == 'p' )
 680         {
 681             char pointer[11];
 682
 683             flags.PadZero = 0;
 684             if( flags.Alternate )
 685                 sprintf(pointer, "0X%08lX", va_arg(valist, long));
 686             else
 687                 sprintf(pointer, "%08lX", va_arg(valist, long));
 688             r = pf_output_format_A( out, pointer, -1, &flags );
 689         }
 690
 691         /* deal with %n */
 692         else if( flags.Format == 'n' )
 693         {
 694             int *x = va_arg(valist, int *);
 695             *x = out->used;
 696         }
 697
 698         /* deal with 64-bit integers */
 699         else if( pf_is_integer_format( flags.Format ) && flags.IntegerDouble )
 700         {
 701             char number[40], *x = number;
 702
 703             /* Estimate largest possible required buffer size:
 704                * Chooses the larger of the field or precision
 705                * Includes extra bytes: 1 byte for null, 1 byte for sign,
 706                  4 bytes for exponent, 2 bytes for alternate formats, 1 byte
 707                  for a decimal, and 1 byte for an additional float digit. */
 708             int x_len = ((flags.FieldLength > flags.Precision) ?
 709                         flags.FieldLength : flags.Precision) + 10;
 710
 711             if( x_len >= sizeof number)
 712                 x = HeapAlloc( GetProcessHeap(), 0, x_len );
 713
 714             pf_integer_conv( x, x_len, &flags, va_arg(valist, LONGLONG) );
 715
 716             r = pf_output_format_A( out, x, -1, &flags );
 717             if( x != number )
 718                 HeapFree( GetProcessHeap(), 0, x );
 719         }
 720
 721         /* deal with integers and floats using libc's printf */
 722         else if( pf_is_valid_format( flags.Format ) )
 723         {
 724             char fmt[20], number[40], *x = number;
 725
 726             /* Estimate largest possible required buffer size:
 727                * Chooses the larger of the field or precision
 728                * Includes extra bytes: 1 byte for null, 1 byte for sign,
 729                  4 bytes for exponent, 2 bytes for alternate formats, 1 byte
 730                  for a decimal, and 1 byte for an additional float digit. */
 731             int x_len = ((flags.FieldLength > flags.Precision) ?
 732                         flags.FieldLength : flags.Precision) + 10;
 733
 734             if( x_len >= sizeof number)
 735                 x = HeapAlloc( GetProcessHeap(), 0, x_len );
 736
 737             pf_rebuild_format_string( fmt, &flags );
 738
 739             if( pf_is_double_format( flags.Format ) )
 740             {
 741                 sprintf( x, fmt, va_arg(valist, double) );
 742                 if (toupper(flags.Format) == 'E' || toupper(flags.Format) == 'G')
 743                     pf_fixup_exponent( x );
 744             }
 745             else
 746                 sprintf( x, fmt, va_arg(valist, int) );
 747
 748             r = pf_output_stringA( out, x, -1 );
 749             if( x != number )
 750                 HeapFree( GetProcessHeap(), 0, x );
 751         }
 752         else
 753             continue;
 754
 755         if( r<0 )
 756             return r;
 757         p++;
 758     }
 759
 760     /* check we reached the end, and null terminate the string */
 761     assert( *p == 0 );
 762     pf_output_stringW( out, p, 1 );
 763
 764     return out->used - 1;
 765 }
 766
 767 /*********************************************************************
 768  *              _vsnprintf (MSVCRT.@)
 769  */
 770 int CDECL MSVCRT_vsnprintf( char *str, unsigned int len,
 771                             const char *format, va_list valist )
 772 {
 773     DWORD sz;
 774     LPWSTR formatW = NULL;
 775     pf_output out;
 776     int r;
 777
 778     out.unicode = FALSE;
 779     out.buf.A = str;
 780     out.used = 0;
 781     out.len = len;
 782
 783     if( format )
 784     {
 785         sz = MultiByteToWideChar( CP_ACP, 0, format, -1, NULL, 0 );
 786         formatW = HeapAlloc( GetProcessHeap(), 0, sz*sizeof(WCHAR) );
 787         MultiByteToWideChar( CP_ACP, 0, format, -1, formatW, sz );
 788     }
 789
 790     r = pf_vsnprintf( &out, formatW, valist );
 791
 792     HeapFree( GetProcessHeap(), 0, formatW );
 793
 794     return r;
 795 }
 796
 797 /*********************************************************************
 798  *              vsprintf (MSVCRT.@)
 799  */
 800 int CDECL MSVCRT_vsprintf( char *str, const char *format, va_list valist)
 801 {
 802     return MSVCRT_vsnprintf(str, INT_MAX, format, valist);
 803 }
 804
 805 /*********************************************************************
 806  *              _snprintf (MSVCRT.@)
 807  */
 808 int CDECL MSVCRT__snprintf(char *str, unsigned int len, const char *format, ...)
 809 {
 810     int retval;
 811     va_list valist;
 812     va_start(valist, format);
 813     retval = MSVCRT_vsnprintf(str, len, format, valist);
 814     va_end(valist);
 815     return retval;
 816 }
 817
 818 /*********************************************************************
 819  *              _vsnwsprintf (MSVCRT.@)
 820  */
 821 int CDECL MSVCRT_vsnwprintf( MSVCRT_wchar_t *str, unsigned int len,
 822                              const MSVCRT_wchar_t *format, va_list valist )
 823 {
 824     pf_output out;
 825
 826     out.unicode = TRUE;
 827     out.buf.W = str;
 828     out.used = 0;
 829     out.len = len;
 830
 831     return pf_vsnprintf( &out, format, valist );
 832 }
 833
 834 /*********************************************************************
 835  *              _snwprintf (MSVCRT.@)
 836  */
 837 int CDECL MSVCRT__snwprintf( MSVCRT_wchar_t *str, unsigned int len, const MSVCRT_wchar_t *format, ...)
 838 {
 839     int retval;
 840     va_list valist;
 841     va_start(valist, format);
 842     retval = MSVCRT_vsnwprintf(str, len, format, valist);
 843     va_end(valist);
 844     return retval;
 845 }
 846
 847 /*********************************************************************
 848  *              sprintf (MSVCRT.@)
 849  */
 850 int CDECL MSVCRT_sprintf( char *str, const char *format, ... )
 851 {
 852     va_list ap;
 853     int r;
 854
 855     va_start( ap, format );
 856     r = MSVCRT_vsnprintf( str, INT_MAX, format, ap );
 857     va_end( ap );
 858     return r;
 859 }
 860
 861 /*********************************************************************
 862  *              swprintf (MSVCRT.@)
 863  */
 864 int CDECL MSVCRT_swprintf( MSVCRT_wchar_t *str, const MSVCRT_wchar_t *format, ... )
 865 {
 866     va_list ap;
 867     int r;
 868
 869     va_start( ap, format );
 870     r = MSVCRT_vsnwprintf( str, INT_MAX, format, ap );
 871     va_end( ap );
 872     return r;
 873 }
 874
 875 /*********************************************************************
 876  *              vswprintf (MSVCRT.@)
 877  */
 878 int CDECL MSVCRT_vswprintf( MSVCRT_wchar_t* str, const MSVCRT_wchar_t* format, va_list args )
 879 {
 880     return MSVCRT_vsnwprintf( str, INT_MAX, format, args );
 881 }
 882
 883 /*********************************************************************
 884  *              vswprintf_s (MSVCRT.@)
 885  */
 886 int CDECL MSVCRT_vswprintf_s( MSVCRT_wchar_t* str, MSVCRT_size_t num, const MSVCRT_wchar_t* format, va_list args )
 887 {
 888     /* FIXME: must handle positional arguments */
 889     return MSVCRT_vsnwprintf( str, num, format, args );
 890 }
 891
 892 /*********************************************************************
 893  *              wcscoll (MSVCRT.@)
 894  */
 895 int CDECL MSVCRT_wcscoll( const MSVCRT_wchar_t* str1, const MSVCRT_wchar_t* str2 )
 896 {
 897   /* FIXME: handle collates */
 898   return strcmpW( str1, str2 );
 899 }
 900
 901 /*********************************************************************
 902  *              wcspbrk (MSVCRT.@)
 903  */
 904 MSVCRT_wchar_t* CDECL MSVCRT_wcspbrk( const MSVCRT_wchar_t* str, const MSVCRT_wchar_t* accept )
 905 {
 906   const MSVCRT_wchar_t* p;
 907   while (*str)
 908   {
 909     for (p = accept; *p; p++) if (*p == *str) return (MSVCRT_wchar_t*)str;
 910       str++;
 911   }
 912   return NULL;
 913 }
 914
 915 /*********************************************************************
 916  *              wcstok  (MSVCRT.@)
 917  */
 918 MSVCRT_wchar_t * CDECL MSVCRT_wcstok( MSVCRT_wchar_t *str, const MSVCRT_wchar_t *delim )
 919 {
 920     thread_data_t *data = msvcrt_get_thread_data();
 921     MSVCRT_wchar_t *ret;
 922
 923     if (!str)
 924         if (!(str = data->wcstok_next)) return NULL;
 925
 926     while (*str && strchrW( delim, *str )) str++;
 927     if (!*str) return NULL;
 928     ret = str++;
 929     while (*str && !strchrW( delim, *str )) str++;
 930     if (*str) *str++ = 0;
 931     data->wcstok_next = str;
 932     return ret;
 933 }
 934
 935
 936 /*********************************************************************
 937  *              wctomb (MSVCRT.@)
 938  */
 939 INT CDECL MSVCRT_wctomb( char *dst, MSVCRT_wchar_t ch )
 940 {
 941   return WideCharToMultiByte( CP_ACP, 0, &ch, 1, dst, 6, NULL, NULL );
 942 }
 943
 944 /*********************************************************************
 945  *              iswalnum (MSVCRT.@)
 946  */
 947 INT CDECL MSVCRT_iswalnum( MSVCRT_wchar_t wc )
 948 {
 949     return isalnumW( wc );
 950 }
 951
 952 /*********************************************************************
 953  *              iswalpha (MSVCRT.@)
 954  */
 955 INT CDECL MSVCRT_iswalpha( MSVCRT_wchar_t wc )
 956 {
 957     return isalphaW( wc );
 958 }
 959
 960 /*********************************************************************
 961  *              iswcntrl (MSVCRT.@)
 962  */
 963 INT CDECL MSVCRT_iswcntrl( MSVCRT_wchar_t wc )
 964 {
 965     return iscntrlW( wc );
 966 }
 967
 968 /*********************************************************************
 969  *              iswdigit (MSVCRT.@)
 970  */
 971 INT CDECL MSVCRT_iswdigit( MSVCRT_wchar_t wc )
 972 {
 973     return isdigitW( wc );
 974 }
 975
 976 /*********************************************************************
 977  *              iswgraph (MSVCRT.@)
 978  */
 979 INT CDECL MSVCRT_iswgraph( MSVCRT_wchar_t wc )
 980 {
 981     return isgraphW( wc );
 982 }
 983
 984 /*********************************************************************
 985  *              iswlower (MSVCRT.@)
 986  */
 987 INT CDECL MSVCRT_iswlower( MSVCRT_wchar_t wc )
 988 {
 989     return islowerW( wc );
 990 }
 991
 992 /*********************************************************************
 993  *              iswprint (MSVCRT.@)
 994  */
 995 INT CDECL MSVCRT_iswprint( MSVCRT_wchar_t wc )
 996 {
 997     return isprintW( wc );
 998 }
 999
1000 /*********************************************************************
1001  *              iswpunct (MSVCRT.@)
1002  */
1003 INT CDECL MSVCRT_iswpunct( MSVCRT_wchar_t wc )
1004 {
1005     return ispunctW( wc );
1006 }
1007
1008 /*********************************************************************
1009  *              iswspace (MSVCRT.@)
1010  */
1011 INT CDECL MSVCRT_iswspace( MSVCRT_wchar_t wc )
1012 {
1013     return isspaceW( wc );
1014 }
1015
1016 /*********************************************************************
1017  *              iswupper (MSVCRT.@)
1018  */
1019 INT CDECL MSVCRT_iswupper( MSVCRT_wchar_t wc )
1020 {
1021     return isupperW( wc );
1022 }
1023
1024 /*********************************************************************
1025  *              iswxdigit (MSVCRT.@)
1026  */
1027 INT CDECL MSVCRT_iswxdigit( MSVCRT_wchar_t wc )
1028 {
1029     return isxdigitW( wc );
1030 }
1031
1032 /*********************************************************************
1033  *              wcscpy_s (MSVCRT.@)
1034  */
1035 INT CDECL MSVCRT_wcscpy_s( MSVCRT_wchar_t* wcDest, MSVCRT_size_t numElement, const  MSVCRT_wchar_t *wcSrc)
1036 {
1037     MSVCRT_size_t size = 0;
1038
1039     if(!wcDest || !numElement)
1040         return MSVCRT_EINVAL;
1041
1042     wcDest[0] = 0;
1043
1044     if(!wcSrc)
1045     {
1046         return MSVCRT_EINVAL;
1047     }
1048
1049     size = strlenW(wcSrc) + 1;
1050
1051     if(size > numElement)
1052     {
1053         return MSVCRT_ERANGE;
1054     }
1055
1056     if(size > numElement)
1057         size = numElement;
1058
1059     memcpy( wcDest, wcSrc, size*sizeof(WCHAR) );
1060
1061     return 0;
1062 }
1063
1064 /******************************************************************
1065  *              wcsncpy_s (MSVCRT.@)
1066  */
1067 INT CDECL MSVCRT_wcsncpy_s( MSVCRT_wchar_t* wcDest, MSVCRT_size_t numElement, const MSVCRT_wchar_t *wcSrc,
1068                             MSVCRT_size_t count )
1069 {
1070     MSVCRT_size_t size = 0;
1071
1072     if (!wcDest || !numElement)
1073         return MSVCRT_EINVAL;
1074
1075     wcDest[0] = 0;
1076
1077     if (!wcSrc)
1078     {
1079         return MSVCRT_EINVAL;
1080     }
1081
1082     size = min(strlenW(wcSrc), count);
1083
1084     if (size >= numElement)
1085     {
1086         return MSVCRT_ERANGE;
1087     }
1088
1089     memcpy( wcDest, wcSrc, size*sizeof(WCHAR) );
1090     wcDest[size] = '\0';
1091
1092     return 0;
1093 }
1094
1095 /******************************************************************
1096  *              wcscat_s (MSVCRT.@)
1097  *
1098  */
1099 INT CDECL MSVCRT_wcscat_s(MSVCRT_wchar_t* dst, MSVCRT_size_t elem, const MSVCRT_wchar_t* src)
1100 {
1101     MSVCRT_wchar_t* ptr = dst;
1102
1103     if (!dst || elem == 0) return MSVCRT_EINVAL;
1104     if (!src)
1105     {
1106         dst[0] = '\0';
1107         return MSVCRT_EINVAL;
1108     }
1109
1110     /* seek to end of dst string (or elem if no end of string is found */
1111     while (ptr < dst + elem && *ptr != '\0') ptr++;
1112     while (ptr < dst + elem)
1113     {
1114         if ((*ptr++ = *src++) == '\0') return 0;
1115     }
1116     /* not enough space */
1117     dst[0] = '\0';
1118     return MSVCRT_ERANGE;
1119 }