/* * Copyright (C) 1999-2001 Harri Porten (porten@kde.org) * Copyright (C) 2004-2019 Apple Inc. All rights reserved. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * */ #include "config.h" #include "StringConstructor.h" #include "JSArrayInlines.h" #include "JSCInlines.h" #include "SparseArrayValueMap.h" #include "StringPrototype.h" #include #include namespace JSC { static JSC_DECLARE_HOST_FUNCTION(stringFromCharCode); static JSC_DECLARE_HOST_FUNCTION(stringFromCodePoint); static JSC_DECLARE_HOST_FUNCTION(stringRaw); } #include "StringConstructor.lut.h" namespace JSC { const ClassInfo StringConstructor::s_info = { "Function"_s, &Base::s_info, &stringConstructorTable, nullptr, CREATE_METHOD_TABLE(StringConstructor) }; /* Source for StringConstructor.lut.h @begin stringConstructorTable fromCharCode stringFromCharCode DontEnum|Function 1 FromCharCodeIntrinsic fromCodePoint stringFromCodePoint DontEnum|Function 1 FromCodePointIntrinsic raw stringRaw DontEnum|Function 1 @end */ STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(StringConstructor); static JSC_DECLARE_HOST_FUNCTION(callStringConstructor); static JSC_DECLARE_HOST_FUNCTION(constructWithStringConstructor); StringConstructor::StringConstructor(VM& vm, NativeExecutable* executable, JSGlobalObject* globalObject, Structure* structure) : Base(vm, executable, globalObject, structure) { } void StringConstructor::finishCreation(VM& vm, StringPrototype* stringPrototype) { Base::finishCreation(vm); putDirectWithoutTransition(vm, vm.propertyNames->prototype, stringPrototype, PropertyAttribute::ReadOnly | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete); } StringConstructor* StringConstructor::create(VM& vm, Structure* structure, StringPrototype* stringPrototype) { JSGlobalObject* globalObject = structure->realm(); NativeExecutable* executable = vm.getHostFunction(callStringConstructor, ImplementationVisibility::Public, StringConstructorIntrinsic, constructWithStringConstructor, nullptr, 1, vm.propertyNames->String.string()); StringConstructor* constructor = new (NotNull, allocateCell(vm)) StringConstructor(vm, executable, globalObject, structure); constructor->finishCreation(vm, stringPrototype); return constructor; } // ------------------------------ Functions -------------------------------- enum class CharCodesKind : uint8_t { AllInt32With8BitChar, AllInt32With16BitChar, NotAllInt32, }; static ALWAYS_INLINE CharCodesKind classifyCharCodes(std::span charCodes) { if (!charCodes.front().isInt32()) return CharCodesKind::NotAllInt32; EncodedJSValue commonBits = -1; EncodedJSValue mergedBits = 0; for (JSValue charCode : charCodes) { commonBits &= JSValue::encode(charCode); mergedBits |= JSValue::encode(charCode); } if (!JSValue::decode(commonBits).isInt32()) return CharCodesKind::NotAllInt32; return isLatin1(static_cast(mergedBits)) ? CharCodesKind::AllInt32With8BitChar : CharCodesKind::AllInt32With16BitChar; } template static ALWAYS_INLINE Ref createStringImplFromInt32CharCodes(std::span charCodes) { ASSERT(std::ranges::all_of(charCodes, &JSValue::isInt32)); std::span characters; Ref impl = StringImpl::createUninitialized(charCodes.size(), characters); WTF::copyElements(spanReinterpretCast>(characters), spanReinterpretCast(charCodes)); return impl; } static NEVER_INLINE JSString* stringFromCharCodesSlow(JSGlobalObject* globalObject, std::span charCodes) { VM& vm = globalObject->vm(); auto scope = DECLARE_THROW_SCOPE(vm); Vector buffer(charCodes.size()); for (size_t i = 0; i < charCodes.size(); ++i) { buffer[i] = static_cast(charCodes[i].toInt32(globalObject)); RETURN_IF_EXCEPTION(scope, nullptr); } return jsNontrivialString(vm, StringImpl::create8BitIfPossible(borrow(buffer)->span())); } JSC_DEFINE_HOST_FUNCTION(stringFromCharCode, (JSGlobalObject* globalObject, CallFrame* callFrame)) { VM& vm = globalObject->vm(); auto scope = DECLARE_THROW_SCOPE(vm); std::span arguments = callFrame->argumentsSpan(); if (arguments.size() == 1) { scope.release(); char16_t code = arguments.front().toUInt32(globalObject); // Not checking for an exception here is ok because jsSingleCharacterString will just fetch an unused string if there's an exception. return JSValue::encode(jsSingleCharacterString(vm, code)); } if (arguments.empty()) [[unlikely]] return JSValue::encode(jsEmptyString(vm)); switch (classifyCharCodes(arguments)) { case CharCodesKind::AllInt32With8BitChar: return JSValue::encode(jsNontrivialString(vm, createStringImplFromInt32CharCodes(arguments))); case CharCodesKind::AllInt32With16BitChar: return JSValue::encode(jsNontrivialString(vm, createStringImplFromInt32CharCodes(arguments))); case CharCodesKind::NotAllInt32: RELEASE_AND_RETURN(scope, JSValue::encode(stringFromCharCodesSlow(globalObject, arguments))); } RELEASE_ASSERT_NOT_REACHED(); } JSString* stringFromCharCode(JSGlobalObject* globalObject, int32_t arg) { return jsSingleCharacterString(globalObject->vm(), static_cast(arg)); } JSC_DEFINE_HOST_FUNCTION(stringFromCodePoint, (JSGlobalObject* globalObject, CallFrame* callFrame)) { VM& vm = globalObject->vm(); auto scope = DECLARE_THROW_SCOPE(vm); unsigned length = callFrame->argumentCount(); if (vm.hasCompiledCode() && length == 1 && callFrame->uncheckedArgument(0).isInt32()) [[unlikely]] RELEASE_AND_RETURN(scope, JSValue::encode(stringFromCodePoint(globalObject, callFrame->uncheckedArgument(0).asInt32()))); StringBuilder builder; builder.reserveCapacity(length); for (unsigned i = 0; i < length; ++i) { double codePointAsDouble = callFrame->uncheckedArgument(i).toNumber(globalObject); RETURN_IF_EXCEPTION(scope, encodedJSValue()); uint32_t codePoint = truncateDoubleToUint32(codePointAsDouble); if (codePoint != codePointAsDouble || codePoint > UCHAR_MAX_VALUE) return throwVMError(globalObject, scope, createRangeError(globalObject, "Arguments contain a value that is out of range of code points"_s)); if (U_IS_BMP(codePoint)) builder.append(static_cast(codePoint)); else { builder.append(U16_LEAD(codePoint)); builder.append(U16_TRAIL(codePoint)); } } RELEASE_AND_RETURN(scope, JSValue::encode(jsString(vm, WTF::move(builder).toString()))); } JSString* stringFromCodePoint(JSGlobalObject* globalObject, int32_t arg) { VM& vm = globalObject->vm(); auto scope = DECLARE_THROW_SCOPE(vm); uint32_t codePoint = static_cast(arg); if (arg < 0 || codePoint > UCHAR_MAX_VALUE) [[unlikely]] { throwRangeError(globalObject, scope, "Arguments contain a value that is out of range of code points"_s); return nullptr; } scope.release(); if (U_IS_BMP(codePoint)) return jsSingleCharacterString(vm, static_cast(codePoint)); char16_t buffer[2] = { U16_LEAD(codePoint), U16_TRAIL(codePoint) }; return jsNontrivialString(vm, String({ buffer, 2 })); } // https://tc39.es/ecma262/#sec-string.raw JSC_DEFINE_HOST_FUNCTION(stringRaw, (JSGlobalObject* globalObject, CallFrame* callFrame)) { VM& vm = globalObject->vm(); auto scope = DECLARE_THROW_SCOPE(vm); JSValue templateValue = callFrame->argument(0); if (templateValue.isUndefinedOrNull()) [[unlikely]] return throwVMTypeError(globalObject, scope, "String.raw requires template not be null or undefined"_s); JSObject* cooked = templateValue.toObject(globalObject); RETURN_IF_EXCEPTION(scope, { }); JSValue rawValue = cooked->getDirect(vm, vm.propertyNames->raw); if (!rawValue || rawValue.isGetterSetter() || rawValue.isCustomGetterSetter()) [[unlikely]] { rawValue = cooked->get(globalObject, vm.propertyNames->raw); RETURN_IF_EXCEPTION(scope, { }); } if (rawValue.isUndefinedOrNull()) [[unlikely]] return throwVMTypeError(globalObject, scope, "String.raw requires template.raw not be null or undefined"_s); JSObject* raw = rawValue.toObject(globalObject); RETURN_IF_EXCEPTION(scope, { }); uint64_t literalCount = toLength(globalObject, raw); RETURN_IF_EXCEPTION(scope, { }); if (!literalCount) return JSValue::encode(jsEmptyString(vm)); unsigned argumentCount = callFrame->argumentCount(); unsigned substitutionCount = argumentCount ? argumentCount - 1 : 0; JSArray* rawArray = isJSArray(raw) ? asArray(raw) : nullptr; JSRopeString::RopeBuilder ropeBuilder(vm); for (uint64_t index = 0; ; ++index) { JSValue segment; if (rawArray) [[likely]] { Butterfly* butterfly = rawArray->butterfly(); switch (rawArray->indexingType()) { case ALL_INT32_INDEXING_TYPES: if (index < butterfly->publicLength()) { JSValue value = butterfly->contiguous().at(rawArray, index).get(); if (value) [[likely]] segment = jsString(vm, vm.numericStrings.add(value.asInt32())); } break; case ALL_DOUBLE_INDEXING_TYPES: if (index < butterfly->publicLength()) { double value = butterfly->contiguousDouble().at(rawArray, index); if (value == value) [[likely]] segment = jsString(vm, vm.numericStrings.add(value)); } break; case ALL_CONTIGUOUS_INDEXING_TYPES: if (index < butterfly->publicLength()) segment = butterfly->contiguous().at(rawArray, index).get(); break; case ALL_ARRAY_STORAGE_INDEXING_TYPES: [[likely]] { // This is the hot case because String.raw is used with tagged-templates, // and its template callsite object is a frozen array. ArrayStorage* storage = butterfly->arrayStorage(); if (index < storage->length()) { JSValue value; if (index < storage->vectorLength()) { WTF_ALLOW_UNSAFE_BUFFER_USAGE_BEGIN value = storage->m_vector[index].get(); WTF_ALLOW_UNSAFE_BUFFER_USAGE_END } else if (SparseArrayValueMap* map = storage->m_sparseMap.get()) { auto it = map->find(index); if (it != map->notFound()) { JSValue candidate = it->get(); if (!candidate.isGetterSetter() && !candidate.isCustomGetterSetter()) [[likely]] value = candidate; } } segment = value; } break; } default: break; } } if (!segment) [[unlikely]] { segment = raw->get(globalObject, index); RETURN_IF_EXCEPTION(scope, { }); } JSString* segmentString; if (segment.isString()) [[likely]] segmentString = asString(segment); else { segmentString = segment.toString(globalObject); RETURN_IF_EXCEPTION(scope, { }); } if (!ropeBuilder.append(segmentString)) [[unlikely]] return JSValue::encode(throwOutOfMemoryError(globalObject, scope)); if (index + 1 == literalCount) break; if (index < substitutionCount) { JSString* substitution = callFrame->uncheckedArgument(index + 1).toString(globalObject); RETURN_IF_EXCEPTION(scope, { }); if (!ropeBuilder.append(substitution)) [[unlikely]] return JSValue::encode(throwOutOfMemoryError(globalObject, scope)); } } RELEASE_AND_RETURN(scope, JSValue::encode(ropeBuilder.release())); } JSC_DEFINE_HOST_FUNCTION(constructWithStringConstructor, (JSGlobalObject* globalObject, CallFrame* callFrame)) { VM& vm = globalObject->vm(); auto scope = DECLARE_THROW_SCOPE(vm); JSObject* newTarget = asObject(callFrame->newTarget()); Structure* structure = JSC_GET_DERIVED_STRUCTURE(vm, stringObjectStructure, newTarget, callFrame->jsCallee()); RETURN_IF_EXCEPTION(scope, { }); if (!callFrame->argumentCount()) return JSValue::encode(StringObject::create(vm, structure)); JSString* str = callFrame->uncheckedArgument(0).toString(globalObject); RETURN_IF_EXCEPTION(scope, encodedJSValue()); return JSValue::encode(StringObject::create(vm, structure, str)); } JSString* stringConstructor(JSGlobalObject* globalObject, JSValue argument) { if (argument.isSymbol()) return asSymbol(argument)->toString(globalObject); return argument.toString(globalObject); } JSC_DEFINE_HOST_FUNCTION(callStringConstructor, (JSGlobalObject * globalObject, CallFrame* callFrame)) { VM& vm = globalObject->vm(); if (!callFrame->argumentCount()) return JSValue::encode(jsEmptyString(vm)); return JSValue::encode(stringConstructor(globalObject, callFrame->uncheckedArgument(0))); } } // namespace JSC