#include "double-conversion/double-conversion.h"

#include "mozilla/Assertions.h"

#include "mozilla/CheckedInt.h"

#include "mozilla/MathAlgorithms.h"

#include "mozilla/MemoryReporting.h"

#include "mozilla/Printf.h"

#include "mozilla/ResultExtensions.h"

#include <iterator>

#include "fmt/format.h"

#include "fmt/xchar.h"

#include "nsASCIIMask.h"

#include "nsCharTraits.h"

#include "nsISupports.h"

#include "nsString.h"

#include "nsTArray.h"

const uint32_t kNsStringBufferShrinkingThreshold = 384;

using double_conversion::DoubleToStringConverter;

static void ReleaseData(void* aData, nsAString::DataFlags aFlags) {

}

#ifdef XPCOM_STRING_CONSTRUCTOR_OUT_OF_LINE

template <typename T>

nsTSubstring<T>::nsTSubstring(char_type* aData, size_type aLength,

DataFlags aDataFlags, ClassFlags aClassFlags)

: ::mozilla::detail::nsTStringRepr<T>(aData, aLength, aDataFlags,

aClassFlags) {

AssertValid();

if (aDataFlags & DataFlags::OWNED) {

MOZ_LOG_CTOR(this->mData, "StringAdopt", 1);

}

}

#endif /* XPCOM_STRING_CONSTRUCTOR_OUT_OF_LINE */

template <typename T>

inline const nsTAutoString<T>* AsAutoString(const nsTSubstring<T>* aStr) {

return static_cast<const nsTAutoString<T>*>(aStr);

}

template <typename T>

mozilla::Result<mozilla::BulkWriteHandle<T>, nsresult>

nsTSubstring<T>::BulkWrite(size_type aCapacity, size_type aPrefixToPreserve,

bool aAllowShrinking) {

auto r = StartBulkWriteImpl(aCapacity, aPrefixToPreserve, aAllowShrinking);

if (MOZ_UNLIKELY(r.isErr())) {

return r.propagateErr();

}

return mozilla::BulkWriteHandle<T>(this, r.unwrap());

}

template <typename T>

auto nsTSubstring<T>::StartBulkWriteImpl(size_type aCapacity,

size_type aPrefixToPreserve,

bool aAllowShrinking,

size_type aSuffixLength,

size_type aOldSuffixStart,

size_type aNewSuffixStart)

-> mozilla::Result<size_type, nsresult> {

// Note! Capacity does not include room for the terminating null char.

MOZ_ASSERT(aPrefixToPreserve <= aCapacity,

"Requested preservation of an overlong prefix.");

MOZ_ASSERT(aNewSuffixStart + aSuffixLength <= aCapacity,

"Requesed move of suffix to out-of-bounds location.");

// Can't assert aOldSuffixStart, because mLength may not be valid anymore,

// since this method allows itself to be called more than once.

// If zero capacity is requested, set the string to the special empty

// string.

if (MOZ_UNLIKELY(!aCapacity)) {

ReleaseData(this->mData, this->mDataFlags);

SetToEmptyBuffer();

return 0;

}

// Note! Capacity() returns 0 when the string is immutable.

const size_type curCapacity = Capacity();

bool shrinking = false;

// We've established that aCapacity > 0.

// |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 (aCapacity <= curCapacity) {

if (aAllowShrinking) {

shrinking = true;

} else {

char_traits::move(this->mData + aNewSuffixStart,

this->mData + aOldSuffixStart, aSuffixLength);

if (aSuffixLength) {

char_traits::uninitialize(this->mData + aPrefixToPreserve,

XPCOM_MIN(aNewSuffixStart - aPrefixToPreserve,

kNsStringBufferMaxPoison));

char_traits::uninitialize(

this->mData + aNewSuffixStart + aSuffixLength,

XPCOM_MIN(curCapacity + 1 - aNewSuffixStart - aSuffixLength,

kNsStringBufferMaxPoison));

} else {

char_traits::uninitialize(this->mData + aPrefixToPreserve,

XPCOM_MIN(curCapacity + 1 - aPrefixToPreserve,

kNsStringBufferMaxPoison));

}

return curCapacity;

}

}

