libs/wine/string.c

   1 /*
   2  * Unicode string manipulation functions
   3  *
   4  * Copyright 2000 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "wine/asm.h"
  22
  23 #ifdef __ASM_OBSOLETE
  24
  25 #include <assert.h>
  26 #include <errno.h>
  27 #include <limits.h>
  28 #include <stdio.h>
  29 #include <stdarg.h>
  30
  31 #include <windef.h>
  32 #include <winbase.h>
  33 #include <winnls.h>
  34
  35 WCHAR tolowerW( WCHAR ch )
  36 {
  37     extern const WCHAR wine_casemap_lower[];
  38     return ch + wine_casemap_lower[wine_casemap_lower[ch >> 8] + (ch & 0xff)];
  39 }
  40
  41 WCHAR toupperW( WCHAR ch )
  42 {
  43     extern const WCHAR wine_casemap_upper[];
  44     return ch + wine_casemap_upper[wine_casemap_upper[ch >> 8] + (ch & 0xff)];
  45 }
  46
  47 /* the character type contains the C1_* flags in the low 12 bits */
  48 /* and the C2_* type in the high 4 bits */
  49 unsigned short get_char_typeW( WCHAR ch )
  50 {
  51     extern const unsigned short wine_wctype_table[];
  52     return wine_wctype_table[wine_wctype_table[ch >> 8] + (ch & 0xff)];
  53 }
  54
  55 int iscntrlW( WCHAR wc )
  56 {
  57     return get_char_typeW(wc) & C1_CNTRL;
  58 }
  59
  60 int ispunctW( WCHAR wc )
  61 {
  62     return get_char_typeW(wc) & C1_PUNCT;
  63 }
  64
  65 int isspaceW( WCHAR wc )
  66 {
  67     return get_char_typeW(wc) & C1_SPACE;
  68 }
  69
  70 int isdigitW( WCHAR wc )
  71 {
  72     return get_char_typeW(wc) & C1_DIGIT;
  73 }
  74
  75 int isxdigitW( WCHAR wc )
  76 {
  77     return get_char_typeW(wc) & C1_XDIGIT;
  78 }
  79
  80 int islowerW( WCHAR wc )
  81 {
  82     return get_char_typeW(wc) & C1_LOWER;
  83 }
  84
  85 int isupperW( WCHAR wc )
  86 {
  87     return get_char_typeW(wc) & C1_UPPER;
  88 }
  89
  90 int isalnumW( WCHAR wc )
  91 {
  92     return get_char_typeW(wc) & (C1_ALPHA|C1_DIGIT|C1_LOWER|C1_UPPER);
  93 }
  94
  95 int isalphaW( WCHAR wc )
  96 {
  97     return get_char_typeW(wc) & (C1_ALPHA|C1_LOWER|C1_UPPER);
  98 }
  99
 100 int isgraphW( WCHAR wc )
 101 {
 102     return get_char_typeW(wc) & (C1_ALPHA|C1_PUNCT|C1_DIGIT|C1_LOWER|C1_UPPER);
 103 }
 104
 105 int isprintW( WCHAR wc )
 106 {
 107     return get_char_typeW(wc) & (C1_ALPHA|C1_BLANK|C1_PUNCT|C1_DIGIT|C1_LOWER|C1_UPPER);
 108 }
 109
 110 unsigned int strlenW( const WCHAR *str )
 111 {
 112     const WCHAR *s = str;
 113     while (*s) s++;
 114     return s - str;
 115 }
 116
 117 WCHAR *strcpyW( WCHAR *dst, const WCHAR *src )
 118 {
 119     WCHAR *p = dst;
 120     while ((*p++ = *src++));
 121     return dst;
 122 }
 123
 124 int strcmpW( const WCHAR *str1, const WCHAR *str2 )
 125 {
 126     while (*str1 && (*str1 == *str2)) { str1++; str2++; }
 127     return *str1 - *str2;
 128 }
 129
 130 int strncmpW( const WCHAR *str1, const WCHAR *str2, int n )
 131 {
 132     if (n <= 0) return 0;
 133     while ((--n > 0) && *str1 && (*str1 == *str2)) { str1++; str2++; }
 134     return *str1 - *str2;
 135 }
 136
 137 WCHAR *strcatW( WCHAR *dst, const WCHAR *src )
 138 {
 139     strcpyW( dst + strlenW(dst), src );
 140     return dst;
 141 }
 142
 143 WCHAR *strchrW( const WCHAR *str, WCHAR ch )
 144 {
 145     do { if (*str == ch) return (WCHAR *)(ULONG_PTR)str; } while (*str++);
 146     return NULL;
 147 }
 148
 149 WCHAR *strrchrW( const WCHAR *str, WCHAR ch )
 150 {
 151     WCHAR *ret = NULL;
 152     do { if (*str == ch) ret = (WCHAR *)(ULONG_PTR)str; } while (*str++);
 153     return ret;
 154 }
 155
 156 WCHAR *strpbrkW( const WCHAR *str, const WCHAR *accept )
 157 {
 158     for ( ; *str; str++) if (strchrW( accept, *str )) return (WCHAR *)(ULONG_PTR)str;
 159     return NULL;
 160 }
 161
 162 size_t strspnW( const WCHAR *str, const WCHAR *accept )
 163 {
 164     const WCHAR *ptr;
 165     for (ptr = str; *ptr; ptr++) if (!strchrW( accept, *ptr )) break;
 166     return ptr - str;
 167 }
 168
 169 size_t strcspnW( const WCHAR *str, const WCHAR *reject )
 170 {
 171     const WCHAR *ptr;
 172     for (ptr = str; *ptr; ptr++) if (strchrW( reject, *ptr )) break;
 173     return ptr - str;
 174 }
 175
 176 WCHAR *strlwrW( WCHAR *str )
 177 {
 178     WCHAR *ret;
 179     for (ret = str; *str; str++) *str = tolowerW(*str);
 180     return ret;
 181 }
 182
 183 WCHAR *struprW( WCHAR *str )
 184 {
 185     WCHAR *ret;
 186     for (ret = str; *str; str++) *str = toupperW(*str);
 187     return ret;
 188 }
 189
 190 WCHAR *memchrW( const WCHAR *ptr, WCHAR ch, size_t n )
 191 {
 192     const WCHAR *end;
 193     for (end = ptr + n; ptr < end; ptr++) if (*ptr == ch) return (WCHAR *)(ULONG_PTR)ptr;
 194     return NULL;
 195 }
 196
 197 WCHAR *memrchrW( const WCHAR *ptr, WCHAR ch, size_t n )
 198 {
 199     const WCHAR *end;
 200     WCHAR *ret = NULL;
 201     for (end = ptr + n; ptr < end; ptr++) if (*ptr == ch) ret = (WCHAR *)(ULONG_PTR)ptr;
 202     return ret;
 203 }
 204
 205 int strcmpiW( const WCHAR *str1, const WCHAR *str2 )
 206 {
 207     for (;;)
 208     {
 209         int ret = tolowerW(*str1) - tolowerW(*str2);
 210         if (ret || !*str1) return ret;
 211         str1++;
 212         str2++;
 213     }
 214 }
 215
 216 int strncmpiW( const WCHAR *str1, const WCHAR *str2, int n )
 217 {
 218     int ret = 0;
 219     for ( ; n > 0; n--, str1++, str2++)
 220         if ((ret = tolowerW(*str1) - tolowerW(*str2)) || !*str1) break;
 221     return ret;
 222 }
 223
 224 int memicmpW( const WCHAR *str1, const WCHAR *str2, int n )
 225 {
 226     int ret = 0;
 227     for ( ; n > 0; n--, str1++, str2++)
 228         if ((ret = tolowerW(*str1) - tolowerW(*str2))) break;
 229     return ret;
 230 }
 231
 232 WCHAR *strstrW( const WCHAR *str, const WCHAR *sub )
 233 {
 234     while (*str)
 235     {
 236         const WCHAR *p1 = str, *p2 = sub;
 237         while (*p1 && *p2 && *p1 == *p2) { p1++; p2++; }
 238         if (!*p2) return (WCHAR *)str;
 239         str++;
 240     }
 241     return NULL;
 242 }
 243
 244 /* strtolW and strtoulW implementation based on the GNU C library code */
 245 /* Copyright (C) 1991,92,94,95,96,97,98,99,2000,2001 Free Software Foundation, Inc. */
 246
 247 long int strtolW( const WCHAR *nptr, WCHAR **endptr, int base )
 248 {
 249   int negative;
 250   register unsigned long int cutoff;
 251   register unsigned int cutlim;
 252   register unsigned long int i;
 253   register const WCHAR *s;
 254   register WCHAR c;
 255   const WCHAR *save, *end;
 256   int overflow;
 257
 258   if (base < 0 || base == 1 || base > 36) return 0;
 259
 260   save = s = nptr;
 261
 262   /* Skip white space.  */
 263   while (isspaceW (*s))
 264     ++s;
 265   if (!*s) goto noconv;
 266
 267   /* Check for a sign.  */
 268   negative = 0;
 269   if (*s == '-')
 270     {
 271       negative = 1;
 272       ++s;
 273     }
 274   else if (*s == '+')
 275     ++s;
 276
 277   /* Recognize number prefix and if BASE is zero, figure it out ourselves.  */
 278   if (*s == '0')
 279     {
 280       if ((base == 0 || base == 16) && toupperW(s[1]) == 'X')
 281         {
 282           s += 2;
 283           base = 16;
 284         }
 285       else if (base == 0)
 286         base = 8;
 287     }
 288   else if (base == 0)
 289     base = 10;
 290
 291   /* Save the pointer so we can check later if anything happened.  */
 292   save = s;
 293   end = NULL;
 294
 295   cutoff = ULONG_MAX / (unsigned long int) base;
 296   cutlim = ULONG_MAX % (unsigned long int) base;
 297
 298   overflow = 0;
 299   i = 0;
 300   c = *s;
 301   for (;c != '\0'; c = *++s)
 302   {
 303       if (s == end)
 304           break;
 305       if (c >= '0' && c <= '9')
 306           c -= '0';
 307       else if (isalphaW (c))
 308           c = toupperW (c) - 'A' + 10;
 309       else
 310           break;
 311       if ((int) c >= base)
 312           break;
 313       /* Check for overflow.  */
 314       if (i > cutoff || (i == cutoff && c > cutlim))
 315           overflow = 1;
 316       else
 317       {
 318           i *= (unsigned long int) base;
 319           i += c;
 320       }
 321   }
 322
 323   /* Check if anything actually happened.  */
 324   if (s == save)
 325     goto noconv;
 326
 327   /* Store in ENDPTR the address of one character
 328      past the last character we converted.  */
 329   if (endptr != NULL)
 330     *endptr = (WCHAR *)s;
 331
 332   /* Check for a value that is within the range of
 333      `unsigned LONG int', but outside the range of `LONG int'.  */
 334   if (overflow == 0
 335       && i > (negative
 336               ? -((unsigned long int) (LONG_MIN + 1)) + 1
 337               : (unsigned long int) LONG_MAX))
 338     overflow = 1;
 339
 340   if (overflow)
 341     {
 342       errno = ERANGE;
 343       return negative ? LONG_MIN : LONG_MAX;
 344     }
 345
 346   /* Return the result of the appropriate sign.  */
 347   return negative ? -i : i;
 348
 349 noconv:
 350   /* We must handle a special case here: the base is 0 or 16 and the
 351      first two characters are '0' and 'x', but the rest are not
 352      hexadecimal digits.  This is no error case.  We return 0 and
 353      ENDPTR points to the `x`.  */
 354   if (endptr != NULL)
 355     {
 356       if (save - nptr >= 2 && toupperW (save[-1]) == 'X'
 357           && save[-2] == '0')
 358         *endptr = (WCHAR *)&save[-1];
 359       else
 360         /*  There was no number to convert.  */
 361         *endptr = (WCHAR *)nptr;
 362     }
 363
 364   return 0L;
 365 }
 366
 367
 368 unsigned long int strtoulW( const WCHAR *nptr, WCHAR **endptr, int base )
 369 {
 370   int negative;
 371   register unsigned long int cutoff;
 372   register unsigned int cutlim;
 373   register unsigned long int i;
 374   register const WCHAR *s;
 375   register WCHAR c;
 376   const WCHAR *save, *end;
 377   int overflow;
 378
 379   if (base < 0 || base == 1 || base > 36) return 0;
 380
 381   save = s = nptr;
 382
 383   /* Skip white space.  */
 384   while (isspaceW (*s))
 385     ++s;
 386   if (!*s) goto noconv;
 387
 388   /* Check for a sign.  */
 389   negative = 0;
 390   if (*s == '-')
 391     {
 392       negative = 1;
 393       ++s;
 394     }
 395   else if (*s == '+')
 396     ++s;
 397
 398   /* Recognize number prefix and if BASE is zero, figure it out ourselves.  */
 399   if (*s == '0')
 400     {
 401       if ((base == 0 || base == 16) && toupperW(s[1]) == 'X')
 402         {
 403           s += 2;
 404           base = 16;
 405         }
 406       else if (base == 0)
 407         base = 8;
 408     }
 409   else if (base == 0)
 410     base = 10;
 411
 412   /* Save the pointer so we can check later if anything happened.  */
 413   save = s;
 414   end = NULL;
 415
 416   cutoff = ULONG_MAX / (unsigned long int) base;
 417   cutlim = ULONG_MAX % (unsigned long int) base;
 418
 419   overflow = 0;
 420   i = 0;
 421   c = *s;
 422   for (;c != '\0'; c = *++s)
 423   {
 424       if (s == end)
 425           break;
 426       if (c >= '0' && c <= '9')
 427           c -= '0';
 428       else if (isalphaW (c))
 429           c = toupperW (c) - 'A' + 10;
 430       else
 431           break;
 432       if ((int) c >= base)
 433           break;
 434       /* Check for overflow.  */
 435       if (i > cutoff || (i == cutoff && c > cutlim))
 436           overflow = 1;
 437       else
 438       {
 439           i *= (unsigned long int) base;
 440           i += c;
 441       }
 442   }
 443
 444   /* Check if anything actually happened.  */
 445   if (s == save)
 446     goto noconv;
 447
 448   /* Store in ENDPTR the address of one character
 449      past the last character we converted.  */
 450   if (endptr != NULL)
 451     *endptr = (WCHAR *)s;
 452
 453   if (overflow)
 454     {
 455       errno = ERANGE;
 456       return ULONG_MAX;
 457     }
 458
 459   /* Return the result of the appropriate sign.  */
 460   return negative ? -i : i;
 461
 462 noconv:
 463   /* We must handle a special case here: the base is 0 or 16 and the
 464      first two characters are '0' and 'x', but the rest are not
 465      hexadecimal digits.  This is no error case.  We return 0 and
 466      ENDPTR points to the `x`.  */
 467   if (endptr != NULL)
 468     {
 469       if (save - nptr >= 2 && toupperW (save[-1]) == 'X'
 470           && save[-2] == '0')
 471         *endptr = (WCHAR *)&save[-1];
 472       else
 473         /*  There was no number to convert.  */
 474         *endptr = (WCHAR *)nptr;
 475     }
 476
 477   return 0L;
 478 }
 479
 480 long int atolW( const WCHAR *str )
 481 {
 482     return strtolW( str, NULL, 10 );
 483 }
 484
 485 int atoiW( const WCHAR *str )
 486 {
 487     return (int)atolW( str );
 488 }
 489
 490
 491 /* format a WCHAR string according to a printf format; helper for vsnprintfW */
 492 static size_t format_string( WCHAR *buffer, size_t len, const char *format, const WCHAR *str, int str_len )
 493 {
 494     size_t count = 0;
 495     int i, left_align = 0, width = 0, max = 0;
 496
 497     assert( *format == '%' );
 498     format++; /* skip '%' */
 499
 500     while (*format == '0' || *format == '+' || *format == '-' || *format == ' ' || *format == '#')
 501     {
 502         if (*format == '-') left_align = 1;
 503         format++;
 504     }
 505
 506     while (isdigit(*format)) width = width * 10 + *format++ - '0';
 507
 508     if (str_len == -1) str_len = strlenW( str );
 509     if (*format == '.')
 510     {
 511         format++;
 512         while (isdigit(*format)) max = max * 10 + *format++ - '0';
 513         if (max > str_len) max = str_len;
 514     }
 515     else max = str_len;
 516
 517     if (*format == 'h' || *format == 'l') format++;
 518
 519     assert( *format == 's' );
 520
 521     if (!left_align && width > max)
 522     {
 523         for (i = 0; i < width - max; i++)
 524         {
 525             if (count++ < len)
 526                 *buffer++ = ' ';
 527         }
 528     }
 529
 530     if (count < len)
 531         memcpy( buffer, str, min( max, len - count ) * sizeof(WCHAR) );
 532     count += max;
 533     buffer += max;
 534
 535     if (left_align && width > max)
 536     {
 537         for (i = 0; i < width - max; i++)
 538         {
 539             if (count++ < len)
 540                 *buffer++ = ' ';
 541         }
 542     }
 543     return count;
 544 }
 545
 546 int vsnprintfW(WCHAR *str, size_t len, const WCHAR *format, va_list valist)
 547 {
 548     unsigned int written = 0;
 549     const WCHAR *iter = format;
 550     char bufa[512], fmtbufa[64], *fmta;
 551
 552     while (*iter)
 553     {
 554         while (*iter && *iter != '%')
 555         {
 556             if (written++ < len)
 557                 *str++ = *iter;
 558             iter++;
 559         }
 560         if (*iter == '%')
 561         {
 562             if (iter[1] == '%')
 563             {
 564                 if (written++ < len)
 565                     *str++ = '%'; /* "%%"->'%' */
 566                 iter += 2;
 567                 continue;
 568             }
 569
 570             fmta = fmtbufa;
 571             *fmta++ = *iter++;
 572             while (*iter == '0' ||
 573                    *iter == '+' ||
 574                    *iter == '-' ||
 575                    *iter == ' ' ||
 576                    *iter == '*' ||
 577                    *iter == '#')
 578             {
 579                 if (*iter == '*')
 580                 {
 581                     char *buffiter = bufa;
 582                     int fieldlen = va_arg(valist, int);
 583                     sprintf(buffiter, "%d", fieldlen);
 584                     while (*buffiter)
 585                         *fmta++ = *buffiter++;
 586                 }
 587                 else
 588                     *fmta++ = *iter;
 589                 iter++;
 590             }
 591
 592             while (isdigit(*iter))
 593                 *fmta++ = *iter++;
 594
 595             if (*iter == '.')
 596             {
 597                 *fmta++ = *iter++;
 598                 if (*iter == '*')
 599                 {
 600                     char *buffiter = bufa;
 601                     int fieldlen = va_arg(valist, int);
 602                     sprintf(buffiter, "%d", fieldlen);
 603                     while (*buffiter)
 604                         *fmta++ = *buffiter++;
 605                     iter++;
 606                 }
 607                 else
 608                     while (isdigit(*iter))
 609                         *fmta++ = *iter++;
 610             }
 611             if (*iter == 'h' || *iter == 'l')
 612                 *fmta++ = *iter++;
 613
 614             switch (*iter)
 615             {
 616             case 's':
 617             {
 618                 static const WCHAR none[] = { '(','n','u','l','l',')',0 };
 619                 const WCHAR *wstr = va_arg(valist, const WCHAR *);
 620                 size_t remaining = written < len ? len - written : 0;
 621                 size_t count;
 622
 623                 *fmta++ = 's';
 624                 *fmta = 0;
 625                 count = format_string( str, remaining, fmtbufa, wstr ? wstr : none, -1 );
 626                 str += min( count, remaining );
 627                 written += count;
 628                 iter++;
 629                 break;
 630             }
 631
 632             case 'c':
 633             {
 634                 WCHAR wstr;
 635                 size_t remaining = written < len ? len - written : 0;
 636                 size_t count;
 637
 638                 wstr = va_arg(valist, int);
 639                 *fmta++ = 's';
 640                 *fmta = 0;
 641                 count = format_string( str, remaining, fmtbufa, &wstr, 1 );
 642                 str += min( count, remaining );
 643                 written += count;
 644                 iter++;
 645                 break;
 646             }
 647
 648             default:
 649             {
 650                 /* For non wc types, use system sprintf and append to wide char output */
 651                 /* FIXME: for unrecognised types, should ignore % when printing */
 652                 char *bufaiter = bufa;
 653                 if (*iter == 'p')
 654                     sprintf(bufaiter, "%0*lX", 2 * (int)sizeof(void*),
 655                             (unsigned long)va_arg(valist, void *));
 656                 else
 657                 {
 658                     *fmta++ = *iter;
 659                     *fmta = '\0';
 660                     if (*iter == 'a' || *iter == 'A' ||
 661                         *iter == 'e' || *iter == 'E' ||
 662                         *iter == 'f' || *iter == 'F' ||
 663                         *iter == 'g' || *iter == 'G')
 664                         sprintf(bufaiter, fmtbufa, va_arg(valist, double));
 665                     else
 666                     {
 667                         /* FIXME: On 32 bit systems this doesn't handle int 64's. */
 668                         sprintf(bufaiter, fmtbufa, va_arg(valist, void *));
 669                     }
 670                 }
 671                 while (*bufaiter)
 672                 {
 673                     if (written++ < len)
 674                         *str++ = *bufaiter;
 675                     bufaiter++;
 676                 }
 677                 iter++;
 678                 break;
 679             }
 680             }
 681         }
 682     }
 683     if (len)
 684     {
 685         if (written >= len)
 686             str--;
 687         *str++ = 0;
 688     }
 689
 690     /* FIXME: POSIX [v]snprintf() returns the equivalent of written, not -1, on short buffer. */
 691     return written < len ? (int)written : -1;
 692 }
 693
 694 int vsprintfW( WCHAR *str, const WCHAR *format, va_list valist )
 695 {
 696     return vsnprintfW( str, INT_MAX, format, valist );
 697 }
 698
 699 int snprintfW( WCHAR *str, size_t len, const WCHAR *format, ...)
 700 {
 701     int retval;
 702     va_list valist;
 703     va_start(valist, format);
 704     retval = vsnprintfW(str, len, format, valist);
 705     va_end(valist);
 706     return retval;
 707 }
 708
 709 int sprintfW( WCHAR *str, const WCHAR *format, ...)
 710 {
 711     int retval;
 712     va_list valist;
 713     va_start(valist, format);
 714     retval = vsnprintfW(str, INT_MAX, format, valist);
 715     va_end(valist);
 716     return retval;
 717 }
 718
 719 #endif /* __ASM_OBSOLETE */