git.oblomov.eu Git - wine/blob - dlls/ntdll/wcstring.c

   1 /*
   2  * NTDLL wide-char functions
   3  *
   4  * Copyright 2000 Alexandre Julliard
   5  * Copyright 2000 Jon Griffiths
   6  */
   7
   8 #include "config.h"
   9
  10 #include <ctype.h>
  11 #include <limits.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <stdio.h>
  15
  16 #include "windef.h"
  17 #include "winbase.h"
  18 #include "winnls.h"
  19 #include "wine/unicode.h"
  20 #include "heap.h"
  21 #include "debugtools.h"
  22
  23 DEFAULT_DEBUG_CHANNEL(ntdll);
  24
  25
  26 /*********************************************************************
  27  *           _wcsicmp    (NTDLL.@)
  28  */
  29 INT __cdecl NTDLL__wcsicmp( LPCWSTR str1, LPCWSTR str2 )
  30 {
  31     return strcmpiW( str1, str2 );
  32 }
  33
  34
  35 /*********************************************************************
  36  *           _wcslwr    (NTDLL.@)
  37  */
  38 LPWSTR __cdecl NTDLL__wcslwr( LPWSTR str )
  39 {
  40     return strlwrW( str );
  41 }
  42
  43
  44 /*********************************************************************
  45  *           _wcsnicmp    (NTDLL.@)
  46  */
  47 INT __cdecl NTDLL__wcsnicmp( LPCWSTR str1, LPCWSTR str2, INT n )
  48 {
  49     return strncmpiW( str1, str2, n );
  50 }
  51
  52
  53 /*********************************************************************
  54  *           _wcsupr    (NTDLL.@)
  55  */
  56 LPWSTR __cdecl NTDLL__wcsupr( LPWSTR str )
  57 {
  58     return struprW( str );
  59 }
  60
  61
  62 /*********************************************************************
  63  *           towlower    (NTDLL.@)
  64  */
  65 WCHAR __cdecl NTDLL_towlower( WCHAR ch )
  66 {
  67     return tolowerW(ch);
  68 }
  69
  70
  71 /*********************************************************************
  72  *           towupper    (NTDLL.@)
  73  */
  74 WCHAR __cdecl NTDLL_towupper( WCHAR ch )
  75 {
  76     return toupperW(ch);
  77 }
  78
  79
  80 /***********************************************************************
  81  *           wcscat    (NTDLL.@)
  82  */
  83 LPWSTR __cdecl NTDLL_wcscat( LPWSTR dst, LPCWSTR src )
  84 {
  85     return strcatW( dst, src );
  86 }
  87
  88
  89 /*********************************************************************
  90  *           wcschr    (NTDLL.@)
  91  */
  92 LPWSTR __cdecl NTDLL_wcschr( LPCWSTR str, WCHAR ch )
  93 {
  94     return strchrW( str, ch );
  95 }
  96
  97
  98 /*********************************************************************
  99  *           wcscmp    (NTDLL.@)
 100  */
 101 INT __cdecl NTDLL_wcscmp( LPCWSTR str1, LPCWSTR str2 )
 102 {
 103     return strcmpW( str1, str2 );
 104 }
 105
 106
 107 /***********************************************************************
 108  *           wcscpy    (NTDLL.@)
 109  */
 110 LPWSTR __cdecl NTDLL_wcscpy( LPWSTR dst, LPCWSTR src )
 111 {
 112     return strcpyW( dst, src );
 113 }
 114
 115
 116 /*********************************************************************
 117  *           wcscspn    (NTDLL.@)
 118  */
 119 INT __cdecl NTDLL_wcscspn( LPCWSTR str, LPCWSTR reject )
 120 {
 121     LPCWSTR start = str;
 122     while (*str)
 123     {
 124         LPCWSTR p = reject;
 125         while (*p && (*p != *str)) p++;
 126         if (*p) break;
 127         str++;
 128     }
 129     return str - start;
 130 }
 131
 132
 133 /***********************************************************************
 134  *           wcslen    (NTDLL.@)
 135  */
 136 INT __cdecl NTDLL_wcslen( LPCWSTR str )
 137 {
 138     return strlenW( str );
 139 }
 140
 141
 142 /*********************************************************************
 143  *           wcsncat    (NTDLL.@)
 144  */
 145 LPWSTR __cdecl NTDLL_wcsncat( LPWSTR s1, LPCWSTR s2, INT n )
 146 {
 147     LPWSTR ret = s1;
 148     while (*s1) s1++;
 149     while (n-- > 0) if (!(*s1++ = *s2++)) return ret;
 150     *s1 = 0;
 151     return ret;
 152 }
 153
 154
 155 /*********************************************************************
 156  *           wcsncmp    (NTDLL.@)
 157  */
 158 INT __cdecl NTDLL_wcsncmp( LPCWSTR str1, LPCWSTR str2, INT n )
 159 {
 160     return strncmpW( str1, str2, n );
 161 }
 162
 163
 164 /*********************************************************************
 165  *           wcsncpy    (NTDLL.@)
 166  */
 167 LPWSTR __cdecl NTDLL_wcsncpy( LPWSTR s1, LPCWSTR s2, INT n )
 168 {
 169     return strncpyW( s1, s2, n );
 170 }
 171
 172
 173 /*********************************************************************
 174  *           wcspbrk    (NTDLL.@)
 175  */
 176 LPWSTR __cdecl NTDLL_wcspbrk( LPCWSTR str, LPCWSTR accept )
 177 {
 178     LPCWSTR p;
 179     while (*str)
 180     {
 181         for (p = accept; *p; p++) if (*p == *str) return (LPWSTR)str;
 182         str++;
 183     }
 184     return NULL;
 185 }
 186
 187
 188 /*********************************************************************
 189  *           wcsrchr    (NTDLL.@)
 190  */
 191 LPWSTR __cdecl NTDLL_wcsrchr( LPWSTR str, WCHAR ch )
 192 {
 193     LPWSTR last = NULL;
 194     while (*str)
 195     {
 196         if (*str == ch) last = str;
 197         str++;
 198     }
 199     return last;
 200 }
 201
 202
 203 /*********************************************************************
 204  *           wcsspn    (NTDLL.@)
 205  */
 206 INT __cdecl NTDLL_wcsspn( LPCWSTR str, LPCWSTR accept )
 207 {
 208     LPCWSTR start = str;
 209     while (*str)
 210     {
 211         LPCWSTR p = accept;
 212         while (*p && (*p != *str)) p++;
 213         if (!*p) break;
 214         str++;
 215     }
 216     return str - start;
 217 }
 218
 219
 220 /*********************************************************************
 221  *           wcsstr    (NTDLL.@)
 222  */
 223 LPWSTR __cdecl NTDLL_wcsstr( LPCWSTR str, LPCWSTR sub )
 224 {
 225     return strstrW( str, sub );
 226 }
 227
 228
 229 /*********************************************************************
 230  *           wcstok    (NTDLL.@)
 231  */
 232 LPWSTR __cdecl NTDLL_wcstok( LPWSTR str, LPCWSTR delim )
 233 {
 234     static LPWSTR next = NULL;
 235     LPWSTR ret;
 236
 237     if (!str)
 238         if (!(str = next)) return NULL;
 239
 240     while (*str && NTDLL_wcschr( delim, *str )) str++;
 241     if (!*str) return NULL;
 242     ret = str++;
 243     while (*str && !NTDLL_wcschr( delim, *str )) str++;
 244     if (*str) *str++ = 0;
 245     next = str;
 246     return ret;
 247 }
 248
 249
 250 /*********************************************************************
 251  *           wcstombs    (NTDLL.@)
 252  */
 253 INT __cdecl NTDLL_wcstombs( LPSTR dst, LPCWSTR src, INT n )
 254 {
 255     INT ret;
 256     if (n <= 0) return 0;
 257     ret = WideCharToMultiByte( CP_ACP, 0, src, -1, dst, dst ? n : 0, NULL, NULL );
 258     if (!ret) return n;  /* overflow */
 259     return ret - 1;  /* do not count terminating NULL */
 260 }
 261
 262
 263 /*********************************************************************
 264  *           mbstowcs    (NTDLL.@)
 265  */
 266 INT __cdecl NTDLL_mbstowcs( LPWSTR dst, LPCSTR src, INT n )
 267 {
 268     INT ret;
 269     if (n <= 0) return 0;
 270     ret = MultiByteToWideChar( CP_ACP, 0, src, -1, dst, dst ? n : 0 );
 271     if (!ret) return n;  /* overflow */
 272     return ret - 1;  /* do not count terminating NULL */
 273 }
 274
 275
 276 /*********************************************************************
 277  *                  wcstol  (NTDLL.@)
 278  * Like strtol, but for wide character strings.
 279  */
 280 INT __cdecl NTDLL_wcstol(LPCWSTR s,LPWSTR *end,INT base)
 281 {
 282     LPSTR sA = HEAP_strdupWtoA(GetProcessHeap(),0,s),endA;
 283     INT ret = strtol(sA,&endA,base);
 284
 285     HeapFree(GetProcessHeap(),0,sA);
 286     if (end) *end = ((LPWSTR)s)+(endA-sA); /* pointer magic checked. */
 287     return ret;
 288 }
 289
 290
 291 /*********************************************************************
 292  *                  wcstoul  (NTDLL.@)
 293  * Like strtoul, but for wide character strings.
 294  */
 295 INT __cdecl NTDLL_wcstoul(LPCWSTR s,LPWSTR *end,INT base)
 296 {
 297     LPSTR sA = HEAP_strdupWtoA(GetProcessHeap(),0,s),endA;
 298     INT ret = strtoul(sA,&endA,base);
 299
 300     HeapFree(GetProcessHeap(),0,sA);
 301     if (end) *end = ((LPWSTR)s)+(endA-sA); /* pointer magic checked. */
 302     return ret;
 303 }
 304
 305
 306 /*********************************************************************
 307  *           iswctype    (NTDLL.@)
 308  */
 309 INT __cdecl NTDLL_iswctype( WCHAR wc, WCHAR wct )
 310 {
 311     return (get_char_typeW(wc) & 0xfff) & wct;
 312 }
 313
 314
 315 /*********************************************************************
 316  *           iswalpha    (NTDLL.@)
 317  */
 318 INT __cdecl NTDLL_iswalpha( WCHAR wc )
 319 {
 320     return get_char_typeW(wc) & C1_ALPHA;
 321 }
 322
 323
 324 /*********************************************************************
 325  *           _ultow    (NTDLL.@)
 326  * Like _ultoa, but for wide character strings.
 327  */
 328 LPWSTR __cdecl _ultow(ULONG value, LPWSTR string, INT radix)
 329 {
 330     WCHAR tmp[33];
 331     LPWSTR tp = tmp;
 332     LPWSTR sp;
 333     LONG i;
 334     ULONG v = value;
 335
 336     if (radix > 36 || radix <= 1)
 337         return 0;
 338
 339     while (v || tp == tmp)
 340     {
 341         i = v % radix;
 342         v = v / radix;
 343         if (i < 10)
 344             *tp++ = i + '0';
 345         else
 346             *tp++ = i + 'a' - 10;
 347     }
 348
 349     sp = string;
 350     while (tp > tmp)
 351         *sp++ = *--tp;
 352     *sp = 0;
 353     return string;
 354 }
 355
 356 /*********************************************************************
 357  *           _wtol    (NTDLL.@)
 358  * Like atol, but for wide character strings.
 359  */
 360 LONG __cdecl _wtol(LPWSTR string)
 361 {
 362     char buffer[30];
 363     NTDLL_wcstombs( buffer, string, sizeof(buffer) );
 364     return atol( buffer );
 365 }
 366
 367 /*********************************************************************
 368  *           _wtoi    (NTDLL.@)
 369  */
 370 INT __cdecl _wtoi(LPWSTR string)
 371 {
 372     return _wtol(string);
 373 }
 374
 375 /* INTERNAL: Wide char snprintf
 376  * If you fix a bug in this function, fix it in msvcrt/wcs.c also!
 377  */
 378 static int __cdecl NTDLL_vsnwprintf(WCHAR *str, unsigned int len,
 379                                     const WCHAR *format, va_list valist)
 380 {
 381   unsigned int written = 0;
 382   const WCHAR *iter = format;
 383   char bufa[256], fmtbufa[64], *fmta;
 384
 385   TRACE("(%d,%s)\n",len,debugstr_w(format));
 386
 387   while (*iter)
 388   {
 389     while (*iter && *iter != (WCHAR)L'%')
 390     {
 391      if (written++ >= len)
 392        return -1;
 393      *str++ = *iter++;
 394     }
 395     if (*iter == (WCHAR)L'%')
 396     {
 397       fmta = fmtbufa;
 398       *fmta++ = *iter++;
 399       while (*iter == (WCHAR)L'0' ||
 400              *iter == (WCHAR)L'+' ||
 401              *iter == (WCHAR)L'-' ||
 402              *iter == (WCHAR)L' ' ||
 403              *iter == (WCHAR)L'0' ||
 404              *iter == (WCHAR)L'*' ||
 405              *iter == (WCHAR)L'#')
 406       {
 407         if (*iter == (WCHAR)L'*')
 408         {
 409           char *buffiter = bufa;
 410           int fieldlen = va_arg(valist, int);
 411           sprintf(buffiter, "%d", fieldlen);
 412           while (*buffiter)
 413             *fmta++ = *buffiter++;
 414         }
 415         else
 416           *fmta++ = *iter;
 417         iter++;
 418       }
 419
 420       while (isdigit(*iter))
 421         *fmta++ = *iter++;
 422
 423       if (*iter == (WCHAR)L'.')
 424       {
 425         *fmta++ = *iter++;
 426         if (*iter == (WCHAR)L'*')
 427         {
 428           char *buffiter = bufa;
 429           int fieldlen = va_arg(valist, int);
 430           sprintf(buffiter, "%d", fieldlen);
 431           while (*buffiter)
 432             *fmta++ = *buffiter++;
 433         }
 434         else
 435           while (isdigit(*iter))
 436             *fmta++ = *iter++;
 437       }
 438       if (*iter == (WCHAR)L'h' ||
 439           *iter == (WCHAR)L'l')
 440       {
 441           *fmta++ = *iter++;
 442           *fmta++ = *iter++;
 443       }
 444
 445       switch (*iter)
 446       {
 447       case (WCHAR)L's':
 448         {
 449           static const WCHAR none[] = { '(', 'n', 'u', 'l', 'l', ')', 0 };
 450           const WCHAR *wstr = va_arg(valist, const WCHAR *);
 451           const WCHAR *striter = wstr ? wstr : none;
 452           while (*striter)
 453           {
 454             if (written++ >= len)
 455               return -1;
 456             *str++ = *striter++;
 457           }
 458           iter++;
 459           break;
 460         }
 461
 462       case (WCHAR)L'c':
 463         if (written++ >= len)
 464           return -1;
 465         *str++ = (WCHAR)va_arg(valist, int);
 466         iter++;
 467         break;
 468
 469       default:
 470         {
 471           /* For non wc types, use system sprintf and append to wide char output */
 472           /* FIXME: for unrecognised types, should ignore % when printing */
 473           char *bufaiter = bufa;
 474           if (*iter == (WCHAR)L'p')
 475             sprintf(bufaiter, "%08lX", va_arg(valist, long));
 476           else
 477           {
 478             *fmta++ = *iter;
 479             *fmta = '\0';
 480             if (*iter == (WCHAR)L'f')
 481               sprintf(bufaiter, fmtbufa, va_arg(valist, double));
 482             else
 483               sprintf(bufaiter, fmtbufa, va_arg(valist, void *));
 484           }
 485           while (*bufaiter)
 486           {
 487             if (written++ >= len)
 488               return -1;
 489             *str++ = *bufaiter++;
 490           }
 491           iter++;
 492           break;
 493         }
 494       }
 495     }
 496   }
 497   if (written >= len)
 498     return -1;
 499   *str++ = (WCHAR)L'\0';
 500   return (int)written;
 501 }
 502
 503
 504 /***********************************************************************
 505  *        _snwprintf (NTDLL.@)
 506  */
 507 int __cdecl _snwprintf(WCHAR *str, unsigned int len, const WCHAR *format, ...)
 508 {
 509   int retval;
 510   va_list valist;
 511   va_start(valist, format);
 512   retval = NTDLL_vsnwprintf(str, len, format, valist);
 513   va_end(valist);
 514   return retval;
 515 }
 516
 517
 518 /***********************************************************************
 519  *        swprintf (NTDLL.@)
 520  */
 521 int __cdecl NTDLL_swprintf(WCHAR *str, const WCHAR *format, ...)
 522 {
 523   int retval;
 524   va_list valist;
 525   va_start(valist, format);
 526   retval = NTDLL_vsnwprintf(str, INT_MAX, format, valist);
 527   va_end(valist);
 528   return retval;
 529 }