char_type* oldData = this->mData;

DataFlags oldFlags = this->mDataFlags;

char_type* newData;

DataFlags newDataFlags;

size_type newCapacity;

// If this is an nsTAutoStringN, it's possible that we can use the inline

// buffer.

if ((this->mClassFlags & ClassFlags::INLINE) &&

(aCapacity <= AsAutoString(this)->mInlineCapacity)) {

newCapacity = AsAutoString(this)->mInlineCapacity;

newData = (char_type*)AsAutoString(this)->mStorage;

newDataFlags = DataFlags::TERMINATED | DataFlags::INLINE;

} else {

// If |aCapacity > 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.

static_assert((sizeof(mozilla::StringBuffer) & 0x1) == 0,

"bad size for mozilla::StringBuffer");

if (MOZ_UNLIKELY(!this->CheckCapacity(aCapacity))) {

return mozilla::Err(NS_ERROR_OUT_OF_MEMORY);

}

// We increase our capacity so that the allocated buffer grows

// exponentially, which gives us amortized O(1) appending. Below the

// threshold, we use powers-of-two. Above the threshold, we grow by at

// least 1.125, rounding up to the nearest MiB.

const size_type slowGrowthThreshold = 8 * 1024 * 1024;

// mozilla::StringBuffer allocates sizeof(mozilla::StringBuffer) + passed

// size, and storageSize below wants extra 1 * sizeof(char_type).

const size_type neededExtraSpace =

sizeof(mozilla::StringBuffer) / sizeof(char_type) + 1;

size_type temp;

if (aCapacity >= slowGrowthThreshold) {

size_type minNewCapacity =

curCapacity + (curCapacity >> 3); // multiply by 1.125

temp = XPCOM_MAX(aCapacity, minNewCapacity) + neededExtraSpace;

// Round up to the next multiple of MiB, but ensure the expected

// capacity doesn't include the extra space required by

// mozilla::StringBuffer and null-termination.

const size_t MiB = 1 << 20;

temp = (MiB * ((temp + MiB - 1) / MiB)) - neededExtraSpace;

} else {

// Round up to the next power of two.

temp =

mozilla::RoundUpPow2(aCapacity + neededExtraSpace) - neededExtraSpace;

}

newCapacity = XPCOM_MIN(temp, base_string_type::kMaxCapacity);

MOZ_ASSERT(newCapacity >= aCapacity,

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

// Avoid shrinking if the new buffer size is close to the old. Note that

// unsigned underflow is defined behavior.

if ((curCapacity - newCapacity) <= kNsStringBufferShrinkingThreshold &&

(this->mDataFlags & DataFlags::REFCOUNTED)) {

MOZ_ASSERT(aAllowShrinking, "How come we didn't return earlier?");

// We're already close enough to the right size.

newData = oldData;

newCapacity = curCapacity;

} else {

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

// Since we allocate only by powers of 2 we always fit into a full

// mozjemalloc bucket, it's not useful to use realloc, which may spend

// time uselessly copying too much.

mozilla::StringBuffer* newHdr =

mozilla::StringBuffer::Alloc(storageSize).take();

if (newHdr) {

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

} else if (shrinking) {

// We're still in a consistent state.

//

// Since shrinking is just a memory footprint optimization, we

// don't propagate OOM if we tried to shrink in order to avoid

// OOM crashes from infallible callers. If we're lucky, soon enough

// a fallible caller reaches OOM and is able to deal or we end up

// disposing of this string before reaching OOM again.

newData = oldData;

newCapacity = curCapacity;

} else {

return mozilla::Err(NS_ERROR_OUT_OF_MEMORY);

}

}

newDataFlags = DataFlags::TERMINATED | DataFlags::REFCOUNTED;

}

this->mData = newData;

this->mDataFlags = newDataFlags;

if (oldData == newData) {

char_traits::move(newData + aNewSuffixStart, oldData + aOldSuffixStart,

aSuffixLength);

if (aSuffixLength) {

char_traits::uninitialize(this->mData + aPrefixToPreserve,

XPCOM_MIN(aNewSuffixStart - aPrefixToPreserve,

kNsStringBufferMaxPoison));

char_traits::uninitialize(

this->mData + aNewSuffixStart + aSuffixLength,

XPCOM_MIN(newCapacity + 1 - aNewSuffixStart - aSuffixLength,

kNsStringBufferMaxPoison));

} else {

char_traits::uninitialize(this->mData + aPrefixToPreserve,

XPCOM_MIN(newCapacity + 1 - aPrefixToPreserve,

kNsStringBufferMaxPoison));

}

} else {

char_traits::copy(newData, oldData, aPrefixToPreserve);

char_traits::copy(newData + aNewSuffixStart, oldData + aOldSuffixStart,

aSuffixLength);

ReleaseData(oldData, oldFlags);

}

return newCapacity;

}

