xpcom/glue/nsStringAPI.cpp

   1 /* vim:set ts=2 sw=2 et cindent: */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is Mozilla.
  16  *
  17  * The Initial Developer of the Original Code is IBM Corporation.
  18  * Portions created by IBM Corporation are Copyright (C) 2003
  19  * IBM Corporation.  All Rights Reserved.
  20  *
  21  * Contributor(s):
  22  *   Darin Fisher <darin@meer.net>
  23  *   Benjamin Smedberg <benjamin@smedbergs.us>
  24  *   Ben Turner <mozilla@songbirdnest.com>
  25  *   Prasad Sunkari <prasad@medhas.org>
  26  *
  27  * Alternatively, the contents of this file may be used under the terms of
  28  * either the GNU General Public License Version 2 or later (the "GPL"), or
  29  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  30  * in which case the provisions of the GPL or the LGPL are applicable instead
  31  * of those above. If you wish to allow use of your version of this file only
  32  * under the terms of either the GPL or the LGPL, and not to allow others to
  33  * use your version of this file under the terms of the MPL, indicate your
  34  * decision by deleting the provisions above and replace them with the notice
  35  * and other provisions required by the GPL or the LGPL. If you do not delete
  36  * the provisions above, a recipient may use your version of this file under
  37  * the terms of any one of the MPL, the GPL or the LGPL.
  38  *
  39  * ***** END LICENSE BLOCK ***** */
  40
  41 #include "nscore.h"
  42 #include "nsCRTGlue.h"
  43 #include "prprf.h"
  44 #include "nsStringAPI.h"
  45 #include "nsXPCOMStrings.h"
  46 #include "nsDebug.h"
  47
  48 #include <stdio.h>
  49
  50 #ifdef XP_WIN
  51 #define snprintf _snprintf
  52 #endif
  53
  54 // nsAString
  55
  56 PRUint32
  57 nsAString::BeginReading(const char_type **begin, const char_type **end) const
  58 {
  59   PRUint32 len = NS_StringGetData(*this, begin);
  60   if (end)
  61     *end = *begin + len;
  62
  63   return len;
  64 }
  65
  66 const nsAString::char_type*
  67 nsAString::BeginReading() const
  68 {
  69   const char_type *data;
  70   NS_StringGetData(*this, &data);
  71   return data;
  72 }
  73
  74 const nsAString::char_type*
  75 nsAString::EndReading() const
  76 {
  77   const char_type *data;
  78   PRUint32 len = NS_StringGetData(*this, &data);
  79   return data + len;
  80 }
  81
  82 PRUint32
  83 nsAString::BeginWriting(char_type **begin, char_type **end, PRUint32 newSize)
  84 {
  85   PRUint32 len = NS_StringGetMutableData(*this, newSize, begin);
  86   if (end)
  87     *end = *begin + len;
  88
  89   return len;
  90 }
  91
  92 nsAString::char_type*
  93 nsAString::BeginWriting(PRUint32 aLen)
  94 {
  95   char_type *data;
  96   NS_StringGetMutableData(*this, aLen, &data);
  97   return data;
  98 }
  99
 100 nsAString::char_type*
 101 nsAString::EndWriting()
 102 {
 103   char_type *data;
 104   PRUint32 len = NS_StringGetMutableData(*this, PR_UINT32_MAX, &data);
 105   return data + len;
 106 }
 107
 108 PRBool
 109 nsAString::SetLength(PRUint32 aLen)
 110 {
 111   char_type *data;
 112   NS_StringGetMutableData(*this, aLen, &data);
 113   return data != nsnull;
 114 }
 115
 116 void
 117 nsAString::AssignLiteral(const char *aStr)
 118 {
 119   PRUint32 len = strlen(aStr);
 120   PRUnichar *buf = BeginWriting(len);
 121   if (!buf)
 122     return;
 123
 124   for (; *aStr; ++aStr, ++buf)
 125     *buf = *aStr;
 126 }
 127
 128 void
 129 nsAString::AppendLiteral(const char *aASCIIStr)
 130 {
 131   PRUint32 appendLen = strlen(aASCIIStr);
 132
 133   PRUint32 thisLen = Length();
 134   PRUnichar *begin, *end;
 135   BeginWriting(&begin, &end, appendLen + thisLen);
 136   if (!begin)
 137     return;
 138
 139   for (begin += thisLen; begin < end; ++begin, ++aASCIIStr)
 140     *begin = *aASCIIStr;
 141 }
 142
 143 void
 144 nsAString::StripChars(const char *aSet)
 145 {
 146   nsString copy(*this);
 147
 148   const char_type *source, *sourceEnd;
 149   copy.BeginReading(&source, &sourceEnd);
 150
 151   char_type *dest;
 152   BeginWriting(&dest);
 153   if (!dest)
 154     return;
 155
 156   char_type *curDest = dest;
 157
 158   for (; source < sourceEnd; ++source) {
 159     const char *test;
 160     for (test = aSet; *test; ++test) {
 161       if (*source == char_type(*test))
 162         break;
 163     }
 164
 165     if (!*test) {
 166       // not stripped, copy this char
 167       *curDest = *source;
 168       ++curDest;
 169     }
 170   }
 171
 172   SetLength(curDest - dest);
 173 }
 174
 175 void
 176 nsAString::Trim(const char *aSet, PRBool aLeading, PRBool aTrailing)
 177 {
 178   NS_ASSERTION(aLeading || aTrailing, "Ineffective Trim");
 179
 180   const PRUnichar *start, *end;
 181   PRUint32 cutLen;
 182
 183   if (aLeading) {
 184     BeginReading(&start, &end);
 185     for (cutLen = 0; start < end; ++start, ++cutLen) {
 186       const char *test;
 187       for (test = aSet; *test; ++test) {
 188         if (*test == *start)
 189           break;
 190       }
 191       if (!*test)
 192         break;
 193     }
 194     if (cutLen) {
 195       NS_StringCutData(*this, 0, cutLen);
 196     }
 197   }
 198   if (aTrailing) {
 199     PRUint32 len = BeginReading(&start, &end);
 200     --end;
 201     for (cutLen = 0; end >= start; --end, ++cutLen) {
 202       const char *test;
 203       for (test = aSet; *test; ++test) {
 204         if (*test == *end)
 205           break;
 206       }
 207       if (!*test)
 208         break;
 209     }
 210     if (cutLen) {
 211       NS_StringCutData(*this, len - cutLen, cutLen);
 212     }
 213   }
 214 }
 215
 216 PRInt32
 217 nsAString::DefaultComparator(const char_type *a, const char_type *b,
 218                              PRUint32 len)
 219 {
 220   for (const char_type *end = a + len; a < end; ++a, ++b) {
 221     if (*a == *b)
 222       continue;
 223
 224     return *a < *b ? -1 : 1;
 225   }
 226
 227   return 0;
 228 }
 229
 230 PRInt32
 231 nsAString::Compare(const char_type *other, ComparatorFunc c) const
 232 {
 233   const char_type *cself;
 234   PRUint32 selflen = NS_StringGetData(*this, &cself);
 235   PRUint32 otherlen = NS_strlen(other);
 236   PRUint32 comparelen = selflen <= otherlen ? selflen : otherlen;
 237
 238   PRInt32 result = c(cself, other, comparelen);
 239   if (result == 0) {
 240     if (selflen < otherlen)
 241       return -1;
 242     else if (selflen > otherlen)
 243       return 1;
 244   }
 245   return result;
 246 }
 247
 248 PRInt32
 249 nsAString::Compare(const self_type &other, ComparatorFunc c) const
 250 {
 251   const char_type *cself, *cother;
 252   PRUint32 selflen = NS_StringGetData(*this, &cself);
 253   PRUint32 otherlen = NS_StringGetData(other, &cother);
 254   PRUint32 comparelen = selflen <= otherlen ? selflen : otherlen;
 255
 256   PRInt32 result = c(cself, cother, comparelen);
 257   if (result == 0) {
 258     if (selflen < otherlen)
 259       return -1;
 260     else if (selflen > otherlen)
 261       return 1;
 262   }
 263   return result;
 264 }
 265
 266 PRBool
 267 nsAString::Equals(const char_type *other, ComparatorFunc c) const
 268 {
 269   const char_type *cself;
 270   PRUint32 selflen = NS_StringGetData(*this, &cself);
 271   PRUint32 otherlen = NS_strlen(other);
 272
 273   if (selflen != otherlen)
 274     return PR_FALSE;
 275
 276   return c(cself, other, selflen) == 0;
 277 }
 278
 279 PRBool
 280 nsAString::Equals(const self_type &other, ComparatorFunc c) const
 281 {
 282   const char_type *cself;
 283   const char_type *cother;
 284   PRUint32 selflen = NS_StringGetData(*this, &cself);
 285   PRUint32 otherlen = NS_StringGetData(other, &cother);
 286
 287   if (selflen != otherlen)
 288     return PR_FALSE;
 289
 290   return c(cself, cother, selflen) == 0;
 291 }
 292
 293 PRBool
 294 nsAString::EqualsLiteral(const char *aASCIIString) const
 295 {
 296   const PRUnichar *begin, *end;
 297   BeginReading(&begin, &end);
 298
 299   for (; begin < end; ++begin, ++aASCIIString) {
 300     if (!*aASCIIString || !NS_IsAscii(*begin) ||
 301         (char) *begin != *aASCIIString) {
 302       return PR_FALSE;
 303     }
 304   }
 305
 306   return *aASCIIString == nsnull;
 307 }
 308
 309 PRBool
 310 nsAString::LowerCaseEqualsLiteral(const char *aASCIIString) const
 311 {
 312   const PRUnichar *begin, *end;
 313   BeginReading(&begin, &end);
 314
 315   for (; begin < end; ++begin, ++aASCIIString) {
 316     if (!*aASCIIString || !NS_IsAscii(*begin) ||
 317         NS_ToLower((char) *begin) != *aASCIIString) {
 318       return PR_FALSE;
 319     }
 320   }
 321
 322   return *aASCIIString == nsnull;
 323 }
 324
 325 PRInt32
 326 nsAString::Find(const self_type& aStr, PRUint32 aOffset,
 327                 ComparatorFunc c) const
 328 {
 329   const char_type *begin, *end;
 330   PRUint32 selflen = BeginReading(&begin, &end);
 331
 332   if (aOffset > selflen)
 333     return -1;
 334
 335   const char_type *other;
 336   PRUint32 otherlen = aStr.BeginReading(&other);
 337
 338   if (otherlen > selflen - aOffset)
 339     return -1;
 340
 341   // We want to stop searching otherlen characters before the end of the string
 342   end -= otherlen;
 343
 344   for (const char_type *cur = begin + aOffset; cur <= end; ++cur) {
 345     if (!c(cur, other, otherlen))
 346       return cur - begin;
 347   }
 348   return -1;
 349 }
 350
 351 static PRBool ns_strnmatch(const PRUnichar *aStr, const char* aSubstring,
 352                            PRUint32 aLen)
 353 {
 354   for (; aLen; ++aStr, ++aSubstring, --aLen) {
 355     if (!NS_IsAscii(*aStr))
 356       return PR_FALSE;
 357
 358     if ((char) *aStr != *aSubstring)
 359       return PR_FALSE;
 360   }
 361
 362   return PR_TRUE;
 363 }
 364
 365 static PRBool ns_strnimatch(const PRUnichar *aStr, const char* aSubstring,
 366                             PRUint32 aLen)
 367 {
 368   for (; aLen; ++aStr, ++aSubstring, --aLen) {
 369     if (!NS_IsAscii(*aStr))
 370       return PR_FALSE;
 371
 372     if (NS_ToLower((char) *aStr) != NS_ToLower(*aSubstring))
 373       return PR_FALSE;
 374   }
 375
 376   return PR_TRUE;
 377 }
 378
 379 PRInt32
 380 nsAString::Find(const char *aStr, PRUint32 aOffset, PRBool aIgnoreCase) const
 381 {
 382   PRBool (*match)(const PRUnichar*, const char*, PRUint32) =
 383     aIgnoreCase ? ns_strnimatch : ns_strnmatch;
 384
 385   const char_type *begin, *end;
 386   PRUint32 selflen = BeginReading(&begin, &end);
 387
 388   if (aOffset > selflen)
 389     return -1;
 390
 391   PRUint32 otherlen = strlen(aStr);
 392
 393   if (otherlen > selflen - aOffset)
 394     return -1;
 395
 396   // We want to stop searching otherlen characters before the end of the string
 397   end -= otherlen;
 398
 399   for (const char_type *cur = begin + aOffset; cur <= end; ++cur) {
 400     if (match(cur, aStr, otherlen)) {
 401       return cur - begin;
 402     }
 403   }
 404   return -1;
 405 }
 406
 407 PRInt32
 408 nsAString::RFind(const self_type& aStr, PRInt32 aOffset, ComparatorFunc c) const
 409 {
 410   const char_type *begin, *end;
 411   PRUint32 selflen = BeginReading(&begin, &end);
 412
 413   const char_type *other;
 414   PRUint32 otherlen = aStr.BeginReading(&other);
 415
 416   if (selflen < otherlen)
 417     return -1;
 418
 419   if (aOffset < 0 || PRUint32(aOffset) > (selflen - otherlen))
 420     end -= otherlen;
 421   else
 422     end = begin + aOffset;
 423
 424   for (const char_type *cur = end; cur >= begin; --cur) {
 425     if (!c(cur, other, otherlen))
 426       return cur - begin;
 427   }
 428   return -1;
 429 }
 430
 431 PRInt32
 432 nsAString::RFind(const char *aStr, PRInt32 aOffset, PRBool aIgnoreCase) const
 433 {
 434   PRBool (*match)(const PRUnichar*, const char*, PRUint32) =
 435     aIgnoreCase ? ns_strnimatch : ns_strnmatch;
 436
 437   const char_type *begin, *end;
 438   PRUint32 selflen = BeginReading(&begin, &end);
 439   PRUint32 otherlen = strlen(aStr);
 440
 441   if (selflen < otherlen)
 442     return -1;
 443
 444   if (aOffset < 0 || PRUint32(aOffset) > (selflen - otherlen))
 445     end -= otherlen;
 446   else
 447     end = begin + aOffset;
 448
 449   for (const char_type *cur = end; cur >= begin; --cur) {
 450     if (match(cur, aStr, otherlen)) {
 451       return cur - begin;
 452     }
 453   }
 454   return -1;
 455 }
 456
 457 PRInt32
 458 nsAString::FindChar(char_type aChar, PRUint32 aOffset) const
 459 {
 460   const char_type *start, *end;
 461   PRUint32 len = BeginReading(&start, &end);
 462   if (aOffset > len)
 463     return -1;
 464
 465   const char_type *cur;
 466
 467   for (cur = start + aOffset; cur < end; ++cur) {
 468     if (*cur == aChar)
 469       return cur - start;
 470   }
 471
 472   return -1;
 473 }
 474
 475 PRInt32
 476 nsAString::RFindChar(char_type aChar) const
 477 {
 478   const PRUnichar *start, *end;
 479   BeginReading(&start, &end);
 480
 481   do {
 482     --end;
 483
 484     if (*end == aChar)
 485       return end - start;
 486
 487   } while (end >= start);
 488
 489   return -1;
 490 }
 491
 492 void
 493 nsAString::AppendInt(int aInt, PRInt32 aRadix)
 494 {
 495   const char *fmt;
 496   switch (aRadix) {
 497   case 8:
 498     fmt = "%o";
 499     break;
 500
 501   case 10:
 502     fmt = "%d";
 503     break;
 504
 505   case 16:
 506     fmt = "%x";
 507     break;
 508
 509   default:
 510     NS_ERROR("Unrecognized radix");
 511     fmt = "";
 512   };
 513
 514   char buf[20];
 515   int len = snprintf(buf, sizeof(buf), fmt, aInt);
 516   buf[sizeof(buf) - 1] = '\0';
 517
 518   Append(NS_ConvertASCIItoUTF16(buf, len));
 519 }
 520
 521 // Strings
 522
 523 #ifndef XPCOM_GLUE_AVOID_NSPR
 524 PRInt32
 525 nsAString::ToInteger(nsresult *aErrorCode, PRUint32 aRadix) const
 526 {
 527   NS_ConvertUTF16toUTF8 narrow(*this);
 528
 529   const char *fmt;
 530   switch (aRadix) {
 531   case 10:
 532     fmt = "%i";
 533     break;
 534
 535   case 16:
 536     fmt = "%x";
 537     break;
 538
 539   default:
 540     NS_ERROR("Unrecognized radix!");
 541     *aErrorCode = NS_ERROR_INVALID_ARG;
 542     return 0;
 543   }
 544
 545   PRInt32 result = 0;
 546   if (PR_sscanf(narrow.get(), fmt, &result) == 1)
 547     *aErrorCode = NS_OK;
 548   else
 549     *aErrorCode = NS_ERROR_FAILURE;
 550
 551   return result;
 552 }
 553 #endif // XPCOM_GLUE_AVOID_NSPR
 554
 555 // nsACString
 556
 557 PRUint32
 558 nsACString::BeginReading(const char_type **begin, const char_type **end) const
 559 {
 560   PRUint32 len = NS_CStringGetData(*this, begin);
 561   if (end)
 562     *end = *begin + len;
 563
 564   return len;
 565 }
 566
 567 const nsACString::char_type*
 568 nsACString::BeginReading() const
 569 {
 570   const char_type *data;
 571   NS_CStringGetData(*this, &data);
 572   return data;
 573 }
 574
 575 const nsACString::char_type*
 576 nsACString::EndReading() const
 577 {
 578   const char_type *data;
 579   PRUint32 len = NS_CStringGetData(*this, &data);
 580   return data + len;
 581 }
 582
 583 PRUint32
 584 nsACString::BeginWriting(char_type **begin, char_type **end, PRUint32 newSize)
 585 {
 586   PRUint32 len = NS_CStringGetMutableData(*this, newSize, begin);
 587   if (end)
 588     *end = *begin + len;
 589
 590   return len;
 591 }
 592
 593 nsACString::char_type*
 594 nsACString::BeginWriting(PRUint32 aLen)
 595 {
 596   char_type *data;
 597   NS_CStringGetMutableData(*this, aLen, &data);
 598   return data;
 599 }
 600
 601 nsACString::char_type*
 602 nsACString::EndWriting()
 603 {
 604   char_type *data;
 605   PRUint32 len = NS_CStringGetMutableData(*this, PR_UINT32_MAX, &data);
 606   return data + len;
 607 }
 608
 609 PRBool
 610 nsACString::SetLength(PRUint32 aLen)
 611 {
 612   char_type *data;
 613   NS_CStringGetMutableData(*this, aLen, &data);
 614   return data != nsnull;
 615 }
 616
 617 void
 618 nsACString::StripChars(const char *aSet)
 619 {
 620   nsCString copy(*this);
 621
 622   const char_type *source, *sourceEnd;
 623   copy.BeginReading(&source, &sourceEnd);
 624
 625   char_type *dest;
 626   BeginWriting(&dest);
 627   if (!dest)
 628     return;
 629
 630   char_type *curDest = dest;
 631
 632   for (; source < sourceEnd; ++source) {
 633     const char *test;
 634     for (test = aSet; *test; ++test) {
 635       if (*source == char_type(*test))
 636         break;
 637     }
 638
 639     if (!*test) {
 640       // not stripped, copy this char
 641       *curDest = *source;
 642       ++curDest;
 643     }
 644   }
 645
 646   SetLength(curDest - dest);
 647 }
 648
 649 void
 650 nsACString::Trim(const char *aSet, PRBool aLeading, PRBool aTrailing)
 651 {
 652   NS_ASSERTION(aLeading || aTrailing, "Ineffective Trim");
 653
 654   const char *start, *end;
 655   PRUint32 cutLen;
 656
 657   if (aLeading) {
 658     BeginReading(&start, &end);
 659     for (cutLen = 0; start < end; ++start, ++cutLen) {
 660       const char *test;
 661       for (test = aSet; *test; ++test) {
 662         if (*test == *start)
 663           break;
 664       }
 665       if (!*test)
 666         break;
 667     }
 668     if (cutLen) {
 669       NS_CStringCutData(*this, 0, cutLen);
 670     }
 671   }
 672   if (aTrailing) {
 673     PRUint32 len = BeginReading(&start, &end);
 674     --end;
 675     for (cutLen = 0; end >= start; --end, ++cutLen) {
 676       const char *test;
 677       for (test = aSet; *test; ++test) {
 678         if (*test == *end)
 679           break;
 680       }
 681       if (!*test)
 682         break;
 683     }
 684     if (cutLen) {
 685       NS_CStringCutData(*this, len - cutLen, cutLen);
 686     }
 687   }
 688 }
 689
 690 PRInt32
 691 nsACString::DefaultComparator(const char_type *a, const char_type *b,
 692                               PRUint32 len)
 693 {
 694   return memcmp(a, b, len);
 695 }
 696
 697 PRInt32
 698 nsACString::Compare(const char_type *other, ComparatorFunc c) const
 699 {
 700   const char_type *cself;
 701   PRUint32 selflen = NS_CStringGetData(*this, &cself);
 702   PRUint32 otherlen = strlen(other);
 703   PRUint32 comparelen = selflen <= otherlen ? selflen : otherlen;
 704
 705   PRInt32 result = c(cself, other, comparelen);
 706   if (result == 0) {
 707     if (selflen < otherlen)
 708       return -1;
 709     else if (selflen > otherlen)
 710       return 1;
 711   }
 712   return result;
 713 }
 714
 715 PRInt32
 716 nsACString::Compare(const self_type &other, ComparatorFunc c) const
 717 {
 718   const char_type *cself, *cother;
 719   PRUint32 selflen = NS_CStringGetData(*this, &cself);
 720   PRUint32 otherlen = NS_CStringGetData(other, &cother);
 721   PRUint32 comparelen = selflen <= otherlen ? selflen : otherlen;
 722
 723   PRInt32 result = c(cself, cother, comparelen);
 724   if (result == 0) {
 725     if (selflen < otherlen)
 726       return -1;
 727     else if (selflen > otherlen)
 728       return 1;
 729   }
 730   return result;
 731 }
 732
 733 PRBool
 734 nsACString::Equals(const char_type *other, ComparatorFunc c) const
 735 {
 736   const char_type *cself;
 737   PRUint32 selflen = NS_CStringGetData(*this, &cself);
 738   PRUint32 otherlen = strlen(other);
 739
 740   if (selflen != otherlen)
 741     return PR_FALSE;
 742
 743   return c(cself, other, selflen) == 0;
 744 }
 745
 746 PRBool
 747 nsACString::Equals(const self_type &other, ComparatorFunc c) const
 748 {
 749   const char_type *cself;
 750   const char_type *cother;
 751   PRUint32 selflen = NS_CStringGetData(*this, &cself);
 752   PRUint32 otherlen = NS_CStringGetData(other, &cother);
 753
 754   if (selflen != otherlen)
 755     return PR_FALSE;
 756
 757   return c(cself, cother, selflen) == 0;
 758 }
 759
 760 PRInt32
 761 nsACString::Find(const self_type& aStr, PRUint32 aOffset,
 762                  ComparatorFunc c) const
 763 {
 764   const char_type *begin, *end;
 765   PRUint32 selflen = BeginReading(&begin, &end);
 766
 767   if (aOffset > selflen)
 768     return -1;
 769
 770   const char_type *other;
 771   PRUint32 otherlen = aStr.BeginReading(&other);
 772
 773   if (otherlen > selflen - aOffset)
 774     return -1;
 775
 776   // We want to stop searching otherlen characters before the end of the string
 777   end -= otherlen;
 778
 779   for (const char_type *cur = begin + aOffset; cur <= end; ++cur) {
 780     if (!c(cur, other, otherlen))
 781       return cur - begin;
 782   }
 783   return -1;
 784 }
 785
 786 PRInt32
 787 nsACString::Find(const char_type *aStr, ComparatorFunc c) const
 788 {
 789   return Find(aStr, strlen(aStr), c);
 790 }
 791
 792 PRInt32
 793 nsACString::Find(const char_type *aStr, PRUint32 aLen, ComparatorFunc c) const
 794 {
 795   const char_type *begin, *end;
 796   PRUint32 selflen = BeginReading(&begin, &end);
 797
 798   if (aLen == 0) {
 799     NS_WARNING("Searching for zero-length string.");
 800     return -1;
 801   }
 802
 803    if (aLen > selflen)
 804     return -1;
 805
 806   // We want to stop searching otherlen characters before the end of the string
 807   end -= aLen;
 808
 809   for (const char_type *cur = begin; cur <= end; ++cur) {
 810     if (!c(cur, aStr, aLen))
 811       return cur - begin;
 812   }
 813   return -1;
 814 }
 815
 816 PRInt32
 817 nsACString::RFind(const self_type& aStr, PRInt32 aOffset, ComparatorFunc c) const
 818 {
 819   const char_type *begin, *end;
 820   PRUint32 selflen = BeginReading(&begin, &end);
 821
 822   const char_type *other;
 823   PRUint32 otherlen = aStr.BeginReading(&other);
 824
 825   if (selflen < otherlen)
 826     return -1;
 827
 828   if (aOffset < 0 || PRUint32(aOffset) > (selflen - otherlen))
 829     end -= otherlen;
 830   else
 831     end = begin + aOffset;
 832
 833   for (const char_type *cur = end; cur >= begin; --cur) {
 834     if (!c(cur, other, otherlen))
 835       return cur - begin;
 836   }
 837   return -1;
 838 }
 839
 840 PRInt32
 841 nsACString::RFind(const char_type *aStr, ComparatorFunc c) const
 842 {
 843   return RFind(aStr, strlen(aStr), c);
 844 }
 845
 846 PRInt32
 847 nsACString::RFind(const char_type *aStr, PRInt32 aLen, ComparatorFunc c) const
 848 {
 849   const char_type *begin, *end;
 850   PRUint32 selflen = BeginReading(&begin, &end);
 851
 852   if (aLen <= 0) {
 853     NS_WARNING("Searching for zero-length string.");
 854     return -1;
 855   }
 856
 857   if (PRUint32(aLen) > selflen)
 858     return -1;
 859
 860   // We want to start searching otherlen characters before the end of the string
 861   end -= aLen;
 862
 863   for (const char_type *cur = end; cur >= begin; --cur) {
 864     if (!c(cur, aStr, aLen))
 865       return cur - begin;
 866   }
 867   return -1;
 868 }
 869
 870 PRInt32
 871 nsACString::FindChar(char_type aChar, PRUint32 aOffset) const
 872 {
 873   const char_type *start, *end;
 874   PRUint32 len = BeginReading(&start, &end);
 875   if (aOffset > len)
 876     return -1;
 877
 878   const char_type *cur;
 879
 880   for (cur = start + aOffset; cur < end; ++cur) {
 881     if (*cur == aChar)
 882       return cur - start;
 883   }
 884
 885   return -1;
 886 }
 887
 888 PRInt32
 889 nsACString::RFindChar(char_type aChar) const
 890 {
 891   const char *start, *end;
 892   BeginReading(&start, &end);
 893
 894   for (; end >= start; --end) {
 895     if (*end == aChar)
 896       return end - start;
 897   }
 898
 899   return -1;
 900 }
 901
 902 void
 903 nsACString::AppendInt(int aInt, PRInt32 aRadix)
 904 {
 905   const char *fmt;
 906   switch (aRadix) {
 907   case 8:
 908     fmt = "%o";
 909     break;
 910
 911   case 10:
 912     fmt = "%d";
 913     break;
 914
 915   case 16:
 916     fmt = "%x";
 917     break;
 918
 919   default:
 920     NS_ERROR("Unrecognized radix");
 921     fmt = "";
 922   };
 923
 924   char buf[20];
 925   int len = snprintf(buf, sizeof(buf), fmt, aInt);
 926   buf[sizeof(buf) - 1] = '\0';
 927
 928   Append(buf, len);
 929 }
 930
 931 #ifndef XPCOM_GLUE_AVOID_NSPR
 932 PRInt32
 933 nsACString::ToInteger(nsresult *aErrorCode, PRUint32 aRadix) const
 934 {
 935   const char *fmt;
 936   switch (aRadix) {
 937   case 10:
 938     fmt = "%i";
 939     break;
 940
 941   case 16:
 942     fmt = "%x";
 943     break;
 944
 945   default:
 946     NS_ERROR("Unrecognized radix!");
 947     *aErrorCode = NS_ERROR_INVALID_ARG;
 948     return 0;
 949   }
 950
 951   PRInt32 result = 0;
 952   if (PR_sscanf(nsCString(*this).get(), fmt, &result) == 1)
 953     *aErrorCode = NS_OK;
 954   else
 955     *aErrorCode = NS_ERROR_FAILURE;
 956
 957   return result;
 958 }
 959 #endif // XPCOM_GLUE_AVOID_NSPR
 960
 961 // Substrings
 962
 963 nsDependentSubstring::nsDependentSubstring(const abstract_string_type& aStr,
 964                                            PRUint32 aStartPos)
 965 {
 966   const PRUnichar* data;
 967   PRUint32 len = NS_StringGetData(aStr, &data);
 968
 969   if (aStartPos > len)
 970     aStartPos = len;
 971
 972   NS_StringContainerInit2(*this, data + aStartPos, len - aStartPos,
 973                           NS_STRING_CONTAINER_INIT_DEPEND |
 974                           NS_STRING_CONTAINER_INIT_SUBSTRING);
 975 }
 976
 977 nsDependentSubstring::nsDependentSubstring(const abstract_string_type& aStr,
 978                                            PRUint32 aStartPos,
 979                                            PRUint32 aLength)
 980 {
 981   const PRUnichar* data;
 982   PRUint32 len = NS_StringGetData(aStr, &data);
 983
 984   if (aStartPos > len)
 985     aStartPos = len;
 986
 987   if (aStartPos + aLength > len)
 988     aLength = len - aStartPos;
 989
 990   NS_StringContainerInit2(*this, data + aStartPos, aLength,
 991                           NS_STRING_CONTAINER_INIT_DEPEND |
 992                             NS_STRING_CONTAINER_INIT_SUBSTRING);
 993 }
 994
 995 nsDependentCSubstring::nsDependentCSubstring(const abstract_string_type& aStr,
 996                                              PRUint32 aStartPos)
 997 {
 998   const char* data;
 999   PRUint32 len = NS_CStringGetData(aStr, &data);
1000
1001   if (aStartPos > len)
1002     aStartPos = len;
1003
1004   NS_CStringContainerInit2(*this, data + aStartPos, len - aStartPos,
1005                            NS_CSTRING_CONTAINER_INIT_DEPEND |
1006                            NS_CSTRING_CONTAINER_INIT_SUBSTRING);
1007 }
1008
1009 nsDependentCSubstring::nsDependentCSubstring(const abstract_string_type& aStr,
1010                                              PRUint32 aStartPos,
1011                                              PRUint32 aLength)
1012 {
1013   const char* data;
1014   PRUint32 len = NS_CStringGetData(aStr, &data);
1015
1016   if (aStartPos > len)
1017     aStartPos = len;
1018
1019   if (aStartPos + aLength > len)
1020     aLength = len - aStartPos;
1021
1022   NS_CStringContainerInit2(*this, data + aStartPos, aLength,
1023                            NS_CSTRING_CONTAINER_INIT_DEPEND |
1024                            NS_CSTRING_CONTAINER_INIT_SUBSTRING);
1025 }
1026
1027 // Utils
1028
1029 char*
1030 ToNewUTF8String(const nsAString& aSource)
1031 {
1032   nsCString temp;
1033   CopyUTF16toUTF8(aSource, temp);
1034   return NS_CStringCloneData(temp);
1035 }
1036
1037 void
1038 CompressWhitespace(nsAString& aString)
1039 {
1040   PRUnichar *start;
1041   PRUint32 len = NS_StringGetMutableData(aString, PR_UINT32_MAX, &start);
1042   PRUnichar *end = start + len;
1043   PRUnichar *from = start, *to = start;
1044
1045   // Skip any leading whitespace
1046   while (from < end && NS_IsAsciiWhitespace(*from))
1047     from++;
1048
1049   while (from < end) {
1050     PRUnichar theChar = *from++;
1051
1052     if (NS_IsAsciiWhitespace(theChar)) {
1053       // We found a whitespace char, so skip over any more
1054       while (from < end && NS_IsAsciiWhitespace(*from))
1055         from++;
1056
1057       // Turn all whitespace into spaces
1058       theChar = ' ';
1059     }
1060
1061     *to++ = theChar;
1062   }
1063
1064   // Drop any trailing space
1065   if (to > start && to[-1] == ' ')
1066     to--;
1067
1068   // Re-terminate the string
1069   *to = '\0';
1070
1071   // Set the new length
1072   aString.SetLength(to - start);
1073 }
1074
1075 PRUint32
1076 ToLowerCase(nsACString& aStr)
1077 {
1078   char *begin, *end;
1079   PRUint32 len = aStr.BeginWriting(&begin, &end);
1080
1081   for (; begin < end; ++begin) {
1082     *begin = NS_ToLower(*begin);
1083   }
1084
1085   return len;
1086 }
1087
1088 PRUint32
1089 ToUpperCase(nsACString& aStr)
1090 {
1091   char *begin, *end;
1092   PRUint32 len = aStr.BeginWriting(&begin, &end);
1093
1094   for (; begin < end; ++begin) {
1095     *begin = NS_ToUpper(*begin);
1096   }
1097
1098   return len;
1099 }
1100
1101 PRUint32
1102 ToLowerCase(const nsACString& aSrc, nsACString& aDest)
1103 {
1104   const char *begin,  *end;
1105   PRUint32 len = aSrc.BeginReading(&begin, &end);
1106
1107   char *dest;
1108   NS_CStringGetMutableData(aDest, len, &dest);
1109
1110   for (; begin < end; ++begin, ++dest) {
1111     *dest = NS_ToLower(*begin);
1112   }
1113
1114   return len;
1115 }
1116
1117 PRUint32
1118 ToUpperCase(const nsACString& aSrc, nsACString& aDest)
1119 {
1120   const char *begin,  *end;
1121   PRUint32 len = aSrc.BeginReading(&begin, &end);
1122
1123   char *dest;
1124   NS_CStringGetMutableData(aDest, len, &dest);
1125
1126   for (; begin < end; ++begin, ++dest) {
1127     *dest = NS_ToUpper(*begin);
1128   }
1129
1130   return len;
1131 }
1132
1133 PRInt32
1134 CaseInsensitiveCompare(const char *a, const char *b,
1135                        PRUint32 len)
1136 {
1137   for (const char *aend = a + len; a < aend; ++a, ++b) {
1138     char la = NS_ToLower(*a);
1139     char lb = NS_ToLower(*b);
1140
1141     if (la == lb)
1142       continue;
1143
1144     return la < lb ? -1 : 1;
1145   }
1146
1147   return 0;
1148 }
1149
1150 PRBool
1151 ParseString(const nsACString& aSource, char aDelimiter,
1152             nsTArray<nsCString>& aArray)
1153 {
1154   PRInt32 start = 0;
1155   PRInt32 end = aSource.Length();
1156
1157   PRUint32 oldLength = aArray.Length();
1158
1159   for (;;) {
1160     PRInt32 delimiter = aSource.FindChar(aDelimiter, start);
1161     if (delimiter < 0) {
1162       delimiter = end;
1163     }
1164
1165     if (delimiter != start) {
1166       if (!aArray.AppendElement(Substring(aSource, start, delimiter - start))) {
1167         aArray.RemoveElementsAt(oldLength, aArray.Length() - oldLength);
1168         return PR_FALSE;
1169       }
1170     }
1171
1172     if (delimiter == end)
1173       break;
1174     start = ++delimiter;
1175     if (start == end)
1176       break;
1177   }
1178
1179   return PR_TRUE;
1180 }