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 MSVCRT_wchar_t* msvcrt_wstrndup(const MSVCRT_wchar_t *buf, unsigned int size)
  39 {
  40   MSVCRT_wchar_t* 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 (MSVCRT_wchar_t));
  46   if (ret)
  47   {
  48     memcpy(ret,buf,max_len * sizeof (MSVCRT_wchar_t));
  49     ret[max_len] = 0;
  50   }
  51   return ret;
  52 }
  53
  54 /*********************************************************************
  55  *              _wcsdup (MSVCRT.@)
  56  */
  57 MSVCRT_wchar_t* _wcsdup( const MSVCRT_wchar_t* str )
  58 {
  59   MSVCRT_wchar_t* ret = NULL;
  60   if (str)
  61   {
  62     int size = (strlenW(str) + 1) * sizeof(MSVCRT_wchar_t);
  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 MSVCRT_wchar_t* str1, const MSVCRT_wchar_t* str2 )
  73 {
  74   /* FIXME: handle collates */
  75   return strcmpiW( str1, str2 );
  76 }
  77
  78 /*********************************************************************
  79  *              _wcsnset (MSVCRT.@)
  80  */
  81 MSVCRT_wchar_t* _wcsnset( MSVCRT_wchar_t* str, MSVCRT_wchar_t c, MSVCRT_size_t n )
  82 {
  83   MSVCRT_wchar_t* ret = str;
  84   while ((n-- > 0) && *str) *str++ = c;
  85   return ret;
  86 }
  87
  88 /*********************************************************************
  89  *              _wcsrev (MSVCRT.@)
  90  */
  91 MSVCRT_wchar_t* _wcsrev( MSVCRT_wchar_t* str )
  92 {
  93   MSVCRT_wchar_t* ret = str;
  94   MSVCRT_wchar_t* end = str + strlenW(str) - 1;
  95   while (end > str)
  96   {
  97     MSVCRT_wchar_t t = *end;
  98     *end--  = *str;
  99     *str++  = t;
 100   }
 101   return ret;
 102 }
 103
 104 /*********************************************************************
 105  *              _wcsset (MSVCRT.@)
 106  */
 107 MSVCRT_wchar_t* _wcsset( MSVCRT_wchar_t* str, MSVCRT_wchar_t c )
 108 {
 109   MSVCRT_wchar_t* ret = str;
 110   while (*str) *str++ = c;
 111   return ret;
 112 }
 113
 114 /*********************************************************************
 115  *              wcstod (MSVCRT.@)
 116  */
 117 double MSVCRT_wcstod(const MSVCRT_wchar_t* lpszStr, MSVCRT_wchar_t** end)
 118 {
 119   const MSVCRT_wchar_t* str = lpszStr;
 120   int negative = 0;
 121   double ret = 0, divisor = 10.0;
 122
 123   TRACE("(%s,%p) semi-stub\n", debugstr_w(lpszStr), end);
 124
 125   /* FIXME:
 126    * - Should set errno on failure
 127    * - Should fail on overflow
 128    * - Need to check which input formats are allowed
 129    */
 130   while (isspaceW(*str))
 131     str++;
 132
 133   if (*str == '-')
 134   {
 135     negative = 1;
 136     str++;
 137   }
 138
 139   while (isdigitW(*str))
 140   {
 141     ret = ret * 10.0 + (*str - '0');
 142     str++;
 143   }
 144   if (*str == '.')
 145     str++;
 146   while (isdigitW(*str))
 147   {
 148     ret = ret + (*str - '0') / divisor;
 149     divisor *= 10;
 150     str++;
 151   }
 152
 153   if (end)
 154     *end = (MSVCRT_wchar_t*)str;
 155
 156   TRACE("returning %g\n", ret);
 157   return ret;
 158 }
 159
 160 /*********************************************************************
 161  *              _vsnwprintf (MSVCRT.@)
 162  */
 163 int _vsnwprintf(MSVCRT_wchar_t *str, unsigned int len,
 164                 const MSVCRT_wchar_t *format, va_list valist)
 165 {
 166     return vsnprintfW(str, len, format, valist);
 167 }
 168
 169 /*********************************************************************
 170  *              vswprintf (MSVCRT.@)
 171  */
 172 int MSVCRT_vswprintf( MSVCRT_wchar_t* str, const MSVCRT_wchar_t* format, va_list args )
 173 {
 174     return vsnprintfW( str, INT_MAX, format, args );
 175 }
 176
 177 /*********************************************************************
 178  *              wcscoll (MSVCRT.@)
 179  */
 180 int MSVCRT_wcscoll( const MSVCRT_wchar_t* str1, const MSVCRT_wchar_t* str2 )
 181 {
 182   /* FIXME: handle collates */
 183   return strcmpW( str1, str2 );
 184 }
 185
 186 /*********************************************************************
 187  *              wcspbrk (MSVCRT.@)
 188  */
 189 MSVCRT_wchar_t* MSVCRT_wcspbrk( const MSVCRT_wchar_t* str, const MSVCRT_wchar_t* accept )
 190 {
 191   const MSVCRT_wchar_t* p;
 192   while (*str)
 193   {
 194     for (p = accept; *p; p++) if (*p == *str) return (MSVCRT_wchar_t*)str;
 195       str++;
 196   }
 197   return NULL;
 198 }
 199
 200 /*********************************************************************
 201  *              wctomb (MSVCRT.@)
 202  */
 203 INT MSVCRT_wctomb( char *dst, MSVCRT_wchar_t ch )
 204 {
 205   return WideCharToMultiByte( CP_ACP, 0, &ch, 1, dst, 6, NULL, NULL );
 206 }
 207
 208 /*********************************************************************
 209  *              iswalnum (MSVCRT.@)
 210  */
 211 INT MSVCRT_iswalnum( MSVCRT_wchar_t wc )
 212 {
 213     return isalnumW( wc );
 214 }
 215
 216 /*********************************************************************
 217  *              iswalpha (MSVCRT.@)
 218  */
 219 INT MSVCRT_iswalpha( MSVCRT_wchar_t wc )
 220 {
 221     return isalphaW( wc );
 222 }
 223
 224 /*********************************************************************
 225  *              iswcntrl (MSVCRT.@)
 226  */
 227 INT MSVCRT_iswcntrl( MSVCRT_wchar_t wc )
 228 {
 229     return iscntrlW( wc );
 230 }
 231
 232 /*********************************************************************
 233  *              iswdigit (MSVCRT.@)
 234  */
 235 INT MSVCRT_iswdigit( MSVCRT_wchar_t wc )
 236 {
 237     return isdigitW( wc );
 238 }
 239
 240 /*********************************************************************
 241  *              iswgraph (MSVCRT.@)
 242  */
 243 INT MSVCRT_iswgraph( MSVCRT_wchar_t wc )
 244 {
 245     return isgraphW( wc );
 246 }
 247
 248 /*********************************************************************
 249  *              iswlower (MSVCRT.@)
 250  */
 251 INT MSVCRT_iswlower( MSVCRT_wchar_t wc )
 252 {
 253     return islowerW( wc );
 254 }
 255
 256 /*********************************************************************
 257  *              iswprint (MSVCRT.@)
 258  */
 259 INT MSVCRT_iswprint( MSVCRT_wchar_t wc )
 260 {
 261     return isprintW( wc );
 262 }
 263
 264 /*********************************************************************
 265  *              iswpunct (MSVCRT.@)
 266  */
 267 INT MSVCRT_iswpunct( MSVCRT_wchar_t wc )
 268 {
 269     return ispunctW( wc );
 270 }
 271
 272 /*********************************************************************
 273  *              iswspace (MSVCRT.@)
 274  */
 275 INT MSVCRT_iswspace( MSVCRT_wchar_t wc )
 276 {
 277     return isspaceW( wc );
 278 }
 279
 280 /*********************************************************************
 281  *              iswupper (MSVCRT.@)
 282  */
 283 INT MSVCRT_iswupper( MSVCRT_wchar_t wc )
 284 {
 285     return isupperW( wc );
 286 }
 287
 288 /*********************************************************************
 289  *              iswxdigit (MSVCRT.@)
 290  */
 291 INT MSVCRT_iswxdigit( MSVCRT_wchar_t wc )
 292 {
 293     return isxdigitW( wc );
 294 }