template <typename T>

void nsTSubstring<T>::FinishBulkWriteImpl(size_type aLength) {

if (aLength) {

FinishBulkWriteImplImpl(aLength);

} else {

ReleaseData(this->mData, this->mDataFlags);

SetToEmptyBuffer();

}

AssertValid();

}

template <typename T>

void nsTSubstring<T>::Finalize() {

ReleaseData(this->mData, this->mDataFlags);

// this->mData, this->mLength, and this->mDataFlags are purposefully left

// dangling

}

template <typename T>

bool nsTSubstring<T>::ReplacePrep(index_type aCutStart, size_type aCutLength,

size_type aNewLength) {

aCutLength = XPCOM_MIN(aCutLength, this->mLength - aCutStart);

mozilla::CheckedInt<size_type> newTotalLen = this->Length();

newTotalLen += aNewLength;

newTotalLen -= aCutLength;

if (!newTotalLen.isValid()) {

return false;

}

if (aCutStart == this->mLength && Capacity() > newTotalLen.value()) {

this->mDataFlags &= ~DataFlags::VOIDED;

this->mData[newTotalLen.value()] = char_type(0);

this->mLength = newTotalLen.value();

return true;

}

return ReplacePrepInternal(aCutStart, aCutLength, aNewLength,

newTotalLen.value());

}

template <typename T>

bool nsTSubstring<T>::ReplacePrepInternal(index_type aCutStart,

size_type aCutLen, size_type aFragLen,

size_type aNewLen) {

size_type newSuffixStart = aCutStart + aFragLen;

size_type oldSuffixStart = aCutStart + aCutLen;

size_type suffixLength = this->mLength - oldSuffixStart;

mozilla::Result<size_type, nsresult> r = StartBulkWriteImpl(

aNewLen, aCutStart, false, suffixLength, oldSuffixStart, newSuffixStart);

if (r.isErr()) {

return false;

}

FinishBulkWriteImpl(aNewLen);

return true;

}

template <typename T>

typename nsTSubstring<T>::size_type nsTSubstring<T>::Capacity() const {

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

size_type capacity;

if (this->mDataFlags & DataFlags::REFCOUNTED) {

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

mozilla::StringBuffer* hdr = mozilla::StringBuffer::FromData(this->mData);

if (hdr->IsReadonly()) {

capacity = 0;

} else {

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

}

} else if (this->mDataFlags & DataFlags::INLINE) {

MOZ_ASSERT(this->mClassFlags & ClassFlags::INLINE);

capacity = AsAutoString(this)->mInlineCapacity;

} else if (this->mDataFlags & DataFlags::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 = this->mLength;

} else {

capacity = 0;

}

return capacity;

}

template <typename T>

bool nsTSubstring<T>::EnsureMutable(size_type aNewLen) {

if (aNewLen == size_type(-1) || aNewLen == this->mLength) {

if (this->mDataFlags & (DataFlags::INLINE | DataFlags::OWNED)) {

return true;

}

if ((this->mDataFlags & DataFlags::REFCOUNTED) &&

!mozilla::StringBuffer::FromData(this->mData)->IsReadonly()) {

return true;

}

aNewLen = this->mLength;

}

return SetLength(aNewLen, mozilla::fallible);

}

