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, __ms_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[32];
 682             void *ptr = va_arg( valist, void * );
 683
 684             flags.PadZero = 0;
 685             if( flags.Alternate )
 686                 sprintf(pointer, "0X%0*lX", 2 * sizeof(ptr), (ULONG_PTR)ptr);
 687             else
 688                 sprintf(pointer, "%0*lX", 2 * sizeof(ptr), (ULONG_PTR)ptr);
 689             r = pf_output_format_A( out, pointer, -1, &flags );
 690         }
 691
 692         /* deal with %n */
 693         else if( flags.Format == 'n' )
 694         {
 695             int *x = va_arg(valist, int *);
 696             *x = out->used;
 697         }
 698
 699         /* deal with 64-bit integers */
 700         else if( pf_is_integer_format( flags.Format ) && flags.IntegerDouble )
 701         {
 702             char number[40], *x = number;
 703
 704             /* Estimate largest possible required buffer size:
 705                * Chooses the larger of the field or precision
 706                * Includes extra bytes: 1 byte for null, 1 byte for sign,
 707                  4 bytes for exponent, 2 bytes for alternate formats, 1 byte
 708                  for a decimal, and 1 byte for an additional float digit. */
 709             int x_len = ((flags.FieldLength > flags.Precision) ?
 710                         flags.FieldLength : flags.Precision) + 10;
 711
 712             if( x_len >= sizeof number)
 713                 x = HeapAlloc( GetProcessHeap(), 0, x_len );
 714
 715             pf_integer_conv( x, x_len, &flags, va_arg(valist, LONGLONG) );
 716
 717             r = pf_output_format_A( out, x, -1, &flags );
 718             if( x != number )
 719                 HeapFree( GetProcessHeap(), 0, x );
 720         }
 721
 722         /* deal with integers and floats using libc's printf */
 723         else if( pf_is_valid_format( flags.Format ) )
 724         {
 725             char fmt[20], number[40], *x = number;
 726
 727             /* Estimate largest possible required buffer size:
 728                * Chooses the larger of the field or precision
 729                * Includes extra bytes: 1 byte for null, 1 byte for sign,
 730                  4 bytes for exponent, 2 bytes for alternate formats, 1 byte
 731                  for a decimal, and 1 byte for an additional float digit. */
 732             int x_len = ((flags.FieldLength > flags.Precision) ?
 733                         flags.FieldLength : flags.Precision) + 10;
 734
 735             if( x_len >= sizeof number)
 736                 x = HeapAlloc( GetProcessHeap(), 0, x_len );
 737
 738             pf_rebuild_format_string( fmt, &flags );
 739
 740             if( pf_is_double_format( flags.Format ) )
 741             {
 742                 sprintf( x, fmt, va_arg(valist, double) );
 743                 if (toupper(flags.Format) == 'E' || toupper(flags.Format) == 'G')
 744                     pf_fixup_exponent( x );
 745             }
 746             else
 747                 sprintf( x, fmt, va_arg(valist, int) );
 748
 749             r = pf_output_stringA( out, x, -1 );
 750             if( x != number )
 751                 HeapFree( GetProcessHeap(), 0, x );
 752         }
 753         else
 754             continue;
 755
 756         if( r<0 )
 757             return r;
 758         p++;
 759     }
 760
 761     /* check we reached the end, and null terminate the string */
 762     assert( *p == 0 );
 763     pf_output_stringW( out, p, 1 );
 764
 765     return out->used - 1;
 766 }
 767
 768 /*********************************************************************
 769  *              _vsnprintf (MSVCRT.@)
 770  */
 771 int CDECL MSVCRT_vsnprintf( char *str, unsigned int len,
 772                             const char *format, __ms_va_list valist )
 773 {
 774     DWORD sz;
 775     LPWSTR formatW = NULL;
 776     pf_output out;
 777     int r;
 778
 779     out.unicode = FALSE;
 780     out.buf.A = str;
 781     out.used = 0;
 782     out.len = len;
 783
 784     if( format )
 785     {
 786         sz = MultiByteToWideChar( CP_ACP, 0, format, -1, NULL, 0 );
 787         formatW = HeapAlloc( GetProcessHeap(), 0, sz*sizeof(WCHAR) );
 788         MultiByteToWideChar( CP_ACP, 0, format, -1, formatW, sz );
 789     }
 790
 791     r = pf_vsnprintf( &out, formatW, valist );
 792
 793     HeapFree( GetProcessHeap(), 0, formatW );
 794
 795     return r;
 796 }
 797
 798 /*********************************************************************
 799  *              vsprintf (MSVCRT.@)
 800  */
 801 int CDECL MSVCRT_vsprintf( char *str, const char *format, __ms_va_list valist)
 802 {
 803     return MSVCRT_vsnprintf(str, INT_MAX, format, valist);
 804 }
 805
 806 /*********************************************************************
 807  *              _snprintf (MSVCRT.@)
 808  */
 809 int CDECL MSVCRT__snprintf(char *str, unsigned int len, const char *format, ...)
 810 {
 811     int retval;
 812     __ms_va_list valist;
 813     __ms_va_start(valist, format);
 814     retval = MSVCRT_vsnprintf(str, len, format, valist);
 815     __ms_va_end(valist);
 816     return retval;
 817 }
 818
 819 /*********************************************************************
 820  *              _vsnwsprintf (MSVCRT.@)
 821  */
 822 int CDECL MSVCRT_vsnwprintf( MSVCRT_wchar_t *str, unsigned int len,
 823                              const MSVCRT_wchar_t *format, __ms_va_list valist )
 824 {
 825     pf_output out;
 826
 827     out.unicode = TRUE;
 828     out.buf.W = str;
 829     out.used = 0;
 830     out.len = len;
 831
 832     return pf_vsnprintf( &out, format, valist );
 833 }
 834
 835 /*********************************************************************
 836  *              _snwprintf (MSVCRT.@)
 837  */
 838 int CDECL MSVCRT__snwprintf( MSVCRT_wchar_t *str, unsigned int len, const MSVCRT_wchar_t *format, ...)
 839 {
 840     int retval;
 841     __ms_va_list valist;
 842     __ms_va_start(valist, format);
 843     retval = MSVCRT_vsnwprintf(str, len, format, valist);
 844     __ms_va_end(valist);
 845     return retval;
 846 }
 847
 848 /*********************************************************************
 849  *              sprintf (MSVCRT.@)
 850  */
 851 int CDECL MSVCRT_sprintf( char *str, const char *format, ... )
 852 {
 853     __ms_va_list ap;
 854     int r;
 855
 856     __ms_va_start( ap, format );
 857     r = MSVCRT_vsnprintf( str, INT_MAX, format, ap );
 858     __ms_va_end( ap );
 859     return r;
 860 }
 861
 862 /*********************************************************************
 863  *              swprintf (MSVCRT.@)
 864  */
 865 int CDECL MSVCRT_swprintf( MSVCRT_wchar_t *str, const MSVCRT_wchar_t *format, ... )
 866 {
 867     __ms_va_list ap;
 868     int r;
 869
 870     __ms_va_start( ap, format );
 871     r = MSVCRT_vsnwprintf( str, INT_MAX, format, ap );
 872     __ms_va_end( ap );
 873     return r;
 874 }
 875
 876 /*********************************************************************
 877  *              vswprintf (MSVCRT.@)
 878  */
 879 int CDECL MSVCRT_vswprintf( MSVCRT_wchar_t* str, const MSVCRT_wchar_t* format, __ms_va_list args )
 880 {
 881     return MSVCRT_vsnwprintf( str, INT_MAX, format, args );
 882 }
 883
 884 /*********************************************************************
 885  *              vswprintf_s (MSVCRT.@)
 886  */
 887 int CDECL MSVCRT_vswprintf_s( MSVCRT_wchar_t* str, MSVCRT_size_t num, const MSVCRT_wchar_t* format, __ms_va_list args )
 888 {
 889     /* FIXME: must handle positional arguments */
 890     return MSVCRT_vsnwprintf( str, num, format, args );
 891 }
 892
 893 /*********************************************************************
 894  *              wcscoll (MSVCRT.@)
 895  */
 896 int CDECL MSVCRT_wcscoll( const MSVCRT_wchar_t* str1, const MSVCRT_wchar_t* str2 )
 897 {
 898   /* FIXME: handle collates */
 899   return strcmpW( str1, str2 );
 900 }
 901
 902 /*********************************************************************
 903  *              wcspbrk (MSVCRT.@)
 904  */
 905 MSVCRT_wchar_t* CDECL MSVCRT_wcspbrk( const MSVCRT_wchar_t* str, const MSVCRT_wchar_t* accept )
 906 {
 907   const MSVCRT_wchar_t* p;
 908   while (*str)
 909   {
 910     for (p = accept; *p; p++) if (*p == *str) return (MSVCRT_wchar_t*)str;
 911       str++;
 912   }
 913   return NULL;
 914 }
 915
 916 /*********************************************************************
 917  *              wcstok  (MSVCRT.@)
 918  */
 919 MSVCRT_wchar_t * CDECL MSVCRT_wcstok( MSVCRT_wchar_t *str, const MSVCRT_wchar_t *delim )
 920 {
 921     thread_data_t *data = msvcrt_get_thread_data();
 922     MSVCRT_wchar_t *ret;
 923
 924     if (!str)
 925         if (!(str = data->wcstok_next)) return NULL;
 926
 927     while (*str && strchrW( delim, *str )) str++;
 928     if (!*str) return NULL;
 929     ret = str++;
 930     while (*str && !strchrW( delim, *str )) str++;
 931     if (*str) *str++ = 0;
 932     data->wcstok_next = str;
 933     return ret;
 934 }
 935
 936
 937 /*********************************************************************
 938  *              wctomb (MSVCRT.@)
 939  */
 940 INT CDECL MSVCRT_wctomb( char *dst, MSVCRT_wchar_t ch )
 941 {
 942   return WideCharToMultiByte( CP_ACP, 0, &ch, 1, dst, 6, NULL, NULL );
 943 }
 944
 945 /*********************************************************************
 946  *              iswalnum (MSVCRT.@)
 947  */
 948 INT CDECL MSVCRT_iswalnum( MSVCRT_wchar_t wc )
 949 {
 950     return isalnumW( wc );
 951 }
 952
 953 /*********************************************************************
 954  *              iswalpha (MSVCRT.@)
 955  */
 956 INT CDECL MSVCRT_iswalpha( MSVCRT_wchar_t wc )
 957 {
 958     return isalphaW( wc );
 959 }
 960
 961 /*********************************************************************
 962  *              iswcntrl (MSVCRT.@)
 963  */
 964 INT CDECL MSVCRT_iswcntrl( MSVCRT_wchar_t wc )
 965 {
 966     return iscntrlW( wc );
 967 }
 968
 969 /*********************************************************************
 970  *              iswdigit (MSVCRT.@)
 971  */
 972 INT CDECL MSVCRT_iswdigit( MSVCRT_wchar_t wc )
 973 {
 974     return isdigitW( wc );
 975 }
 976
 977 /*********************************************************************
 978  *              iswgraph (MSVCRT.@)
 979  */
 980 INT CDECL MSVCRT_iswgraph( MSVCRT_wchar_t wc )
 981 {
 982     return isgraphW( wc );
 983 }
 984
 985 /*********************************************************************
 986  *              iswlower (MSVCRT.@)
 987  */
 988 INT CDECL MSVCRT_iswlower( MSVCRT_wchar_t wc )
 989 {
 990     return islowerW( wc );
 991 }
 992
 993 /*********************************************************************
 994  *              iswprint (MSVCRT.@)
 995  */
 996 INT CDECL MSVCRT_iswprint( MSVCRT_wchar_t wc )
 997 {
 998     return isprintW( wc );
 999 }
