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