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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 /* INTERNAL: MSVCRT_malloc() based wstrndup */
  34 MSVCRT_wchar_t* msvcrt_wstrndup(const MSVCRT_wchar_t *buf, unsigned int size)
  35 {
  36   MSVCRT_wchar_t* ret;
  37   unsigned int len = strlenW(buf), max_len;
  38
  39   max_len = size <= len? size : len + 1;
  40
  41   ret = MSVCRT_malloc(max_len * sizeof (MSVCRT_wchar_t));
  42   if (ret)
  43   {
  44     memcpy(ret,buf,max_len * sizeof (MSVCRT_wchar_t));
  45     ret[max_len] = 0;
  46   }
  47   return ret;
  48 }
  49
  50 /*********************************************************************
  51  *              _wcsdup (MSVCRT.@)
  52  */
  53 MSVCRT_wchar_t* _wcsdup( const MSVCRT_wchar_t* str )
  54 {
  55   MSVCRT_wchar_t* ret = NULL;
  56   if (str)
  57   {
  58     int size = (strlenW(str) + 1) * sizeof(MSVCRT_wchar_t);
  59     ret = MSVCRT_malloc( size );
  60     if (ret) memcpy( ret, str, size );
  61   }
  62   return ret;
  63 }
  64
  65 /*********************************************************************
  66  *              _wcsicoll (MSVCRT.@)
  67  */
  68 INT _wcsicoll( const MSVCRT_wchar_t* str1, const MSVCRT_wchar_t* str2 )
  69 {
  70   /* FIXME: handle collates */
  71   return strcmpiW( str1, str2 );
  72 }
  73
  74 /*********************************************************************
  75  *              _wcsnset (MSVCRT.@)
  76  */
  77 MSVCRT_wchar_t* _wcsnset( MSVCRT_wchar_t* str, MSVCRT_wchar_t c, MSVCRT_size_t n )
  78 {
  79   MSVCRT_wchar_t* ret = str;
  80   while ((n-- > 0) && *str) *str++ = c;
  81   return ret;
  82 }
  83
  84 /*********************************************************************
  85  *              _wcsrev (MSVCRT.@)
  86  */
  87 MSVCRT_wchar_t* _wcsrev( MSVCRT_wchar_t* str )
  88 {
  89   MSVCRT_wchar_t* ret = str;
  90   MSVCRT_wchar_t* end = str + strlenW(str) - 1;
  91   while (end > str)
  92   {
  93     MSVCRT_wchar_t t = *end;
  94     *end--  = *str;
  95     *str++  = t;
  96   }
  97   return ret;
  98 }
  99
 100 /*********************************************************************
 101  *              _wcsset (MSVCRT.@)
 102  */
 103 MSVCRT_wchar_t* _wcsset( MSVCRT_wchar_t* str, MSVCRT_wchar_t c )
 104 {
 105   MSVCRT_wchar_t* ret = str;
 106   while (*str) *str++ = c;
 107   return ret;
 108 }
 109
 110 /*********************************************************************
 111  *              wcstod (MSVCRT.@)
 112  */
 113 double MSVCRT_wcstod(const MSVCRT_wchar_t* lpszStr, MSVCRT_wchar_t** end)
 114 {
 115   const MSVCRT_wchar_t* str = lpszStr;
 116   int negative = 0;
 117   double ret = 0, divisor = 10.0;
 118
 119   TRACE("(%s,%p) semi-stub\n", debugstr_w(lpszStr), end);
 120
 121   /* FIXME:
 122    * - Should set errno on failure
 123    * - Should fail on overflow
 124    * - Need to check which input formats are allowed
 125    */
 126   while (isspaceW(*str))
 127     str++;
 128
 129   if (*str == '-')
 130   {
 131     negative = 1;
 132     str++;
 133   }
 134
 135   while (isdigitW(*str))
 136   {
 137     ret = ret * 10.0 + (*str - '0');
 138     str++;
 139   }
 140   if (*str == '.')
 141     str++;
 142   while (isdigitW(*str))
 143   {
 144     ret = ret + (*str - '0') / divisor;
 145     divisor *= 10;
 146     str++;
 147   }
 148
 149   if (*str == 'E' || *str == 'e' || *str == 'D' || *str == 'd')
 150   {
 151     int negativeExponent = 0;
 152     int exponent = 0;
 153     if (*(++str) == '-')
 154     {
 155       negativeExponent = 1;
 156       str++;
 157     }
 158     while (isdigitW(*str))
 159     {
 160       exponent = exponent * 10 + (*str - '0');
 161       str++;
 162     }
 163     if (exponent != 0)
 164     {
 165       if (negativeExponent)
 166         ret = ret / pow(10.0, exponent);
 167       else
 168         ret = ret * pow(10.0, exponent);
 169     }
 170   }
 171
 172   if (negative)
 173     ret = -ret;
 174
 175   if (end)
 176     *end = (MSVCRT_wchar_t*)str;
 177
 178   TRACE("returning %g\n", ret);
 179   return ret;
 180 }
 181
 182
 183 typedef struct pf_output_t
 184 {
 185     int used;
 186     int len;
 187     BOOL unicode;
 188     union {
 189         LPWSTR W;
 190         LPSTR  A;
 191     } buf;
 192 } pf_output;
 193
 194 typedef struct pf_flags_t
 195 {
 196     char Sign, LeftAlign, Alternate, PadZero;
 197     char FieldLength, Precision;
 198     char IntegerLength, IntegerDouble;
 199     char WideString;
 200     char Format;
 201 } pf_flags;
 202
 203 /*
 204  * writes a string of characters to the output
 205  * returns -1 if the string doesn't fit in the output buffer
 206  * return the length of the string if all characters were written
 207  */
 208 static inline int pf_output_stringW( pf_output *out, LPCWSTR str, int len )
 209 {
 210     int space = out->len - out->used;
 211
 212     if( len < 0 )
 213         len = strlenW( str );
 214     if( out->unicode )
 215     {
 216         LPWSTR p = out->buf.W + out->used;
 217
 218         if( space >= len )
 219         {
 220             memcpy( p, str, len*sizeof(WCHAR) );
 221             out->used += len;
 222             return len;
 223         }
 224         if( space > 0 )
 225             memcpy( p, str, space*sizeof(WCHAR) );
 226         out->used += len;
 227     }
 228     else
 229     {
 230         int n = WideCharToMultiByte( CP_ACP, 0, str, len, NULL, 0, NULL, NULL );
 231         LPSTR p = out->buf.A + out->used;
 232
 233         if( space >= n )
 234         {
 235             WideCharToMultiByte( CP_ACP, 0, str, len, p, n, NULL, NULL );
 236             out->used += n;
 237             return len;
 238         }
 239         if( space > 0 )
 240             WideCharToMultiByte( CP_ACP, 0, str, len, p, space, NULL, NULL );
 241         out->used += n;
 242     }
 243     return -1;
 244 }
 245
 246 static inline int pf_output_stringA( pf_output *out, LPCSTR str, int len )
 247 {
 248     int space = out->len - out->used;
 249
 250     if( len < 0 )
 251         len = strlen( str );
 252     if( !out->unicode )
 253     {
 254         LPSTR p = out->buf.A + out->used;
 255
 256         if( space >= len )
 257         {
 258             memcpy( p, str, len );
 259             out->used += len;
 260             return len;
 261         }
 262         if( space > 0 )
 263             memcpy( p, str, space );
 264         out->used += len;
 265     }
 266     else
 267     {
 268         int n = MultiByteToWideChar( CP_ACP, 0, str, len, NULL, 0 );
 269         LPWSTR p = out->buf.W + out->used;
 270
 271         if( space >= n )
 272         {
 273             MultiByteToWideChar( CP_ACP, 0, str, len, p, n );
 274             out->used += n;
 275             return len;
 276         }
 277         if( space > 0 )
 278             MultiByteToWideChar( CP_ACP, 0, str, len, p, space );
 279         out->used += n;
 280     }
 281     return -1;
 282 }
 283
 284 static inline int pf_fill( pf_output *out, int len, pf_flags *flags, char left )
 285 {
 286     int i, r = 0;
 287
 288     if( ( !left &&  flags->LeftAlign ) ||
 289         (  left && !flags->LeftAlign ) ||
 290         (  left &&  flags->PadZero   ) )
 291     {
 292         for( i=0; (i<(flags->FieldLength-len)) && (r>=0); i++ )
 293         {
 294             if( flags->PadZero )
 295                 r = pf_output_stringA( out, "0", 1 );
 296             else
 297                 r = pf_output_stringA( out, " ", 1 );
 298         }
 299     }
 300
 301     return r;
 302 }
 303
 304 static inline int pf_output_format_W( pf_output *out, LPCWSTR str,
 305                                       int len, pf_flags *flags )
 306 {
 307     int r = 0;
 308
 309     if( len < 0 )
 310         len = strlenW( str );
 311
 312     r = pf_fill( out, len, flags, 1 );
 313
 314     if( r>=0 )
 315         r = pf_output_stringW( out, str, len );
 316
 317     if( r>=0 )
 318         r = pf_fill( out, len, flags, 0 );
 319
 320     return r;
 321 }
 322
 323 static inline int pf_output_format_A( pf_output *out, LPCSTR str,
 324                                       int len, pf_flags *flags )
 325 {
 326     int r = 0;
 327
 328     if( len < 0 )
 329         len = strlen( str );
 330
 331     r = pf_fill( out, len, flags, 1 );
 332
 333     if( r>=0 )
 334         r = pf_output_stringA( out, str, len );
 335
 336     if( r>=0 )
 337         r = pf_fill( out, len, flags, 0 );
 338
 339     return r;
 340 }
 341
 342 static inline BOOL pf_is_double_format( char fmt )
 343 {
 344     char float_fmts[] = "aefg";
 345     if (!fmt)
 346         return FALSE;
 347     fmt = tolower( fmt );
 348     return strchr( float_fmts, fmt ) ? TRUE : FALSE;
 349 }
 350
 351 static inline BOOL pf_is_valid_format( char fmt )
 352 {
 353     char float_fmts[] = "acdefginoux";
 354     if (!fmt)
 355         return FALSE;
 356     fmt = tolower( fmt );
 357     return strchr( float_fmts, fmt ) ? TRUE : FALSE;
 358 }
 359
 360 static void pf_rebuild_format_string( char *p, pf_flags *flags )
 361 {
 362     *p++ = '%';
 363     if( flags->Sign )
 364         *p++ = flags->Sign;
 365     if( flags->LeftAlign )
 366         *p++ = flags->LeftAlign;
 367     if( flags->Alternate )
 368         *p++ = flags->Alternate;
 369     if( flags->PadZero )
 370         *p++ = flags->PadZero;
 371     if( flags->FieldLength )
 372     {
 373         sprintf(p, "%d", flags->FieldLength);
 374         p += strlen(p);
 375     }
 376     if( flags->Precision )
 377     {
 378         sprintf(p, ".%d", flags->Precision);
 379         p += strlen(p);
 380     }
 381     *p++ = flags->Format;
 382     *p++ = 0;
 383 }
 384
 385 /*********************************************************************
 386  *  pf_vsnprintf  (INTERNAL)
 387  *
 388  *  implements both A and W vsnprintf functions
 389  */
 390 static int pf_vsnprintf( pf_output *out, const WCHAR *format, va_list valist )
 391 {
 392     int r;
 393     LPCWSTR q, p = format;
 394     pf_flags flags;
 395
 396     while (*p)
 397     {
 398         q = strchrW( p, '%' );
 399
 400         /* there's no % characters left, output the rest of the string */
 401         if( !q )
 402         {
 403             r = pf_output_stringW(out, p, -1);
 404             if( r<0 )
 405                 return r;
 406             p += r;
 407             continue;
 408         }
 409
 410         /* there's characters before the %, output them */
 411         if( q != p )
 412         {
 413             r = pf_output_stringW(out, p, q - p);
 414             if( r<0 )
 415                 return r;
 416             p = q;
 417         }
 418
 419         /* we must be at a % now, skip over it */
 420         assert( *p == '%' );
 421         p++;
 422
 423         /* output a single % character */
 424         if( *p == '%' )
 425         {
 426             r = pf_output_stringW(out, p, 1);
 427             if( r<0 )
 428                 return r;
 429             continue;
 430         }
 431
 432         /* parse the flags */
 433         memset( &flags, 0, sizeof flags );
 434         while (*p)
 435         {
 436             if( *p == '+' || *p == ' ' )
 437                 flags.Sign = '+';
 438             else if( *p == '-' )
 439                 flags.LeftAlign = *p;
 440             else if( *p == '0' )
 441                 flags.PadZero = *p;
 442             else if( *p == '#' )
 443                 flags.Alternate = *p;
 444             else
 445                 break;
 446             p++;
 447         }
 448
 449         /* deal with the field width specifier */
 450         flags.FieldLength = 0;
 451         if( *p == '*' )
 452             flags.FieldLength = va_arg( valist, int );
 453         else while( isdigit(*p) )
 454         {
 455             flags.FieldLength *= 10;
 456             flags.FieldLength += *p++ - '0';
 457         }
 458
 459         /* deal with precision */
 460         if( *p == '.' )
 461         {
 462             p++;
 463             if( *p == '*' )
 464                 flags.Precision = va_arg( valist, int );
 465             else while( isdigit(*p) )
 466             {
 467                 flags.Precision *= 10;
 468                 flags.Precision += *p++ - '0';
 469             }
 470         }
 471
 472         /* deal with integer width modifier */
 473         while( *p )
 474         {
 475             if( *p == 'h' || *p == 'l' || *p == 'L' )
 476             {
 477                 if( flags.IntegerLength == *p )  /* FIXME: this is wrong */
 478                     flags.IntegerDouble++;
 479                 else
 480                     flags.IntegerLength = *p;
 481                 p++;
 482             }
 483             else if( *p == 'w' )
 484                 flags.WideString = *p++;
 485             else
 486                 break;
 487         }
 488
 489         flags.Format = *p;
 490         r = 0;
 491
 492         /* output a unicode string */
 493         if( ( flags.Format == 's' && flags.WideString ) ||
 494             ( !out->unicode && flags.Format == 'S' ) ||
 495             ( out->unicode && flags.Format == 's' ) )
 496         {
 497             LPCWSTR str = va_arg( valist, const WCHAR * );
 498
 499             if( str )
 500                 r = pf_output_format_W( out, str, -1, &flags );
 501             else
 502                 r = pf_output_format_A( out, "(null)", -1, &flags );
 503         }
 504
 505         /* output a ASCII string */
 506         else if( ( flags.Format == 's' && flags.IntegerLength == 'h' ) ||
 507             ( out->unicode && flags.Format == 'S' ) ||
 508             ( !out->unicode && flags.Format == 's' ) )
 509         {
 510             LPCSTR str = va_arg( valist, const CHAR * );
 511
 512             if( str )
 513                 r = pf_output_format_A( out, str, -1, &flags );
 514             else
 515                 r = pf_output_format_A( out, "(null)", -1, &flags );
 516         }
 517
 518         /* output a single wide character */
 519         else if( ( flags.Format == 'c' && flags.IntegerLength == 'w' ) ||
 520             ( out->unicode && flags.Format == 'c' ) ||
 521             ( !out->unicode && flags.Format == 'C' ) )
 522         {
 523             WCHAR ch = va_arg( valist, int );
 524
 525             r = pf_output_format_W( out, &ch, 1, &flags );
 526         }
 527
 528         /* output a single ascii character */
 529         else if( ( flags.Format == 'c' && flags.IntegerLength == 'h' ) ||
 530             ( out->unicode && flags.Format == 'C' ) ||
 531             ( !out->unicode && flags.Format == 'c' ) )
 532         {
 533             CHAR ch = va_arg( valist, int );
 534
 535             r = pf_output_format_A( out, &ch, 1, &flags );
 536         }
 537
 538         /* output a pointer */
 539         else if( flags.Format == 'p' )
 540         {
 541             char pointer[10];
 542
 543             flags.PadZero = 0;
 544             if( flags.Alternate )
 545                 sprintf(pointer, "0X%08lX", va_arg(valist, long));
 546             else
 547                 sprintf(pointer, "%08lX", va_arg(valist, long));
 548             r = pf_output_format_A( out, pointer, -1, &flags );
 549         }
 550
 551         /* deal with %n */
 552         else if( flags.Format == 'n' )
 553         {
 554             int *x = va_arg(valist, int *);
 555             *x = out->used;
 556         }
 557
 558         /* deal with integers and floats using libc's printf */
 559         else if( pf_is_valid_format( flags.Format ) )
 560         {
 561             char fmt[20], number[40], *x = number;
 562
 563             if( flags.FieldLength >= sizeof number )
 564                 x = HeapAlloc( GetProcessHeap(), 0, flags.FieldLength+1 );
 565
 566             pf_rebuild_format_string( fmt, &flags );
 567
 568             if( pf_is_double_format( flags.Format ) )
 569                 sprintf( number, fmt, va_arg(valist, double) );
 570             else
 571                 sprintf( number, fmt, va_arg(valist, int) );
 572
 573             r = pf_output_stringA( out, number, -1 );
 574             if( x != number )
 575                 HeapFree( GetProcessHeap(), 0, number );
 576         }
 577         else
 578             continue;
 579
 580         if( r<0 )
 581             return r;
 582         p++;
 583     }
 584
 585     /* check we reached the end, and null terminate the string */
 586     assert( *p == 0 );
 587     r = pf_output_stringW( out, p, 1 );
 588     if( r<0 )
 589         return r;
 590
 591     return out->used - 1;
 592 }
 593
 594 /*********************************************************************
 595  *              _vsnprintf (MSVCRT.@)
 596  */
 597 int MSVCRT_vsnprintf( char *str, unsigned int len,
 598                 const char *format, va_list valist )
 599 {
 600     DWORD sz;
 601     LPWSTR formatW = NULL;
 602     pf_output out;
 603     int r;
 604
 605     out.unicode = FALSE;
 606     out.buf.A = str;
 607     out.used = 0;
 608     out.len = len;
 609
 610     if( format )
 611     {
 612         sz = MultiByteToWideChar( CP_ACP, 0, format, -1, NULL, 0 );
 613         formatW = HeapAlloc( GetProcessHeap(), 0, sz*sizeof(WCHAR) );
 614         MultiByteToWideChar( CP_ACP, 0, format, -1, formatW, sz );
 615     }
 616
 617     r = pf_vsnprintf( &out, formatW, valist );
 618
 619     HeapFree( GetProcessHeap(), 0, formatW );
 620
 621     return r;
 622 }
 623
 624 /*********************************************************************
 625  *              _vsnwsprintf (MSVCRT.@)
 626  */
 627 int MSVCRT_vsnwprintf( MSVCRT_wchar_t *str, unsigned int len,
 628                               const WCHAR *format, va_list valist )
 629 {
 630     pf_output out;
 631
 632     out.unicode = TRUE;
 633     out.buf.W = str;
 634     out.used = 0;
 635     out.len = len;
 636
 637     return pf_vsnprintf( &out, format, valist );
 638 }
 639
 640 /*********************************************************************
 641  *              sprintf (MSVCRT.@)
 642  */
 643 int MSVCRT_sprintf( char *str, const char *format, ... )
 644 {
 645     va_list ap;
 646     int r;
 647
 648     va_start( ap, format );
 649     r = MSVCRT_vsnprintf( str, INT_MAX, format, ap );
 650     va_end( ap );
 651     return r;
 652 }
 653
 654 /*********************************************************************
 655  *              swprintf (MSVCRT.@)
 656  */
 657 int MSVCRT_swprintf( MSVCRT_wchar_t *str, const MSVCRT_wchar_t *format, ... )
 658 {
 659     va_list ap;
 660     int r;
 661
 662     va_start( ap, format );
 663     r = MSVCRT_vsnwprintf( str, INT_MAX, format, ap );
 664     va_end( ap );
 665     return r;
 666 }
 667
 668 /*********************************************************************
 669  *              vswprintf (MSVCRT.@)
 670  */
 671 int MSVCRT_vswprintf( MSVCRT_wchar_t* str, const MSVCRT_wchar_t* format, va_list args )
 672 {
 673     return MSVCRT_vsnwprintf( str, INT_MAX, format, args );
 674 }
 675
 676 /*********************************************************************
 677  *              wcscoll (MSVCRT.@)
 678  */
 679 int MSVCRT_wcscoll( const MSVCRT_wchar_t* str1, const MSVCRT_wchar_t* str2 )
 680 {
 681   /* FIXME: handle collates */
 682   return strcmpW( str1, str2 );
 683 }
 684
 685 /*********************************************************************
 686  *              wcspbrk (MSVCRT.@)
 687  */
 688 MSVCRT_wchar_t* MSVCRT_wcspbrk( const MSVCRT_wchar_t* str, const MSVCRT_wchar_t* accept )
 689 {
 690   const MSVCRT_wchar_t* p;
 691   while (*str)
 692   {
 693     for (p = accept; *p; p++) if (*p == *str) return (MSVCRT_wchar_t*)str;
 694       str++;
 695   }
 696   return NULL;
 697 }
 698
 699 /*********************************************************************
 700  *              wctomb (MSVCRT.@)
 701  */
 702 INT MSVCRT_wctomb( char *dst, MSVCRT_wchar_t ch )
 703 {
 704   return WideCharToMultiByte( CP_ACP, 0, &ch, 1, dst, 6, NULL, NULL );
 705 }
 706
 707 /*********************************************************************
 708  *              iswalnum (MSVCRT.@)
 709  */
 710 INT MSVCRT_iswalnum( MSVCRT_wchar_t wc )
 711 {
 712     return isalnumW( wc );
 713 }
 714
 715 /*********************************************************************
 716  *              iswalpha (MSVCRT.@)
 717  */
 718 INT MSVCRT_iswalpha( MSVCRT_wchar_t wc )
 719 {
 720     return isalphaW( wc );
 721 }
 722
 723 /*********************************************************************
 724  *              iswcntrl (MSVCRT.@)
 725  */
 726 INT MSVCRT_iswcntrl( MSVCRT_wchar_t wc )
 727 {
 728     return iscntrlW( wc );
 729 }
 730
 731 /*********************************************************************
 732  *              iswdigit (MSVCRT.@)
 733  */
 734 INT MSVCRT_iswdigit( MSVCRT_wchar_t wc )
 735 {
 736     return isdigitW( wc );
 737 }
 738
 739 /*********************************************************************
 740  *              iswgraph (MSVCRT.@)
 741  */
 742 INT MSVCRT_iswgraph( MSVCRT_wchar_t wc )
 743 {
 744     return isgraphW( wc );
 745 }
 746
 747 /*********************************************************************
 748  *              iswlower (MSVCRT.@)
 749  */
 750 INT MSVCRT_iswlower( MSVCRT_wchar_t wc )
 751 {
 752     return islowerW( wc );
 753 }
 754
 755 /*********************************************************************
 756  *              iswprint (MSVCRT.@)
 757  */
 758 INT MSVCRT_iswprint( MSVCRT_wchar_t wc )
 759 {
 760     return isprintW( wc );
 761 }
 762
 763 /*********************************************************************
 764  *              iswpunct (MSVCRT.@)
 765  */
 766 INT MSVCRT_iswpunct( MSVCRT_wchar_t wc )
 767 {
 768     return ispunctW( wc );
 769 }
 770
 771 /*********************************************************************
 772  *              iswspace (MSVCRT.@)
 773  */
 774 INT MSVCRT_iswspace( MSVCRT_wchar_t wc )
 775 {
 776     return isspaceW( wc );
 777 }
 778
 779 /*********************************************************************
 780  *              iswupper (MSVCRT.@)
 781  */
 782 INT MSVCRT_iswupper( MSVCRT_wchar_t wc )
 783 {
 784     return isupperW( wc );
 785 }
 786
 787 /*********************************************************************
 788  *              iswxdigit (MSVCRT.@)
 789  */
 790 INT MSVCRT_iswxdigit( MSVCRT_wchar_t wc )
 791 {
 792     return isxdigitW( wc );
 793 }