template <typename T>

void nsTSubstring<T>::Assign(char_type aChar) {

if (MOZ_UNLIKELY(!Assign(aChar, mozilla::fallible))) {

AllocFailed(1);

}

}

template <typename T>

bool nsTSubstring<T>::Assign(char_type aChar, const fallible_t&) {

auto r = StartBulkWriteImpl(1, 0, true);

if (MOZ_UNLIKELY(r.isErr())) {

return false;

}

*this->mData = aChar;

FinishBulkWriteImpl(1);

return true;

}

template <typename T>

void nsTSubstring<T>::Assign(const char_type* aData, size_type aLength) {

if (MOZ_UNLIKELY(!Assign(aData, aLength, mozilla::fallible))) {

AllocFailed(aLength == size_type(-1) ? char_traits::length(aData)

: aLength);

}

}

template <typename T>

bool nsTSubstring<T>::Assign(const char_type* aData,

const fallible_t& aFallible) {

return Assign(aData, size_type(-1), aFallible);

}

template <typename T>

bool nsTSubstring<T>::Assign(const char_type* aData, size_type aLength,

const fallible_t& aFallible) {

if (!aData || aLength == 0) {

Truncate();

return true;

}

if (MOZ_UNLIKELY(aLength == size_type(-1))) {

aLength = char_traits::length(aData);

}

if (MOZ_UNLIKELY(this->IsDependentOn(aData, aData + aLength))) {

return Assign(string_type(aData, aLength), aFallible);

}

auto r = StartBulkWriteImpl(aLength, 0, true);

if (MOZ_UNLIKELY(r.isErr())) {

return false;

}

char_traits::copy(this->mData, aData, aLength);

FinishBulkWriteImpl(aLength);

return true;

}

template <typename T>

void nsTSubstring<T>::AssignASCII(const char* aData, size_type aLength) {

if (MOZ_UNLIKELY(!AssignASCII(aData, aLength, mozilla::fallible))) {

AllocFailed(aLength);

}

}

template <typename T>

void nsTSubstring<T>::AssignASCII(const nsLiteralCString& aData) {

AssignASCII(aData.get(), aData.Length());

}

template <typename T>

bool nsTSubstring<T>::AssignASCII(const char* aData, size_type aLength,

const fallible_t& aFallible) {

MOZ_ASSERT(aLength != size_type(-1));

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

// so this dependence check only applies to CStrings.

if constexpr (std::is_same_v<T, char>) {

if (this->IsDependentOn(aData, aData + aLength)) {

return Assign(string_type(aData, aLength), aFallible);

}

}

auto r = StartBulkWriteImpl(aLength, 0, true);

if (MOZ_UNLIKELY(r.isErr())) {

return false;

}

char_traits::copyASCII(this->mData, aData, aLength);

FinishBulkWriteImpl(aLength);

return true;

}

template <typename T>

void nsTSubstring<T>::AssignLiteral(const char_type* aData, size_type aLength) {

ReleaseData(this->mData, this->mDataFlags);

SetData(const_cast<char_type*>(aData), aLength,

DataFlags::TERMINATED | DataFlags::LITERAL);

}

template <typename T>

void nsTSubstring<T>::Assign(const self_type& aStr) {

if (!Assign(aStr, mozilla::fallible)) {

AllocFailed(aStr.Length());

}

}

template <typename T>

