dlls/msvcrt/wcs.c

   1 /*
   2  * msvcrt.dll wide-char functions
   3  *
   4  * Copyright 1999 Alexandre Julliard
   5  * Copyright 2000 Jon Griffiths
   6  */
   7 #include <limits.h>
   8 #include <stdio.h>
   9 #include "msvcrt.h"
  10 #include "winnls.h"
  11 #include "wine/unicode.h"
  12
  13 #include "msvcrt/stdio.h"
  14 #include "msvcrt/stdlib.h"
  15 #include "msvcrt/string.h"
  16 #include "msvcrt/wctype.h"
  17
  18 DEFAULT_DEBUG_CHANNEL(msvcrt);
  19
  20
  21 /* INTERNAL: MSVCRT_malloc() based wstrndup */
  22 WCHAR* msvcrt_wstrndup(LPCWSTR buf, unsigned int size)
  23 {
  24   WCHAR* ret;
  25   unsigned int len = strlenW(buf), max_len;
  26
  27   max_len = size <= len? size : len + 1;
  28
  29   ret = MSVCRT_malloc(max_len * sizeof (WCHAR));
  30   if (ret)
  31   {
  32     memcpy(ret,buf,max_len * sizeof (WCHAR));
  33     ret[max_len] = 0;
  34   }
  35   return ret;
  36 }
  37
  38 /*********************************************************************
  39  *              _wcsdup (MSVCRT.@)
  40  */
  41 WCHAR* _wcsdup( const WCHAR* str )
  42 {
  43   WCHAR* ret = NULL;
  44   if (str)
  45   {
  46     int size = (strlenW(str) + 1) * sizeof(WCHAR);
  47     ret = MSVCRT_malloc( size );
  48     if (ret) memcpy( ret, str, size );
  49   }
  50   return ret;
  51 }
  52
  53 /*********************************************************************
  54  *              _wcsicoll (MSVCRT.@)
  55  */
  56 INT _wcsicoll( const WCHAR* str1, const WCHAR* str2 )
  57 {
  58   /* FIXME: handle collates */
  59   return strcmpiW( str1, str2 );
  60 }
  61
  62 /*********************************************************************
  63  *              _wcsnset (MSVCRT.@)
  64  */
  65 WCHAR* _wcsnset( WCHAR* str, WCHAR c, MSVCRT_size_t n )
  66 {
  67   WCHAR* ret = str;
  68   while ((n-- > 0) && *str) *str++ = c;
  69   return ret;
  70 }
  71
  72 /*********************************************************************
  73  *              _wcsrev (MSVCRT.@)
  74  */
  75 WCHAR* _wcsrev( WCHAR* str )
  76 {
  77   WCHAR* ret = str;
  78   WCHAR* end = str + strlenW(str) - 1;
  79   while (end > str)
  80   {
  81     WCHAR t = *end;
  82     *end--  = *str;
  83     *str++  = t;
  84   }
  85   return ret;
  86 }
  87
  88 /*********************************************************************
  89  *              _wcsset (MSVCRT.@)
  90  */
  91 WCHAR* _wcsset( WCHAR* str, WCHAR c )
  92 {
  93   WCHAR* ret = str;
  94   while (*str) *str++ = c;
  95   return ret;
  96 }
  97
  98 /*********************************************************************
  99  *              _vsnwprintf (MSVCRT.@)
 100  */
 101 int _vsnwprintf(WCHAR *str, unsigned int len,
 102                               const WCHAR *format, va_list valist)
 103 {
 104 /* If you fix a bug in this function, fix it in ntdll/wcstring.c also! */
 105   unsigned int written = 0;
 106   const WCHAR *iter = format;
 107   char bufa[256], fmtbufa[64], *fmta;
 108
 109   TRACE("(%d,%s)\n",len,debugstr_w(format));
 110
 111   while (*iter)
 112   {
 113     while (*iter && *iter != (WCHAR)L'%')
 114     {
 115      if (written++ >= len)
 116        return -1;
 117      *str++ = *iter++;
 118     }
 119     if (*iter == (WCHAR)L'%')
 120     {
 121       fmta = fmtbufa;
 122       *fmta++ = *iter++;
 123       while (*iter == (WCHAR)L'0' ||
 124              *iter == (WCHAR)L'+' ||
 125              *iter == (WCHAR)L'-' ||
 126              *iter == (WCHAR)L' ' ||
 127              *iter == (WCHAR)L'0' ||
 128              *iter == (WCHAR)L'*' ||
 129              *iter == (WCHAR)L'#')
 130       {
 131         if (*iter == (WCHAR)L'*')
 132         {
 133           char *buffiter = bufa;
 134           int fieldlen = va_arg(valist, int);
 135           sprintf(buffiter, "%d", fieldlen);
 136           while (*buffiter)
 137             *fmta++ = *buffiter++;
 138         }
 139         else
 140           *fmta++ = *iter;
 141         iter++;
 142       }
 143
 144       while (isdigit(*iter))
 145         *fmta++ = *iter++;
 146
 147       if (*iter == (WCHAR)L'.')
 148       {
 149         *fmta++ = *iter++;
 150         if (*iter == (WCHAR)L'*')
 151         {
 152           char *buffiter = bufa;
 153           int fieldlen = va_arg(valist, int);
 154           sprintf(buffiter, "%d", fieldlen);
 155           while (*buffiter)
 156             *fmta++ = *buffiter++;
 157         }
 158         else
 159           while (isdigit(*iter))
 160             *fmta++ = *iter++;
 161       }
 162       if (*iter == (WCHAR)L'h' ||
 163           *iter == (WCHAR)L'l')
 164       {
 165           *fmta++ = *iter++;
 166           *fmta++ = *iter++;
 167       }
 168
 169       switch (*iter)
 170       {
 171       case (WCHAR)L's':
 172         {
 173           static const WCHAR none[] = { '(', 'n', 'u', 'l', 'l', ')', 0 };
 174           const WCHAR *wstr = va_arg(valist, const WCHAR *);
 175           const WCHAR *striter = wstr ? wstr : none;
 176           while (*striter)
 177           {
 178             if (written++ >= len)
 179               return -1;
 180             *str++ = *striter++;
 181           }
 182           iter++;
 183           break;
 184         }
 185
 186       case (WCHAR)L'c':
 187         if (written++ >= len)
 188           return -1;
 189         *str++ = (WCHAR)va_arg(valist, int);
 190         iter++;
 191         break;
 192
 193       default:
 194         {
 195           /* For non wc types, use system sprintf and append to wide char output */
 196           /* FIXME: for unrecognised types, should ignore % when printing */
 197           char *bufaiter = bufa;
 198           if (*iter == (WCHAR)L'p')
 199             sprintf(bufaiter, "%08lX", va_arg(valist, long));
 200           else
 201           {
 202             *fmta++ = *iter;
 203             *fmta = '\0';
 204             if (*iter == (WCHAR)L'f')
 205               sprintf(bufaiter, fmtbufa, va_arg(valist, double));
 206             else
 207               sprintf(bufaiter, fmtbufa, va_arg(valist, void *));
 208           }
 209           while (*bufaiter)
 210           {
 211             if (written++ >= len)
 212               return -1;
 213             *str++ = *bufaiter++;
 214           }
 215           iter++;
 216           break;
 217         }
 218       }
 219     }
 220   }
 221   if (written >= len)
 222     return -1;
 223   *str++ = (WCHAR)L'\0';
 224   return (int)written;
 225 }
 226
 227 /*********************************************************************
 228  *              vswprintf (MSVCRT.@)
 229  */
 230 int MSVCRT_vswprintf( WCHAR* str, const WCHAR* format, va_list args )
 231 {
 232   return _vsnwprintf( str, INT_MAX, format, args );
 233 }
 234
 235 /*********************************************************************
 236  *              wcscoll (MSVCRT.@)
 237  */
 238 int MSVCRT_wcscoll( const WCHAR* str1, const WCHAR* str2 )
 239 {
 240   /* FIXME: handle collates */
 241   return strcmpW( str1, str2 );
 242 }
 243
 244 /*********************************************************************
 245  *              wcspbrk (MSVCRT.@)
 246  */
 247 WCHAR* MSVCRT_wcspbrk( const WCHAR* str, const WCHAR* accept )
 248 {
 249   const WCHAR* p;
 250   while (*str)
 251   {
 252     for (p = accept; *p; p++) if (*p == *str) return (WCHAR*)str;
 253       str++;
 254   }
 255   return NULL;
 256 }
 257
 258 /*********************************************************************
 259  *              wctomb (MSVCRT.@)
 260  */
 261 INT MSVCRT_wctomb( char *dst, WCHAR ch )
 262 {
 263   return WideCharToMultiByte( CP_ACP, 0, &ch, 1, dst, 6, NULL, NULL );
 264 }
 265
 266 /*********************************************************************
 267  *              iswalnum (MSVCRT.@)
 268  */
 269 INT MSVCRT_iswalnum( WCHAR wc )
 270 {
 271     return isalnumW( wc );
 272 }
 273
 274 /*********************************************************************
 275  *              iswalpha (MSVCRT.@)
 276  */
 277 INT MSVCRT_iswalpha( WCHAR wc )
 278 {
 279     return isalphaW( wc );
 280 }
 281
 282 /*********************************************************************
 283  *              iswcntrl (MSVCRT.@)
 284  */
 285 INT MSVCRT_iswcntrl( WCHAR wc )
 286 {
 287     return iscntrlW( wc );
 288 }
 289
 290 /*********************************************************************
 291  *              iswdigit (MSVCRT.@)
 292  */
 293 INT MSVCRT_iswdigit( WCHAR wc )
 294 {
 295     return isdigitW( wc );
 296 }
 297
 298 /*********************************************************************
 299  *              iswgraph (MSVCRT.@)
 300  */
 301 INT MSVCRT_iswgraph( WCHAR wc )
 302 {
 303     return isgraphW( wc );
 304 }
 305
 306 /*********************************************************************
 307  *              iswlower (MSVCRT.@)
 308  */
 309 INT MSVCRT_iswlower( WCHAR wc )
 310 {
 311     return islowerW( wc );
 312 }
 313
 314 /*********************************************************************
 315  *              iswprint (MSVCRT.@)
 316  */
 317 INT MSVCRT_iswprint( WCHAR wc )
 318 {
 319     return isprintW( wc );
 320 }
 321
 322 /*********************************************************************
 323  *              iswpunct (MSVCRT.@)
 324  */
 325 INT MSVCRT_iswpunct( WCHAR wc )
 326 {
 327     return ispunctW( wc );
 328 }
 329
 330 /*********************************************************************
 331  *              iswspace (MSVCRT.@)
 332  */
 333 INT MSVCRT_iswspace( WCHAR wc )
 334 {
 335     return isspaceW( wc );
 336 }
 337
 338 /*********************************************************************
 339  *              iswupper (MSVCRT.@)
 340  */
 341 INT MSVCRT_iswupper( WCHAR wc )
 342 {
 343     return isupperW( wc );
 344 }
 345
 346 /*********************************************************************
 347  *              iswxdigit (MSVCRT.@)
 348  */
 349 INT MSVCRT_iswxdigit( WCHAR wc )
 350 {
 351     return isxdigitW( wc );
 352 }
 353
 354 /*********************************************************************
 355  *              _itow (MSVCRT.@)
 356  */
 357 WCHAR* _itow(int value,WCHAR* out,int base)
 358 {
 359   char buf[64];
 360   _itoa(value, buf, base);
 361   MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, buf, -1, out, 128);
 362   return out;
 363 }
 364
 365 /*********************************************************************
 366  *              _ltow (MSVCRT.@)
 367  */
 368 WCHAR* _ltow(long value,WCHAR* out,int base)
 369 {
 370   char buf[128];
 371   _ltoa(value, buf, base);
 372   MultiByteToWideChar (CP_ACP, MB_PRECOMPOSED, buf, -1, out, 128);
 373   return out;
 374 }
 375