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  *              _vscprintf (MSVCRT.@)
 834  */
 835 int CDECL _vscprintf( const char *format, __ms_va_list valist )
 836 {
 837     return MSVCRT_vsnprintf( NULL, INT_MAX, format, valist );
 838 }
 839
 840 /*********************************************************************
 841  *              _snprintf (MSVCRT.@)
 842  */
 843 int CDECL MSVCRT__snprintf(char *str, unsigned int len, const char *format, ...)
 844 {
 845     int retval;
 846     __ms_va_list valist;
 847     __ms_va_start(valist, format);
 848     retval = MSVCRT_vsnprintf(str, len, format, valist);
 849     __ms_va_end(valist);
 850     return retval;
 851 }
 852
 853 /*********************************************************************
 854  *              _vsnwsprintf (MSVCRT.@)
 855  */
 856 int CDECL MSVCRT_vsnwprintf( MSVCRT_wchar_t *str, unsigned int len,
 857                              const MSVCRT_wchar_t *format, __ms_va_list valist )
 858 {
 859     pf_output out;
 860
 861     out.unicode = TRUE;
 862     out.buf.W = str;
 863     out.used = 0;
 864     out.len = len;
 865
 866     return pf_vsnprintf( &out, format, valist );
 867 }
 868
 869 /*********************************************************************
 870  *              _snwprintf (MSVCRT.@)
 871  */
 872 int CDECL MSVCRT__snwprintf( MSVCRT_wchar_t *str, unsigned int len, const MSVCRT_wchar_t *format, ...)
 873 {
 874     int retval;
 875     __ms_va_list valist;
 876     __ms_va_start(valist, format);
 877     retval = MSVCRT_vsnwprintf(str, len, format, valist);
 878     __ms_va_end(valist);
 879     return retval;
 880 }
 881
 882 /*********************************************************************
 883  *              sprintf (MSVCRT.@)
 884  */
 885 int CDECL MSVCRT_sprintf( char *str, const char *format, ... )
 886 {
 887     __ms_va_list ap;
 888     int r;
 889
 890     __ms_va_start( ap, format );
 891     r = MSVCRT_vsnprintf( str, INT_MAX, format, ap );
 892     __ms_va_end( ap );
 893     return r;
 894 }
 895
 896 /*********************************************************************
 897  *              swprintf (MSVCRT.@)
 898  */
 899 int CDECL MSVCRT_swprintf( MSVCRT_wchar_t *str, const MSVCRT_wchar_t *format, ... )
 900 {
 901     __ms_va_list ap;
 902     int r;
 903
 904     __ms_va_start( ap, format );
 905     r = MSVCRT_vsnwprintf( str, INT_MAX, format, ap );
 906     __ms_va_end( ap );
 907     return r;
 908 }
 909
 910 /*********************************************************************
 911  *              vswprintf (MSVCRT.@)
 912  */
 913 int CDECL MSVCRT_vswprintf( MSVCRT_wchar_t* str, const MSVCRT_wchar_t* format, __ms_va_list args )
 914 {
 915     return MSVCRT_vsnwprintf( str, INT_MAX, format, args );
 916 }
 917
 918 /*********************************************************************
 919  *              _vscwprintf (MSVCRT.@)
 920  */
 921 int CDECL _vscwprintf( const MSVCRT_wchar_t *format, __ms_va_list args )
 922 {
 923     return MSVCRT_vsnwprintf( NULL, INT_MAX, format, args );
 924 }
 925
 926 /*********************************************************************
 927  *              vswprintf_s (MSVCRT.@)
 928  */
 929 int CDECL MSVCRT_vswprintf_s( MSVCRT_wchar_t* str, MSVCRT_size_t num, const MSVCRT_wchar_t* format, __ms_va_list args )
 930 {
 931     /* FIXME: must handle positional arguments */
 932     return MSVCRT_vsnwprintf( str, num, format, args );
 933 }
 934
 935 /*********************************************************************
 936  *              wcscoll (MSVCRT.@)
 937  */
 938 int CDECL MSVCRT_wcscoll( const MSVCRT_wchar_t* str1, const MSVCRT_wchar_t* str2 )
 939 {
 940   /* FIXME: handle collates */
 941   return strcmpW( str1, str2 );
 942 }
 943
 944 /*********************************************************************
 945  *              wcspbrk (MSVCRT.@)
 946  */
 947 MSVCRT_wchar_t* CDECL MSVCRT_wcspbrk( const MSVCRT_wchar_t* str, const MSVCRT_wchar_t* accept )
 948 {
 949   const MSVCRT_wchar_t* p;
 950   while (*str)
 951   {
 952     for (p = accept; *p; p++) if (*p == *str) return (MSVCRT_wchar_t*)str;
 953       str++;
 954   }
 955   return NULL;
 956 }
 957
 958 /*********************************************************************
 959  *              wcstok  (MSVCRT.@)
 960  */
 961 MSVCRT_wchar_t * CDECL MSVCRT_wcstok( MSVCRT_wchar_t *str, const MSVCRT_wchar_t *delim )
 962 {
 963     thread_data_t *data = msvcrt_get_thread_data();
 964     MSVCRT_wchar_t *ret;
 965
 966     if (!str)
 967         if (!(str = data->wcstok_next)) return NULL;
 968
 969     while (*str && strchrW( delim, *str )) str++;
 970     if (!*str) return NULL;
 971     ret = str++;
 972     while (*str && !strchrW( delim, *str )) str++;
 973     if (*str) *str++ = 0;
 974     data->wcstok_next = str;
 975     return ret;
 976 }
 977
 978
 979 /*********************************************************************
 980  *              wctomb (MSVCRT.@)
 981  */
 982 INT CDECL MSVCRT_wctomb( char *dst, MSVCRT_wchar_t ch )
 983 {
 984   return WideCharToMultiByte( CP_ACP, 0, &ch, 1, dst, 6, NULL, NULL );
 985 }
 986
 987 /*********************************************************************
 988  *              iswalnum (MSVCRT.@)
 989  */
 990 INT CDECL MSVCRT_iswalnum( MSVCRT_wchar_t wc )
 991 {
 992     return isalnumW( wc );
 993 }
 994
 995 /*********************************************************************
 996  *              iswalpha (MSVCRT.@)
 997  */
 998 INT CDECL MSVCRT_iswalpha( MSVCRT_wchar_t wc )
 999 {
1000     return isalphaW( wc );
1001 }
1002
1003 /*********************************************************************
1004  *              iswcntrl (MSVCRT.@)
1005  */
1006 INT CDECL MSVCRT_iswcntrl( MSVCRT_wchar_t wc )
1007 {
1008     return iscntrlW( wc );
1009 }
1010
1011 /*********************************************************************
1012  *              iswdigit (MSVCRT.@)
1013  */
1014 INT CDECL MSVCRT_iswdigit( MSVCRT_wchar_t wc )
1015 {
1016     return isdigitW( wc );
1017 }
1018
1019 /*********************************************************************
1020  *              iswgraph (MSVCRT.@)
1021  */
1022 INT CDECL MSVCRT_iswgraph( MSVCRT_wchar_t wc )
1023 {
1024     return isgraphW( wc );
1025 }
1026
1027 /*********************************************************************
1028  *              iswlower (MSVCRT.@)
1029  */
1030 INT CDECL MSVCRT_iswlower( MSVCRT_wchar_t wc )
1031 {
1032     return islowerW( wc );
1033 }
1034
1035 /*********************************************************************
1036  *              iswprint (MSVCRT.@)
1037  */
1038 INT CDECL MSVCRT_iswprint( MSVCRT_wchar_t wc )
1039 {
1040     return isprintW( wc );
1041 }
1042
1043 /*********************************************************************
1044  *              iswpunct (MSVCRT.@)
1045  */
1046 INT CDECL MSVCRT_iswpunct( MSVCRT_wchar_t wc )
1047 {
1048     return ispunctW( wc );
1049 }
1050
1051 /*********************************************************************
1052  *              iswspace (MSVCRT.@)
1053  */
1054 INT CDECL MSVCRT_iswspace( MSVCRT_wchar_t wc )
1055 {
1056     return isspaceW( wc );
1057 }
1058
1059 /*********************************************************************
1060  *              iswupper (MSVCRT.@)
1061  */
1062 INT CDECL MSVCRT_iswupper( MSVCRT_wchar_t wc )
1063 {
1064     return isupperW( wc );
1065 }
1066
1067 /*********************************************************************
1068  *              iswxdigit (MSVCRT.@)
1069  */
1070 INT CDECL MSVCRT_iswxdigit( MSVCRT_wchar_t wc )
1071 {
1072     return isxdigitW( wc );
1073 }
1074
1075 /*********************************************************************
1076  *              wcscpy_s (MSVCRT.@)
1077  */
1078 INT CDECL MSVCRT_wcscpy_s( MSVCRT_wchar_t* wcDest, MSVCRT_size_t numElement, const  MSVCRT_wchar_t *wcSrc)
1079 {
1080     MSVCRT_size_t size = 0;
1081
1082     if(!wcDest || !numElement)
1083         return MSVCRT_EINVAL;
1084
1085     wcDest[0] = 0;
1086
1087     if(!wcSrc)
1088     {
1089         return MSVCRT_EINVAL;
1090     }
1091
1092     size = strlenW(wcSrc) + 1;
1093
1094     if(size > numElement)
1095     {
1096         return MSVCRT_ERANGE;
1097     }
1098
1099     memcpy( wcDest, wcSrc, size*sizeof(WCHAR) );
1100
1101     return 0;
1102 }
1103
1104 /******************************************************************
1105  *              wcsncpy_s (MSVCRT.@)
1106  */
1107 INT CDECL MSVCRT_wcsncpy_s( MSVCRT_wchar_t* wcDest, MSVCRT_size_t numElement, const MSVCRT_wchar_t *wcSrc,
1108                             MSVCRT_size_t count )
1109 {
1110     MSVCRT_size_t size = 0;
1111
1112     if (!wcDest || !numElement)
1113         return MSVCRT_EINVAL;
1114
1115     wcDest[0] = 0;
1116
1117     if (!wcSrc)
1118     {
1119         return MSVCRT_EINVAL;
1120     }
1121
1122     size = min(strlenW(wcSrc), count);
1123
1124     if (size >= numElement)
1125     {
1126         return MSVCRT_ERANGE;
1127     }
1128
1129     memcpy( wcDest, wcSrc, size*sizeof(WCHAR) );
1130     wcDest[size] = '\0';
1131
1132     return 0;
1133 }
1134
1135 /******************************************************************
1136  *              wcscat_s (MSVCRT.@)
1137  *
1138  */
1139 INT CDECL MSVCRT_wcscat_s(MSVCRT_wchar_t* dst, MSVCRT_size_t elem, const MSVCRT_wchar_t* src)
1140 {
1141     MSVCRT_wchar_t* ptr = dst;
1142
1143     if (!dst || elem == 0) return MSVCRT_EINVAL;
1144     if (!src)
1145     {
1146         dst[0] = '\0';
1147         return MSVCRT_EINVAL;
1148     }
1149
1150     /* seek to end of dst string (or elem if no end of string is found */
1151     while (ptr < dst + elem && *ptr != '\0') ptr++;
1152     while (ptr < dst + elem)
1153     {
1154         if ((*ptr++ = *src++) == '\0') return 0;
1155     }
1156     /* not enough space */
1157     dst[0] = '\0';
1158     return MSVCRT_ERANGE;
1159 }