bool nsTSubstring<T>::Assign(const self_type& aStr,

const fallible_t& aFallible) {

// |aStr| could be sharable. We need to check its flags to know how to

// deal with it.

if (&aStr == this) {

return true;

}

if (!aStr.mLength) {

Truncate();

this->mDataFlags |= aStr.mDataFlags & DataFlags::VOIDED;

return true;

}

if (aStr.mDataFlags & DataFlags::REFCOUNTED) {

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

// |aStr| should be null-terminated

NS_ASSERTION(aStr.mDataFlags & DataFlags::TERMINATED,

"shared, but not terminated");

ReleaseData(this->mData, this->mDataFlags);

SetData(aStr.mData, aStr.mLength,

DataFlags::TERMINATED | DataFlags::REFCOUNTED);

// get an owning reference to the this->mData

mozilla::StringBuffer::FromData(this->mData)->AddRef();

return true;

}

if (aStr.mDataFlags & DataFlags::LITERAL) {

MOZ_ASSERT(aStr.mDataFlags & DataFlags::TERMINATED, "Unterminated literal");

AssignLiteral(aStr.mData, aStr.mLength);

return true;

}

// else, treat this like an ordinary assignment.

return Assign(aStr.Data(), aStr.Length(), aFallible);

}

template <typename T>

void nsTSubstring<T>::Assign(self_type&& aStr) {

if (!Assign(std::move(aStr), mozilla::fallible)) {

AllocFailed(aStr.Length());

}

}

template <typename T>

void nsTSubstring<T>::AssignOwned(self_type&& aStr) {

MOZ_ASSERT(aStr.mDataFlags & (DataFlags::REFCOUNTED | DataFlags::OWNED),

"neither shared nor owned");

// If they have a REFCOUNTED or OWNED buffer, we can avoid a copy - so steal

// their buffer and reset them to the empty string.

// |aStr| should be null-terminated

MOZ_ASSERT(aStr.mDataFlags & DataFlags::TERMINATED,

"shared or owned, but not terminated");

ReleaseData(this->mData, this->mDataFlags);

SetData(aStr.mData, aStr.mLength, aStr.mDataFlags);

aStr.SetToEmptyBuffer();

}

template <typename T>

bool nsTSubstring<T>::Assign(self_type&& aStr, const fallible_t& aFallible) {

// We're moving |aStr| in this method, so we need to try to steal the data,

// and in the fallback perform a copy-assignment followed by a truncation of

// the original string.

if (&aStr == this) {

NS_WARNING("Move assigning a string to itself?");

return true;

}

if (aStr.mDataFlags & (DataFlags::REFCOUNTED | DataFlags::OWNED)) {

AssignOwned(std::move(aStr));

return true;

}

// Otherwise treat this as a normal assignment, and truncate the moved string.

// We don't truncate the source string if the allocation failed.

if (!Assign(aStr, aFallible)) {

return false;

}

aStr.Truncate();

return true;

}

template <typename T>

void nsTSubstring<T>::Assign(const substring_tuple_type& aTuple) {

if (!Assign(aTuple, mozilla::fallible)) {

AllocFailed(aTuple.Length());

}

}

template <typename T>

bool nsTSubstring<T>::AssignNonDependent(const substring_tuple_type& aTuple,

size_type aTupleLength,

const mozilla::fallible_t& aFallible) {

NS_ASSERTION(aTuple.Length() == aTupleLength, "wrong length passed");

auto r = StartBulkWriteImpl(aTupleLength);

if (r.isErr()) {

return false;

}

aTuple.WriteTo(this->mData, aTupleLength);

FinishBulkWriteImpl(aTupleLength);

return true;

}

template <typename T>

bool nsTSubstring<T>::Assign(const substring_tuple_type& aTuple,

const fallible_t& aFallible) {

const auto [isDependentOnThis, tupleLength] =

aTuple.IsDependentOnWithLength(this->mData, this->mData + this->mLength);

if (isDependentOnThis) {

string_type temp;

self_type& tempSubstring = temp;

if (!tempSubstring.AssignNonDependent(aTuple, tupleLength, aFallible)) {

return false;

}

AssignOwned(std::move(temp));

return true;

}

return AssignNonDependent(aTuple, tupleLength, aFallible);

}

template <typename T>

void nsTSubstring<T>::Adopt(char_type* aData, size_type aLength) {

if (aData) {

ReleaseData(this->mData, this->mDataFlags);

if (aLength == size_type(-1)) {

aLength = char_traits::length(aData);

}

SetData(aData, aLength, DataFlags::TERMINATED | DataFlags::OWNED);

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

// tracking purposes.

MOZ_LOG_CTOR(this->mData, "StringAdopt", 1);

} else {

SetIsVoid(true);

}

}