1000
1001 /*********************************************************************
1002  *              iswpunct (MSVCRT.@)
1003  */
1004 INT CDECL MSVCRT_iswpunct( MSVCRT_wchar_t wc )
1005 {
1006     return ispunctW( wc );
1007 }
1008
1009 /*********************************************************************
1010  *              iswspace (MSVCRT.@)
1011  */
1012 INT CDECL MSVCRT_iswspace( MSVCRT_wchar_t wc )
1013 {
1014     return isspaceW( wc );
1015 }
1016
1017 /*********************************************************************
1018  *              iswupper (MSVCRT.@)
1019  */
1020 INT CDECL MSVCRT_iswupper( MSVCRT_wchar_t wc )
1021 {
1022     return isupperW( wc );
1023 }
1024
1025 /*********************************************************************
1026  *              iswxdigit (MSVCRT.@)
1027  */
1028 INT CDECL MSVCRT_iswxdigit( MSVCRT_wchar_t wc )
1029 {
1030     return isxdigitW( wc );
1031 }
1032
1033 /*********************************************************************
1034  *              wcscpy_s (MSVCRT.@)
1035  */
1036 INT CDECL MSVCRT_wcscpy_s( MSVCRT_wchar_t* wcDest, MSVCRT_size_t numElement, const  MSVCRT_wchar_t *wcSrc)
1037 {
1038     MSVCRT_size_t size = 0;
1039
1040     if(!wcDest || !numElement)
1041         return MSVCRT_EINVAL;
1042
1043     wcDest[0] = 0;
1044
1045     if(!wcSrc)
1046     {
1047         return MSVCRT_EINVAL;
1048     }
1049
1050     size = strlenW(wcSrc) + 1;
1051
1052     if(size > numElement)
1053     {
1054         return MSVCRT_ERANGE;
1055     }
1056
1057     if(size > numElement)
1058         size = numElement;
1059
1060     memcpy( wcDest, wcSrc, size*sizeof(WCHAR) );
1061
1062     return 0;
1063 }
1064
1065 /******************************************************************
1066  *              wcsncpy_s (MSVCRT.@)
1067  */
1068 INT CDECL MSVCRT_wcsncpy_s( MSVCRT_wchar_t* wcDest, MSVCRT_size_t numElement, const MSVCRT_wchar_t *wcSrc,
1069                             MSVCRT_size_t count )
1070 {
1071     MSVCRT_size_t size = 0;
1072
1073     if (!wcDest || !numElement)
1074         return MSVCRT_EINVAL;
1075
1076     wcDest[0] = 0;
1077
1078     if (!wcSrc)
1079     {
1080         return MSVCRT_EINVAL;
1081     }
1082
1083     size = min(strlenW(wcSrc), count);
1084
1085     if (size >= numElement)
1086     {
1087         return MSVCRT_ERANGE;
1088     }
1089
1090     memcpy( wcDest, wcSrc, size*sizeof(WCHAR) );
1091     wcDest[size] = '\0';
1092
1093     return 0;
1094 }
1095
1096 /******************************************************************
1097  *              wcscat_s (MSVCRT.@)
1098  *
1099  */
1100 INT CDECL MSVCRT_wcscat_s(MSVCRT_wchar_t* dst, MSVCRT_size_t elem, const MSVCRT_wchar_t* src)
1101 {
1102     MSVCRT_wchar_t* ptr = dst;
1103
1104     if (!dst || elem == 0) return MSVCRT_EINVAL;
1105     if (!src)
1106     {
1107         dst[0] = '\0';
1108         return MSVCRT_EINVAL;
1109     }
1110
1111     /* seek to end of dst string (or elem if no end of string is found */
1112     while (ptr < dst + elem && *ptr != '\0') ptr++;
1113     while (ptr < dst + elem)
1114     {
1115         if ((*ptr++ = *src++) == '\0') return 0;
1116     }
1117     /* not enough space */
1118     dst[0] = '\0';
1119     return MSVCRT_ERANGE;
1120 }