Source code

Revision control

Other Tools

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: set ts=8 sts=2 et sw=2 tw=80:
* 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 "builtin/String.h"
#include "mozilla/Attributes.h"
#include "mozilla/CheckedInt.h"
#include "mozilla/FloatingPoint.h"
#include "mozilla/PodOperations.h"
#include "mozilla/Range.h"
#include "mozilla/TextUtils.h"
#include <algorithm>
#include <limits>
#include <string.h>
#include <type_traits>
#include "jsnum.h"
#include "jstypes.h"
#include "builtin/Array.h"
#include "builtin/Boolean.h"
#if JS_HAS_INTL_API
# include "builtin/intl/CommonFunctions.h"
#endif
#include "builtin/RegExp.h"
#include "jit/InlinableNatives.h"
#include "js/Conversions.h"
#include "js/friend/ErrorMessages.h" // js::GetErrorMessage, JSMSG_*
#include "js/friend/StackLimits.h" // js::AutoCheckRecursionLimit
#if !JS_HAS_INTL_API
# include "js/LocaleSensitive.h"
#endif
#include "js/PropertyAndElement.h" // JS_DefineFunctions
#include "js/PropertySpec.h"
#include "js/StableStringChars.h"
#include "js/UniquePtr.h"
#if JS_HAS_INTL_API
# include "unicode/uchar.h"
# include "unicode/unorm2.h"
# include "unicode/ustring.h"
# include "unicode/utypes.h"
#endif
#include "util/StringBuffer.h"
#include "util/Unicode.h"
#include "vm/BytecodeUtil.h"
#include "vm/GlobalObject.h"
#include "vm/Interpreter.h"
#include "vm/JSAtom.h"
#include "vm/JSContext.h"
#include "vm/JSObject.h"
#include "vm/Opcodes.h"
#include "vm/Printer.h"
#include "vm/RegExpObject.h"
#include "vm/RegExpStatics.h"
#include "vm/SelfHosting.h"
#include "vm/ToSource.h" // js::ValueToSource
#include "vm/WellKnownAtom.h" // js_*_str
#include "vm/InlineCharBuffer-inl.h"
#include "vm/Interpreter-inl.h"
#include "vm/StringObject-inl.h"
#include "vm/StringType-inl.h"
using namespace js;
using JS::Symbol;
using JS::SymbolCode;
using mozilla::AsciiAlphanumericToNumber;
using mozilla::CheckedInt;
using mozilla::IsAsciiHexDigit;
using mozilla::IsNaN;
using mozilla::PodCopy;
using mozilla::RangedPtr;
using JS::AutoCheckCannotGC;
using JS::AutoStableStringChars;
static JSLinearString* ArgToLinearString(JSContext* cx, const CallArgs& args,
unsigned argno) {
if (argno >= args.length()) {
return cx->names().undefined;
}
JSString* str = ToString<CanGC>(cx, args[argno]);
if (!str) {
return nullptr;
}
return str->ensureLinear(cx);
}
/*
* Forward declarations for URI encode/decode and helper routines
*/
static bool str_decodeURI(JSContext* cx, unsigned argc, Value* vp);
static bool str_decodeURI_Component(JSContext* cx, unsigned argc, Value* vp);
static bool str_encodeURI(JSContext* cx, unsigned argc, Value* vp);
static bool str_encodeURI_Component(JSContext* cx, unsigned argc, Value* vp);
/*
* Global string methods
*/
/* ES5 B.2.1 */
template <typename CharT>
static bool Escape(JSContext* cx, const CharT* chars, uint32_t length,
InlineCharBuffer<Latin1Char>& newChars,
uint32_t* newLengthOut) {
// clang-format off
static const uint8_t shouldPassThrough[128] = {
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1, /* !"#$%&'()*+,-./ */
1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0, /* 0123456789:;<=>? */
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* @ABCDEFGHIJKLMNO */
1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1, /* PQRSTUVWXYZ[\]^_ */
0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* `abcdefghijklmno */
1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0, /* pqrstuvwxyz{\}~ DEL */
};
// clang-format on
/* Take a first pass and see how big the result string will need to be. */
uint32_t newLength = length;
for (size_t i = 0; i < length; i++) {
char16_t ch = chars[i];
if (ch < 128 && shouldPassThrough[ch]) {
continue;
}
/*
* newlength is incremented below by at most 5 and at this point it must
* be a valid string length, so this should never overflow uint32_t.
*/
static_assert(JSString::MAX_LENGTH < UINT32_MAX - 5,
"Adding 5 to valid string length should not overflow");
MOZ_ASSERT(newLength <= JSString::MAX_LENGTH);
/* The character will be encoded as %XX or %uXXXX. */
newLength += (ch < 256) ? 2 : 5;
if (MOZ_UNLIKELY(newLength > JSString::MAX_LENGTH)) {
ReportAllocationOverflow(cx);
return false;
}
}
if (newLength == length) {
*newLengthOut = newLength;
return true;
}
if (!newChars.maybeAlloc(cx, newLength)) {
return false;
}
static const char digits[] = "0123456789ABCDEF";
Latin1Char* rawNewChars = newChars.get();
size_t i, ni;
for (i = 0, ni = 0; i < length; i++) {
char16_t ch = chars[i];
if (ch < 128 && shouldPassThrough[ch]) {
rawNewChars[ni++] = ch;
} else if (ch < 256) {
rawNewChars[ni++] = '%';
rawNewChars[ni++] = digits[ch >> 4];
rawNewChars[ni++] = digits[ch & 0xF];
} else {
rawNewChars[ni++] = '%';
rawNewChars[ni++] = 'u';
rawNewChars[ni++] = digits[ch >> 12];
rawNewChars[ni++] = digits[(ch & 0xF00) >> 8];
rawNewChars[ni++] = digits[(ch & 0xF0) >> 4];
rawNewChars[ni++] = digits[ch & 0xF];
}
}
MOZ_ASSERT(ni == newLength);
*newLengthOut = newLength;
return true;
}
static bool str_escape(JSContext* cx, unsigned argc, Value* vp) {
CallArgs args = CallArgsFromVp(argc, vp);
RootedLinearString str(cx, ArgToLinearString(cx, args, 0));
if (!str) {
return false;
}
InlineCharBuffer<Latin1Char> newChars;
uint32_t newLength = 0; // initialize to silence GCC warning
if (str->hasLatin1Chars()) {
AutoCheckCannotGC nogc;
if (!Escape(cx, str->latin1Chars(nogc), str->length(), newChars,
&newLength)) {
return false;
}
} else {
AutoCheckCannotGC nogc;
if (!Escape(cx, str->twoByteChars(nogc), str->length(), newChars,
&newLength)) {
return false;
}
}
// Return input if no characters need to be escaped.
if (newLength == str->length()) {
args.rval().setString(str);
return true;
}
JSString* res = newChars.toString(cx, newLength);
if (!res) {
return false;
}
args.rval().setString(res);
return true;
}
template <typename CharT>
static inline bool Unhex4(const RangedPtr<const CharT> chars,
char16_t* result) {
CharT a = chars[0], b = chars[1], c = chars[2], d = chars[3];
if (!(IsAsciiHexDigit(a) && IsAsciiHexDigit(b) && IsAsciiHexDigit(c) &&
IsAsciiHexDigit(d))) {
return false;
}
char16_t unhex = AsciiAlphanumericToNumber(a);
unhex = (unhex << 4) + AsciiAlphanumericToNumber(b);
unhex = (unhex << 4) + AsciiAlphanumericToNumber(c);
unhex = (unhex << 4) + AsciiAlphanumericToNumber(d);
*result = unhex;
return true;
}
template <typename CharT>
static inline bool Unhex2(const RangedPtr<const CharT> chars,
char16_t* result) {
CharT a = chars[0], b = chars[1];
if (!(IsAsciiHexDigit(a) && IsAsciiHexDigit(b))) {
return false;
}
*result = (AsciiAlphanumericToNumber(a) << 4) + AsciiAlphanumericToNumber(b);
return true;
}
template <typename CharT>
static bool Unescape(StringBuffer& sb,
const mozilla::Range<const CharT> chars) {
// Step 2.
uint32_t length = chars.length();
/*
* Note that the spec algorithm has been optimized to avoid building
* a string in the case where no escapes are present.
*/
bool building = false;
#define ENSURE_BUILDING \
do { \
if (!building) { \
building = true; \
if (!sb.reserve(length)) return false; \
sb.infallibleAppend(chars.begin().get(), k); \
} \
} while (false);
// Step 4.
uint32_t k = 0;
// Step 5.
while (k < length) {
// Step 5.a.
char16_t c = chars[k];
// Step 5.b.
if (c == '%') {
static_assert(JSString::MAX_LENGTH < UINT32_MAX - 6,
"String length is not near UINT32_MAX");
// Steps 5.b.i-ii.
if (k + 6 <= length && chars[k + 1] == 'u') {
if (Unhex4(chars.begin() + k + 2, &c)) {
ENSURE_BUILDING
k += 5;
}
} else if (k + 3 <= length) {
if (Unhex2(chars.begin() + k + 1, &c)) {
ENSURE_BUILDING
k += 2;
}
}
}
// Step 5.c.
if (building && !sb.append(c)) {
return false;
}
// Step 5.d.
k += 1;
}
return true;
#undef ENSURE_BUILDING
}
// ES2018 draft rev f83aa38282c2a60c6916ebc410bfdf105a0f6a54
// B.2.1.2 unescape ( string )
static bool str_unescape(JSContext* cx, unsigned argc, Value* vp) {
CallArgs args = CallArgsFromVp(argc, vp);
// Step 1.
RootedLinearString str(cx, ArgToLinearString(cx, args, 0));
if (!str) {
return false;
}
// Step 3.
JSStringBuilder sb(cx);
if (str->hasTwoByteChars() && !sb.ensureTwoByteChars()) {
return false;
}
// Steps 2, 4-5.
if (str->hasLatin1Chars()) {
AutoCheckCannotGC nogc;
if (!Unescape(sb, str->latin1Range(nogc))) {
return false;
}
} else {
AutoCheckCannotGC nogc;
if (!Unescape(sb, str->twoByteRange(nogc))) {
return false;
}
}
// Step 6.
JSLinearString* result;
if (!sb.empty()) {
result = sb.finishString();
if (!result) {
return false;
}
} else {
result = str;
}
args.rval().setString(result);
return true;
}
static bool str_uneval(JSContext* cx, unsigned argc, Value* vp) {
CallArgs args = CallArgsFromVp(argc, vp);
JSString* str = ValueToSource(cx, args.get(0));
if (!str) {
return false;
}
args.rval().setString(str);
return true;
}
static const JSFunctionSpec string_functions[] = {
JS_FN(js_escape_str, str_escape, 1, JSPROP_RESOLVING),
JS_FN(js_unescape_str, str_unescape, 1, JSPROP_RESOLVING),
JS_FN(js_uneval_str, str_uneval, 1, JSPROP_RESOLVING),
JS_FN(js_decodeURI_str, str_decodeURI, 1, JSPROP_RESOLVING),
JS_FN(js_encodeURI_str, str_encodeURI, 1, JSPROP_RESOLVING),
JS_FN(js_decodeURIComponent_str, str_decodeURI_Component, 1,
JSPROP_RESOLVING),
JS_FN(js_encodeURIComponent_str, str_encodeURI_Component, 1,
JSPROP_RESOLVING),
JS_FS_END};
static const unsigned STRING_ELEMENT_ATTRS =
JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT;
static bool str_enumerate(JSContext* cx, HandleObject obj) {
RootedString str(cx, obj->as<StringObject>().unbox());
js::StaticStrings& staticStrings = cx->staticStrings();
RootedValue value(cx);
for (size_t i = 0, length = str->length(); i < length; i++) {
JSString* str1 = staticStrings.getUnitStringForElement(cx, str, i);
if (!str1) {
return false;
}
value.setString(str1);
if (!DefineDataElement(cx, obj, i, value,
STRING_ELEMENT_ATTRS | JSPROP_RESOLVING)) {
return false;
}
}
return true;
}
static bool str_mayResolve(const JSAtomState&, jsid id, JSObject*) {
// str_resolve ignores non-integer ids.
return JSID_IS_INT(id);
}
static bool str_resolve(JSContext* cx, HandleObject obj, HandleId id,
bool* resolvedp) {
if (!JSID_IS_INT(id)) {
return true;
}
RootedString str(cx, obj->as<StringObject>().unbox());
int32_t slot = JSID_TO_INT(id);
if ((size_t)slot < str->length()) {
JSString* str1 =
cx->staticStrings().getUnitStringForElement(cx, str, size_t(slot));
if (!str1) {
return false;
}
RootedValue value(cx, StringValue(str1));
if (!DefineDataElement(cx, obj, uint32_t(slot), value,
STRING_ELEMENT_ATTRS | JSPROP_RESOLVING)) {
return false;
}
*resolvedp = true;
}
return true;
}
static const JSClassOps StringObjectClassOps = {
nullptr, // addProperty
nullptr, // delProperty
str_enumerate, // enumerate
nullptr, // newEnumerate
str_resolve, // resolve
str_mayResolve, // mayResolve
nullptr, // finalize
nullptr, // call
nullptr, // hasInstance
nullptr, // construct
nullptr, // trace
};
const JSClass StringObject::class_ = {
js_String_str,
JSCLASS_HAS_RESERVED_SLOTS(StringObject::RESERVED_SLOTS) |
JSCLASS_HAS_CACHED_PROTO(JSProto_String),
&StringObjectClassOps, &StringObject::classSpec_};
/*
* Perform the initial |RequireObjectCoercible(thisv)| and |ToString(thisv)|
* from nearly all String.prototype.* functions.
*/
static MOZ_ALWAYS_INLINE JSString* ToStringForStringFunction(
JSContext* cx, const char* funName, HandleValue thisv) {
AutoCheckRecursionLimit recursion(cx);
if (!recursion.check(cx)) {
return nullptr;
}
if (thisv.isString()) {
return thisv.toString();
}
if (thisv.isObject()) {
RootedObject obj(cx, &thisv.toObject());
if (obj->is<StringObject>()) {
StringObject* nobj = &obj->as<StringObject>();
// We have to make sure that the ToPrimitive call from ToString
// would be unobservable.
if (HasNoToPrimitiveMethodPure(nobj, cx) &&
HasNativeMethodPure(nobj, cx->names().toString, str_toString, cx)) {
return nobj->unbox();
}
}
} else if (thisv.isNullOrUndefined()) {
JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
JSMSG_INCOMPATIBLE_PROTO, "String", funName,
thisv.isNull() ? "null" : "undefined");
return nullptr;
}
return ToStringSlow<CanGC>(cx, thisv);
}
MOZ_ALWAYS_INLINE bool IsString(HandleValue v) {
return v.isString() || (v.isObject() && v.toObject().is<StringObject>());
}
MOZ_ALWAYS_INLINE bool str_toSource_impl(JSContext* cx, const CallArgs& args) {
MOZ_ASSERT(IsString(args.thisv()));
JSString* str = ToString<CanGC>(cx, args.thisv());
if (!str) {
return false;
}
UniqueChars quoted = QuoteString(cx, str, '"');
if (!quoted) {
return false;
}
JSStringBuilder sb(cx);
if (!sb.append("(new String(") ||
!sb.append(quoted.get(), strlen(quoted.get())) || !sb.append("))")) {
return false;
}
JSString* result = sb.finishString();
if (!result) {
return false;
}
args.rval().setString(result);
return true;
}
static bool str_toSource(JSContext* cx, unsigned argc, Value* vp) {
CallArgs args = CallArgsFromVp(argc, vp);
return CallNonGenericMethod<IsString, str_toSource_impl>(cx, args);
}
MOZ_ALWAYS_INLINE bool str_toString_impl(JSContext* cx, const CallArgs& args) {
MOZ_ASSERT(IsString(args.thisv()));
args.rval().setString(
args.thisv().isString()
? args.thisv().toString()
: args.thisv().toObject().as<StringObject>().unbox());
return true;
}
bool js::str_toString(JSContext* cx, unsigned argc, Value* vp) {
CallArgs args = CallArgsFromVp(argc, vp);
return CallNonGenericMethod<IsString, str_toString_impl>(cx, args);
}
/*
* Java-like string native methods.
*/
JSString* js::SubstringKernel(JSContext* cx, HandleString str, int32_t beginInt,
int32_t lengthInt) {
MOZ_ASSERT(0 <= beginInt);
MOZ_ASSERT(0 <= lengthInt);
MOZ_ASSERT(uint32_t(beginInt) <= str->length());
MOZ_ASSERT(uint32_t(lengthInt) <= str->length() - beginInt);
uint32_t begin = beginInt;
uint32_t len = lengthInt;
/*
* Optimization for one level deep ropes.
* This is common for the following pattern:
*
* while() {
* text = text.substr(0, x) + "bla" + text.substr(x)
* test.charCodeAt(x + 1)
* }
*/
if (str->isRope()) {
JSRope* rope = &str->asRope();
/* Substring is totally in leftChild of rope. */
if (begin + len <= rope->leftChild()->length()) {
return NewDependentString(cx, rope->leftChild(), begin, len);
}
/* Substring is totally in rightChild of rope. */
if (begin >= rope->leftChild()->length()) {
begin -= rope->leftChild()->length();
return NewDependentString(cx, rope->rightChild(), begin, len);
}
/*
* Requested substring is partly in the left and partly in right child.
* Create a rope of substrings for both childs.
*/
MOZ_ASSERT(begin < rope->leftChild()->length() &&
begin + len > rope->leftChild()->length());
size_t lhsLength = rope->leftChild()->length() - begin;
size_t rhsLength = begin + len - rope->leftChild()->length();
Rooted<JSRope*> ropeRoot(cx, rope);
RootedString lhs(
cx, NewDependentString(cx, ropeRoot->leftChild(), begin, lhsLength));
if (!lhs) {
return nullptr;
}
RootedString rhs(
cx, NewDependentString(cx, ropeRoot->rightChild(), 0, rhsLength));
if (!rhs) {
return nullptr;
}
return JSRope::new_<CanGC>(cx, lhs, rhs, len);
}
return NewDependentString(cx, str, begin, len);
}
/**
* U+03A3 GREEK CAPITAL LETTER SIGMA has two different lower case mappings
* depending on its context:
* When it's preceded by a cased character and not followed by another cased
* character, its lower case form is U+03C2 GREEK SMALL LETTER FINAL SIGMA.
* Otherwise its lower case mapping is U+03C3 GREEK SMALL LETTER SIGMA.
*
* Unicode 9.0, §3.13 Default Case Algorithms
*/
static char16_t Final_Sigma(const char16_t* chars, size_t length,
size_t index) {
MOZ_ASSERT(index < length);
MOZ_ASSERT(chars[index] == unicode::GREEK_CAPITAL_LETTER_SIGMA);
MOZ_ASSERT(unicode::ToLowerCase(unicode::GREEK_CAPITAL_LETTER_SIGMA) ==
unicode::GREEK_SMALL_LETTER_SIGMA);
#if JS_HAS_INTL_API
// Tell the analysis the BinaryProperty.contains function pointer called by
// u_hasBinaryProperty cannot GC.
JS::AutoSuppressGCAnalysis nogc;
bool precededByCased = false;
for (size_t i = index; i > 0;) {
char16_t c = chars[--i];
uint32_t codePoint = c;
if (unicode::IsTrailSurrogate(c) && i > 0) {
char16_t lead = chars[i - 1];
if (unicode::IsLeadSurrogate(lead)) {
codePoint = unicode::UTF16Decode(lead, c);
i--;
}
}
// Ignore any characters with the property Case_Ignorable.
// NB: We need to skip over all Case_Ignorable characters, even when
// they also have the Cased binary property.
if (u_hasBinaryProperty(codePoint, UCHAR_CASE_IGNORABLE)) {
continue;
}
precededByCased = u_hasBinaryProperty(codePoint, UCHAR_CASED);
break;
}
if (!precededByCased) {
return unicode::GREEK_SMALL_LETTER_SIGMA;
}
bool followedByCased = false;
for (size_t i = index + 1; i < length;) {
char16_t c = chars[i++];
uint32_t codePoint = c;
if (unicode::IsLeadSurrogate(c) && i < length) {
char16_t trail = chars[i];
if (unicode::IsTrailSurrogate(trail)) {
codePoint = unicode::UTF16Decode(c, trail);
i++;
}
}
// Ignore any characters with the property Case_Ignorable.
// NB: We need to skip over all Case_Ignorable characters, even when
// they also have the Cased binary property.
if (u_hasBinaryProperty(codePoint, UCHAR_CASE_IGNORABLE)) {
continue;
}
followedByCased = u_hasBinaryProperty(codePoint, UCHAR_CASED);
break;
}
if (!followedByCased) {
return unicode::GREEK_SMALL_LETTER_FINAL_SIGMA;
}
#endif
return unicode::GREEK_SMALL_LETTER_SIGMA;
}
// If |srcLength == destLength| is true, the destination buffer was allocated
// with the same size as the source buffer. When we append characters which
// have special casing mappings, we test |srcLength == destLength| to decide
// if we need to back out and reallocate a sufficiently large destination
// buffer. Otherwise the destination buffer was allocated with the correct
// size to hold all lower case mapped characters, i.e.
// |destLength == ToLowerCaseLength(srcChars, 0, srcLength)| is true.
template <typename CharT>
static size_t ToLowerCaseImpl(CharT* destChars, const CharT* srcChars,
size_t startIndex, size_t srcLength,
size_t destLength) {
MOZ_ASSERT(startIndex < srcLength);
MOZ_ASSERT(srcLength <= destLength);
if constexpr (std::is_same_v<CharT, Latin1Char>) {
MOZ_ASSERT(srcLength == destLength);
}
size_t j = startIndex;
for (size_t i = startIndex; i < srcLength; i++) {
CharT c = srcChars[i];
if constexpr (!std::is_same_v<CharT, Latin1Char>) {
if (unicode::IsLeadSurrogate(c) && i + 1 < srcLength) {
char16_t trail = srcChars[i + 1];
if (unicode::IsTrailSurrogate(trail)) {
trail = unicode::ToLowerCaseNonBMPTrail(c, trail);
destChars[j++] = c;
destChars[j++] = trail;
i++;
continue;
}
}
// Special case: U+0130 LATIN CAPITAL LETTER I WITH DOT ABOVE
// lowercases to <U+0069 U+0307>.
if (c == unicode::LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE) {
// Return if the output buffer is too small.
if (srcLength == destLength) {
return i;
}
destChars[j++] = CharT('i');
destChars[j++] = CharT(unicode::COMBINING_DOT_ABOVE);
continue;
}
// Special case: U+03A3 GREEK CAPITAL LETTER SIGMA lowercases to
// one of two codepoints depending on context.
if (c == unicode::GREEK_CAPITAL_LETTER_SIGMA) {
destChars[j++] = Final_Sigma(srcChars, srcLength, i);
continue;
}
}
c = unicode::ToLowerCase(c);
destChars[j++] = c;
}
MOZ_ASSERT(j == destLength);
return srcLength;
}
static size_t ToLowerCaseLength(const char16_t* chars, size_t startIndex,
size_t length) {
size_t lowerLength = length;
for (size_t i = startIndex; i < length; i++) {
char16_t c = chars[i];
// U+0130 is lowercased to the two-element sequence <U+0069 U+0307>.
if (c == unicode::LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE) {
lowerLength += 1;
}
}
return lowerLength;
}
template <typename CharT>
static JSString* ToLowerCase(JSContext* cx, JSLinearString* str) {
// Unlike toUpperCase, toLowerCase has the nice invariant that if the
// input is a Latin-1 string, the output is also a Latin-1 string.
InlineCharBuffer<CharT> newChars;
const size_t length = str->length();
size_t resultLength;
{
AutoCheckCannotGC nogc;
const CharT* chars = str->chars<CharT>(nogc);
// We don't need extra special casing checks in the loop below,
// because U+0130 LATIN CAPITAL LETTER I WITH DOT ABOVE and U+03A3
// GREEK CAPITAL LETTER SIGMA already have simple lower case mappings.
MOZ_ASSERT(unicode::ChangesWhenLowerCased(
unicode::LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE),
"U+0130 has a simple lower case mapping");
MOZ_ASSERT(
unicode::ChangesWhenLowerCased(unicode::GREEK_CAPITAL_LETTER_SIGMA),
"U+03A3 has a simple lower case mapping");
// One element Latin-1 strings can be directly retrieved from the
// static strings cache.
if constexpr (std::is_same_v<CharT, Latin1Char>) {
if (length == 1) {
CharT lower = unicode::ToLowerCase(chars[0]);
MOZ_ASSERT(StaticStrings::hasUnit(lower));
return cx->staticStrings().getUnit(lower);
}
}
// Look for the first character that changes when lowercased.
size_t i = 0;
for (; i < length; i++) {
CharT c = chars[i];
if constexpr (!std::is_same_v<CharT, Latin1Char>) {
if (unicode::IsLeadSurrogate(c) && i + 1 < length) {
CharT trail = chars[i + 1];
if (unicode::IsTrailSurrogate(trail)) {
if (unicode::ChangesWhenLowerCasedNonBMP(c, trail)) {
break;
}
i++;
continue;
}
}
}
if (unicode::ChangesWhenLowerCased(c)) {
break;
}
}
// If no character needs to change, return the input string.
if (i == length) {
return str;
}
resultLength = length;
if (!newChars.maybeAlloc(cx, resultLength)) {
return nullptr;
}
PodCopy(newChars.get(), chars, i);
size_t readChars =
ToLowerCaseImpl(newChars.get(), chars, i, length, resultLength);
if constexpr (!std::is_same_v<CharT, Latin1Char>) {
if (readChars < length) {
resultLength = ToLowerCaseLength(chars, readChars, length);
if (!newChars.maybeRealloc(cx, length, resultLength)) {
return nullptr;
}
MOZ_ALWAYS_TRUE(length == ToLowerCaseImpl(newChars.get(), chars,
readChars, length,
resultLength));
}
} else {
MOZ_ASSERT(readChars == length,
"Latin-1 strings don't have special lower case mappings");
}
}
return newChars.toStringDontDeflate(cx, resultLength);
}
JSString* js::StringToLowerCase(JSContext* cx, HandleString string) {
JSLinearString* linear = string->ensureLinear(cx);
if (!linear) {
return nullptr;
}
if (linear->hasLatin1Chars()) {
return ToLowerCase<Latin1Char>(cx, linear);
}
return ToLowerCase<char16_t>(cx, linear);
}
static bool str_toLowerCase(JSContext* cx, unsigned argc, Value* vp) {
CallArgs args = CallArgsFromVp(argc, vp);
RootedString str(cx,
ToStringForStringFunction(cx, "toLowerCase", args.thisv()));
if (!str) {
return false;
}
JSString* result = StringToLowerCase(cx, str);
if (!result) {
return false;
}
args.rval().setString(result);
return true;
}
#if JS_HAS_INTL_API
// String.prototype.toLocaleLowerCase is self-hosted when Intl is exposed,
// with core functionality performed by the intrinsic below.
static const char* CaseMappingLocale(JSContext* cx, JSString* str) {
JSLinearString* locale = str->ensureLinear(cx);
if (!locale) {
return nullptr;
}
MOZ_ASSERT(locale->length() >= 2, "locale is a valid language tag");
// Lithuanian, Turkish, and Azeri have language dependent case mappings.
static const char languagesWithSpecialCasing[][3] = {"lt", "tr", "az"};
// All strings in |languagesWithSpecialCasing| are of length two, so we
// only need to compare the first two characters to find a matching locale.
// ES2017 Intl, §9.2.2 BestAvailableLocale
if (locale->length() == 2 || locale->latin1OrTwoByteChar(2) == '-') {
for (const auto& language : languagesWithSpecialCasing) {
if (locale->latin1OrTwoByteChar(0) == language[0] &&
locale->latin1OrTwoByteChar(1) == language[1]) {
return language;
}
}
}
return ""; // ICU root locale
}
bool js::intl_toLocaleLowerCase(JSContext* cx, unsigned argc, Value* vp) {
CallArgs args = CallArgsFromVp(argc, vp);
MOZ_ASSERT(args.length() == 2);
MOZ_ASSERT(args[0].isString());
MOZ_ASSERT(args[1].isString());
RootedString string(cx, args[0].toString());
const char* locale = CaseMappingLocale(cx, args[1].toString());
if (!locale) {
return false;
}
// Call String.prototype.toLowerCase() for language independent casing.
if (intl::StringsAreEqual(locale, "")) {
JSString* str = StringToLowerCase(cx, string);
if (!str) {
return false;
}
args.rval().setString(str);
return true;
}
AutoStableStringChars inputChars(cx);
if (!inputChars.initTwoByte(cx, string)) {
return false;
}
mozilla::Range<const char16_t> input = inputChars.twoByteRange();
// Note: maximum case mapping length is three characters, so the result
// length might be > INT32_MAX. ICU will fail in this case.
static_assert(JSString::MAX_LENGTH <= INT32_MAX,
"String length must fit in int32_t for ICU");
static const size_t INLINE_CAPACITY = js::intl::INITIAL_CHAR_BUFFER_SIZE;
Vector<char16_t, INLINE_CAPACITY> chars(cx);
if (!chars.resize(std::max(INLINE_CAPACITY, input.length()))) {
return false;
}
int32_t size = intl::CallICU(
cx,
[&input, locale](UChar* chars, int32_t size, UErrorCode* status) {
return u_strToLower(chars, size, input.begin().get(), input.length(),
locale, status);
},
chars);
if (size < 0) {
return false;
}
JSString* result = NewStringCopyN<CanGC>(cx, chars.begin(), size);
if (!result) {
return false;
}
args.rval().setString(result);
return true;
}
#else
// When the Intl API is not exposed, String.prototype.toLowerCase is implemented
// in C++.
static bool str_toLocaleLowerCase(JSContext* cx, unsigned argc, Value* vp) {
CallArgs args = CallArgsFromVp(argc, vp);
RootedString str(
cx, ToStringForStringFunction(cx, "toLocaleLowerCase", args.thisv()));
if (!str) {
return false;
}
/*
* Forcefully ignore the first (or any) argument and return toLowerCase(),
* ECMA has reserved that argument, presumably for defining the locale.
*/
if (cx->runtime()->localeCallbacks &&
cx->runtime()->localeCallbacks->localeToLowerCase) {
RootedValue result(cx);
if (!cx->runtime()->localeCallbacks->localeToLowerCase(cx, str, &result)) {
return false;
}
args.rval().set(result);
return true;
}
RootedLinearString linear(cx, str->ensureLinear(cx));
if (!linear) {
return false;
}
JSString* result = StringToLowerCase(cx, linear);
if (!result) {
return false;
}
args.rval().setString(result);
return true;
}
#endif // JS_HAS_INTL_API
static inline bool ToUpperCaseHasSpecialCasing(Latin1Char charCode) {
// U+00DF LATIN SMALL LETTER SHARP S is the only Latin-1 code point with
// special casing rules, so detect it inline.
bool hasUpperCaseSpecialCasing =
charCode == unicode::LATIN_SMALL_LETTER_SHARP_S;
MOZ_ASSERT(hasUpperCaseSpecialCasing ==
unicode::ChangesWhenUpperCasedSpecialCasing(charCode));
return hasUpperCaseSpecialCasing;
}
static inline bool ToUpperCaseHasSpecialCasing(char16_t charCode) {
return unicode::ChangesWhenUpperCasedSpecialCasing(charCode);
}
static inline size_t ToUpperCaseLengthSpecialCasing(Latin1Char charCode) {
// U+00DF LATIN SMALL LETTER SHARP S is uppercased to two 'S'.
MOZ_ASSERT(charCode == unicode::LATIN_SMALL_LETTER_SHARP_S);
return 2;
}
static inline size_t ToUpperCaseLengthSpecialCasing(char16_t charCode) {
MOZ_ASSERT(ToUpperCaseHasSpecialCasing(charCode));
return unicode::LengthUpperCaseSpecialCasing(charCode);
}
static inline void ToUpperCaseAppendUpperCaseSpecialCasing(char16_t charCode,
Latin1Char* elements,
size_t* index) {
// U+00DF LATIN SMALL LETTER SHARP S is uppercased to two 'S'.
MOZ_ASSERT(charCode == unicode::LATIN_SMALL_LETTER_SHARP_S);
static_assert('S' <= JSString::MAX_LATIN1_CHAR, "'S' is a Latin-1 character");
elements[(*index)++] = 'S';
elements[(*index)++] = 'S';
}
static inline void ToUpperCaseAppendUpperCaseSpecialCasing(char16_t charCode,
char16_t* elements,
size_t* index) {
unicode::AppendUpperCaseSpecialCasing(charCode, elements, index);
}
// See ToLowerCaseImpl for an explanation of the parameters.
template <typename DestChar, typename SrcChar>
static size_t ToUpperCaseImpl(DestChar* destChars, const SrcChar* srcChars,
size_t startIndex, size_t srcLength,
size_t destLength) {
static_assert(std::is_same_v<SrcChar, Latin1Char> ||
!std::is_same_v<DestChar, Latin1Char>,
"cannot write non-Latin-1 characters into Latin-1 string");
MOZ_ASSERT(startIndex < srcLength);
MOZ_ASSERT(srcLength <= destLength);
size_t j = startIndex;
for (size_t i = startIndex; i < srcLength; i++) {
char16_t c = srcChars[i];
if constexpr (!std::is_same_v<DestChar, Latin1Char>) {
if (unicode::IsLeadSurrogate(c) && i + 1 < srcLength) {
char16_t trail = srcChars[i + 1];
if (unicode::IsTrailSurrogate(trail)) {
trail = unicode::ToUpperCaseNonBMPTrail(c, trail);
destChars[j++] = c;
destChars[j++] = trail;
i++;
continue;
}
}
}
if (MOZ_UNLIKELY(c > 0x7f &&
ToUpperCaseHasSpecialCasing(static_cast<SrcChar>(c)))) {
// Return if the output buffer is too small.
if (srcLength == destLength) {
return i;
}
ToUpperCaseAppendUpperCaseSpecialCasing(c, destChars, &j);
continue;
}
c = unicode::ToUpperCase(c);
if constexpr (std::is_same_v<DestChar, Latin1Char>) {
MOZ_ASSERT(c <= JSString::MAX_LATIN1_CHAR);
}
destChars[j++] = c;
}
MOZ_ASSERT(j == destLength);
return srcLength;
}
template <typename CharT>
static size_t ToUpperCaseLength(const CharT* chars, size_t startIndex,
size_t length) {
size_t upperLength = length;
for (size_t i = startIndex; i < length; i++) {
char16_t c = chars[i];
if (c > 0x7f && ToUpperCaseHasSpecialCasing(static_cast<CharT>(c))) {
upperLength += ToUpperCaseLengthSpecialCasing(static_cast<CharT>(c)) - 1;
}
}
return upperLength;
}
template <typename DestChar, typename SrcChar>
static inline void CopyChars(DestChar* destChars, const SrcChar* srcChars,
size_t length) {
static_assert(!std::is_same_v<DestChar, SrcChar>,
"PodCopy is used for the same type case");
for (size_t i = 0; i < length; i++) {
destChars[i] = srcChars[i];
}
}
template <typename CharT>
static inline void CopyChars(CharT* destChars, const CharT* srcChars,
size_t length) {
PodCopy(destChars, srcChars, length);
}
template <typename DestChar, typename SrcChar>
static inline bool ToUpperCase(JSContext* cx,
InlineCharBuffer<DestChar>& newChars,
const SrcChar* chars, size_t startIndex,
size_t length, size_t* resultLength) {
MOZ_ASSERT(startIndex < length);
*resultLength = length;
if (!newChars.maybeAlloc(cx, length)) {
return false;
}
CopyChars(newChars.get(), chars, startIndex);
size_t readChars =
ToUpperCaseImpl(newChars.get(), chars, startIndex, length, length);
if (readChars < length) {
size_t actualLength = ToUpperCaseLength(chars, readChars, length);
*resultLength = actualLength;
if (!newChars.maybeRealloc(cx, length, actualLength)) {
return false;
}
MOZ_ALWAYS_TRUE(length == ToUpperCaseImpl(newChars.get(), chars, readChars,
length, actualLength));
}
return true;
}
template <typename CharT>
static JSString* ToUpperCase(JSContext* cx, JSLinearString* str) {
using Latin1Buffer = InlineCharBuffer<Latin1Char>;
using TwoByteBuffer = InlineCharBuffer<char16_t>;
mozilla::MaybeOneOf<Latin1Buffer, TwoByteBuffer> newChars;
const size_t length = str->length();
size_t resultLength;
{
AutoCheckCannotGC nogc;
const CharT* chars = str->chars<CharT>(nogc);
// Most one element Latin-1 strings can be directly retrieved from the
// static strings cache.
if constexpr (std::is_same_v<CharT, Latin1Char>) {
if (length == 1) {
Latin1Char c = chars[0];
if (c != unicode::MICRO_SIGN &&
c != unicode::LATIN_SMALL_LETTER_Y_WITH_DIAERESIS &&
c != unicode::LATIN_SMALL_LETTER_SHARP_S) {
char16_t upper = unicode::ToUpperCase(c);
MOZ_ASSERT(upper <= JSString::MAX_LATIN1_CHAR);
MOZ_ASSERT(StaticStrings::hasUnit(upper));
return cx->staticStrings().getUnit(upper);
}
MOZ_ASSERT(unicode::ToUpperCase(c) > JSString::MAX_LATIN1_CHAR ||
ToUpperCaseHasSpecialCasing(c));
}
}
// Look for the first character that changes when uppercased.
size_t i = 0;
for (; i < length; i++) {
CharT c = chars[i];
if constexpr (!std::is_same_v<CharT, Latin1Char>) {
if (unicode::IsLeadSurrogate(c) && i + 1 < length) {
CharT trail = chars[i + 1];
if (unicode::IsTrailSurrogate(trail)) {
if (unicode::ChangesWhenUpperCasedNonBMP(c, trail)) {
break;
}
i++;
continue;
}
}
}
if (unicode::ChangesWhenUpperCased(c)) {
break;
}
if (MOZ_UNLIKELY(c > 0x7f && ToUpperCaseHasSpecialCasing(c))) {
break;
}
}
// If no character needs to change, return the input string.
if (i == length) {
return str;
}
// The string changes when uppercased, so we must create a new string.
// Can it be Latin-1?
//
// If the original string is Latin-1, it can -- unless the string
// contains U+00B5 MICRO SIGN or U+00FF SMALL LETTER Y WITH DIAERESIS,
// the only Latin-1 codepoints that don't uppercase within Latin-1.
// Search for those codepoints to decide whether the new string can be
// Latin-1.
// If the original string is a two-byte string, its uppercase form is
// so rarely Latin-1 that we don't even consider creating a new
// Latin-1 string.
if constexpr (std::is_same_v<CharT, Latin1Char>) {
bool resultIsLatin1 = true;
for (size_t j = i; j < length; j++) {
Latin1Char c = chars[j];
if (c == unicode::MICRO_SIGN ||
c == unicode::LATIN_SMALL_LETTER_Y_WITH_DIAERESIS) {
MOZ_ASSERT(unicode::ToUpperCase(c) > JSString::MAX_LATIN1_CHAR);
resultIsLatin1 = false;
break;
} else {
MOZ_ASSERT(unicode::ToUpperCase(c) <= JSString::MAX_LATIN1_CHAR);
}
}
if (resultIsLatin1) {
newChars.construct<Latin1Buffer>();
if (!ToUpperCase(cx, newChars.ref<Latin1Buffer>(), chars, i, length,
&resultLength)) {
return nullptr;
}
} else {
newChars.construct<TwoByteBuffer>();
if (!ToUpperCase(cx, newChars.ref<TwoByteBuffer>(), chars, i, length,
&resultLength)) {
return nullptr;
}
}
} else {
newChars.construct<TwoByteBuffer>();
if (!ToUpperCase(cx, newChars.ref<TwoByteBuffer>(), chars, i, length,
&resultLength)) {
return nullptr;
}
}
}
return newChars.constructed<Latin1Buffer>()
? newChars.ref<Latin1Buffer>().toStringDontDeflate(cx,
resultLength)
: newChars.ref<TwoByteBuffer>().toStringDontDeflate(cx,
resultLength);
}
JSString* js::StringToUpperCase(JSContext* cx, HandleString string) {
JSLinearString* linear = string->ensureLinear(cx);
if (!linear) {
return nullptr;
}
if (linear->hasLatin1Chars()) {
return ToUpperCase<Latin1Char>(cx, linear);
}
return ToUpperCase<char16_t>(cx, linear);
}
static bool str_toUpperCase(JSContext* cx, unsigned argc, Value* vp) {
CallArgs args = CallArgsFromVp(argc, vp);
RootedString str(cx,
ToStringForStringFunction(cx, "toUpperCase", args.thisv()));
if (!str) {
return false;
}
JSString* result = StringToUpperCase(cx, str);
if (!result) {
return false;
}
args.rval().setString(result);
return true;
}
#if JS_HAS_INTL_API
// String.prototype.toLocaleUpperCase is self-hosted when Intl is exposed,
// with core functionality performed by the intrinsic below.
bool js::intl_toLocaleUpperCase(JSContext* cx, unsigned argc, Value* vp) {
CallArgs args = CallArgsFromVp(argc, vp);
MOZ_ASSERT(args.length() == 2);
MOZ_ASSERT(args[0].isString());
MOZ_ASSERT(args[1].isString());
RootedString string(cx, args[0].toString());
const char* locale = CaseMappingLocale(cx, args[1].toString());
if (!locale) {
return false;
}
// Call String.prototype.toUpperCase() for language independent casing.
if (intl::StringsAreEqual(locale, "")) {
JSString* str = js::StringToUpperCase(cx, string);
if (!str) {
return false;
}
args.rval().setString(str);
return true;
}
AutoStableStringChars inputChars(cx);
if (!inputChars.initTwoByte(cx, string)) {
return false;
}
mozilla::Range<const char16_t> input = inputChars.twoByteRange();
// Note: maximum case mapping length is three characters, so the result
// length might be > INT32_MAX. ICU will fail in this case.
static_assert(JSString::MAX_LENGTH <= INT32_MAX,
"String length must fit in int32_t for ICU");
static const size_t INLINE_CAPACITY = js::intl::INITIAL_CHAR_BUFFER_SIZE;
Vector<char16_t, INLINE_CAPACITY> chars(cx);
if (!chars.resize(std::max(INLINE_CAPACITY, input.length()))) {
return false;
}
int32_t size = intl::CallICU(
cx,
[&input, locale](UChar* chars, int32_t size, UErrorCode* status) {
return u_strToUpper(chars, size, input.begin().get(), input.length(),
locale, status);
},
chars);
if (size < 0) {
return false;
}
JSString* result = NewStringCopyN<CanGC>(cx, chars.begin(), size);
if (!result) {
return false;
}
args.rval().setString(result);
return true;
}
#else
// When the Intl API is not exposed, String.prototype.toUpperCase is implemented
// in C++.
static bool str_toLocaleUpperCase(JSContext* cx, unsigned argc, Value* vp) {
CallArgs args = CallArgsFromVp(argc, vp);
RootedString str(
cx, ToStringForStringFunction(cx, "toLocaleUpperCase", args.thisv()));
if (!str) {
return false;
}
/*
* Forcefully ignore the first (or any) argument and return toUpperCase(),
* ECMA has reserved that argument, presumably for defining the locale.
*/
if (cx->runtime()->localeCallbacks &&
cx->runtime()->localeCallbacks->localeToUpperCase) {
RootedValue result(cx);
if (!cx->runtime()->localeCallbacks->localeToUpperCase(cx, str, &result)) {
return false;
}
args.rval().set(result);
return true;
}
RootedLinearString linear(cx, str->ensureLinear(cx));
if (!linear) {
return false;
}
JSString* result = StringToUpperCase(cx, linear);
if (!result) {
return false;
}
args.rval().setString(result);
return true;
}
#endif // JS_HAS_INTL_API
#if JS_HAS_INTL_API
// String.prototype.localeCompare is self-hosted when Intl functionality is
// exposed, and the only intrinsics it requires are provided in the
// implementation of Intl.Collator.
#else
// String.prototype.localeCompare is implemented in C++ (delegating to
// JSLocaleCallbacks) when Intl functionality is not exposed.
static bool str_localeCompare(JSContext* cx, unsigned argc, Value* vp) {
CallArgs args = CallArgsFromVp(argc, vp);
RootedString str(
cx, ToStringForStringFunction(cx, "localeCompare", args.thisv()));
if (!str) {
return false;
}
RootedString thatStr(cx, ToString<CanGC>(cx, args.get(0)));
if (!thatStr) {
return false;
}
if (cx->runtime()->localeCallbacks &&
cx->runtime()->localeCallbacks->localeCompare) {
RootedValue result(cx);
if (!cx->runtime()->localeCallbacks->localeCompare(cx, str, thatStr,
&result)) {
return false;
}
args.rval().set(result);
return true;
}
int32_t result;
if (!CompareStrings(cx, str, thatStr, &result)) {
return false;
}
args.rval().setInt32(result);
return true;
}
#endif // JS_HAS_INTL_API
#if JS_HAS_INTL_API
// ES2017 draft rev 45e890512fd77add72cc0ee742785f9f6f6482de
// 21.1.3.12 String.prototype.normalize ( [ form ] )
//
// String.prototype.normalize is only implementable if ICU's normalization
// functionality is available.
static bool str_normalize(JSContext* cx, unsigned argc, Value* vp) {
CallArgs args = CallArgsFromVp(argc, vp);
// Steps 1-2.
RootedString str(cx,
ToStringForStringFunction(cx, "normalize", args.