template <typename T>

void nsTSubstring<T>::Replace(index_type aCutStart, size_type aCutLength,

char_type aChar) {

aCutStart = XPCOM_MIN(aCutStart, this->Length());

if (ReplacePrep(aCutStart, aCutLength, 1)) {

this->mData[aCutStart] = aChar;

}

}

template <typename T>

bool nsTSubstring<T>::Replace(index_type aCutStart, size_type aCutLength,

char_type aChar, const fallible_t&) {

aCutStart = XPCOM_MIN(aCutStart, this->Length());

if (!ReplacePrep(aCutStart, aCutLength, 1)) {

return false;

}

this->mData[aCutStart] = aChar;

return true;

}

template <typename T>

void nsTSubstring<T>::Replace(index_type aCutStart, size_type aCutLength,

const char_type* aData, size_type aLength) {

if (!Replace(aCutStart, aCutLength, aData, aLength, mozilla::fallible)) {

AllocFailed(this->Length() - aCutLength + 1);

}

}

template <typename T>

bool nsTSubstring<T>::Replace(index_type aCutStart, size_type aCutLength,

const char_type* aData, size_type aLength,

const fallible_t& aFallible) {

// unfortunately, some callers pass null :-(

if (!aData) {

aLength = 0;

} else {

if (aLength == size_type(-1)) {

aLength = char_traits::length(aData);

}

if (this->IsDependentOn(aData, aData + aLength)) {

nsTAutoString<T> temp(aData, aLength);

return Replace(aCutStart, aCutLength, temp, aFallible);

}

}

aCutStart = XPCOM_MIN(aCutStart, this->Length());

bool ok = ReplacePrep(aCutStart, aCutLength, aLength);

if (!ok) {

return false;

}

if (aLength > 0) {

char_traits::copy(this->mData + aCutStart, aData, aLength);

}

return true;

}

template <typename T>

void nsTSubstring<T>::Replace(index_type aCutStart, size_type aCutLength,

const substring_tuple_type& aTuple) {

if (!Replace(aCutStart, aCutLength, aTuple, mozilla::fallible)) {

AllocFailed(this->Length() - aCutLength + aTuple.Length());

}

}

template <typename T>

bool nsTSubstring<T>::Replace(index_type aCutStart, size_type aCutLength,

const substring_tuple_type& aTuple,

const fallible_t& aFallible) {

const auto [isDependentOnThis, tupleLength] =

aTuple.IsDependentOnWithLength(this->mData, this->mData + this->mLength);

if (isDependentOnThis) {

nsTAutoString<T> temp;

if (!temp.AssignNonDependent(aTuple, tupleLength, mozilla::fallible)) {

return false;

}

return Replace(aCutStart, aCutLength, temp, aFallible);

}

aCutStart = XPCOM_MIN(aCutStart, this->Length());

if (!ReplacePrep(aCutStart, aCutLength, tupleLength)) {

return false;

}

if (tupleLength > 0) {

aTuple.WriteTo(this->mData + aCutStart, tupleLength);

}

return true;

}

template <typename T>

void nsTSubstring<T>::ReplaceLiteral(index_type aCutStart, size_type aCutLength,

const char_type* aData,

size_type aLength) {

aCutStart = XPCOM_MIN(aCutStart, this->Length());

if (!aCutStart && aCutLength == this->Length() &&

!(this->mDataFlags & DataFlags::REFCOUNTED)) {

// Check for REFCOUNTED above to avoid undoing the effect of

// SetCapacity().

AssignLiteral(aData, aLength);

} else if (ReplacePrep(aCutStart, aCutLength, aLength) && aLength > 0) {

char_traits::copy(this->mData + aCutStart, aData, aLength);

}

}

template <typename T>

