The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 /* vim:set ts=2 sw=2 sts=2 et cindent: */

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 #include "nsString.h"

   /**

    * nsTString obsolete API support

    */

 #if MOZ_STRING_WITH_OBSOLETE_API

 #include "nsDependentString.h"

 #include "nsDependentSubstring.h"

 #include "nsReadableUtils.h"

 #include "nsCRT.h"

 #include "nsUTF8Utils.h"

 #include "prdtoa.h"

 /* ***** BEGIN RICKG BLOCK *****

  *

  * NOTE: This section of code was extracted from rickg's bufferRoutines.h file.

  *       For the most part it remains unmodified.  We want to eliminate (or at

  *       least clean up) this code at some point.  If you find the formatting

  *       in this section somewhat inconsistent, don't blame me! ;-)

  */

 // avoid STDC's tolower since it may do weird things with non-ASCII bytes

 inline char

 ascii_tolower(char aChar)

 {

   if (aChar >= 'A' && aChar <= 'Z')

     return aChar + ('a' - 'A');

   return aChar;

 }

 //-----------------------------------------------------------------------------

 //

 //  This set of methods is used to search a buffer looking for a char.

 //

 /**

  *  This methods cans the given buffer for the given char

  *  

  *  @update  gess 02/17/00

  *  @param   aDest is the buffer to be searched

  *  @param   aDestLength is the size (in char-units, not bytes) of the buffer

  *  @param   anOffset is the start pos to begin searching

  *  @param   aChar is the target character we're looking for

  *  @param   aCount tells us how many characters to iterate through (which may be different than aLength); -1 means use full length.

  *  @return  index of pos if found, else -1 (kNotFound)

  */

 static int32_t

 FindChar1(const char* aDest,uint32_t aDestLength,int32_t anOffset,const char16_t aChar,int32_t aCount) {

   if(anOffset < 0)

     anOffset=0;

   if(aCount < 0)

     aCount = (int32_t)aDestLength;

   if((aChar < 256) && (0 < aDestLength) && ((uint32_t)anOffset < aDestLength)) {

     //We'll only search if the given aChar is within the normal ascii a range,

     //(Since this string is definitely within the ascii range).

     if(0<aCount) {

       const char* left= aDest+anOffset;

       const char* last= left+aCount;

       const char* max = aDest+aDestLength;

       const char* end = (last<max) ? last : max;

       int32_t theMax = end-left;

       if(0<theMax) {

         unsigned char theChar = (unsigned char) aChar;

         const char* result=(const char*)memchr(left, (int)theChar, theMax);

         if(result)

           return result-aDest;

       }

     }

   }

   return kNotFound;

 }

 /**

  *  This methods cans the given buffer for the given char

  *  

  *  @update  gess 3/25/98

  *  @param   aDest is the buffer to be searched

  *  @param   aDestLength is the size (in char-units, not bytes) of the buffer

  *  @param   anOffset is the start pos to begin searching

  *  @param   aChar is the target character we're looking for

  *  @param   aCount tells us how many characters to iterate through (which may be different than aLength); -1 means use full length.

  *  @return  index of pos if found, else -1 (kNotFound)

  */

 static int32_t

 FindChar2(const char16_t* aDest,uint32_t aDestLength,int32_t anOffset,const char16_t aChar,int32_t aCount) {

   if(anOffset < 0)

     anOffset=0;

   if(aCount < 0)

     aCount = (int32_t)aDestLength;

   if((0<aDestLength) && ((uint32_t)anOffset < aDestLength)) {

     if(0<aCount) {

       const char16_t* root = aDest;

       const char16_t* left = root+anOffset;

       const char16_t* last = left+aCount;

       const char16_t* max  = root+aDestLength;

       const char16_t* end  = (last<max) ? last : max;

       while(left<end){

         if(*left==aChar)

           return (left-root);

         ++left;

       }

     }

   }

   return kNotFound;

 }

 /**

  *  This methods cans the given buffer (in reverse) for the given char

  *  

  *  @update  gess 02/17/00

  *  @param   aDest is the buffer to be searched

  *  @param   aDestLength is the size (in char-units, not bytes) of the buffer

  *  @param   anOffset is the start pos to begin searching

  *  @param   aChar is the target character we're looking for

  *  @param   aCount tells us how many characters to iterate through (which may be different than aLength); -1 means use full length.

  *  @return  index of pos if found, else -1 (kNotFound)

  */

 static int32_t

 RFindChar1(const char* aDest,uint32_t aDestLength,int32_t anOffset,const char16_t aChar,int32_t aCount) {

   if(anOffset < 0)

     anOffset=(int32_t)aDestLength-1;

   if(aCount < 0)

     aCount = int32_t(aDestLength);

   if((aChar<256) && (0 < aDestLength) && ((uint32_t)anOffset < aDestLength)) {

     //We'll only search if the given aChar is within the normal ascii a range,

     //(Since this string is definitely within the ascii range).

     if(0 < aCount) {

       const char* rightmost = aDest + anOffset;  

       const char* min       = rightmost - aCount + 1;

       const char* leftmost  = (min<aDest) ? aDest: min;

       char theChar=(char)aChar;

       while(leftmost <= rightmost){

         if((*rightmost) == theChar)

           return rightmost - aDest;

         --rightmost;

       }

     }

   }

   return kNotFound;

 }

 /**

  *  This methods cans the given buffer for the given char

  *  

  *  @update  gess 3/25/98

  *  @param   aDest is the buffer to be searched

  *  @param   aDestLength is the size (in char-units, not bytes) of the buffer

  *  @param   anOffset is the start pos to begin searching

  *  @param   aChar is the target character we're looking for

  *  @param   aCount tells us how many characters to iterate through (which may be different than aLength); -1 means use full length.

  *  @return  index of pos if found, else -1 (kNotFound)

  */

 static int32_t

 RFindChar2(const char16_t* aDest,uint32_t aDestLength,int32_t anOffset,const char16_t aChar,int32_t aCount) {

   if(anOffset < 0)

     anOffset=(int32_t)aDestLength-1;

   if(aCount < 0)

     aCount = int32_t(aDestLength);

   if((0 < aDestLength) && ((uint32_t)anOffset < aDestLength)) {

     if(0 < aCount) {

       const char16_t* root      = aDest;

       const char16_t* rightmost = root + anOffset;  

       const char16_t* min       = rightmost - aCount + 1;

       const char16_t* leftmost  = (min<root) ? root: min;

       while(leftmost <= rightmost){

         if((*rightmost) == aChar)

           return rightmost - root;

         --rightmost;

       }

     }

   }

   return kNotFound;

 }

 //-----------------------------------------------------------------------------

 //

 //  This set of methods is used to compare one buffer onto another.  The

 //  functions are differentiated by the size of source and dest character

 //  sizes.  WARNING: Your destination buffer MUST be big enough to hold all the

 //  source bytes.  We don't validate these ranges here (this should be done in

 //  higher level routines).

 //

 /**

  * This method compares the data in one buffer with another

  * @update	gess 01/04/99

  * @param   aStr1 is the first buffer to be compared

  * @param   aStr2 is the 2nd buffer to be compared

  * @param   aCount is the number of chars to compare

  * @param   aIgnoreCase tells us whether to use a case-sensitive comparison

  * @return  -1,0,1 depending on <,==,>

  */

 static

 #ifdef __SUNPRO_CC

 inline

 #endif /* __SUNPRO_CC */

 int32_t

 Compare1To1(const char* aStr1,const char* aStr2,uint32_t aCount,bool aIgnoreCase){ 

   int32_t result=0;

   if(aIgnoreCase)

     result=int32_t(PL_strncasecmp(aStr1, aStr2, aCount));

   else 

     result=nsCharTraits<char>::compare(aStr1,aStr2,aCount);

       // alien comparisons may return out-of-bound answers

       //  instead of the -1, 0, 1 expected by most clients

   if ( result < -1 )

     result = -1;

   else if ( result > 1 )

     result = 1;

   return result;

 }

 /**

  * This method compares the data in one buffer with another

  * @update	gess 01/04/99

  * @param   aStr1 is the first buffer to be compared

  * @param   aStr2 is the 2nd buffer to be compared

  * @param   aCount is the number of chars to compare

  * @param   aIgnoreCase tells us whether to use a case-sensitive comparison

  * @return  -1,0,1 depending on <,==,>

  */

 static 

 #ifdef __SUNPRO_CC

 inline

 #endif /* __SUNPRO_CC */

 int32_t

 Compare2To2(const char16_t* aStr1,const char16_t* aStr2,uint32_t aCount){

   int32_t result;

   if ( aStr1 && aStr2 )

     result = nsCharTraits<char16_t>::compare(aStr1, aStr2, aCount);

       // The following cases are rare and survivable caller errors.

       //  Two null pointers are equal, but any string, even 0 length

       //  is greater than a null pointer.  It might not really matter,

       //  but we pick something reasonable anyway.

   else if ( !aStr1 && !aStr2 )

     result = 0;

   else if ( aStr1 )

     result = 1;

   else

     result = -1;

       // alien comparisons may give answers outside the -1, 0, 1 expected by callers

   if ( result < -1 )

     result = -1;

   else if ( result > 1 )

     result = 1;

   return result;

 }

 /**

  * This method compares the data in one buffer with another

  * @update	gess 01/04/99

  * @param   aStr1 is the first buffer to be compared

  * @param   aStr2 is the 2nd buffer to be compared

  * @param   aCount is the number of chars to compare

  * @param   aIgnoreCase tells us whether to use a case-sensitive comparison

  * @return  -1,0,1 depending on <,==,>

  */

 static

 #ifdef __SUNPRO_CC

 inline

 #endif /* __SUNPRO_CC */

 int32_t

 Compare2To1(const char16_t* aStr1,const char* aStr2,uint32_t aCount,bool aIgnoreCase){

   const char16_t* s1 = aStr1;

   const char *s2 = aStr2;

   if (aStr1 && aStr2) {

     if (aCount != 0) {

       do {

         char16_t c1 = *s1++;

         char16_t c2 = char16_t((unsigned char)*s2++);

         if (c1 != c2) {

 #ifdef DEBUG

           // we won't warn on c1>=128 (the 2-byte value) because often

           // it is just fine to compare an constant, ascii value (i.e. "body")

           // against some non-ascii value (i.e. a unicode string that

           // was downloaded from a web page)

           if (aIgnoreCase && c2>=128)

             NS_WARNING("got a non-ASCII string, but we can't do an accurate case conversion!");

 #endif

           // can't do case conversion on characters out of our range

           if (aIgnoreCase && c1<128 && c2<128) {

               c1 = ascii_tolower(char(c1));

               c2 = ascii_tolower(char(c2));

               if (c1 == c2) continue;

           }

           if (c1 < c2) return -1;

           return 1;

         }

       } while (--aCount);

     }

   }

   return 0;

 }

 /**

  * This method compares the data in one buffer with another

  * @update	gess 01/04/99

  * @param   aStr1 is the first buffer to be compared

  * @param   aStr2 is the 2nd buffer to be compared

  * @param   aCount is the number of chars to compare

  * @param   aIgnoreCase tells us whether to use a case-sensitive comparison

  * @return  -1,0,1 depending on <,==,>

  */

 inline int32_t

 Compare1To2(const char* aStr1,const char16_t* aStr2,uint32_t aCount,bool aIgnoreCase){

   return Compare2To1(aStr2, aStr1, aCount, aIgnoreCase) * -1;

 }

 //-----------------------------------------------------------------------------

 //

 //  This set of methods is used compress char sequences in a buffer...

 //

 /**

  * This method compresses duplicate runs of a given char from the given buffer 

  *

  * @update	rickg 03.23.2000

  * @param   aString is the buffer to be manipulated

  * @param   aLength is the length of the buffer

  * @param   aSet tells us which chars to compress from given buffer

  * @param   aEliminateLeading tells us whether to strip chars from the start of the buffer

  * @param   aEliminateTrailing tells us whether to strip chars from the start of the buffer

  * @return  the new length of the given buffer

  */

 static int32_t

 CompressChars1(char* aString,uint32_t aLength,const char* aSet){ 

   char*  from = aString;

   char*  end =  aString + aLength;

   char*  to = from;

     //this code converts /n, /t, /r into normal space ' ';

     //it also compresses runs of whitespace down to a single char...

   if(aSet && aString && (0 < aLength)){

     uint32_t aSetLen=strlen(aSet);

     while (from < end) {

       char theChar = *from++;

       *to++=theChar; //always copy this char...

       if((kNotFound!=FindChar1(aSet,aSetLen,0,theChar,aSetLen))){

         while (from < end) {

           theChar = *from++;

           if(kNotFound==FindChar1(aSet,aSetLen,0,theChar,aSetLen)){

             *to++ = theChar;

             break;

           }

         } //while

       } //if

     } //if

     *to = 0;

   }

   return to - aString;

 }

 /**

  * This method compresses duplicate runs of a given char from the given buffer 

  *

  * @update	rickg 03.23.2000

  * @param   aString is the buffer to be manipulated

  * @param   aLength is the length of the buffer

  * @param   aSet tells us which chars to compress from given buffer

  * @param   aEliminateLeading tells us whether to strip chars from the start of the buffer

  * @param   aEliminateTrailing tells us whether to strip chars from the start of the buffer

  * @return  the new length of the given buffer

  */

 static int32_t

 CompressChars2(char16_t* aString,uint32_t aLength,const char* aSet){ 

   char16_t*  from = aString;

   char16_t*  end =  from + aLength;

   char16_t*  to = from;

     //this code converts /n, /t, /r into normal space ' ';

     //it also compresses runs of whitespace down to a single char...

   if(aSet && aString && (0 < aLength)){

     uint32_t aSetLen=strlen(aSet);

     while (from < end) {

       char16_t theChar = *from++;

       *to++=theChar; //always copy this char...

       if((theChar<256) && (kNotFound!=FindChar1(aSet,aSetLen,0,theChar,aSetLen))){

         while (from < end) {

           theChar = *from++;

           if(kNotFound==FindChar1(aSet,aSetLen,0,theChar,aSetLen)){

             *to++ = theChar;

             break;

           }

         } //while

       } //if

     } //if

     *to = 0;

   }

   return to - (char16_t*)aString;

 }

 /**

  * This method strips chars in a given set from the given buffer 

  *

  * @update	gess 01/04/99

  * @param   aString is the buffer to be manipulated

  * @param   aLength is the length of the buffer

  * @param   aSet tells us which chars to compress from given buffer

  * @param   aEliminateLeading tells us whether to strip chars from the start of the buffer

  * @param   aEliminateTrailing tells us whether to strip chars from the start of the buffer

  * @return  the new length of the given buffer

  */

 static int32_t

 StripChars1(char* aString,uint32_t aLength,const char* aSet){ 

   // XXX(darin): this code should defer writing until necessary.

   char*  to   = aString;

   char*  from = aString-1;

   char*  end  = aString + aLength;

   if(aSet && aString && (0 < aLength)){

     uint32_t aSetLen=strlen(aSet);

     while (++from < end) {

       char theChar = *from;

       if(kNotFound==FindChar1(aSet,aSetLen,0,theChar,aSetLen)){

         *to++ = theChar;

       }

     }

     *to = 0;

   }

   return to - (char*)aString;

 }

 /**

  * This method strips chars in a given set from the given buffer 

  *

  * @update	gess 01/04/99

  * @param   aString is the buffer to be manipulated

  * @param   aLength is the length of the buffer

  * @param   aSet tells us which chars to compress from given buffer

  * @param   aEliminateLeading tells us whether to strip chars from the start of the buffer

  * @param   aEliminateTrailing tells us whether to strip chars from the start of the buffer

  * @return  the new length of the given buffer

  */

 static int32_t

 StripChars2(char16_t* aString,uint32_t aLength,const char* aSet){ 

   // XXX(darin): this code should defer writing until necessary.

   char16_t*  to   = aString;

   char16_t*  from = aString-1;

   char16_t*  end  = to + aLength;

   if(aSet && aString && (0 < aLength)){

     uint32_t aSetLen=strlen(aSet);

     while (++from < end) {

       char16_t theChar = *from;

       //Note the test for ascii range below. If you have a real unicode char, 

       //and you're searching for chars in the (given) ascii string, there's no

       //point in doing the real search since it's out of the ascii range.

       if((255<theChar) || (kNotFound==FindChar1(aSet,aSetLen,0,theChar,aSetLen))){

         *to++ = theChar;

       }

     }

     *to = 0;

   }

   return to - (char16_t*)aString;

 }

 /* ***** END RICKG BLOCK ***** */

 static const char* kWhitespace="\b\t\r\n ";

 // This function is used to implement FindCharInSet and friends

 template <class CharT>

 #ifndef __SUNPRO_CC

 static

 #endif /* !__SUNPRO_CC */

 CharT

 GetFindInSetFilter( const CharT* set)

   {

     CharT filter = ~CharT(0); // All bits set

     while (*set) {

       filter &= ~(*set);

       ++set;

     }

     return filter;

   }

 // This template class is used by our code to access rickg's buffer routines.

 template <class CharT> struct nsBufferRoutines {};

 template <>

 struct nsBufferRoutines<char>

   {

     static

     int32_t compare( const char* a, const char* b, uint32_t max, bool ic )

       {

         return Compare1To1(a, b, max, ic);

       }

     static

     int32_t compare( const char* a, const char16_t* b, uint32_t max, bool ic )

       {

         return Compare1To2(a, b, max, ic);

       }

     static

     int32_t find_char( const char* s, uint32_t max, int32_t offset, const char16_t c, int32_t count )

       {

         return FindChar1(s, max, offset, c, count);

       }

     static

     int32_t rfind_char( const char* s, uint32_t max, int32_t offset, const char16_t c, int32_t count )

       {

         return RFindChar1(s, max, offset, c, count);

       }

     static

     char get_find_in_set_filter( const char* set )

       {

         return GetFindInSetFilter(set);

       }

     static

     int32_t strip_chars( char* s, uint32_t len, const char* set )

       {

         return StripChars1(s, len, set);

       }

     static

     int32_t compress_chars( char* s, uint32_t len, const char* set ) 

       {

         return CompressChars1(s, len, set);

       }

   };

 template <>

 struct nsBufferRoutines<char16_t>

   {

     static

     int32_t compare( const char16_t* a, const char16_t* b, uint32_t max, bool ic )

       {

         NS_ASSERTION(!ic, "no case-insensitive compare here");

         return Compare2To2(a, b, max);

       }

     static

     int32_t compare( const char16_t* a, const char* b, uint32_t max, bool ic )

       {

         return Compare2To1(a, b, max, ic);

       }

     static

     int32_t find_char( const char16_t* s, uint32_t max, int32_t offset, const char16_t c, int32_t count )

       {

         return FindChar2(s, max, offset, c, count);

       }

     static

     int32_t rfind_char( const char16_t* s, uint32_t max, int32_t offset, const char16_t c, int32_t count )

       {

         return RFindChar2(s, max, offset, c, count);

       }

     static

     char16_t get_find_in_set_filter( const char16_t* set )

       {

         return GetFindInSetFilter(set);

       }

     static

     char16_t get_find_in_set_filter( const char* set )

       {

         return (~char16_t(0)^~char(0)) | GetFindInSetFilter(set);

       }

     static

     int32_t strip_chars( char16_t* s, uint32_t max, const char* set )

       {

         return StripChars2(s, max, set);

       }

     static

     int32_t compress_chars( char16_t* s, uint32_t len, const char* set ) 

       {

         return CompressChars2(s, len, set);

       }

   };

 //-----------------------------------------------------------------------------

 template <class L, class R>

 #ifndef __SUNPRO_CC

 static

 #endif /* !__SUNPRO_CC */

 int32_t

 FindSubstring( const L* big, uint32_t bigLen,

                const R* little, uint32_t littleLen,

                bool ignoreCase )

   {

     if (littleLen > bigLen)

       return kNotFound;

     int32_t i, max = int32_t(bigLen - littleLen);

     for (i=0; i<=max; ++i, ++big)

       {

         if (nsBufferRoutines<L>::compare(big, little, littleLen, ignoreCase) == 0)

           return i;

       }

     return kNotFound;

   }

 template <class L, class R>

 #ifndef __SUNPRO_CC

 static

 #endif /* !__SUNPRO_CC */

 int32_t

 RFindSubstring( const L* big, uint32_t bigLen,

                 const R* little, uint32_t littleLen,

                 bool ignoreCase )

   {

     if (littleLen > bigLen)

       return kNotFound;

     int32_t i, max = int32_t(bigLen - littleLen);

     const L* iter = big + max;

     for (i=max; iter >= big; --i, --iter)

       {

         if (nsBufferRoutines<L>::compare(iter, little, littleLen, ignoreCase) == 0)

           return i;

       }

     return kNotFound;

   }

 template <class CharT, class SetCharT>

 #ifndef __SUNPRO_CC

 static

 #endif /* !__SUNPRO_CC */

 int32_t

 FindCharInSet( const CharT* data, uint32_t dataLen, const SetCharT* set )

   {

     CharT filter = nsBufferRoutines<CharT>::get_find_in_set_filter(set);

     const CharT* end = data + dataLen; 

     for (const CharT* iter = data; iter < end; ++iter)

       {

         CharT currentChar = *iter;

         if (currentChar & filter)

           continue; // char is not in filter set; go on with next char.

         // test all chars

         const SetCharT* charInSet = set;

         CharT setChar = CharT(*charInSet);

         while (setChar)

           {

             if (setChar == currentChar)

               return iter - data; // found it!  return index of the found char.

             setChar = CharT(*(++charInSet));

           }

       }

     return kNotFound;

   }

 template <class CharT, class SetCharT>

 #ifndef __SUNPRO_CC

 static

 #endif /* !__SUNPRO_CC */

 int32_t

 RFindCharInSet( const CharT* data, uint32_t dataLen, const SetCharT* set )

   {

     CharT filter = nsBufferRoutines<CharT>::get_find_in_set_filter(set);

     for (const CharT* iter = data + dataLen - 1; iter >= data; --iter)

       {

         CharT currentChar = *iter;

         if (currentChar & filter)

           continue; // char is not in filter set; go on with next char.

         // test all chars

         const CharT* charInSet = set;

         CharT setChar = *charInSet;

         while (setChar)

           {

             if (setChar == currentChar)

               return iter - data; // found it!  return index of the found char.

             setChar = *(++charInSet);

           }

       }

     return kNotFound;

   }

   /**

    * this method changes the meaning of |offset| and |count|:

    * 

    * upon return,

    *   |offset| specifies start of search range

    *   |count| specifies length of search range

    */ 

 static void

 Find_ComputeSearchRange( uint32_t bigLen, uint32_t littleLen, int32_t& offset, int32_t& count )

   {

     // |count| specifies how many iterations to make from |offset|

     if (offset < 0)

       {

         offset = 0;

       }

     else if (uint32_t(offset) > bigLen)

       {

         count = 0;

         return;

       }

     int32_t maxCount = bigLen - offset;

     if (count < 0 || count > maxCount)

       {

         count = maxCount;

       } 

     else

       {

         count += littleLen;

         if (count > maxCount)

           count = maxCount;

       }

   }

   /**

    * this method changes the meaning of |offset| and |count|:

    *

    * upon entry,

    *   |offset| specifies the end point from which to search backwards

    *   |count| specifies the number of iterations from |offset|

    * 

    * upon return,

    *   |offset| specifies start of search range

    *   |count| specifies length of search range

    *

    *

    * EXAMPLE

    * 

    *                            + -- littleLen=4 -- +

    *                            :                   :

    *   |____|____|____|____|____|____|____|____|____|____|____|____|

    *                            :                                  :

    *                         offset=5                           bigLen=12

    *

    *   if count = 4, then we expect this function to return offset = 2 and

    *   count = 7.

    *

    */ 

 static void

 RFind_ComputeSearchRange( uint32_t bigLen, uint32_t littleLen, int32_t& offset, int32_t& count )

   {

     if (littleLen > bigLen)

       {

         offset = 0;

         count = 0;

         return;

       }

     if (offset < 0)

       offset = bigLen - littleLen;

     if (count < 0)

       count = offset + 1;

     int32_t start = offset - count + 1;

     if (start < 0)

       start = 0;

     count = offset + littleLen - start;

     offset = start;

   }

 //-----------------------------------------------------------------------------

   // define nsString obsolete methods

 #include "string-template-def-unichar.h"

 #include "nsTStringObsolete.cpp"

 #include "string-template-undef.h"

   // define nsCString obsolete methods

 #include "string-template-def-char.h"

 #include "nsTStringObsolete.cpp"

 #include "string-template-undef.h"

 //-----------------------------------------------------------------------------

 // specialized methods:

 int32_t

 nsString::Find( const nsAFlatString& aString, int32_t aOffset, int32_t aCount ) const

   {

     // this method changes the meaning of aOffset and aCount:

     Find_ComputeSearchRange(mLength, aString.Length(), aOffset, aCount);

     int32_t result = FindSubstring(mData + aOffset, aCount, static_cast<const char16_t*>(aString.get()), aString.Length(), false);

     if (result != kNotFound)

       result += aOffset;

     return result;

   }

 int32_t

 nsString::Find( const char16_t* aString, int32_t aOffset, int32_t aCount ) const

   {

     return Find(nsDependentString(aString), aOffset, aCount);

   }

 int32_t

 nsString::RFind( const nsAFlatString& aString, int32_t aOffset, int32_t aCount ) const

   {

     // this method changes the meaning of aOffset and aCount:

     RFind_ComputeSearchRange(mLength, aString.Length(), aOffset, aCount);

     int32_t result = RFindSubstring(mData + aOffset, aCount, static_cast<const char16_t*>(aString.get()), aString.Length(), false);

     if (result != kNotFound)

       result += aOffset;

     return result;

   }

 int32_t

 nsString::RFind( const char16_t* aString, int32_t aOffset, int32_t aCount ) const

   {

     return RFind(nsDependentString(aString), aOffset, aCount);

   }

 int32_t

 nsString::FindCharInSet( const char16_t* aSet, int32_t aOffset ) const

   {

     if (aOffset < 0)

       aOffset = 0;

     else if (aOffset >= int32_t(mLength))

       return kNotFound;

     int32_t result = ::FindCharInSet(mData + aOffset, mLength - aOffset, aSet);

     if (result != kNotFound)

       result += aOffset;

     return result;

   }

 void

 nsString::ReplaceChar( const char16_t* aSet, char16_t aNewChar )

   {

     if (!EnsureMutable()) // XXX do this lazily?

       NS_ABORT_OOM(mLength);

     char16_t* data = mData;

     uint32_t lenRemaining = mLength;

     while (lenRemaining)

       {

         int32_t i = ::FindCharInSet(data, lenRemaining, aSet);

         if (i == kNotFound)

           break;

         data[i++] = aNewChar;

         data += i;

         lenRemaining -= i;

       }

   }

   /**

    * nsTString::Compare,CompareWithConversion,etc.

    */

 int32_t

 nsCString::Compare( const char* aString, bool aIgnoreCase, int32_t aCount ) const

   {

     uint32_t strLen = char_traits::length(aString);

     int32_t maxCount = int32_t(XPCOM_MIN(mLength, strLen));

     int32_t compareCount;

     if (aCount < 0 || aCount > maxCount)

       compareCount = maxCount;

     else

       compareCount = aCount;

     int32_t result =

         nsBufferRoutines<char>::compare(mData, aString, compareCount, aIgnoreCase);

     if (result == 0 &&

           (aCount < 0 || strLen < uint32_t(aCount) || mLength < uint32_t(aCount)))

       {

         // Since the caller didn't give us a length to test, or strings shorter

         // than aCount, and compareCount characters matched, we have to assume

         // that the longer string is greater.

         if (mLength != strLen)

           result = (mLength < strLen) ? -1 : 1;

       }

     return result;

   }

 bool

 nsString::EqualsIgnoreCase( const char* aString, int32_t aCount ) const

   {

     uint32_t strLen = nsCharTraits<char>::length(aString);

     int32_t maxCount = int32_t(XPCOM_MIN(mLength, strLen));

     int32_t compareCount;

     if (aCount < 0 || aCount > maxCount)

       compareCount = maxCount;

     else

       compareCount = aCount;

     int32_t result =

         nsBufferRoutines<char16_t>::compare(mData, aString, compareCount, true);

     if (result == 0 &&

           (aCount < 0 || strLen < uint32_t(aCount) || mLength < uint32_t(aCount)))

       {

         // Since the caller didn't give us a length to test, or strings shorter

         // than aCount, and compareCount characters matched, we have to assume

         // that the longer string is greater.

         if (mLength != strLen)

           result = 1; // Arbitrarily using any number != 0

       }

     return result == 0;

   }

   /**

    * nsTString::ToDouble

    */

 double

 nsCString::ToDouble(nsresult* aErrorCode) const

   {

     double res = 0.0;

     if (mLength > 0)

       {

         char *conv_stopped;

         const char *str = mData;

         // Use PR_strtod, not strtod, since we don't want locale involved.

         res = PR_strtod(str, &conv_stopped);

         if (conv_stopped == str+mLength)

           *aErrorCode = NS_OK;

         else // Not all the string was scanned

           *aErrorCode = NS_ERROR_ILLEGAL_VALUE;

       }

     else

       {

         // The string was too short (0 characters)

         *aErrorCode = NS_ERROR_ILLEGAL_VALUE;

       }

     return res;

   }

 double

 nsString::ToDouble(nsresult* aErrorCode) const

   {

     return NS_LossyConvertUTF16toASCII(*this).ToDouble(aErrorCode);

   }

   /**

    * nsTString::AssignWithConversion

    */

 void

 nsCString::AssignWithConversion( const nsAString& aData )

   {

     LossyCopyUTF16toASCII(aData, *this);

   }

 void

 nsString::AssignWithConversion( const nsACString& aData )

   {

     CopyASCIItoUTF16(aData, *this);

   }

 #endif // !MOZ_STRING_WITH_OBSOLETE_API