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  *              _wcsupr_s (MSVCRT.@)
  95  *
  96  */
  97 INT CDECL MSVCRT__wcsupr_s( MSVCRT_wchar_t* str, MSVCRT_size_t n )
  98 {
  99   MSVCRT_wchar_t* ptr = str;
 100
 101   if (!str || !n)
 102   {
 103     if (str) *str = '\0';
 104     *MSVCRT__errno() = MSVCRT_EINVAL;
 105     return MSVCRT_EINVAL;
 106   }
 107
 108   while (n--)
 109   {
 110     if (!*ptr) return 0;
 111     *ptr = toupperW(*ptr);
 112     ptr++;
 113   }
 114
 115   /* MSDN claims that the function should return and set errno to
 116    * ERANGE, which doesn't seem to be true based on the tests. */
 117   *str = '\0';
 118   *MSVCRT__errno() = MSVCRT_EINVAL;
 119   return MSVCRT_EINVAL;
 120 }
 121
 122 /*********************************************************************
 123  *              wcstod (MSVCRT.@)
 124  */
 125 double CDECL MSVCRT_wcstod(const MSVCRT_wchar_t* lpszStr, MSVCRT_wchar_t** end)
 126 {
 127   const MSVCRT_wchar_t* str = lpszStr;
 128   int negative = 0;
 129   double ret = 0, divisor = 10.0;
 130
 131   TRACE("(%s,%p) semi-stub\n", debugstr_w(lpszStr), end);
 132
 133   /* FIXME:
 134    * - Should set errno on failure
 135    * - Should fail on overflow
 136    * - Need to check which input formats are allowed
 137    */
 138   while (isspaceW(*str))
 139     str++;
 140
 141   if (*str == '-')
 142   {
 143     negative = 1;
 144     str++;
 145   }
 146
 147   while (isdigitW(*str))
 148   {
 149     ret = ret * 10.0 + (*str - '0');
 150     str++;
 151   }
 152   if (*str == '.')
 153     str++;
 154   while (isdigitW(*str))
 155   {
 156     ret = ret + (*str - '0') / divisor;
 157     divisor *= 10;
 158     str++;
 159   }
 160
 161   if (*str == 'E' || *str == 'e' || *str == 'D' || *str == 'd')
 162   {
 163     int negativeExponent = 0;
 164     int exponent = 0;
 165     if (*(++str) == '-')
 166     {
 167       negativeExponent = 1;
 168       str++;
 169     }
 170     while (isdigitW(*str))
 171     {
 172       exponent = exponent * 10 + (*str - '0');
 173       str++;
 174     }
 175     if (exponent != 0)
 176     {
 177       if (negativeExponent)
 178         ret = ret / pow(10.0, exponent);
 179       else
 180         ret = ret * pow(10.0, exponent);
 181     }
 182   }
 183
 184   if (negative)
 185     ret = -ret;
 186
 187   if (end)
 188     *end = (MSVCRT_wchar_t*)str;
 189
 190   TRACE("returning %g\n", ret);
 191   return ret;
 192 }
 193
 194
 195 typedef struct pf_output_t
 196 {
 197     int used;
 198     int len;
 199     BOOL unicode;
 200     union {
 201         LPWSTR W;
 202         LPSTR  A;
 203     } buf;
 204 } pf_output;
 205
 206 typedef struct pf_flags_t
 207 {
 208     char Sign, LeftAlign, Alternate, PadZero;
 209     int FieldLength, Precision;
 210     char IntegerLength, IntegerDouble;
 211     char WideString;
 212     char Format;
 213 } pf_flags;
 214
 215 /*
 216  * writes a string of characters to the output
 217  * returns -1 if the string doesn't fit in the output buffer
 218  * return the length of the string if all characters were written
 219  */
 220 static inline int pf_output_stringW( pf_output *out, LPCWSTR str, int len )
 221 {
 222     int space = out->len - out->used;
 223
 224     if( len < 0 )
 225         len = strlenW( str );
 226     if( out->unicode )
 227     {
 228         LPWSTR p = out->buf.W + out->used;
 229
 230         if( space >= len )
 231         {
 232             if (out->buf.W) memcpy( p, str, len*sizeof(WCHAR) );
 233             out->used += len;
 234             return len;
 235         }
 236         if( space > 0 && out->buf.W )
 237             memcpy( p, str, space*sizeof(WCHAR) );
 238         out->used += len;
 239     }
 240     else
 241     {
 242         int n = WideCharToMultiByte( CP_ACP, 0, str, len, NULL, 0, NULL, NULL );
 243         LPSTR p = out->buf.A + out->used;
 244
 245         if( space >= n )
 246         {
 247             if (out->buf.A) WideCharToMultiByte( CP_ACP, 0, str, len, p, n, NULL, NULL );
 248             out->used += n;
 249             return len;
 250         }
 251         if( space > 0 && out->buf.A )
 252             WideCharToMultiByte( CP_ACP, 0, str, len, p, space, NULL, NULL );
 253         out->used += n;
 254     }
 255     return -1;
 256 }
 257
 258 static inline int pf_output_stringA( pf_output *out, LPCSTR str, int len )
 259 {
 260     int space = out->len - out->used;
 261
 262     if( len < 0 )
 263         len = strlen( str );
 264     if( !out->unicode )
 265     {
 266         LPSTR p = out->buf.A + out->used;
 267
 268         if( space >= len )
 269         {
 270             if (out->buf.A) memcpy( p, str, len );
 271             out->used += len;
 272             return len;
 273         }
 274         if( space > 0 && out->buf.A )
 275             memcpy( p, str, space );
 276         out->used += len;
 277     }
 278     else
 279     {
 280         int n = MultiByteToWideChar( CP_ACP, 0, str, len, NULL, 0 );
 281         LPWSTR p = out->buf.W + out->used;
 282
 283         if( space >= n )
 284         {
 285             if (out->buf.W) MultiByteToWideChar( CP_ACP, 0, str, len, p, n );
 286             out->used += n;
 287             return len;
 288         }
 289         if( space > 0 && out->buf.W )
 290             MultiByteToWideChar( CP_ACP, 0, str, len, p, space );
 291         out->used += n;
 292     }
 293     return -1;
 294 }
 295
 296 /* pf_fill: takes care of signs, alignment, zero and field padding */
 297 static inline int pf_fill( pf_output *out, int len, pf_flags *flags, char left )
 298 {
 299     int i, r = 0;
 300
 301     if( flags->Sign && !( flags->Format == 'd' || flags->Format == 'i' ) )
 302         flags->Sign = 0;
 303
 304     if( left && flags->Sign )
 305     {
 306         flags->FieldLength--;
 307         if( flags->PadZero )
 308             r = pf_output_stringA( out, &flags->Sign, 1 );
 309     }
 310
 311     if( ( !left &&  flags->LeftAlign ) ||
 312         (  left && !flags->LeftAlign ))
 313     {
 314         for( i=0; (i<(flags->FieldLength-len)) && (r>=0); i++ )
 315         {
 316             if( left && flags->PadZero )
 317                 r = pf_output_stringA( out, "0", 1 );
 318             else
 319                 r = pf_output_stringA( out, " ", 1 );
 320         }
 321     }
 322
 323     if( left && flags->Sign && !flags->PadZero )
 324         r = pf_output_stringA( out, &flags->Sign, 1 );
 325
 326     return r;
 327 }
 328
 329 static inline int pf_output_format_W( pf_output *out, LPCWSTR str,
 330                                       int len, pf_flags *flags )
 331 {
 332     int r = 0;
 333
 334     if( len < 0 )
 335         len = strlenW( str );
 336
 337     if (flags->Precision >= 0 && flags->Precision < len)
 338         len = flags->Precision;
 339
 340     r = pf_fill( out, len, flags, 1 );
 341
 342     if( r>=0 )
 343         r = pf_output_stringW( out, str, len );
 344
 345     if( r>=0 )
 346         r = pf_fill( out, len, flags, 0 );
 347
 348     return r;
 349 }
 350
 351 static inline int pf_output_format_A( pf_output *out, LPCSTR str,
 352                                       int len, pf_flags *flags )
 353 {
 354     int r = 0;
 355
 356     if( len < 0 )
 357         len = strlen( str );
 358
 359     if (flags->Precision >= 0 && flags->Precision < len)
 360         len = flags->Precision;
 361
 362     r = pf_fill( out, len, flags, 1 );
 363
 364     if( r>=0 )
 365         r = pf_output_stringA( out, str, len );
 366
 367     if( r>=0 )
 368         r = pf_fill( out, len, flags, 0 );
 369
 370     return r;
 371 }
 372
 373 static int pf_handle_string_format( pf_output *out, const void* str, int len,
 374                              pf_flags *flags, BOOL capital_letter)
 375 {
 376      if(str == NULL)  /* catch NULL pointer */
 377         return pf_output_format_A( out, "(null)", -1, flags);
 378
 379      /* prefixes take priority over %c,%s vs. %C,%S, so we handle them first */
 380     if(flags->WideString || flags->IntegerLength == 'l')
 381         return pf_output_format_W( out, str, len, flags);
 382     if(flags->IntegerLength == 'h')
 383         return pf_output_format_A( out, str, len, flags);
 384
 385     /* %s,%c ->  chars in ansi functions & wchars in unicode
 386      * %S,%C -> wchars in ansi functions &  chars in unicode */
 387     if( capital_letter == out->unicode) /* either both TRUE or both FALSE */
 388         return pf_output_format_A( out, str, len, flags);
 389     else
 390         return pf_output_format_W( out, str, len, flags);
 391 }
 392
 393 static inline BOOL pf_is_integer_format( char fmt )
 394 {
 395     static const char float_fmts[] = "diouxX";
 396     if (!fmt)
 397         return FALSE;
 398     return strchr( float_fmts, fmt ) ? TRUE : FALSE;
 399 }
 400
 401 static inline BOOL pf_is_double_format( char fmt )
 402 {
 403     static const char float_fmts[] = "aeEfgG";
 404     if (!fmt)
 405         return FALSE;
 406     return strchr( float_fmts, fmt ) ? TRUE : FALSE;
 407 }
 408
 409 static inline BOOL pf_is_valid_format( char fmt )
 410 {
 411     static const char float_fmts[] = "acCdeEfgGinouxX";
 412     if (!fmt)
 413         return FALSE;
 414     return strchr( float_fmts, fmt ) ? TRUE : FALSE;
 415 }
 416
 417 static void pf_rebuild_format_string( char *p, pf_flags *flags )
 418 {
 419     *p++ = '%';
 420     if( flags->Sign )
 421         *p++ = flags->Sign;
 422     if( flags->LeftAlign )
 423         *p++ = flags->LeftAlign;
 424     if( flags->Alternate )
 425         *p++ = flags->Alternate;
 426     if( flags->PadZero )
 427         *p++ = flags->PadZero;
 428     if( flags->FieldLength )
 429     {
 430         sprintf(p, "%d", flags->FieldLength);
 431         p += strlen(p);
 432     }
 433     if( flags->Precision >= 0 )
 434     {
 435         sprintf(p, ".%d", flags->Precision);
 436         p += strlen(p);
 437     }
 438     *p++ = flags->Format;
 439     *p++ = 0;
 440 }
 441
 442 /* pf_integer_conv:  prints x to buf, including alternate formats and
 443    additional precision digits, but not field characters or the sign */
 444 static void pf_integer_conv( char *buf, int buf_len, pf_flags *flags,
 445                              LONGLONG x )
 446 {
 447     unsigned int base;
 448     const char *digits;
 449
 450     int i, j, k;
 451     char number[40], *tmp = number;
 452
 453     if( buf_len > sizeof number )
 454         tmp = HeapAlloc( GetProcessHeap(), 0, buf_len );
 455
 456     base = 10;
 457     if( flags->Format == 'o' )
 458         base = 8;
 459     else if( flags->Format == 'x' || flags->Format == 'X' )
 460         base = 16;
 461
 462     if( flags->Format == 'X' )
 463         digits = "0123456789ABCDEFX";
 464     else
 465         digits = "0123456789abcdefx";
 466
 467     if( x < 0 && ( flags->Format == 'd' || flags->Format == 'i' ) )
 468     {
 469         x = -x;
 470         flags->Sign = '-';
 471     }
 472
 473     /* Do conversion (backwards) */
 474     i = 0;
 475     if( x == 0 && flags->Precision )
 476         tmp[i++] = '0';
 477     else
 478         while( x != 0 )
 479         {
 480             j = (ULONGLONG) x % base;
 481             x = (ULONGLONG) x / base;
 482             tmp[i++] = digits[j];
 483         }
 484     k = flags->Precision - i;
 485     while( k-- > 0 )
 486         tmp[i++] = '0';
 487     if( flags->Alternate )
 488     {
 489         if( base == 16 )
 490         {
 491             tmp[i++] = digits[16];
 492             tmp[i++] = '0';
 493         }
 494         else if( base == 8 && tmp[i-1] != '0' )
 495             tmp[i++] = '0';
 496     }
 497
 498     /* Reverse for buf */
 499     j = 0;
 500     while( i-- > 0 )
 501         buf[j++] = tmp[i];
 502     buf[j] = '\0';
 503
 504     /* Adjust precision so pf_fill won't truncate the number later */
 505     flags->Precision = strlen( buf );
 506
 507     if( tmp != number )
 508         HeapFree( GetProcessHeap(), 0, tmp );
 509
 510     return;
 511 }
 512
 513 /* pf_fixup_exponent: convert a string containing a 2 digit exponent
 514    to 3 digits, accounting for padding, in place. Needed to match
 515    the native printf's which always use 3 digits. */
 516 static void pf_fixup_exponent( char *buf )
 517 {
 518     char* tmp = buf;
 519
 520     while (tmp[0] && toupper(tmp[0]) != 'E')
 521         tmp++;
 522
 523     if (tmp[0] && (tmp[1] == '+' || tmp[1] == '-') &&
 524         isdigit(tmp[2]) && isdigit(tmp[3]))
 525     {
 526         char final;
 527
 528         if (isdigit(tmp[4]))
 529             return; /* Exponent already 3 digits */
 530
 531         /* We have a 2 digit exponent. Prepend '0' to make it 3 */
 532         tmp += 2;
 533         final = tmp[2];
 534         tmp[2] = tmp[1];
 535         tmp[1] = tmp[0];
 536         tmp[0] = '0';
 537         if (final == '\0')
 538         {
 539             /* We didn't expand into trailing space, so this string isn't left
 540              * justified. Terminate the string and strip a ' ' at the start of
 541              * the string if there is one (as there may be if the string is
 542              * right justified).
 543              */
 544             tmp[3] = '\0';
 545             if (buf[0] == ' ')
 546                 memmove(buf, buf + 1, (tmp - buf) + 3);
 547         }
 548         /* Otherwise, we expanded into trailing space -> nothing to do */
 549     }
 550 }
 551
 552 /*********************************************************************
 553  *  pf_vsnprintf  (INTERNAL)
 554  *
 555  *  implements both A and W vsnprintf functions
 556  */
 557 static int pf_vsnprintf( pf_output *out, const WCHAR *format, __ms_va_list valist )
 558 {
 559     int r;
 560     LPCWSTR q, p = format;
 561     pf_flags flags;
 562
 563     TRACE("format is %s\n",debugstr_w(format));
 564     while (*p)
 565     {
 566         q = strchrW( p, '%' );
 567
 568         /* there's no % characters left, output the rest of the string */
 569         if( !q )
 570         {
 571             r = pf_output_stringW(out, p, -1);
 572             if( r<0 )
 573                 return r;
 574             p += r;
 575             continue;
 576         }
 577
 578         /* there's characters before the %, output them */
 579         if( q != p )
 580         {
 581             r = pf_output_stringW(out, p, q - p);
 582             if( r<0 )
 583                 return r;
 584             p = q;
 585         }
 586
 587         /* we must be at a % now, skip over it */
 588         assert( *p == '%' );
 589         p++;
 590
 591         /* output a single % character */
 592         if( *p == '%' )
 593         {
 594             r = pf_output_stringW(out, p++, 1);
 595             if( r<0 )
 596                 return r;
 597             continue;
 598         }
 599
 600         /* parse the flags */
 601         memset( &flags, 0, sizeof flags );
 602         while (*p)
 603         {
 604             if( *p == '+' || *p == ' ' )
 605             {
 606                 if ( flags.Sign != '+' )
 607                     flags.Sign = *p;
 608             }
 609             else if( *p == '-' )
 610                 flags.LeftAlign = *p;
 611             else if( *p == '0' )
 612                 flags.PadZero = *p;
 613             else if( *p == '#' )
 614                 flags.Alternate = *p;
 615             else
 616                 break;
 617             p++;
 618         }
 619
 620         /* deal with the field width specifier */
 621         flags.FieldLength = 0;
 622         if( *p == '*' )
 623         {
 624             flags.FieldLength = va_arg( valist, int );
 625             if (flags.FieldLength < 0)
 626             {
 627                 flags.LeftAlign = '-';
 628                 flags.FieldLength = -flags.FieldLength;
 629             }
 630             p++;
 631         }
 632         else while( isdigit(*p) )
 633         {
 634             flags.FieldLength *= 10;
 635             flags.FieldLength += *p++ - '0';
 636         }
 637
 638         /* deal with precision */
 639         flags.Precision = -1;
 640         if( *p == '.' )
 641         {
 642             flags.Precision = 0;
 643             p++;
 644             if( *p == '*' )
 645             {
 646                 flags.Precision = va_arg( valist, int );
 647                 p++;
 648             }
 649             else while( isdigit(*p) )
 650             {
 651                 flags.Precision *= 10;
 652                 flags.Precision += *p++ - '0';
 653             }
 654         }
 655
 656         /* deal with integer width modifier */
 657         while( *p )
 658         {
 659             if( *p == 'h' || *p == 'l' || *p == 'L' )
 660             {
 661                 flags.IntegerLength = *p;
 662                 p++;
 663             }
 664             else if( *p == 'I' )
 665             {
 666                 if( *(p+1) == '6' && *(p+2) == '4' )
 667                 {
 668                     flags.IntegerDouble++;
 669                     p += 3;
 670                 }
 671                 else if( *(p+1) == '3' && *(p+2) == '2' )
 672                     p += 3;
 673                 else if( isdigit(*(p+1)) || *(p+1) == 0 )
 674                     break;
 675                 else
 676                     p++;
 677             }
 678             else if( *p == 'w' )
 679                 flags.WideString = *p++;
 680             else if( *p == 'F' )
 681                 p++; /* ignore */
 682             else
 683                 break;
 684         }
 685
 686         flags.Format = *p;
 687         r = 0;
 688
 689         if (flags.Format == '$')
 690         {
 691             FIXME("Positional parameters are not supported (%s)\n", wine_dbgstr_w(format));
 692             return -1;
 693         }
 694         /* output a string */
 695         if(  flags.Format == 's' || flags.Format == 'S' )
 696             r = pf_handle_string_format( out, va_arg(valist, const void*), -1,
 697                                          &flags, (flags.Format == 'S') );
 698
 699         /* output a single character */
 700         else if( flags.Format == 'c' || flags.Format == 'C' )
 701         {
 702             INT ch = va_arg( valist, int );
 703
 704             r = pf_handle_string_format( out, &ch, 1, &flags, (flags.Format == 'C') );
 705         }
 706
 707         /* output a pointer */
 708         else if( flags.Format == 'p' )
 709         {
 710             char pointer[32];
 711             void *ptr = va_arg( valist, void * );
 712
 713             flags.PadZero = 0;
 714             if( flags.Alternate )
 715                 sprintf(pointer, "0X%0*lX", 2 * (int)sizeof(ptr), (ULONG_PTR)ptr);
 716             else
 717                 sprintf(pointer, "%0*lX", 2 * (int)sizeof(ptr), (ULONG_PTR)ptr);
 718             r = pf_output_format_A( out, pointer, -1, &flags );
 719         }
 720
 721         /* deal with %n */
 722         else if( flags.Format == 'n' )
 723         {
 724             int *x = va_arg(valist, int *);
 725             *x = out->used;
 726         }
 727
 728         /* deal with 64-bit integers */
 729         else if( pf_is_integer_format( flags.Format ) && flags.IntegerDouble )
 730         {
 731             char number[40], *x = number;
 732
 733             /* Estimate largest possible required buffer size:
 734                * Chooses the larger of the field or precision
 735                * Includes extra bytes: 1 byte for null, 1 byte for sign,
 736                  4 bytes for exponent, 2 bytes for alternate formats, 1 byte
 737                  for a decimal, and 1 byte for an additional float digit. */
 738             int x_len = ((flags.FieldLength > flags.Precision) ?
 739                         flags.FieldLength : flags.Precision) + 10;
 740
 741             if( x_len >= sizeof number)
 742                 x = HeapAlloc( GetProcessHeap(), 0, x_len );
 743
 744             pf_integer_conv( x, x_len, &flags, va_arg(valist, LONGLONG) );
 745
 746             r = pf_output_format_A( out, x, -1, &flags );
 747             if( x != number )
 748                 HeapFree( GetProcessHeap(), 0, x );
 749         }
 750
 751         /* deal with integers and floats using libc's printf */
 752         else if( pf_is_valid_format( flags.Format ) )
 753         {
 754             char fmt[20], number[40], *x = number;
 755
 756             /* Estimate largest possible required buffer size:
 757                * Chooses the larger of the field or precision
 758                * Includes extra bytes: 1 byte for null, 1 byte for sign,
 759                  4 bytes for exponent, 2 bytes for alternate formats, 1 byte
 760                  for a decimal, and 1 byte for an additional float digit. */
 761             int x_len = ((flags.FieldLength > flags.Precision) ?
 762                         flags.FieldLength : flags.Precision) + 10;
 763
 764             if( x_len >= sizeof number)
 765                 x = HeapAlloc( GetProcessHeap(), 0, x_len );
 766
 767             pf_rebuild_format_string( fmt, &flags );
 768
 769             if( pf_is_double_format( flags.Format ) )
 770             {
 771                 sprintf( x, fmt, va_arg(valist, double) );
 772                 if (toupper(flags.Format) == 'E' || toupper(flags.Format) == 'G')
 773                     pf_fixup_exponent( x );
 774             }
 775             else
 776                 sprintf( x, fmt, va_arg(valist, int) );
 777
 778             r = pf_output_stringA( out, x, -1 );
 779             if( x != number )
 780                 HeapFree( GetProcessHeap(), 0, x );
 781         }
 782         else
 783             continue;
 784
 785         if( r<0 )
 786             return r;
 787         p++;
 788     }
 789
 790     /* check we reached the end, and null terminate the string */
 791     assert( *p == 0 );
 792     pf_output_stringW( out, p, 1 );
 793
 794     return out->used - 1;
 795 }
 796
 797 /*********************************************************************
 798  *              _vsnprintf (MSVCRT.@)
 799  */
 800 int CDECL MSVCRT_vsnprintf( char *str, unsigned int len,
 801                             const char *format, __ms_va_list valist )
 802 {
 803     DWORD sz;
 804     LPWSTR formatW = NULL;
 805     pf_output out;
 806     int r;
 807
 808     out.unicode = FALSE;
 809     out.buf.A = str;
 810     out.used = 0;
 811     out.len = len;
 812
 813     sz = MultiByteToWideChar( CP_ACP, 0, format, -1, NULL, 0 );
 814     formatW = HeapAlloc( GetProcessHeap(), 0, sz*sizeof(WCHAR) );
 815     MultiByteToWideChar( CP_ACP, 0, format, -1, formatW, sz );
 816
 817     r = pf_vsnprintf( &out, formatW, valist );
 818
 819     HeapFree( GetProcessHeap(), 0, formatW );
 820
 821     return r;
 822 }
 823
 824 /*********************************************************************
 825  *              vsprintf (MSVCRT.@)
 826  */
 827 int CDECL MSVCRT_vsprintf( char *str, const char *format, __ms_va_list valist)
 828 {
 829     return MSVCRT_vsnprintf(str, INT_MAX, format, valist);
 830 }
 831
 832 /*********************************************************************
 833  *              vsprintf_s (MSVCRT.@)
 834  */
 835 int CDECL MSVCRT_vsprintf_s( char *str, MSVCRT_size_t num, const char *format, __ms_va_list valist)
 836 {
 837     return MSVCRT_vsnprintf(str, num, format, valist);
 838 }
 839
 840 /*********************************************************************
 841  *              _vscprintf (MSVCRT.@)
 842  */
 843 int CDECL _vscprintf( const char *format, __ms_va_list valist )
 844 {
 845     return MSVCRT_vsnprintf( NULL, INT_MAX, format, valist );
 846 }
 847
 848 /*********************************************************************
 849  *              _snprintf (MSVCRT.@)
 850  */
 851 int CDECL MSVCRT__snprintf(char *str, unsigned int len, const char *format, ...)
 852 {
 853     int retval;
 854     __ms_va_list valist;
 855     __ms_va_start(valist, format);
 856     retval = MSVCRT_vsnprintf(str, len, format, valist);
 857     __ms_va_end(valist);
 858     return retval;
 859 }
 860
 861 /*********************************************************************
 862  *              _vsnwsprintf (MSVCRT.@)
 863  */
 864 int CDECL MSVCRT_vsnwprintf( MSVCRT_wchar_t *str, unsigned int len,
 865                              const MSVCRT_wchar_t *format, __ms_va_list valist )
 866 {
 867     pf_output out;
 868
 869     out.unicode = TRUE;
 870     out.buf.W = str;
 871     out.used = 0;
 872     out.len = len;
 873
 874     return pf_vsnprintf( &out, format, valist );
 875 }
 876
 877 /*********************************************************************
 878  *              _snwprintf (MSVCRT.@)
 879  */
 880 int CDECL MSVCRT__snwprintf( MSVCRT_wchar_t *str, unsigned int len, const MSVCRT_wchar_t *format, ...)
 881 {
 882     int retval;
 883     __ms_va_list valist;
 884     __ms_va_start(valist, format);
 885     retval = MSVCRT_vsnwprintf(str, len, format, valist);
 886     __ms_va_end(valist);
 887     return retval;
 888 }
 889
 890 /*********************************************************************
 891  *              sprintf (MSVCRT.@)
 892  */
 893 int CDECL MSVCRT_sprintf( char *str, const char *format, ... )
 894 {
 895     __ms_va_list ap;
 896     int r;
 897
 898     __ms_va_start( ap, format );
 899     r = MSVCRT_vsnprintf( str, INT_MAX, format, ap );
 900     __ms_va_end( ap );
 901     return r;
 902 }
 903
 904 /*********************************************************************
 905  *              sprintf_s (MSVCRT.@)
 906  */
 907 int CDECL MSVCRT_sprintf_s( char *str, MSVCRT_size_t num, const char *format, ... )
 908 {
 909     __ms_va_list ap;
 910     int r;
 911
 912     __ms_va_start( ap, format );
 913     r = MSVCRT_vsnprintf( str, num, format, ap );
 914     __ms_va_end( ap );
 915     return r;
 916 }
 917
 918 /*********************************************************************
 919  *              swprintf (MSVCRT.@)
 920  */
 921 int CDECL MSVCRT_swprintf( MSVCRT_wchar_t *str, const MSVCRT_wchar_t *format, ... )
 922 {
 923     __ms_va_list ap;
 924     int r;
 925
 926     __ms_va_start( ap, format );
 927     r = MSVCRT_vsnwprintf( str, INT_MAX, format, ap );
 928     __ms_va_end( ap );
 929     return r;
 930 }
 931
 932 /*********************************************************************
 933  *              vswprintf (MSVCRT.@)
 934  */
 935 int CDECL MSVCRT_vswprintf( MSVCRT_wchar_t* str, const MSVCRT_wchar_t* format, __ms_va_list args )
 936 {
 937     return MSVCRT_vsnwprintf( str, INT_MAX, format, args );
 938 }
 939
 940 /*********************************************************************
 941  *              _vscwprintf (MSVCRT.@)
 942  */
 943 int CDECL _vscwprintf( const MSVCRT_wchar_t *format, __ms_va_list args )
 944 {
 945     return MSVCRT_vsnwprintf( NULL, INT_MAX, format, args );
 946 }
 947
 948 /*********************************************************************
 949  *              vswprintf_s (MSVCRT.@)
 950  */
 951 int CDECL MSVCRT_vswprintf_s( MSVCRT_wchar_t* str, MSVCRT_size_t num, const MSVCRT_wchar_t* format, __ms_va_list args )
 952 {
 953     /* FIXME: must handle positional arguments */
 954     return MSVCRT_vsnwprintf( str, num, format, args );
 955 }
 956
 957 /*********************************************************************
 958  *              wcscoll (MSVCRT.@)
 959  */
 960 int CDECL MSVCRT_wcscoll( const MSVCRT_wchar_t* str1, const MSVCRT_wchar_t* str2 )
 961 {
 962   /* FIXME: handle collates */
 963   return strcmpW( str1, str2 );
 964 }
 965
 966 /*********************************************************************
 967  *              wcspbrk (MSVCRT.@)
 968  */
 969 MSVCRT_wchar_t* CDECL MSVCRT_wcspbrk( const MSVCRT_wchar_t* str, const MSVCRT_wchar_t* accept )
 970 {
 971   const MSVCRT_wchar_t* p;
 972   while (*str)
 973   {
 974     for (p = accept; *p; p++) if (*p == *str) return (MSVCRT_wchar_t*)str;
 975       str++;
 976   }
 977   return NULL;
 978 }
 979
 980 /*********************************************************************
 981  *              wcstok  (MSVCRT.@)
 982  */
 983 MSVCRT_wchar_t * CDECL MSVCRT_wcstok( MSVCRT_wchar_t *str, const MSVCRT_wchar_t *delim )
 984 {
 985     thread_data_t *data = msvcrt_get_thread_data();
 986     MSVCRT_wchar_t *ret;
 987
 988     if (!str)
 989         if (!(str = data->wcstok_next)) return NULL;
 990
 991     while (*str && strchrW( delim, *str )) str++;
 992     if (!*str) return NULL;
 993     ret = str++;
 994     while (*str && !strchrW( delim, *str )) str++;
 995     if (*str) *str++ = 0;
 996     data->wcstok_next = str;
 997     return ret;
 998 }
 999