void nsTSubstring<T>::Append(char_type aChar) {

if (MOZ_UNLIKELY(!Append(aChar, mozilla::fallible))) {

AllocFailed(this->mLength + 1);

}

}

template <typename T>

bool nsTSubstring<T>::Append(char_type aChar, const fallible_t& aFallible) {

size_type oldLen = this->mLength;

size_type newLen = oldLen + 1; // Can't overflow

auto r = StartBulkWriteImpl(newLen, oldLen, false);

if (MOZ_UNLIKELY(r.isErr())) {

return false;

}

this->mData[oldLen] = aChar;

FinishBulkWriteImpl(newLen);

return true;

}

template <typename T>

void nsTSubstring<T>::Append(const char_type* aData, size_type aLength) {

if (MOZ_UNLIKELY(!Append(aData, aLength, mozilla::fallible))) {

AllocFailed(this->mLength + (aLength == size_type(-1)

? char_traits::length(aData)

: aLength));

}

}

template <typename T>

bool nsTSubstring<T>::Append(const char_type* aData, size_type aLength,

const fallible_t& aFallible) {

if (MOZ_UNLIKELY(aLength == size_type(-1))) {

aLength = char_traits::length(aData);

}

if (MOZ_UNLIKELY(!aLength)) {

// Avoid undoing the effect of SetCapacity() if both

// mLength and aLength are zero.

return true;

}

if (MOZ_UNLIKELY(this->IsDependentOn(aData, aData + aLength))) {

return Append(string_type(aData, aLength), mozilla::fallible);

}

size_type oldLen = this->mLength;

mozilla::CheckedInt<size_type> newLen(oldLen);

newLen += aLength;

if (MOZ_UNLIKELY(!newLen.isValid())) {

return false;

}

auto r = StartBulkWriteImpl(newLen.value(), oldLen, false);

if (MOZ_UNLIKELY(r.isErr())) {

return false;

}

char_traits::copy(this->mData + oldLen, aData, aLength);

FinishBulkWriteImpl(newLen.value());

return true;

}

template <typename T>

void nsTSubstring<T>::AppendASCII(const char* aData, size_type aLength) {

if (MOZ_UNLIKELY(!AppendASCII(aData, aLength, mozilla::fallible))) {

AllocFailed(this->mLength +

(aLength == size_type(-1) ? strlen(aData) : aLength));

}

}

template <typename T>

void nsTSubstring<T>::AppendASCII(const nsLiteralCString& aData) {

AppendASCII(aData.get(), aData.Length());

}

template <typename T>

bool nsTSubstring<T>::AppendASCII(const char* aData,

const fallible_t& aFallible) {

return AppendASCII(aData, size_type(-1), aFallible);

}

template <typename T>

bool nsTSubstring<T>::AppendASCII(const char* aData, size_type aLength,

const fallible_t& aFallible) {

if (MOZ_UNLIKELY(aLength == size_type(-1))) {

aLength = strlen(aData);

}

if (MOZ_UNLIKELY(!aLength)) {

// Avoid undoing the effect of SetCapacity() if both

// mLength and aLength are zero.

return true;

}

if constexpr (std::is_same_v<T, char>) {

// 16-bit string can't depend on an 8-bit buffer

if (MOZ_UNLIKELY(this->IsDependentOn(aData, aData + aLength))) {

return Append(string_type(aData, aLength), mozilla::fallible);

}

}

size_type oldLen = this->mLength;

mozilla::CheckedInt<size_type> newLen(oldLen);

newLen += aLength;

if (MOZ_UNLIKELY(!newLen.isValid())) {

return false;

}

auto r = StartBulkWriteImpl(newLen.value(), oldLen, false);

if (MOZ_UNLIKELY(r.isErr())) {

return false;

}

char_traits::copyASCII(this->mData + oldLen, aData, aLength);

FinishBulkWriteImpl(newLen.value());

return true;

}

template <typename T>

void nsTSubstring<T>::Append(const self_type& aStr) {

if (MOZ_UNLIKELY(!Append(aStr, mozilla::fallible))) {

AllocFailed(this->mLength + aStr.Length());

}

}

