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 "mozilla/MemoryReporting.h"

 #include "double-conversion.h"

 using double_conversion::DoubleToStringConverter;

 #ifdef XPCOM_STRING_CONSTRUCTOR_OUT_OF_LINE

 nsTSubstring_CharT::nsTSubstring_CharT( char_type *data, size_type length,

                                         uint32_t flags)

   : mData(data),

     mLength(length),

     mFlags(flags)

   {

     if (flags & F_OWNED) {

       STRING_STAT_INCREMENT(Adopt);

 #ifdef NS_BUILD_REFCNT_LOGGING

       NS_LogCtor(mData, "StringAdopt", 1);

 #endif

     }

   }

 #endif /* XPCOM_STRING_CONSTRUCTOR_OUT_OF_LINE */

   /**

    * helper function for down-casting a nsTSubstring to a nsTFixedString.

    */

 inline const nsTFixedString_CharT*

 AsFixedString( const nsTSubstring_CharT* s )

   {

     return static_cast<const nsTFixedString_CharT*>(s);

   }

   /**

    * this function is called to prepare mData for writing.  the given capacity

    * indicates the required minimum storage size for mData, in sizeof(char_type)

    * increments.  this function returns true if the operation succeeds.  it also

    * returns the old data and old flags members if mData is newly allocated.

    * the old data must be released by the caller.

    */

 bool

 nsTSubstring_CharT::MutatePrep( size_type capacity, char_type** oldData, uint32_t* oldFlags )

   {

     // initialize to no old data

     *oldData = nullptr;

     *oldFlags = 0;

     size_type curCapacity = Capacity();

     // If |capacity > kMaxCapacity|, then our doubling algorithm may not be

     // able to allocate it.  Just bail out in cases like that.  We don't want

     // to be allocating 2GB+ strings anyway.

     PR_STATIC_ASSERT((sizeof(nsStringBuffer) & 0x1) == 0);

     const size_type kMaxCapacity =

       (size_type(-1)/2 - sizeof(nsStringBuffer)) / sizeof(char_type) - 2;

     if (capacity > kMaxCapacity) {

       // Also assert for |capacity| equal to |size_type(-1)|, since we used to

       // use that value to flag immutability.

       NS_ASSERTION(capacity != size_type(-1), "Bogus capacity");

       return false;

     }

     // |curCapacity == 0| means that the buffer is immutable or 0-sized, so we

     // need to allocate a new buffer. We cannot use the existing buffer even

     // though it might be large enough.

     if (curCapacity != 0)

       {

         if (capacity <= curCapacity) {

           mFlags &= ~F_VOIDED;  // mutation clears voided flag

           return true;

         }

         // Use doubling algorithm when forced to increase available capacity.

         size_type temp = curCapacity;

         while (temp < capacity)

           temp <<= 1;

         NS_ASSERTION(XPCOM_MIN(temp, kMaxCapacity) >= capacity,

                      "should have hit the early return at the top");

         capacity = XPCOM_MIN(temp, kMaxCapacity);

       }

     //

     // several cases:

     //

     //  (1) we have a shared buffer (mFlags & F_SHARED)

     //  (2) we have an owned buffer (mFlags & F_OWNED)

     //  (3) we have a fixed buffer (mFlags & F_FIXED)

     //  (4) we have a readonly buffer

     //

     // requiring that we in some cases preserve the data before creating

     // a new buffer complicates things just a bit ;-)

     //

     size_type storageSize = (capacity + 1) * sizeof(char_type);

     // case #1

     if (mFlags & F_SHARED)

       {

         nsStringBuffer* hdr = nsStringBuffer::FromData(mData);

         if (!hdr->IsReadonly())

           {

             nsStringBuffer *newHdr = nsStringBuffer::Realloc(hdr, storageSize);

             if (!newHdr)

               return false; // out-of-memory (original header left intact)

             hdr = newHdr;

             mData = (char_type*) hdr->Data();

             mFlags &= ~F_VOIDED;  // mutation clears voided flag

             return true;

           }

       }

     char_type* newData;

     uint32_t newDataFlags;

       // if we have a fixed buffer of sufficient size, then use it.  this helps

       // avoid heap allocations.

     if ((mFlags & F_CLASS_FIXED) && (capacity < AsFixedString(this)->mFixedCapacity))

       {

         newData = AsFixedString(this)->mFixedBuf;

         newDataFlags = F_TERMINATED | F_FIXED;

       }

     else

       {

         // if we reach here then, we must allocate a new buffer.  we cannot

         // make use of our F_OWNED or F_FIXED buffers because they are not

         // large enough.

         nsStringBuffer* newHdr =

           nsStringBuffer::Alloc(storageSize).take();

         if (!newHdr)

           return false; // we are still in a consistent state

         newData = (char_type*) newHdr->Data();

         newDataFlags = F_TERMINATED | F_SHARED;

       }

     // save old data and flags

     *oldData = mData;

     *oldFlags = mFlags;

     mData = newData;

     SetDataFlags(newDataFlags);

     // mLength does not change

     // though we are not necessarily terminated at the moment, now is probably

     // still the best time to set F_TERMINATED.

     return true;

   }

 void

 nsTSubstring_CharT::Finalize()

   {

     ::ReleaseData(mData, mFlags);

     // mData, mLength, and mFlags are purposefully left dangling

   }

 bool

 nsTSubstring_CharT::ReplacePrepInternal(index_type cutStart, size_type cutLen,

                                         size_type fragLen, size_type newLen)

   {

     char_type* oldData;

     uint32_t oldFlags;

     if (!MutatePrep(newLen, &oldData, &oldFlags))

       return false; // out-of-memory

     if (oldData)

       {

         // determine whether or not we need to copy part of the old string

         // over to the new string.

         if (cutStart > 0)

           {

             // copy prefix from old string

             char_traits::copy(mData, oldData, cutStart);

           }

         if (cutStart + cutLen < mLength)

           {

             // copy suffix from old string to new offset

             size_type from = cutStart + cutLen;

             size_type fromLen = mLength - from;

             uint32_t to = cutStart + fragLen;

             char_traits::copy(mData + to, oldData + from, fromLen);

           }

         ::ReleaseData(oldData, oldFlags);

       }

     else

       {

         // original data remains intact

         // determine whether or not we need to move part of the existing string

         // to make room for the requested hole.

         if (fragLen != cutLen && cutStart + cutLen < mLength)

           {

             uint32_t from = cutStart + cutLen;

             uint32_t fromLen = mLength - from;

             uint32_t to = cutStart + fragLen;

             char_traits::move(mData + to, mData + from, fromLen);

           }

       }

     // add null terminator (mutable mData always has room for the null-

     // terminator).

     mData[newLen] = char_type(0);

     mLength = newLen;

     return true;

   }

 nsTSubstring_CharT::size_type

 nsTSubstring_CharT::Capacity() const

   {

     // return 0 to indicate an immutable or 0-sized buffer

     size_type capacity;

     if (mFlags & F_SHARED)

       {

         // if the string is readonly, then we pretend that it has no capacity.

         nsStringBuffer* hdr = nsStringBuffer::FromData(mData);

         if (hdr->IsReadonly())

           capacity = 0;

         else {

           capacity = (hdr->StorageSize() / sizeof(char_type)) - 1;

         }

       }

     else if (mFlags & F_FIXED)

       {

         capacity = AsFixedString(this)->mFixedCapacity;

       }

     else if (mFlags & F_OWNED)

       {

         // we don't store the capacity of an adopted buffer because that would

         // require an additional member field.  the best we can do is base the

         // capacity on our length.  remains to be seen if this is the right

         // trade-off.

         capacity = mLength;

       }

     else

       {

         capacity = 0;

       }

     return capacity;

   }

 bool

 nsTSubstring_CharT::EnsureMutable( size_type newLen )

   {

     if (newLen == size_type(-1) || newLen == mLength)

       {

         if (mFlags & (F_FIXED | F_OWNED))

           return true;

         if ((mFlags & F_SHARED) && !nsStringBuffer::FromData(mData)->IsReadonly())

           return true;

         newLen = mLength;

       }

     return SetLength(newLen, fallible_t());

   }

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

   // This version of Assign is optimized for single-character assignment.

 void

 nsTSubstring_CharT::Assign( char_type c )

   {

     if (!ReplacePrep(0, mLength, 1))

       NS_ABORT_OOM(mLength);

     *mData = c;

   }

 bool

 nsTSubstring_CharT::Assign( char_type c, const fallible_t& )

   {

     if (!ReplacePrep(0, mLength, 1))

       return false;

     *mData = c;

     return true;

   }

 void

 nsTSubstring_CharT::Assign( const char_type* data )

   {

     if (!Assign(data, size_type(-1), fallible_t()))

       NS_ABORT_OOM(char_traits::length(data));

   }

 void

 nsTSubstring_CharT::Assign( const char_type* data, size_type length )

   {

     if (!Assign(data, length, fallible_t()))

       NS_ABORT_OOM(length);

   }

 bool

 nsTSubstring_CharT::Assign( const char_type* data, size_type length, const fallible_t& )

   {

     if (!data || length == 0)

       {

         Truncate();

         return true;

       }

     if (length == size_type(-1))

       length = char_traits::length(data);

     if (IsDependentOn(data, data + length))

       {

         return Assign(string_type(data, length), fallible_t());

       }

     if (!ReplacePrep(0, mLength, length))

       return false;

     char_traits::copy(mData, data, length);

     return true;

   }

 void

 nsTSubstring_CharT::AssignASCII( const char* data, size_type length )

   {

     if (!AssignASCII(data, length, fallible_t()))

       NS_ABORT_OOM(length);

   }

 bool

 nsTSubstring_CharT::AssignASCII( const char* data, size_type length, const fallible_t& )

   {

     // A Unicode string can't depend on an ASCII string buffer,

     // so this dependence check only applies to CStrings.

 #ifdef CharT_is_char

     if (IsDependentOn(data, data + length))

       {

         return Assign(string_type(data, length), fallible_t());

       }

 #endif

     if (!ReplacePrep(0, mLength, length))

       return false;

     char_traits::copyASCII(mData, data, length);

     return true;

   }

 void

 nsTSubstring_CharT::AssignLiteral( const char_type* data, size_type length )

   {

     ::ReleaseData(mData, mFlags);

     mData = const_cast<char_type*>(data);

     mLength = length;

     SetDataFlags(F_TERMINATED | F_LITERAL);

   }

 void

 nsTSubstring_CharT::Assign( const self_type& str )

 {

   if (!Assign(str, fallible_t()))

     NS_ABORT_OOM(str.Length());

 }

 bool

 nsTSubstring_CharT::Assign( const self_type& str, const fallible_t& )

   {

     // |str| could be sharable.  we need to check its flags to know how to

     // deal with it.

     if (&str == this)

       return true;

     if (!str.mLength)

       {

         Truncate();

         mFlags |= str.mFlags & F_VOIDED;

         return true;

       }

     if (str.mFlags & F_SHARED)

       {

         // nice! we can avoid a string copy :-)

         // |str| should be null-terminated

         NS_ASSERTION(str.mFlags & F_TERMINATED, "shared, but not terminated");

         ::ReleaseData(mData, mFlags);

         mData = str.mData;

         mLength = str.mLength;

         SetDataFlags(F_TERMINATED | F_SHARED);

         // get an owning reference to the mData

         nsStringBuffer::FromData(mData)->AddRef();

         return true;

       }

     else if (str.mFlags & F_LITERAL)

       {

         NS_ABORT_IF_FALSE(str.mFlags & F_TERMINATED, "Unterminated literal");

         AssignLiteral(str.mData, str.mLength);

         return true;

       }

     // else, treat this like an ordinary assignment.

     return Assign(str.Data(), str.Length(), fallible_t());

   }

 void

 nsTSubstring_CharT::Assign( const substring_tuple_type& tuple )

   {

     if (!Assign(tuple, fallible_t()))

       NS_ABORT_OOM(tuple.Length());

   }

 bool

 nsTSubstring_CharT::Assign( const substring_tuple_type& tuple, const fallible_t& )

   {

     if (tuple.IsDependentOn(mData, mData + mLength))

       {

         // take advantage of sharing here...

         return Assign(string_type(tuple), fallible_t());

       }

     size_type length = tuple.Length();

     // don't use ReplacePrep here because it changes the length

     char_type* oldData;

     uint32_t oldFlags;

     if (!MutatePrep(length, &oldData, &oldFlags))

       return false;

     if (oldData)

       ::ReleaseData(oldData, oldFlags);

     tuple.WriteTo(mData, length);

     mData[length] = 0;

     mLength = length;

     return true;

   }

 void

 nsTSubstring_CharT::Adopt( char_type* data, size_type length )

   {

     if (data)

       {

         ::ReleaseData(mData, mFlags);

         if (length == size_type(-1))

           length = char_traits::length(data);

         mData = data;

         mLength = length;

         SetDataFlags(F_TERMINATED | F_OWNED);

         STRING_STAT_INCREMENT(Adopt);

 #ifdef NS_BUILD_REFCNT_LOGGING

         // Treat this as construction of a "StringAdopt" object for leak

         // tracking purposes.        

         NS_LogCtor(mData, "StringAdopt", 1);

 #endif // NS_BUILD_REFCNT_LOGGING

       }

     else

       {

         SetIsVoid(true);

       }

   }

   // This version of Replace is optimized for single-character replacement.

 void

 nsTSubstring_CharT::Replace( index_type cutStart, size_type cutLength, char_type c )

   {

     cutStart = XPCOM_MIN(cutStart, Length());

     if (ReplacePrep(cutStart, cutLength, 1))

       mData[cutStart] = c;

   }

 bool

 nsTSubstring_CharT::Replace( index_type cutStart, size_type cutLength, char_type c, const mozilla::fallible_t& )

   {

     cutStart = XPCOM_MIN(cutStart, Length());

     if (!ReplacePrep(cutStart, cutLength, 1))

       return false;

     mData[cutStart] = c;

     return true;

   }

 void

 nsTSubstring_CharT::Replace( index_type cutStart, size_type cutLength, const char_type* data, size_type length )

   {

     if (!Replace(cutStart, cutLength, data, length, mozilla::fallible_t()))

       {

         NS_ABORT_OOM(Length() - cutLength + 1);

       }

   }

 bool

 nsTSubstring_CharT::Replace( index_type cutStart, size_type cutLength, const char_type* data, size_type length, const mozilla::fallible_t& )

   {

       // unfortunately, some callers pass null :-(

     if (!data)

       {

         length = 0;

       }

     else

       {

         if (length == size_type(-1))

           length = char_traits::length(data);

         if (IsDependentOn(data, data + length))

           {

             nsTAutoString_CharT temp(data, length);

             return Replace(cutStart, cutLength, temp, mozilla::fallible_t());

           }

       }

     cutStart = XPCOM_MIN(cutStart, Length());

     bool ok = ReplacePrep(cutStart, cutLength, length);

     if (!ok)

       return false;

     if (length > 0)

       char_traits::copy(mData + cutStart, data, length);

     return true;

   }

 void

 nsTSubstring_CharT::ReplaceASCII( index_type cutStart, size_type cutLength, const char* data, size_type length )

   {

     if (length == size_type(-1))

       length = strlen(data);

     // A Unicode string can't depend on an ASCII string buffer,

     // so this dependence check only applies to CStrings.

 #ifdef CharT_is_char

     if (IsDependentOn(data, data + length))

       {

         nsTAutoString_CharT temp(data, length);

         Replace(cutStart, cutLength, temp);

         return;

       }

 #endif

     cutStart = XPCOM_MIN(cutStart, Length());

     if (ReplacePrep(cutStart, cutLength, length) && length > 0)

       char_traits::copyASCII(mData + cutStart, data, length);

   }

 void

 nsTSubstring_CharT::Replace( index_type cutStart, size_type cutLength, const substring_tuple_type& tuple )

   {

     if (tuple.IsDependentOn(mData, mData + mLength))

       {

         nsTAutoString_CharT temp(tuple);

         Replace(cutStart, cutLength, temp);

         return;

       }

     size_type length = tuple.Length();

     cutStart = XPCOM_MIN(cutStart, Length());

     if (ReplacePrep(cutStart, cutLength, length) && length > 0)

       tuple.WriteTo(mData + cutStart, length);

   }

 void

 nsTSubstring_CharT::ReplaceLiteral( index_type cutStart, size_type cutLength, const char_type* data, size_type length )

   {

     cutStart = XPCOM_MIN(cutStart, Length());

     if (!cutStart && cutLength == Length())

       AssignLiteral(data, length);

     else if (ReplacePrep(cutStart, cutLength, length) && length > 0)

       char_traits::copy(mData + cutStart, data, length);

   }

 void

 nsTSubstring_CharT::SetCapacity( size_type capacity )

   {

     if (!SetCapacity(capacity, fallible_t()))

       NS_ABORT_OOM(capacity);

   }

 bool

 nsTSubstring_CharT::SetCapacity( size_type capacity, const fallible_t& )

   {

     // capacity does not include room for the terminating null char

     // if our capacity is reduced to zero, then free our buffer.

     if (capacity == 0)

       {

         ::ReleaseData(mData, mFlags);

         mData = char_traits::sEmptyBuffer;

         mLength = 0;

         SetDataFlags(F_TERMINATED);

         return true;

       }

     char_type* oldData;

     uint32_t oldFlags;

     if (!MutatePrep(capacity, &oldData, &oldFlags))

       return false; // out-of-memory

     // compute new string length

     size_type newLen = XPCOM_MIN(mLength, capacity);

     if (oldData)

       {

         // preserve old data

         if (mLength > 0)

           char_traits::copy(mData, oldData, newLen);

         ::ReleaseData(oldData, oldFlags);

       }

     // adjust mLength if our buffer shrunk down in size

     if (newLen < mLength)

       mLength = newLen;

     // always null-terminate here, even if the buffer got longer.  this is

     // for backwards compat with the old string implementation.

     mData[capacity] = char_type(0);

     return true;

   }

 void

 nsTSubstring_CharT::SetLength( size_type length )

   {

     SetCapacity(length);

     mLength = length;

   }

 bool

 nsTSubstring_CharT::SetLength( size_type length, const fallible_t& )

   {

     if (!SetCapacity(length, fallible_t()))

       return false;

     mLength = length;

     return true;

   }

 void

 nsTSubstring_CharT::SetIsVoid( bool val )

   {

     if (val)

       {

         Truncate();

         mFlags |= F_VOIDED;

       }

     else

       {

         mFlags &= ~F_VOIDED;

       }

   }

 bool

 nsTSubstring_CharT::Equals( const self_type& str ) const

   {

     return mLength == str.mLength && char_traits::compare(mData, str.mData, mLength) == 0;

   }

 bool

 nsTSubstring_CharT::Equals( const self_type& str, const comparator_type& comp ) const

   {

     return mLength == str.mLength && comp(mData, str.mData, mLength, str.mLength) == 0;

   }

 bool

 nsTSubstring_CharT::Equals( const char_type* data ) const

   {

     // unfortunately, some callers pass null :-(

     if (!data)

       {

         NS_NOTREACHED("null data pointer");

         return mLength == 0;

       }

     // XXX avoid length calculation?

     size_type length = char_traits::length(data);

     return mLength == length && char_traits::compare(mData, data, mLength) == 0;

   }

 bool

 nsTSubstring_CharT::Equals( const char_type* data, const comparator_type& comp ) const

   {

     // unfortunately, some callers pass null :-(

     if (!data)

       {

         NS_NOTREACHED("null data pointer");

         return mLength == 0;

       }

     // XXX avoid length calculation?

     size_type length = char_traits::length(data);

     return mLength == length && comp(mData, data, mLength, length) == 0;

   }

 bool

 nsTSubstring_CharT::EqualsASCII( const char* data, size_type len ) const

   {

     return mLength == len && char_traits::compareASCII(mData, data, len) == 0;

   }

 bool

 nsTSubstring_CharT::EqualsASCII( const char* data ) const

   {

     return char_traits::compareASCIINullTerminated(mData, mLength, data) == 0;

   }

 bool

 nsTSubstring_CharT::LowerCaseEqualsASCII( const char* data, size_type len ) const

   {

     return mLength == len && char_traits::compareLowerCaseToASCII(mData, data, len) == 0;

   }

 bool

 nsTSubstring_CharT::LowerCaseEqualsASCII( const char* data ) const

   {

     return char_traits::compareLowerCaseToASCIINullTerminated(mData, mLength, data) == 0;

   }

 nsTSubstring_CharT::size_type

 nsTSubstring_CharT::CountChar( char_type c ) const

   {

     const char_type *start = mData;

     const char_type *end   = mData + mLength;

     return NS_COUNT(start, end, c);

   }

 int32_t

 nsTSubstring_CharT::FindChar( char_type c, index_type offset ) const

   {

     if (offset < mLength)

       {

         const char_type* result = char_traits::find(mData + offset, mLength - offset, c);

         if (result)

           return result - mData;

       }

     return -1;

   }

 void

 nsTSubstring_CharT::StripChar( char_type aChar, int32_t aOffset )

   {

     if (mLength == 0 || aOffset >= int32_t(mLength))

       return;

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

       NS_ABORT_OOM(mLength);

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

     char_type* to   = mData + aOffset;

     char_type* from = mData + aOffset;

     char_type* end  = mData + mLength;

     while (from < end)

       {

         char_type theChar = *from++;

         if (aChar != theChar)

           *to++ = theChar;

       }

     *to = char_type(0); // add the null

     mLength = to - mData;

   }

 void

 nsTSubstring_CharT::StripChars( const char_type* aChars, uint32_t aOffset )

   {

     if (aOffset >= uint32_t(mLength))

       return;

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

       NS_ABORT_OOM(mLength);

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

     char_type* to   = mData + aOffset;

     char_type* from = mData + aOffset;

     char_type* end  = mData + mLength;

     while (from < end)

       {

         char_type theChar = *from++;

         const char_type* test = aChars;

         for (; *test && *test != theChar; ++test);

         if (!*test) {

           // Not stripped, copy this char.

           *to++ = theChar;

         }

       }

     *to = char_type(0); // add the null

     mLength = to - mData;

   }

 int

 nsTSubstring_CharT::AppendFunc(void* arg, const char* s, uint32_t len)

   {

     self_type* self = static_cast<self_type*>(arg);

     // NSPR sends us the final null terminator even though we don't want it

     if (len && s[len - 1] == '\0') {

       --len;

     }

     self->AppendASCII(s, len);

     return len;

   }

 void nsTSubstring_CharT::AppendPrintf( const char* format, ...)

   {

     va_list ap;

     va_start(ap, format);

     uint32_t r = PR_vsxprintf(AppendFunc, this, format, ap);

     if (r == (uint32_t) -1)

       NS_RUNTIMEABORT("Allocation or other failure in PR_vsxprintf");

     va_end(ap);

   }

 void nsTSubstring_CharT::AppendPrintf( const char* format, va_list ap )

   {

     uint32_t r = PR_vsxprintf(AppendFunc, this, format, ap);

     if (r == (uint32_t) -1)

       NS_RUNTIMEABORT("Allocation or other failure in PR_vsxprintf");

   }

 /* hack to make sure we define FormatWithoutTrailingZeros only once */

 #ifdef CharT_is_PRUnichar

 // Returns the length of the formatted aDouble in buf.

 static int

 FormatWithoutTrailingZeros(char (& buf)[40], double aDouble,

                            int precision)

 {

   static const DoubleToStringConverter converter(DoubleToStringConverter::UNIQUE_ZERO |

                                                  DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN,

                                                  "Infinity",

                                                  "NaN",

                                                  'e',

                                                  -6, 21,

                                                  6, 1);

   double_conversion::StringBuilder builder(buf, sizeof(buf));

   bool exponential_notation = false;

   converter.ToPrecision(aDouble, precision, &exponential_notation, &builder);

   int length = builder.position();

   char* formattedDouble = builder.Finalize();

   // If we have a shorter string than precision, it means we have a special

   // value (NaN or Infinity).  All other numbers will be formatted with at

   // least precision digits.

   if (length <= precision) {

     return length;

   }

   char* end = formattedDouble + length;

   char* decimalPoint = strchr(buf, '.');

   // No trailing zeros to remove.

   if (decimalPoint == nullptr) {

     return length;

   }

   if (MOZ_UNLIKELY(exponential_notation)) {

     // We need to check for cases like 1.00000e-10 (yes, this is

     // disgusting).

     char* exponent = end - 1;

     for ( ; ; --exponent) {

       if (*exponent == 'e') {

         break;

       }

     }

     char* zerosBeforeExponent = exponent - 1;

     for ( ; zerosBeforeExponent != decimalPoint; --zerosBeforeExponent) {

       if (*zerosBeforeExponent != '0') {

         break;

       }

     }

     if (zerosBeforeExponent == decimalPoint) {

       --zerosBeforeExponent;

     }

     // Slide the exponent to the left over the trailing zeros.  Don't

     // worry about copying the trailing NUL character.

     size_t exponentSize = end - exponent;

     memmove(zerosBeforeExponent + 1, exponent, exponentSize);

     length -= exponent - (zerosBeforeExponent + 1);

   } else {

     char* trailingZeros = end - 1;

     for ( ; trailingZeros != decimalPoint; --trailingZeros) {

       if (*trailingZeros != '0') {

         break;

       }

     }

     if (trailingZeros == decimalPoint) {

       --trailingZeros;

     }

     length -= end - (trailingZeros + 1);

   }

   return length;

 }

 #endif /* CharT_is_PRUnichar */

 void

 nsTSubstring_CharT::AppendFloat( float aFloat )

 {

   char buf[40];

   int length = FormatWithoutTrailingZeros(buf, aFloat, 6);

   AppendASCII(buf, length);

 }

 void

 nsTSubstring_CharT::AppendFloat( double aFloat )

 {

   char buf[40];

   int length = FormatWithoutTrailingZeros(buf, aFloat, 15);

   AppendASCII(buf, length);

 }

 size_t

 nsTSubstring_CharT::SizeOfExcludingThisMustBeUnshared(

     mozilla::MallocSizeOf mallocSizeOf) const

 {

   if (mFlags & F_SHARED) {

     return nsStringBuffer::FromData(mData)->

              SizeOfIncludingThisMustBeUnshared(mallocSizeOf);

   }

   if (mFlags & F_OWNED) {

     return mallocSizeOf(mData);

   }

   // If we reach here, exactly one of the following must be true:

   // - F_VOIDED is set, and mData points to sEmptyBuffer;

   // - F_FIXED is set, and mData points to a buffer within a string

   //   object (e.g. nsAutoString);

   // - None of F_SHARED, F_OWNED, F_FIXED is set, and mData points to a buffer

   //   owned by something else.

   //

   // In all three cases, we don't measure it.

   return 0;

 }

 size_t

 nsTSubstring_CharT::SizeOfExcludingThisIfUnshared(

     mozilla::MallocSizeOf mallocSizeOf) const

 {

   // This is identical to SizeOfExcludingThisMustBeUnshared except for the

   // F_SHARED case.

   if (mFlags & F_SHARED) {

     return nsStringBuffer::FromData(mData)->

              SizeOfIncludingThisIfUnshared(mallocSizeOf);

   }

   if (mFlags & F_OWNED) {

     return mallocSizeOf(mData);

   }

   return 0;

 }

 size_t

 nsTSubstring_CharT::SizeOfExcludingThisEvenIfShared(

     mozilla::MallocSizeOf mallocSizeOf) const

 {

   // This is identical to SizeOfExcludingThisMustBeUnshared except for the

   // F_SHARED case.

   if (mFlags & F_SHARED) {

     return nsStringBuffer::FromData(mData)->

              SizeOfIncludingThisEvenIfShared(mallocSizeOf);

   }

   if (mFlags & F_OWNED) {

     return mallocSizeOf(mData);

   }

   return 0;

 }

 size_t

 nsTSubstring_CharT::SizeOfIncludingThisMustBeUnshared(

     mozilla::MallocSizeOf mallocSizeOf) const

 {

   return mallocSizeOf(this) + SizeOfExcludingThisMustBeUnshared(mallocSizeOf);

 }

 size_t

 nsTSubstring_CharT::SizeOfIncludingThisIfUnshared(

     mozilla::MallocSizeOf mallocSizeOf) const

 {

   return mallocSizeOf(this) + SizeOfExcludingThisIfUnshared(mallocSizeOf);

 }

 size_t

 nsTSubstring_CharT::SizeOfIncludingThisEvenIfShared(

     mozilla::MallocSizeOf mallocSizeOf) const

 {

   return mallocSizeOf(this) + SizeOfExcludingThisEvenIfShared(mallocSizeOf);

 }