1000
1001 /*********************************************************************
1002  *              wctomb (MSVCRT.@)
1003  */
1004 INT CDECL MSVCRT_wctomb( char *dst, MSVCRT_wchar_t ch )
1005 {
1006   return WideCharToMultiByte( CP_ACP, 0, &ch, 1, dst, 6, NULL, NULL );
1007 }
1008
1009 /*********************************************************************
1010  *              iswalnum (MSVCRT.@)
1011  */
1012 INT CDECL MSVCRT_iswalnum( MSVCRT_wchar_t wc )
1013 {
1014     return isalnumW( wc );
1015 }
1016
1017 /*********************************************************************
1018  *              iswalpha (MSVCRT.@)
1019  */
1020 INT CDECL MSVCRT_iswalpha( MSVCRT_wchar_t wc )
1021 {
1022     return isalphaW( wc );
1023 }
1024
1025 /*********************************************************************
1026  *              iswcntrl (MSVCRT.@)
1027  */
1028 INT CDECL MSVCRT_iswcntrl( MSVCRT_wchar_t wc )
1029 {
1030     return iscntrlW( wc );
1031 }
1032
1033 /*********************************************************************
1034  *              iswdigit (MSVCRT.@)
1035  */
1036 INT CDECL MSVCRT_iswdigit( MSVCRT_wchar_t wc )
1037 {
1038     return isdigitW( wc );
1039 }
1040
1041 /*********************************************************************
1042  *              iswgraph (MSVCRT.@)
1043  */
1044 INT CDECL MSVCRT_iswgraph( MSVCRT_wchar_t wc )
1045 {
1046     return isgraphW( wc );
1047 }
1048
1049 /*********************************************************************
1050  *              iswlower (MSVCRT.@)
1051  */
1052 INT CDECL MSVCRT_iswlower( MSVCRT_wchar_t wc )
1053 {
1054     return islowerW( wc );
1055 }
1056
1057 /*********************************************************************
1058  *              iswprint (MSVCRT.@)
1059  */
1060 INT CDECL MSVCRT_iswprint( MSVCRT_wchar_t wc )
1061 {
1062     return isprintW( wc );
1063 }
1064
1065 /*********************************************************************
1066  *              iswpunct (MSVCRT.@)
1067  */
1068 INT CDECL MSVCRT_iswpunct( MSVCRT_wchar_t wc )
1069 {
1070     return ispunctW( wc );
1071 }
1072
1073 /*********************************************************************
1074  *              iswspace (MSVCRT.@)
1075  */
1076 INT CDECL MSVCRT_iswspace( MSVCRT_wchar_t wc )
1077 {
1078     return isspaceW( wc );
1079 }
1080
1081 /*********************************************************************
1082  *              iswupper (MSVCRT.@)
1083  */
1084 INT CDECL MSVCRT_iswupper( MSVCRT_wchar_t wc )
1085 {
1086     return isupperW( wc );
1087 }
1088
1089 /*********************************************************************
1090  *              iswxdigit (MSVCRT.@)
1091  */
1092 INT CDECL MSVCRT_iswxdigit( MSVCRT_wchar_t wc )
1093 {
1094     return isxdigitW( wc );
1095 }
1096
1097 /*********************************************************************
1098  *              wcscpy_s (MSVCRT.@)
1099  */
1100 INT CDECL MSVCRT_wcscpy_s( MSVCRT_wchar_t* wcDest, MSVCRT_size_t numElement, const  MSVCRT_wchar_t *wcSrc)
1101 {
1102     MSVCRT_size_t size = 0;
1103
1104     if(!wcDest || !numElement)
1105         return MSVCRT_EINVAL;
1106
1107     wcDest[0] = 0;
1108
1109     if(!wcSrc)
1110     {
1111         return MSVCRT_EINVAL;
1112     }
1113
1114     size = strlenW(wcSrc) + 1;
1115
1116     if(size > numElement)
1117     {
1118         return MSVCRT_ERANGE;
1119     }
1120
1121     memcpy( wcDest, wcSrc, size*sizeof(WCHAR) );
1122
1123     return 0;
1124 }
1125
1126 /******************************************************************
1127  *              wcsncpy_s (MSVCRT.@)
1128  */
1129 INT CDECL MSVCRT_wcsncpy_s( MSVCRT_wchar_t* wcDest, MSVCRT_size_t numElement, const MSVCRT_wchar_t *wcSrc,
1130                             MSVCRT_size_t count )
1131 {
1132     MSVCRT_size_t size = 0;
1133
1134     if (!wcDest || !numElement)
1135         return MSVCRT_EINVAL;
1136
1137     wcDest[0] = 0;
1138
1139     if (!wcSrc)
1140     {
1141         return MSVCRT_EINVAL;
1142     }
1143
1144     size = min(strlenW(wcSrc), count);
1145
1146     if (size >= numElement)
1147     {
1148         return MSVCRT_ERANGE;
1149     }
1150
1151     memcpy( wcDest, wcSrc, size*sizeof(WCHAR) );
1152     wcDest[size] = '\0';
1153
1154     return 0;
1155 }
1156
1157 /******************************************************************
1158  *              wcscat_s (MSVCRT.@)
1159  *
1160  */
1161 INT CDECL MSVCRT_wcscat_s(MSVCRT_wchar_t* dst, MSVCRT_size_t elem, const MSVCRT_wchar_t* src)
1162 {
1163     MSVCRT_wchar_t* ptr = dst;
1164
1165     if (!dst || elem == 0) return MSVCRT_EINVAL;
1166     if (!src)
1167     {
1168         dst[0] = '\0';
1169         return MSVCRT_EINVAL;
1170     }
1171
1172     /* seek to end of dst string (or elem if no end of string is found */
1173     while (ptr < dst + elem && *ptr != '\0') ptr++;
1174     while (ptr < dst + elem)
1175     {
1176         if ((*ptr++ = *src++) == '\0') return 0;
1177     }
1178     /* not enough space */
1179     dst[0] = '\0';
1180     return MSVCRT_ERANGE;
1181 }