template <typename T>

bool nsTSubstring<T>::Append(const self_type& aStr,

const fallible_t& aFallible) {

// Check refcounted to avoid undoing the effects of SetCapacity().

if (MOZ_UNLIKELY(!this->mLength &&

!(this->mDataFlags & DataFlags::REFCOUNTED))) {

return Assign(aStr, mozilla::fallible);

}

return Append(aStr.BeginReading(), aStr.Length(), mozilla::fallible);

}

template <typename T>

void nsTSubstring<T>::Append(const substring_tuple_type& aTuple) {

if (MOZ_UNLIKELY(!Append(aTuple, mozilla::fallible))) {

AllocFailed(this->mLength + aTuple.Length());

}

}

template <typename T>

bool nsTSubstring<T>::Append(const substring_tuple_type& aTuple,

const fallible_t& aFallible) {

const auto [isDependentOnThis, tupleLength] =

aTuple.IsDependentOnWithLength(this->mData, this->mData + this->mLength);

if (MOZ_UNLIKELY(!tupleLength)) {

// Avoid undoing the effect of SetCapacity() if both

// mLength and tupleLength are zero.

return true;

}

if (MOZ_UNLIKELY(isDependentOnThis)) {

return Append(string_type(aTuple), aFallible);

}

size_type oldLen = this->mLength;

mozilla::CheckedInt<size_type> newLen(oldLen);

newLen += tupleLength;

if (MOZ_UNLIKELY(!newLen.isValid())) {

return false;

}

auto r = StartBulkWriteImpl(newLen.value(), oldLen, false);

if (MOZ_UNLIKELY(r.isErr())) {

return false;

}

aTuple.WriteTo(this->mData + oldLen, tupleLength);

FinishBulkWriteImpl(newLen.value());

return true;

}

template <typename T>

void nsTSubstring<T>::SetCapacity(size_type aCapacity) {

if (!SetCapacity(aCapacity, mozilla::fallible)) {

AllocFailed(aCapacity);

}

}

template <typename T>

bool nsTSubstring<T>::SetCapacity(size_type aCapacity, const fallible_t&) {

size_type length = this->mLength;

// This method can no longer be used to shorten the

// logical length.

size_type capacity = XPCOM_MAX(aCapacity, length);

auto r = StartBulkWriteImpl(capacity, length, true);

if (r.isErr()) {

return false;

}

if (MOZ_UNLIKELY(!capacity)) {

// Zero capacity was requested on a zero-length

// string. In this special case, we are pointing

// to the special empty buffer, which is already

// zero-terminated and not writable, so we must

// not attempt to zero-terminate it.

AssertValid();

return true;

}

// FinishBulkWriteImpl with argument zero releases

// the heap-allocated buffer. However, SetCapacity()

// is a special case that allows mLength to be zero

// while a heap-allocated buffer exists.

// By calling FinishBulkWriteImplImpl, we skip the

// zero case handling that's inappropriate in the

// SetCapacity() case.

FinishBulkWriteImplImpl(length);

return true;

}

template <typename T>

void nsTSubstring<T>::SetLength(size_type aLength) {

if (!SetLength(aLength, mozilla::fallible)) {

AllocFailed(aLength);

}

}

template <typename T>

bool nsTSubstring<T>::SetLength(size_type aLength,

const fallible_t& aFallible) {

size_type preserve = XPCOM_MIN(aLength, this->Length());

auto r = StartBulkWriteImpl(aLength, preserve, true);

if (r.isErr()) {

return false;

}

FinishBulkWriteImpl(aLength);

return true;

}

template <typename T>

void nsTSubstring<T>::Truncate() {

ReleaseData(this->mData, this->mDataFlags);

SetToEmptyBuffer();

AssertValid();

}

template <typename T>

void nsTSubstring<T>::SetIsVoid(bool aVal) {

if (aVal) {

Truncate();

this->mDataFlags |= DataFlags::VOIDED;

} else {

this->mDataFlags &= ~DataFlags::VOIDED;

}

}

template <typename T>