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 MSVCRT__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,
 558         MSVCRT__locale_t locale, BOOL valid, __ms_va_list valist )
 559 {
 560     int r;
 561     LPCWSTR q, p = format;
 562     pf_flags flags;
 563
 564     if(!locale)
 565         locale = get_locale();
 566
 567     TRACE("format is %s\n",debugstr_w(format));
 568     while (*p)
 569     {
 570         q = strchrW( p, '%' );
 571
 572         /* there's no % characters left, output the rest of the string */
 573         if( !q )
 574         {
 575             r = pf_output_stringW(out, p, -1);
 576             if( r<0 )
 577                 return r;
 578             p += r;
 579             continue;
 580         }
 581
 582         /* there's characters before the %, output them */
 583         if( q != p )
 584         {
 585             r = pf_output_stringW(out, p, q - p);
 586             if( r<0 )
 587                 return r;
 588             p = q;
 589         }
 590
 591         /* we must be at a % now, skip over it */
 592         assert( *p == '%' );
 593         p++;
 594
 595         /* output a single % character */
 596         if( *p == '%' )
 597         {
 598             r = pf_output_stringW(out, p++, 1);
 599             if( r<0 )
 600                 return r;
 601             continue;
 602         }
 603
 604         /* parse the flags */
 605         memset( &flags, 0, sizeof flags );
 606         while (*p)
 607         {
 608             if( *p == '+' || *p == ' ' )
 609             {
 610                 if ( flags.Sign != '+' )
 611                     flags.Sign = *p;
 612             }
 613             else if( *p == '-' )
 614                 flags.LeftAlign = *p;
 615             else if( *p == '0' )
 616                 flags.PadZero = *p;
 617             else if( *p == '#' )
 618                 flags.Alternate = *p;
 619             else
 620                 break;
 621             p++;
 622         }
 623
 624         /* deal with the field width specifier */
 625         flags.FieldLength = 0;
 626         if( *p == '*' )
 627         {
 628             flags.FieldLength = va_arg( valist, int );
 629             if (flags.FieldLength < 0)
 630             {
 631                 flags.LeftAlign = '-';
 632                 flags.FieldLength = -flags.FieldLength;
 633             }
 634             p++;
 635         }
 636         else while( isdigit(*p) )
 637         {
 638             flags.FieldLength *= 10;
 639             flags.FieldLength += *p++ - '0';
 640         }
 641
 642         /* deal with precision */
 643         flags.Precision = -1;
 644         if( *p == '.' )
 645         {
 646             flags.Precision = 0;
 647             p++;
 648             if( *p == '*' )
 649             {
 650                 flags.Precision = va_arg( valist, int );
 651                 p++;
 652             }
 653             else while( isdigit(*p) )
 654             {
 655                 flags.Precision *= 10;
 656                 flags.Precision += *p++ - '0';
 657             }
 658         }
 659
 660         /* deal with integer width modifier */
 661         while( *p )
 662         {
 663             if( *p == 'h' || *p == 'l' || *p == 'L' )
 664             {
 665                 flags.IntegerLength = *p;
 666                 p++;
 667             }
 668             else if( *p == 'I' )
 669             {
 670                 if( *(p+1) == '6' && *(p+2) == '4' )
 671                 {
 672                     flags.IntegerDouble++;
 673                     p += 3;
 674                 }
 675                 else if( *(p+1) == '3' && *(p+2) == '2' )
 676                     p += 3;
 677                 else if( isdigit(*(p+1)) || *(p+1) == 0 )
 678                     break;
 679                 else
 680                     p++;
 681             }
 682             else if( *p == 'w' )
 683                 flags.WideString = *p++;
 684             else if( *p == 'F' )
 685                 p++; /* ignore */
 686             else
 687                 break;
 688         }
 689
 690         flags.Format = *p;
 691         r = 0;
 692
 693         if (flags.Format == '$')
 694         {
 695             FIXME("Positional parameters are not supported (%s)\n", wine_dbgstr_w(format));
 696             return -1;
 697         }
 698         /* output a string */
 699         if(  flags.Format == 's' || flags.Format == 'S' )
 700             r = pf_handle_string_format( out, va_arg(valist, const void*), -1,
 701                                          &flags, (flags.Format == 'S') );
 702
 703         /* output a single character */
 704         else if( flags.Format == 'c' || flags.Format == 'C' )
 705         {
 706             INT ch = va_arg( valist, int );
 707
 708             r = pf_handle_string_format( out, &ch, 1, &flags, (flags.Format == 'C') );
 709         }
 710
 711         /* output a pointer */
 712         else if( flags.Format == 'p' )
 713         {
 714             char pointer[32];
 715             void *ptr = va_arg( valist, void * );
 716
 717             flags.PadZero = 0;
 718             if( flags.Alternate )
 719                 sprintf(pointer, "0X%0*lX", 2 * (int)sizeof(ptr), (ULONG_PTR)ptr);
 720             else
 721                 sprintf(pointer, "%0*lX", 2 * (int)sizeof(ptr), (ULONG_PTR)ptr);
 722             r = pf_output_format_A( out, pointer, -1, &flags );
 723         }
 724
 725         /* deal with %n */
 726         else if( flags.Format == 'n' )
 727         {
 728             int *x = va_arg(valist, int *);
 729             *x = out->used;
 730         }
 731
 732         /* deal with 64-bit integers */
 733         else if( pf_is_integer_format( flags.Format ) && flags.IntegerDouble )
 734         {
 735             char number[40], *x = number;
 736
 737             /* Estimate largest possible required buffer size:
 738                * Chooses the larger of the field or precision
 739                * Includes extra bytes: 1 byte for null, 1 byte for sign,
 740                  4 bytes for exponent, 2 bytes for alternate formats, 1 byte
 741                  for a decimal, and 1 byte for an additional float digit. */
 742             int x_len = ((flags.FieldLength > flags.Precision) ?
 743                         flags.FieldLength : flags.Precision) + 10;
 744
 745             if( x_len >= sizeof number)
 746                 x = HeapAlloc( GetProcessHeap(), 0, x_len );
 747
 748             pf_integer_conv( x, x_len, &flags, va_arg(valist, LONGLONG) );
 749
 750             r = pf_output_format_A( out, x, -1, &flags );
 751             if( x != number )
 752                 HeapFree( GetProcessHeap(), 0, x );
 753         }
 754
 755         /* deal with integers and floats using libc's printf */
 756         else if( pf_is_valid_format( flags.Format ) )
 757         {
 758             char fmt[20], number[40], *x = number, *decimal_point;
 759
 760             /* Estimate largest possible required buffer size:
 761                * Chooses the larger of the field or precision
 762                * Includes extra bytes: 1 byte for null, 1 byte for sign,
 763                  4 bytes for exponent, 2 bytes for alternate formats, 1 byte
 764                  for a decimal, and 1 byte for an additional float digit. */
 765             int x_len = ((flags.FieldLength > flags.Precision) ?
 766                         flags.FieldLength : flags.Precision) + 10;
 767
 768             if( x_len >= sizeof number)
 769                 x = HeapAlloc( GetProcessHeap(), 0, x_len );
 770
 771             pf_rebuild_format_string( fmt, &flags );
 772
 773             if( pf_is_double_format( flags.Format ) )
 774             {
 775                 sprintf( x, fmt, va_arg(valist, double) );
 776                 if (toupper(flags.Format) == 'E' || toupper(flags.Format) == 'G')
 777                     pf_fixup_exponent( x );
 778             }
 779             else
 780                 sprintf( x, fmt, va_arg(valist, int) );
 781
 782             decimal_point = strchr(x, '.');
 783             if(decimal_point)
 784                 *decimal_point = *locale->locinfo->lconv->decimal_point;
 785
 786             r = pf_output_stringA( out, x, -1 );
 787             if( x != number )
 788                 HeapFree( GetProcessHeap(), 0, x );
 789             if(r < 0)
 790                 return r;
 791         }
 792         else
 793         {
 794             if( valid )
 795             {
 796                 MSVCRT__invalid_parameter( NULL, NULL, NULL, 0, 0 );
 797                 *MSVCRT__errno() = MSVCRT_EINVAL;
 798                 return -1;
 799             }
 800
 801             continue;
 802         }
 803
 804         if( r<0 )
 805             return r;
 806         p++;
 807     }
 808
 809     /* check we reached the end, and null terminate the string */
 810     assert( *p == 0 );
 811     pf_output_stringW( out, p, 1 );
 812
 813     return out->used - 1;
 814 }
 815
 816 /*********************************************************************
 817  * vsnprintf_internal (INTERNAL)
 818  */
 819 static inline int vsnprintf_internal( char *str, MSVCRT_size_t len, const char *format,
 820         MSVCRT__locale_t locale, BOOL valid, __ms_va_list valist )
 821 {
 822     DWORD sz;
 823     LPWSTR formatW = NULL;
 824     pf_output out;
 825     int r;
 826
 827     out.unicode = FALSE;
 828     out.buf.A = str;
 829     out.used = 0;
 830     out.len = len;
 831
 832     sz = MultiByteToWideChar( CP_ACP, 0, format, -1, NULL, 0 );
 833     formatW = HeapAlloc( GetProcessHeap(), 0, sz*sizeof(WCHAR) );
 834     MultiByteToWideChar( CP_ACP, 0, format, -1, formatW, sz );
 835
 836     r = pf_vsnprintf( &out, formatW, locale, valid, valist );
 837
 838     HeapFree( GetProcessHeap(), 0, formatW );
 839
 840     return r;
 841 }
 842
 843 /*********************************************************************
 844  *              _vsnprintf (MSVCRT.@)
 845  */
 846 int CDECL MSVCRT_vsnprintf( char *str, MSVCRT_size_t len,
 847                             const char *format, __ms_va_list valist )
 848 {
 849     return vsnprintf_internal(str, len, format, NULL, FALSE, valist);
 850 }
 851
 852 /*********************************************************************
 853 *               _vsnprintf_l (MSVCRT.@)
 854  */
 855 int CDECL MSVCRT_vsnprintf_l( char *str, MSVCRT_size_t len, const char *format,
 856                             MSVCRT__locale_t locale, __ms_va_list valist )
 857 {
 858     return vsnprintf_internal(str, len, format, locale, FALSE, valist);
 859 }
 860
 861 /*********************************************************************
 862  *              _vsnprintf_s_l (MSVCRT.@)
 863  */
 864 int CDECL MSVCRT_vsnprintf_s_l( char *str, MSVCRT_size_t sizeOfBuffer,
 865         MSVCRT_size_t count, const char *format,
 866         MSVCRT__locale_t locale, __ms_va_list valist )
 867 {
 868     int len, ret;
 869
 870     if(sizeOfBuffer<count+1 || count==-1)
 871         len = sizeOfBuffer;
 872     else
 873         len = count+1;
 874
 875     ret = vsnprintf_internal(str, len, format, locale, TRUE, valist);
 876
 877     if(ret<0 || ret==len) {
 878         if(count!=_TRUNCATE && count>sizeOfBuffer) {
 879             MSVCRT__invalid_parameter( NULL, NULL, NULL, 0, 0 );
 880             *MSVCRT__errno() = MSVCRT_ERANGE;
 881             memset(str, 0, sizeOfBuffer);
 882         } else
 883             str[len-1] = '\0';
 884
 885         return -1;
 886     }
 887
 888     return ret;
 889 }
 890
 891 /*********************************************************************
 892  *              _vsnprintf_s (MSVCRT.@)
 893  */
 894 int CDECL MSVCRT_vsnprintf_s( char *str, MSVCRT_size_t sizeOfBuffer,
 895         MSVCRT_size_t count, const char *format, __ms_va_list valist )
 896 {
 897     return MSVCRT_vsnprintf_s_l(str,sizeOfBuffer, count, format, NULL, valist);
 898 }
 899
 900 /*********************************************************************
 901  *              vsprintf (MSVCRT.@)
 902  */
 903 int CDECL MSVCRT_vsprintf( char *str, const char *format, __ms_va_list valist)
 904 {
 905     return MSVCRT_vsnprintf(str, INT_MAX, format, valist);
 906 }
 907
 908 /*********************************************************************
 909  *              vsprintf_s (MSVCRT.@)
 910  */
 911 int CDECL MSVCRT_vsprintf_s( char *str, MSVCRT_size_t num, const char *format, __ms_va_list valist)
 912 {
 913     return MSVCRT_vsnprintf(str, num, format, valist);
 914 }
 915
 916 /*********************************************************************
 917  *              _vscprintf (MSVCRT.@)
 918  */
 919 int CDECL _vscprintf( const char *format, __ms_va_list valist )
 920 {
 921     return MSVCRT_vsnprintf( NULL, INT_MAX, format, valist );
 922 }
 923
 924 /*********************************************************************
 925  *              _snprintf (MSVCRT.@)
 926  */
 927 int CDECL MSVCRT__snprintf(char *str, unsigned int len, const char *format, ...)
 928 {
 929     int retval;
 930     __ms_va_list valist;
 931     __ms_va_start(valist, format);
 932     retval = MSVCRT_vsnprintf(str, len, format, valist);
 933     __ms_va_end(valist);
 934     return retval;
 935 }
 936
 937 /*********************************************************************
 938  * vsnwsprintf_internal (INTERNAL)
 939  */
 940 static inline int vsnwprintf_internal(MSVCRT_wchar_t *str, MSVCRT_size_t len,
 941         const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, BOOL valid,
 942         __ms_va_list valist)
 943 {
 944     pf_output out;
 945
 946     out.unicode = TRUE;
 947     out.buf.W = str;
 948     out.used = 0;
 949     out.len = len;
 950
 951     return pf_vsnprintf( &out, format, locale, valid, valist );
 952 }
 953
 954 /*********************************************************************
 955  *              _vsnwsprintf (MSVCRT.@)
 956  */
 957 int CDECL MSVCRT_vsnwprintf(MSVCRT_wchar_t *str, MSVCRT_size_t len,
 958         const MSVCRT_wchar_t *format, __ms_va_list valist)
 959 {
 960     return vsnwprintf_internal(str, len, format, NULL, FALSE, valist);
 961 }
 962
 963 /*********************************************************************
 964  *              _vsnwsprintf_l (MSVCRT.@)
 965  */
 966 int CDECL MSVCRT_vsnwprintf_l(MSVCRT_wchar_t *str, MSVCRT_size_t len,
 967         const MSVCRT_wchar_t *format, MSVCRT__locale_t locale,
 968         __ms_va_list valist)
 969 {
 970         return vsnwprintf_internal(str, len, format, locale, FALSE, valist);
 971 }
 972
 973 /*********************************************************************
 974  *              _vsnwsprintf_s_l (MSVCRT.@)
 975  */
 976 int CDECL MSVCRT_vsnwprintf_s_l( MSVCRT_wchar_t *str, MSVCRT_size_t sizeOfBuffer,
 977         MSVCRT_size_t count, const MSVCRT_wchar_t *format,
 978         MSVCRT__locale_t locale, __ms_va_list valist)
 979 {
 980     int len, ret;
 981
 982     len = sizeOfBuffer/sizeof(MSVCRT_wchar_t);
 983     if(count!=-1 && len>count+1)
 984         len = count+1;
 985
 986     ret = vsnwprintf_internal(str, len, format, locale, TRUE, valist);
 987
 988     if(ret<0 || ret==len) {
 989         if(count!=_TRUNCATE && count>sizeOfBuffer/sizeof(MSVCRT_wchar_t)) {
 990             MSVCRT__invalid_parameter( NULL, NULL, NULL, 0, 0 );
 991             *MSVCRT__errno() = MSVCRT_ERANGE;
 992             memset(str, 0, sizeOfBuffer);
 993         } else
 994             str[len-1] = '\0';
 995
 996         return -1;
 997     }
 998
 999     return ret;
1000 }
1001
1002 /*********************************************************************
1003  *              _vsnwsprintf_s (MSVCRT.@)
1004  */
1005 int CDECL MSVCRT_vsnwprintf_s(MSVCRT_wchar_t *str, MSVCRT_size_t sizeOfBuffer,
1006         MSVCRT_size_t count, const MSVCRT_wchar_t *format, __ms_va_list valist)
1007 {
1008     return MSVCRT_vsnwprintf_s_l(str, sizeOfBuffer, count,
1009             format, NULL, valist);
1010 }
1011
1012 /*********************************************************************
1013  *              _snwprintf (MSVCRT.@)
1014  */
1015 int CDECL MSVCRT__snwprintf( MSVCRT_wchar_t *str, unsigned int len, const MSVCRT_wchar_t *format, ...)
1016 {
1017     int retval;
1018     __ms_va_list valist;
1019     __ms_va_start(valist, format);
1020     retval = MSVCRT_vsnwprintf(str, len, format, valist);
1021     __ms_va_end(valist);
1022     return retval;
1023 }
1024
1025 /*********************************************************************
1026  *              sprintf (MSVCRT.@)
1027  */
1028 int CDECL MSVCRT_sprintf( char *str, const char *format, ... )
1029 {
1030     __ms_va_list ap;
1031     int r;
1032
1033     __ms_va_start( ap, format );
1034     r = MSVCRT_vsnprintf( str, INT_MAX, format, ap );
1035     __ms_va_end( ap );
1036     return r;
1037 }
1038
1039 /*********************************************************************
1040  *              sprintf_s (MSVCRT.@)
1041  */
1042 int CDECL MSVCRT_sprintf_s( char *str, MSVCRT_size_t num, const char *format, ... )
1043 {
1044     __ms_va_list ap;
1045     int r;
1046
1047     __ms_va_start( ap, format );
1048     r = MSVCRT_vsnprintf( str, num, format, ap );
1049     __ms_va_end( ap );
1050     return r;
1051 }
1052
1053 /*********************************************************************
1054  *              swprintf (MSVCRT.@)
1055  */
1056 int CDECL MSVCRT_swprintf( MSVCRT_wchar_t *str, const MSVCRT_wchar_t *format, ... )
1057 {
1058     __ms_va_list ap;
1059     int r;
1060
1061     __ms_va_start( ap, format );
1062     r = MSVCRT_vsnwprintf( str, INT_MAX, format, ap );
1063     __ms_va_end( ap );
1064     return r;
1065 }
1066
1067 /*********************************************************************
1068  *              vswprintf (MSVCRT.@)
1069  */
1070 int CDECL MSVCRT_vswprintf( MSVCRT_wchar_t* str, const MSVCRT_wchar_t* format, __ms_va_list args )
1071 {
1072     return MSVCRT_vsnwprintf( str, INT_MAX, format, args );
1073 }
1074
1075 /*********************************************************************
1076  *              _vscwprintf (MSVCRT.@)
1077  */
1078 int CDECL _vscwprintf( const MSVCRT_wchar_t *format, __ms_va_list args )
1079 {
1080     return MSVCRT_vsnwprintf( NULL, INT_MAX, format, args );
1081 }
1082
1083 /*********************************************************************
1084  *              vswprintf_s (MSVCRT.@)
1085  */
1086 int CDECL MSVCRT_vswprintf_s(MSVCRT_wchar_t* str, MSVCRT_size_t numberOfElements,
1087         const MSVCRT_wchar_t* format, __ms_va_list args)
1088 {
1089     return MSVCRT_vsnwprintf_s(str, numberOfElements*sizeof(MSVCRT_wchar_t),
1090             INT_MAX, format, args);
1091 }
1092
1093 /*********************************************************************
1094  *              _vswprintf_s_l (MSVCRT.@)
1095  */
1096 int CDECL MSVCRT_vswprintf_s_l(MSVCRT_wchar_t* str, MSVCRT_size_t numberOfElements,
1097         const MSVCRT_wchar_t* format, MSVCRT__locale_t locale, __ms_va_list args)
1098 {
1099     return MSVCRT_vsnwprintf_s_l(str, numberOfElements*sizeof(MSVCRT_wchar_t),
1100             INT_MAX, format, locale, args );
1101 }
1102
1103 /*********************************************************************
1104  *              wcscoll (MSVCRT.@)
1105  */
1106 int CDECL MSVCRT_wcscoll( const MSVCRT_wchar_t* str1, const MSVCRT_wchar_t* str2 )
1107 {
1108   /* FIXME: handle collates */
1109   return strcmpW( str1, str2 );
1110 }
1111
1112 /*********************************************************************
1113  *              wcspbrk (MSVCRT.@)
1114  */
1115 MSVCRT_wchar_t* CDECL MSVCRT_wcspbrk( const MSVCRT_wchar_t* str, const MSVCRT_wchar_t* accept )
1116 {
1117   const MSVCRT_wchar_t* p;
1118   while (*str)
1119   {
1120     for (p = accept; *p; p++) if (*p == *str) return (MSVCRT_wchar_t*)str;
1121       str++;
1122   }
1123   return NULL;
1124 }
1125
1126 /*********************************************************************
1127  *              wcstok  (MSVCRT.@)
1128  */
1129 MSVCRT_wchar_t * CDECL MSVCRT_wcstok( MSVCRT_wchar_t *str, const MSVCRT_wchar_t *delim )
1130 {
1131     thread_data_t *data = msvcrt_get_thread_data();
1132     MSVCRT_wchar_t *ret;
1133
1134     if (!str)
1135         if (!(str = data->wcstok_next)) return NULL;
1136
1137     while (*str && strchrW( delim, *str )) str++;
1138     if (!*str) return NULL;
1139     ret = str++;
1140     while (*str && !strchrW( delim, *str )) str++;
1141     if (*str) *str++ = 0;
1142     data->wcstok_next = str;
1143     return ret;
1144 }
1145
1146
1147 /*********************************************************************
1148  *              wctomb (MSVCRT.@)
1149  */
1150 INT CDECL MSVCRT_wctomb( char *dst, MSVCRT_wchar_t ch )
1151 {
1152   return WideCharToMultiByte( CP_ACP, 0, &ch, 1, dst, 6, NULL, NULL );
1153 }
1154
1155 /*********************************************************************
1156  *              iswalnum (MSVCRT.@)
1157  */
1158 INT CDECL MSVCRT_iswalnum( MSVCRT_wchar_t wc )
1159 {
1160     return isalnumW( wc );
1161 }
1162
1163 /*********************************************************************
1164  *              iswalpha (MSVCRT.@)
1165  */
1166 INT CDECL MSVCRT_iswalpha( MSVCRT_wchar_t wc )
1167 {
1168     return isalphaW( wc );
1169 }
1170
1171 /*********************************************************************
1172  *              iswalpha_l (MSVCRT.@)
1173  */
1174 INT CDECL MSVCRT__iswalpha_l( MSVCRT_wchar_t wc, MSVCRT__locale_t locale )
1175 {
1176     return isalphaW( wc );
1177 }
1178
1179 /*********************************************************************
1180  *              iswcntrl (MSVCRT.@)
1181  */
1182 INT CDECL MSVCRT_iswcntrl( MSVCRT_wchar_t wc )
1183 {
1184     return iscntrlW( wc );
1185 }
1186
1187 /*********************************************************************
1188  *              iswdigit (MSVCRT.@)
1189  */
1190 INT CDECL MSVCRT_iswdigit( MSVCRT_wchar_t wc )
1191 {
1192     return isdigitW( wc );
1193 }
1194
1195 /*********************************************************************
1196  *              iswgraph (MSVCRT.@)
1197  */
1198 INT CDECL MSVCRT_iswgraph( MSVCRT_wchar_t wc )
1199 {
1200     return isgraphW( wc );
1201 }
1202
1203 /*********************************************************************
1204  *              iswlower (MSVCRT.@)
1205  */
1206 INT CDECL MSVCRT_iswlower( MSVCRT_wchar_t wc )
1207 {
1208     return islowerW( wc );
1209 }
1210
1211 /*********************************************************************
1212  *              iswprint (MSVCRT.@)
1213  */
1214 INT CDECL MSVCRT_iswprint( MSVCRT_wchar_t wc )
1215 {
1216     return isprintW( wc );
1217 }
1218
1219 /*********************************************************************
1220  *              iswpunct (MSVCRT.@)
1221  */
1222 INT CDECL MSVCRT_iswpunct( MSVCRT_wchar_t wc )
1223 {
1224     return ispunctW( wc );
1225 }
1226
1227 /*********************************************************************
1228  *              iswspace (MSVCRT.@)
1229  */
1230 INT CDECL MSVCRT_iswspace( MSVCRT_wchar_t wc )
1231 {
1232     return isspaceW( wc );
1233 }
1234
1235 /*********************************************************************
1236  *              iswupper (MSVCRT.@)
1237  */
1238 INT CDECL MSVCRT_iswupper( MSVCRT_wchar_t wc )
1239 {
1240     return isupperW( wc );
1241 }
1242
1243 /*********************************************************************
1244  *              iswxdigit (MSVCRT.@)
1245  */
1246 INT CDECL MSVCRT_iswxdigit( MSVCRT_wchar_t wc )
1247 {
1248     return isxdigitW( wc );
1249 }
1250
1251 /*********************************************************************
1252  *              wcscpy_s (MSVCRT.@)
1253  */
1254 INT CDECL MSVCRT_wcscpy_s( MSVCRT_wchar_t* wcDest, MSVCRT_size_t numElement, const  MSVCRT_wchar_t *wcSrc)
1255 {
1256     MSVCRT_size_t size = 0;
1257
1258     if(!wcDest || !numElement)
1259         return MSVCRT_EINVAL;
1260
1261     wcDest[0] = 0;
1262
1263     if(!wcSrc)
1264     {
1265         return MSVCRT_EINVAL;
1266     }
1267
1268     size = strlenW(wcSrc) + 1;
1269
1270     if(size > numElement)
1271     {
1272         return MSVCRT_ERANGE;
1273     }
1274
1275     memcpy( wcDest, wcSrc, size*sizeof(WCHAR) );
1276
1277     return 0;
1278 }
1279
1280 /******************************************************************
1281  *              wcsncpy_s (MSVCRT.@)
1282  */
1283 INT CDECL MSVCRT_wcsncpy_s( MSVCRT_wchar_t* wcDest, MSVCRT_size_t numElement, const MSVCRT_wchar_t *wcSrc,
1284                             MSVCRT_size_t count )
1285 {
1286     MSVCRT_size_t size = 0;
1287
1288     if (!wcDest || !numElement)
1289         return MSVCRT_EINVAL;
1290
1291     wcDest[0] = 0;
1292
1293     if (!wcSrc)
1294     {
1295         return MSVCRT_EINVAL;
1296     }
1297
1298     size = min(strlenW(wcSrc), count);
1299
1300     if (size >= numElement)
1301     {
1302         return MSVCRT_ERANGE;
1303     }
1304
1305     memcpy( wcDest, wcSrc, size*sizeof(WCHAR) );
1306     wcDest[size] = '\0';
1307
1308     return 0;
1309 }
1310
1311 /******************************************************************
1312  *              wcscat_s (MSVCRT.@)
1313  *
1314  */
1315 INT CDECL MSVCRT_wcscat_s(MSVCRT_wchar_t* dst, MSVCRT_size_t elem, const MSVCRT_wchar_t* src)
1316 {
1317     MSVCRT_wchar_t* ptr = dst;
1318
1319     if (!dst || elem == 0) return MSVCRT_EINVAL;
1320     if (!src)
1321     {
1322         dst[0] = '\0';
1323         return MSVCRT_EINVAL;
1324     }
1325
1326     /* seek to end of dst string (or elem if no end of string is found */
1327     while (ptr < dst + elem && *ptr != '\0') ptr++;
1328     while (ptr < dst + elem)
1329     {
1330         if ((*ptr++ = *src++) == '\0') return 0;
1331     }
1332     /* not enough space */
1333     dst[0] = '\0';
1334     return MSVCRT_ERANGE;
1335 }