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 <assert.h>
  22 #include <limits.h>
  23 #include <stdio.h>
  24
  25 #define WINE_UNICODE_INLINE  /* nothing */
  26 #include "wine/unicode.h"
  27
  28 int strcmpiW( const WCHAR *str1, const WCHAR *str2 )
  29 {
  30     for (;;)
  31     {
  32         int ret = tolowerW(*str1) - tolowerW(*str2);
  33         if (ret || !*str1) return ret;
  34         str1++;
  35         str2++;
  36     }
  37 }
  38
  39 int strncmpiW( const WCHAR *str1, const WCHAR *str2, int n )
  40 {
  41     int ret = 0;
  42     for ( ; n > 0; n--, str1++, str2++)
  43         if ((ret = tolowerW(*str1) - tolowerW(*str2)) || !*str1) break;
  44     return ret;
  45 }
  46
  47 int memicmpW( const WCHAR *str1, const WCHAR *str2, int n )
  48 {
  49     int ret = 0;
  50     for ( ; n > 0; n--, str1++, str2++)
  51         if ((ret = tolowerW(*str1) - tolowerW(*str2))) break;
  52     return ret;
  53 }
  54
  55 WCHAR *strstrW( const WCHAR *str, const WCHAR *sub )
  56 {
  57     while (*str)
  58     {
  59         const WCHAR *p1 = str, *p2 = sub;
  60         while (*p1 && *p2 && *p1 == *p2) { p1++; p2++; }
  61         if (!*p2) return (WCHAR *)str;
  62         str++;
  63     }
  64     return NULL;
  65 }
  66
  67 /* strtolW and strtoulW implementation based on the GNU C library code */
  68 /* Copyright (C) 1991,92,94,95,96,97,98,99,2000,2001 Free Software Foundation, Inc. */
  69
  70 long int strtolW( const WCHAR *nptr, WCHAR **endptr, int base )
  71 {
  72   int negative;
  73   register unsigned long int cutoff;
  74   register unsigned int cutlim;
  75   register unsigned long int i;
  76   register const WCHAR *s;
  77   register WCHAR c;
  78   const WCHAR *save, *end;
  79   int overflow;
  80
  81   if (base < 0 || base == 1 || base > 36) return 0;
  82
  83   save = s = nptr;
  84
  85   /* Skip white space.  */
  86   while (isspaceW (*s))
  87     ++s;
  88   if (!*s) goto noconv;
  89
  90   /* Check for a sign.  */
  91   negative = 0;
  92   if (*s == '-')
  93     {
  94       negative = 1;
  95       ++s;
  96     }
  97   else if (*s == '+')
  98     ++s;
  99
 100   /* Recognize number prefix and if BASE is zero, figure it out ourselves.  */
 101   if (*s == '0')
 102     {
 103       if ((base == 0 || base == 16) && toupperW(s[1]) == 'X')
 104         {
 105           s += 2;
 106           base = 16;
 107         }
 108       else if (base == 0)
 109         base = 8;
 110     }
 111   else if (base == 0)
 112     base = 10;
 113
 114   /* Save the pointer so we can check later if anything happened.  */
 115   save = s;
 116   end = NULL;
 117
 118   cutoff = ULONG_MAX / (unsigned long int) base;
 119   cutlim = ULONG_MAX % (unsigned long int) base;
 120
 121   overflow = 0;
 122   i = 0;
 123   c = *s;
 124   for (;c != '\0'; c = *++s)
 125   {
 126       if (s == end)
 127           break;
 128       if (c >= '0' && c <= '9')
 129           c -= '0';
 130       else if (isalphaW (c))
 131           c = toupperW (c) - 'A' + 10;
 132       else
 133           break;
 134       if ((int) c >= base)
 135           break;
 136       /* Check for overflow.  */
 137       if (i > cutoff || (i == cutoff && c > cutlim))
 138           overflow = 1;
 139       else
 140       {
 141           i *= (unsigned long int) base;
 142           i += c;
 143       }
 144   }
 145
 146   /* Check if anything actually happened.  */
 147   if (s == save)
 148     goto noconv;
 149
 150   /* Store in ENDPTR the address of one character
 151      past the last character we converted.  */
 152   if (endptr != NULL)
 153     *endptr = (WCHAR *)s;
 154
 155   /* Check for a value that is within the range of
 156      `unsigned LONG int', but outside the range of `LONG int'.  */
 157   if (overflow == 0
 158       && i > (negative
 159               ? -((unsigned long int) (LONG_MIN + 1)) + 1
 160               : (unsigned long int) LONG_MAX))
 161     overflow = 1;
 162
 163   if (overflow)
 164     {
 165       return negative ? LONG_MIN : LONG_MAX;
 166     }
 167
 168   /* Return the result of the appropriate sign.  */
 169   return negative ? -i : i;
 170
 171 noconv:
 172   /* We must handle a special case here: the base is 0 or 16 and the
 173      first two characters are '0' and 'x', but the rest are not
 174      hexadecimal digits.  This is no error case.  We return 0 and
 175      ENDPTR points to the `x`.  */
 176   if (endptr != NULL)
 177     {
 178       if (save - nptr >= 2 && toupperW (save[-1]) == 'X'
 179           && save[-2] == '0')
 180         *endptr = (WCHAR *)&save[-1];
 181       else
 182         /*  There was no number to convert.  */
 183         *endptr = (WCHAR *)nptr;
 184     }
 185
 186   return 0L;
 187 }
 188
 189
 190 unsigned long int strtoulW( const WCHAR *nptr, WCHAR **endptr, int base )
 191 {
 192   int negative;
 193   register unsigned long int cutoff;
 194   register unsigned int cutlim;
 195   register unsigned long int i;
 196   register const WCHAR *s;
 197   register WCHAR c;
 198   const WCHAR *save, *end;
 199   int overflow;
 200
 201   if (base < 0 || base == 1 || base > 36) return 0;
 202
 203   save = s = nptr;
 204
 205   /* Skip white space.  */
 206   while (isspaceW (*s))
 207     ++s;
 208   if (!*s) goto noconv;
 209
 210   /* Check for a sign.  */
 211   negative = 0;
 212   if (*s == '-')
 213     {
 214       negative = 1;
 215       ++s;
 216     }
 217   else if (*s == '+')
 218     ++s;
 219
 220   /* Recognize number prefix and if BASE is zero, figure it out ourselves.  */
 221   if (*s == '0')
 222     {
 223       if ((base == 0 || base == 16) && toupperW(s[1]) == 'X')
 224         {
 225           s += 2;
 226           base = 16;
 227         }
 228       else if (base == 0)
 229         base = 8;
 230     }
 231   else if (base == 0)
 232     base = 10;
 233
 234   /* Save the pointer so we can check later if anything happened.  */
 235   save = s;
 236   end = NULL;
 237
 238   cutoff = ULONG_MAX / (unsigned long int) base;
 239   cutlim = ULONG_MAX % (unsigned long int) base;
 240
 241   overflow = 0;
 242   i = 0;
 243   c = *s;
 244   for (;c != '\0'; c = *++s)
 245   {
 246       if (s == end)
 247           break;
 248       if (c >= '0' && c <= '9')
 249           c -= '0';
 250       else if (isalphaW (c))
 251           c = toupperW (c) - 'A' + 10;
 252       else
 253           break;
 254       if ((int) c >= base)
 255           break;
 256       /* Check for overflow.  */
 257       if (i > cutoff || (i == cutoff && c > cutlim))
 258           overflow = 1;
 259       else
 260       {
 261           i *= (unsigned long int) base;
 262           i += c;
 263       }
 264   }
 265
 266   /* Check if anything actually happened.  */
 267   if (s == save)
 268     goto noconv;
 269
 270   /* Store in ENDPTR the address of one character
 271      past the last character we converted.  */
 272   if (endptr != NULL)
 273     *endptr = (WCHAR *)s;
 274
 275   if (overflow)
 276     {
 277       return ULONG_MAX;
 278     }
 279
 280   /* Return the result of the appropriate sign.  */
 281   return negative ? -i : i;
 282
 283 noconv:
 284   /* We must handle a special case here: the base is 0 or 16 and the
 285      first two characters are '0' and 'x', but the rest are not
 286      hexadecimal digits.  This is no error case.  We return 0 and
 287      ENDPTR points to the `x`.  */
 288   if (endptr != NULL)
 289     {
 290       if (save - nptr >= 2 && toupperW (save[-1]) == 'X'
 291           && save[-2] == '0')
 292         *endptr = (WCHAR *)&save[-1];
 293       else
 294         /*  There was no number to convert.  */
 295         *endptr = (WCHAR *)nptr;
 296     }
 297
 298   return 0L;
 299 }
 300
 301
 302 /* format a WCHAR string according to a printf format; helper for vsnprintfW */
 303 static size_t format_string( WCHAR *buffer, size_t len, const char *format, const WCHAR *str, int str_len )
 304 {
 305     size_t count = 0;
 306     int i, left_align = 0, width = 0, max = 0;
 307
 308     assert( *format == '%' );
 309     format++; /* skip '%' */
 310
 311     while (*format == '0' || *format == '+' || *format == '-' || *format == ' ' || *format == '#')
 312     {
 313         if (*format == '-') left_align = 1;
 314         format++;
 315     }
 316
 317     while (isdigit(*format)) width = width * 10 + *format++ - '0';
 318
 319     if (str_len == -1) str_len = strlenW( str );
 320     if (*format == '.')
 321     {
 322         format++;
 323         while (isdigit(*format)) max = max * 10 + *format++ - '0';
 324         if (max > str_len) max = str_len;
 325     }
 326     else max = str_len;
 327
 328     if (*format == 'h' || *format == 'l') format++;
 329
 330     assert( *format == 's' );
 331
 332     if (!left_align && width > max)
 333     {
 334         for (i = 0; i < width - max; i++)
 335         {
 336             if (count++ < len)
 337                 *buffer++ = ' ';
 338         }
 339     }
 340
 341     if (count < len)
 342         memcpy( buffer, str, min( max, len - count ) * sizeof(WCHAR) );
 343     count += max;
 344     buffer += max;
 345
 346     if (left_align && width > max)
 347     {
 348         for (i = 0; i < width - max; i++)
 349         {
 350             if (count++ < len)
 351                 *buffer++ = ' ';
 352         }
 353     }
 354     return count;
 355 }
 356
 357 int vsnprintfW(WCHAR *str, size_t len, const WCHAR *format, va_list valist)
 358 {
 359     unsigned int written = 0;
 360     const WCHAR *iter = format;
 361     char bufa[512], fmtbufa[64], *fmta;
 362
 363     while (*iter)
 364     {
 365         while (*iter && *iter != '%')
 366         {
 367             if (written++ < len)
 368                 *str++ = *iter;
 369             iter++;
 370         }
 371         if (*iter == '%')
 372         {
 373             if (iter[1] == '%')
 374             {
 375                 if (written++ < len)
 376                     *str++ = '%'; /* "%%"->'%' */
 377                 iter += 2;
 378                 continue;
 379             }
 380
 381             fmta = fmtbufa;
 382             *fmta++ = *iter++;
 383             while (*iter == '0' ||
 384                    *iter == '+' ||
 385                    *iter == '-' ||
 386                    *iter == ' ' ||
 387                    *iter == '*' ||
 388                    *iter == '#')
 389             {
 390                 if (*iter == '*')
 391                 {
 392                     char *buffiter = bufa;
 393                     int fieldlen = va_arg(valist, int);
 394                     sprintf(buffiter, "%d", fieldlen);
 395                     while (*buffiter)
 396                         *fmta++ = *buffiter++;
 397                 }
 398                 else
 399                     *fmta++ = *iter;
 400                 iter++;
 401             }
 402
 403             while (isdigit(*iter))
 404                 *fmta++ = *iter++;
 405
 406             if (*iter == '.')
 407             {
 408                 *fmta++ = *iter++;
 409                 if (*iter == '*')
 410                 {
 411                     char *buffiter = bufa;
 412                     int fieldlen = va_arg(valist, int);
 413                     sprintf(buffiter, "%d", fieldlen);
 414                     while (*buffiter)
 415                         *fmta++ = *buffiter++;
 416                     iter++;
 417                 }
 418                 else
 419                     while (isdigit(*iter))
 420                         *fmta++ = *iter++;
 421             }
 422             if (*iter == 'h' || *iter == 'l')
 423                 *fmta++ = *iter++;
 424
 425             switch (*iter)
 426             {
 427             case 's':
 428             {
 429                 static const WCHAR none[] = { '(','n','u','l','l',')',0 };
 430                 const WCHAR *wstr = va_arg(valist, const WCHAR *);
 431                 size_t remaining = written < len ? len - written : 0;
 432                 size_t count;
 433
 434                 *fmta++ = 's';
 435                 *fmta = 0;
 436                 count = format_string( str, remaining, fmtbufa, wstr ? wstr : none, -1 );
 437                 str += min( count, remaining );
 438                 written += count;
 439                 iter++;
 440                 break;
 441             }
 442
 443             case 'c':
 444             {
 445                 WCHAR wstr;
 446                 size_t remaining = written < len ? len - written : 0;
 447                 size_t count;
 448
 449                 wstr = va_arg(valist, int);
 450                 *fmta++ = 's';
 451                 *fmta = 0;
 452                 count = format_string( str, remaining, fmtbufa, &wstr, 1 );
 453                 str += min( count, remaining );
 454                 written += count;
 455                 iter++;
 456                 break;
 457             }
 458
 459             default:
 460             {
 461                 /* For non wc types, use system sprintf and append to wide char output */
 462                 /* FIXME: for unrecognised types, should ignore % when printing */
 463                 char *bufaiter = bufa;
 464                 if (*iter == 'p')
 465                     sprintf(bufaiter, "%0*lX", 2 * (int)sizeof(void*),
 466                             (unsigned long)va_arg(valist, void *));
 467                 else
 468                 {
 469                     *fmta++ = *iter;
 470                     *fmta = '\0';
 471                     if (*iter == 'a' || *iter == 'A' ||
 472                         *iter == 'e' || *iter == 'E' ||
 473                         *iter == 'f' || *iter == 'F' ||
 474                         *iter == 'g' || *iter == 'G')
 475                         sprintf(bufaiter, fmtbufa, va_arg(valist, double));
 476                     else
 477                     {
 478                         /* FIXME: On 32 bit systems this doesn't handle int 64's. */
 479                         sprintf(bufaiter, fmtbufa, va_arg(valist, void *));
 480                     }
 481                 }
 482                 while (*bufaiter)
 483                 {
 484                     if (written++ < len)
 485                         *str++ = *bufaiter;
 486                     bufaiter++;
 487                 }
 488                 iter++;
 489                 break;
 490             }
 491             }
 492         }
 493     }
 494     if (len)
 495     {
 496         if (written >= len)
 497             str--;
 498         *str++ = 0;
 499     }
 500
 501     /* FIXME: POSIX [v]snprintf() returns the equivalent of written, not -1, on short buffer. */
 502     return written < len ? (int)written : -1;
 503 }
 504
 505 int vsprintfW( WCHAR *str, const WCHAR *format, va_list valist )
 506 {
 507     return vsnprintfW( str, INT_MAX, format, valist );
 508 }
 509
 510 int snprintfW( WCHAR *str, size_t len, const WCHAR *format, ...)
 511 {
 512     int retval;
 513     va_list valist;
 514     va_start(valist, format);
 515     retval = vsnprintfW(str, len, format, valist);
 516     va_end(valist);
 517     return retval;
 518 }
 519
 520 int sprintfW( WCHAR *str, const WCHAR *format, ...)
 521 {
 522     int retval;
 523     va_list valist;
 524     va_start(valist, format);
 525     retval = vsnprintfW(str, INT_MAX, format, valist);
 526     va_end(valist);
 527     return retval;
 528 }