/* * Copyright (c) 2021-2022 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "ecmascript/builtins/builtins.h" #include "ecmascript/base/error_type.h" #include "ecmascript/base/number_helper.h" #include "ecmascript/builtins/builtins_ark_tools.h" #include "ecmascript/builtins/builtins_array.h" #include "ecmascript/builtins/builtins_arraybuffer.h" #include "ecmascript/builtins/builtins_async_from_sync_iterator.h" #include "ecmascript/builtins/builtins_async_function.h" #include "ecmascript/builtins/builtins_async_iterator.h" #include "ecmascript/builtins/builtins_async_generator.h" #include "ecmascript/builtins/builtins_atomics.h" #include "ecmascript/builtins/builtins_bigint.h" #include "ecmascript/builtins/builtins_boolean.h" #include "ecmascript/builtins/builtins_cjs_module.h" #include "ecmascript/builtins/builtins_cjs_require.h" #include "ecmascript/builtins/builtins_cjs_exports.h" #include "ecmascript/builtins/builtins_collator.h" #include "ecmascript/builtins/builtins_dataview.h" #include "ecmascript/builtins/builtins_date.h" #include "ecmascript/builtins/builtins_date_time_format.h" #include "ecmascript/builtins/builtins_errors.h" #include "ecmascript/builtins/builtins_finalization_registry.h" #include "ecmascript/builtins/builtins_function.h" #include "ecmascript/builtins/builtins_generator.h" #include "ecmascript/builtins/builtins_global.h" #include "ecmascript/builtins/builtins_intl.h" #include "ecmascript/builtins/builtins_iterator.h" #include "ecmascript/builtins/builtins_json.h" #include "ecmascript/builtins/builtins_locale.h" #include "ecmascript/builtins/builtins_map.h" #include "ecmascript/builtins/builtins_math.h" #include "ecmascript/builtins/builtins_number.h" #include "ecmascript/builtins/builtins_number_format.h" #include "ecmascript/builtins/builtins_object.h" #include "ecmascript/builtins/builtins_plural_rules.h" #include "ecmascript/builtins/builtins_displaynames.h" #include "ecmascript/builtins/builtins_list_format.h" #include "ecmascript/builtins/builtins_promise.h" #include "ecmascript/builtins/builtins_promise_handler.h" #include "ecmascript/builtins/builtins_promise_job.h" #include "ecmascript/builtins/builtins_proxy.h" #include "ecmascript/builtins/builtins_reflect.h" #include "ecmascript/builtins/builtins_regexp.h" #include "ecmascript/builtins/builtins_relative_time_format.h" #include "ecmascript/builtins/builtins_set.h" #include "ecmascript/builtins/builtins_sharedarraybuffer.h" #include "ecmascript/builtins/builtins_string.h" #include "ecmascript/builtins/builtins_string_iterator.h" #include "ecmascript/builtins/builtins_symbol.h" #include "ecmascript/builtins/builtins_typedarray.h" #include "ecmascript/builtins/builtins_weak_map.h" #include "ecmascript/builtins/builtins_weak_ref.h" #include "ecmascript/builtins/builtins_weak_set.h" #include "ecmascript/containers/containers_private.h" #include "ecmascript/ecma_runtime_call_info.h" #include "ecmascript/js_array.h" #include "ecmascript/js_arraybuffer.h" #include "ecmascript/js_array_iterator.h" #include "ecmascript/js_async_function.h" #include "ecmascript/js_async_generator_object.h" #include "ecmascript/js_collator.h" #include "ecmascript/js_dataview.h" #include "ecmascript/js_date_time_format.h" #include "ecmascript/js_for_in_iterator.h" #include "ecmascript/js_finalization_registry.h" #include "ecmascript/js_function.h" #include "ecmascript/js_handle.h" #include "ecmascript/js_hclass.h" #include "ecmascript/js_locale.h" #include "ecmascript/js_map.h" #include "ecmascript/js_map_iterator.h" #include "ecmascript/js_number_format.h" #include "ecmascript/js_plural_rules.h" #include "ecmascript/js_displaynames.h" #include "ecmascript/js_list_format.h" #include "ecmascript/js_primitive_ref.h" #include "ecmascript/js_promise.h" #include "ecmascript/js_regexp.h" #include "ecmascript/js_regexp_iterator.h" #include "ecmascript/js_relative_time_format.h" #include "ecmascript/js_runtime_options.h" #include "ecmascript/js_set.h" #include "ecmascript/js_set_iterator.h" #include "ecmascript/js_string_iterator.h" #include "ecmascript/js_async_from_sync_iterator.h" #include "ecmascript/js_tagged_value.h" #include "ecmascript/js_typed_array.h" #include "ecmascript/js_weak_container.h" #include "ecmascript/js_weak_ref.h" #include "ecmascript/mem/mem.h" #include "ecmascript/module/js_module_namespace.h" #include "ecmascript/require/js_cjs_module.h" #include "ecmascript/require/js_cjs_module_cache.h" #include "ecmascript/require/js_cjs_require.h" #include "ecmascript/require/js_cjs_exports.h" #include "ecmascript/napi/include/jsnapi.h" #include "ecmascript/object_factory.h" #include "ohos/init_data.h" namespace panda::ecmascript { using Number = builtins::BuiltinsNumber; using BuiltinsBigInt = builtins::BuiltinsBigInt; using Object = builtins::BuiltinsObject; using Date = builtins::BuiltinsDate; using Symbol = builtins::BuiltinsSymbol; using Boolean = builtins::BuiltinsBoolean; using BuiltinsMap = builtins::BuiltinsMap; using BuiltinsSet = builtins::BuiltinsSet; using BuiltinsWeakMap = builtins::BuiltinsWeakMap; using BuiltinsWeakSet = builtins::BuiltinsWeakSet; using BuiltinsWeakRef = builtins::BuiltinsWeakRef; using BuiltinsFinalizationRegistry = builtins::BuiltinsFinalizationRegistry; using BuiltinsArray = builtins::BuiltinsArray; using BuiltinsTypedArray = builtins::BuiltinsTypedArray; using BuiltinsIterator = builtins::BuiltinsIterator; using Error = builtins::BuiltinsError; using RangeError = builtins::BuiltinsRangeError; using ReferenceError = builtins::BuiltinsReferenceError; using TypeError = builtins::BuiltinsTypeError; using AggregateError = builtins::BuiltinsAggregateError; using URIError = builtins::BuiltinsURIError; using SyntaxError = builtins::BuiltinsSyntaxError; using EvalError = builtins::BuiltinsEvalError; using OOMError = builtins::BuiltinsOOMError; using ErrorType = base::ErrorType; using RandomGenerator = base::RandomGenerator; using Global = builtins::BuiltinsGlobal; using BuiltinsString = builtins::BuiltinsString; using StringIterator = builtins::BuiltinsStringIterator; using BuiltinsAsyncFromSyncIterator = builtins::BuiltinsAsyncFromSyncIterator; using RegExp = builtins::BuiltinsRegExp; using Function = builtins::BuiltinsFunction; using Math = builtins::BuiltinsMath; using Atomics = builtins::BuiltinsAtomics; using ArrayBuffer = builtins::BuiltinsArrayBuffer; using Json = builtins::BuiltinsJson; using Proxy = builtins::BuiltinsProxy; using Reflect = builtins::BuiltinsReflect; using AsyncFunction = builtins::BuiltinsAsyncFunction; using GeneratorObject = builtins::BuiltinsGenerator; using Promise = builtins::BuiltinsPromise; using BuiltinsPromiseHandler = builtins::BuiltinsPromiseHandler; using BuiltinsPromiseJob = builtins::BuiltinsPromiseJob; using ErrorType = base::ErrorType; using DataView = builtins::BuiltinsDataView; using Intl = builtins::BuiltinsIntl; using Locale = builtins::BuiltinsLocale; using DateTimeFormat = builtins::BuiltinsDateTimeFormat; using RelativeTimeFormat = builtins::BuiltinsRelativeTimeFormat; using NumberFormat = builtins::BuiltinsNumberFormat; using Collator = builtins::BuiltinsCollator; using PluralRules = builtins::BuiltinsPluralRules; using DisplayNames = builtins::BuiltinsDisplayNames; using ListFormat = builtins::BuiltinsListFormat; using BuiltinsCjsModule = builtins::BuiltinsCjsModule; using BuiltinsCjsExports = builtins::BuiltinsCjsExports; using BuiltinsCjsRequire = builtins::BuiltinsCjsRequire; using ContainersPrivate = containers::ContainersPrivate; using SharedArrayBuffer = builtins::BuiltinsSharedArrayBuffer; using BuiltinsAsyncIterator = builtins::BuiltinsAsyncIterator; using AsyncGeneratorObject = builtins::BuiltinsAsyncGenerator; void Builtins::Initialize(const JSHandle &env, JSThread *thread) { thread_ = thread; vm_ = thread->GetEcmaVM(); factory_ = vm_->GetFactory(); [[maybe_unused]] EcmaHandleScope scope(thread_); JSHandle nullHandle(thread, JSTaggedValue::Null()); // Object.prototype[hclass] JSHandle objPrototypeHClass = factory_->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, nullHandle); // Object.prototype JSHandle objFuncPrototype = factory_->NewJSObject(objPrototypeHClass); JSHandle objFuncPrototypeVal(objFuncPrototype); // Object.prototype_or_hclass JSHandle objFuncClass = factory_->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, objFuncPrototypeVal); // GLobalObject.prototype_or_hclass JSHandle globalObjFuncClass = factory_->NewEcmaHClass(JSObject::SIZE, JSType::JS_GLOBAL_OBJECT, 0); globalObjFuncClass->SetPrototype(thread_, objFuncPrototypeVal.GetTaggedValue()); globalObjFuncClass->SetIsDictionaryMode(true); // Function.prototype_or_hclass JSHandle emptyFuncClass( factory_->NewEcmaHClass(JSFunction::SIZE, JSType::JS_FUNCTION, objFuncPrototypeVal)); // PrimitiveRef.prototype_or_hclass JSHandle primRefObjHClass = factory_->NewEcmaHClass(JSPrimitiveRef::SIZE, JSType::JS_PRIMITIVE_REF, objFuncPrototypeVal); // init global object JSHandle globalObject = factory_->NewNonMovableJSObject(globalObjFuncClass); env->SetJSGlobalObject(thread_, globalObject); // init global patch JSHandle globalPatch = factory_->EmptyArray(); env->SetGlobalPatch(thread, globalPatch); // initialize Function, forbidden change order InitializeFunction(env, emptyFuncClass); JSHandle asyncAwaitStatusFuncClass = factory_->CreateFunctionClass(FunctionKind::NORMAL_FUNCTION, JSAsyncAwaitStatusFunction::SIZE, JSType::JS_ASYNC_AWAIT_STATUS_FUNCTION, env->GetFunctionPrototype()); env->SetAsyncAwaitStatusFunctionClass(thread_, asyncAwaitStatusFuncClass); JSHandle asyncGeneratorResNextRetProRstFtnClass = factory_->NewEcmaHClass(JSAsyncGeneratorResNextRetProRstFtn::SIZE, JSType::JS_ASYNC_GENERATOR_RESUME_NEXT_RETURN_PROCESSOR_RST_FTN, env->GetFunctionPrototype()); asyncGeneratorResNextRetProRstFtnClass->SetCallable(true); asyncGeneratorResNextRetProRstFtnClass->SetExtensible(true); env->SetAsyncGeneratorResNextRetProRstFtnClass(thread_, asyncGeneratorResNextRetProRstFtnClass); JSHandle proxyRevocFuncClass = factory_->NewEcmaHClass( JSProxyRevocFunction::SIZE, JSType::JS_PROXY_REVOC_FUNCTION, env->GetFunctionPrototype()); proxyRevocFuncClass->SetCallable(true); proxyRevocFuncClass->SetExtensible(true); env->SetProxyRevocFunctionClass(thread_, proxyRevocFuncClass); // Object = new Function() JSHandle objectFunction( NewBuiltinConstructor(env, objFuncPrototype, Object::ObjectConstructor, "Object", FunctionLength::ONE)); objectFunction.GetObject()->SetFunctionPrototype(thread_, objFuncClass.GetTaggedValue()); // initialize object method. env->SetObjectFunction(thread_, objectFunction); env->SetObjectFunctionPrototype(thread_, objFuncPrototype); JSHandle FunctionClass = factory_->CreateFunctionClass(FunctionKind::BASE_CONSTRUCTOR, JSFunction::SIZE, JSType::JS_FUNCTION, env->GetFunctionPrototype()); env->SetFunctionClassWithProto(thread_, FunctionClass); FunctionClass = factory_->CreateFunctionClass(FunctionKind::NORMAL_FUNCTION, JSFunction::SIZE, JSType::JS_FUNCTION, env->GetFunctionPrototype()); env->SetFunctionClassWithoutProto(thread_, FunctionClass); FunctionClass = factory_->CreateFunctionClass(FunctionKind::CLASS_CONSTRUCTOR, JSFunction::SIZE, JSType::JS_FUNCTION, env->GetFunctionPrototype()); env->SetFunctionClassWithoutName(thread_, FunctionClass); if (env == vm_->GetGlobalEnv()) { InitializeAllTypeError(env, objFuncClass); InitializeSymbol(env, primRefObjHClass); InitializeBigInt(env, primRefObjHClass); } else { // error and symbol need to be shared when initialize realm InitializeAllTypeErrorWithRealm(env); InitializeSymbolWithRealm(env, primRefObjHClass); InitializeBigIntWithRealm(env); } InitializeNumber(env, globalObject, primRefObjHClass); InitializeDate(env, objFuncClass); InitializeObject(env, objFuncPrototype, objectFunction); InitializeBoolean(env, primRefObjHClass); InitializeRegExp(env); InitializeSet(env, objFuncClass); InitializeMap(env, objFuncClass); InitializeWeakMap(env, objFuncClass); InitializeWeakSet(env, objFuncClass); InitializeWeakRef(env, objFuncClass); InitializeFinalizationRegistry(env, objFuncClass); InitializeArray(env, objFuncPrototypeVal); InitializeTypedArray(env, objFuncClass); InitializeString(env, primRefObjHClass); InitializeArrayBuffer(env, objFuncClass); InitializeDataView(env, objFuncClass); InitializeSharedArrayBuffer(env, objFuncClass); JSHandle argumentsClass = factory_->CreateJSArguments(); env->SetArgumentsClass(thread_, argumentsClass); SetArgumentsSharedAccessor(env); InitializeGlobalObject(env, globalObject); InitializeMath(env, objFuncPrototypeVal); InitializeAtomics(env, objFuncPrototypeVal); InitializeJson(env, objFuncPrototypeVal); InitializeIterator(env, objFuncClass); InitializeAsyncIterator(env, objFuncClass); InitializeAsyncFromSyncIterator(env, objFuncClass); InitializeProxy(env); InitializeReflect(env, objFuncPrototypeVal); InitializeAsyncFunction(env, objFuncClass); InitializeGenerator(env, objFuncClass); InitializeAsyncGenerator(env, objFuncClass); InitializeGeneratorFunction(env, objFuncClass); InitializeAsyncGeneratorFunction(env, objFuncClass); InitializePromise(env, objFuncClass); InitializePromiseJob(env); InitializeIntl(env, objFuncPrototypeVal); InitializeLocale(env); InitializeDateTimeFormat(env); InitializeNumberFormat(env); InitializeRelativeTimeFormat(env); InitializeCollator(env); InitializePluralRules(env); InitializeDisplayNames(env); InitializeListFormat(env); InitializeModuleNamespace(env, objFuncClass); InitializeCjsModule(env); InitializeCjsExports(env); InitializeCjsRequire(env); InitializeDefaultExportOfScript(env); JSHandle generatorFuncClass = factory_->CreateFunctionClass(FunctionKind::GENERATOR_FUNCTION, JSFunction::SIZE, JSType::JS_GENERATOR_FUNCTION, env->GetGeneratorFunctionPrototype()); env->SetGeneratorFunctionClass(thread_, generatorFuncClass); JSHandle asyncGenetatorFuncClass = factory_->CreateFunctionClass(FunctionKind::ASYNC_GENERATOR_FUNCTION, JSFunction::SIZE, JSType::JS_ASYNC_GENERATOR_FUNCTION, env->GetAsyncGeneratorFunctionPrototype()); env->SetAsyncGeneratorFunctionClass(thread_, asyncGenetatorFuncClass); env->SetObjectFunctionPrototypeClass(thread_, JSTaggedValue(objFuncPrototype->GetClass())); JSHandle asyncFuncClass = factory_->CreateFunctionClass( FunctionKind::ASYNC_FUNCTION, JSAsyncFunction::SIZE, JSType::JS_ASYNC_FUNCTION, env->GetAsyncFunctionPrototype()); env->SetAsyncFunctionClass(thread_, asyncFuncClass); thread_->ResetGuardians(); } void Builtins::InitializeForSnapshot(JSThread *thread) { thread_ = thread; vm_ = thread->GetEcmaVM(); factory_ = vm_->GetFactory(); // Initialize ArkTools if (vm_->GetJSOptions().EnableArkTools()) { auto env = vm_->GetGlobalEnv(); auto globalObject = JSHandle::Cast(env->GetJSGlobalObject()); JSHandle arkTools(InitializeArkTools(env)); SetConstantObject(globalObject, "ArkTools", arkTools); } } void Builtins::InitializeGlobalObject(const JSHandle &env, const JSHandle &globalObject) { [[maybe_unused]] EcmaHandleScope scope(thread_); // Global object test SetFunction(env, globalObject, "print", Global::PrintEntrypoint, 0); #if ECMASCRIPT_ENABLE_RUNTIME_STAT SetFunction(env, globalObject, "startRuntimeStat", Global::StartRuntimeStat, 0); SetFunction(env, globalObject, "stopRuntimeStat", Global::StopRuntimeStat, 0); #endif if (vm_->GetJSOptions().EnableArkTools()) { JSHandle arkTools(InitializeArkTools(env)); SetConstantObject(globalObject, "ArkTools", arkTools); } #if ECMASCRIPT_ENABLE_ARK_CONTAINER // Set ArkPrivate JSHandle arkPrivate(InitializeArkPrivate(env)); SetConstantObject(globalObject, "ArkPrivate", arkPrivate); #endif // Global object function SetFunction(env, globalObject, "eval", Global::NotSupportEval, FunctionLength::ONE); SetFunction(env, globalObject, "isFinite", Global::IsFinite, FunctionLength::ONE); SetFunction(env, globalObject, "isNaN", Global::IsNaN, FunctionLength::ONE); SetFunction(env, globalObject, "decodeURI", Global::DecodeURI, FunctionLength::ONE); SetFunction(env, globalObject, "encodeURI", Global::EncodeURI, FunctionLength::ONE); SetFunction(env, globalObject, "decodeURIComponent", Global::DecodeURIComponent, FunctionLength::ONE); SetFunction(env, globalObject, "encodeURIComponent", Global::EncodeURIComponent, FunctionLength::ONE); // Global object property SetGlobalThis(globalObject, "globalThis", JSHandle::Cast(globalObject)); SetConstant(globalObject, "Infinity", JSTaggedValue(base::POSITIVE_INFINITY)); SetConstant(globalObject, "NaN", JSTaggedValue(base::NAN_VALUE)); SetConstant(globalObject, "undefined", JSTaggedValue::Undefined()); } void Builtins::InitializeFunction(const JSHandle &env, const JSHandle &emptyFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Initialize Function.prototype JSHandle funcFuncPrototype = factory_->NewJSFunctionByHClass( reinterpret_cast(Function::FunctionPrototypeInvokeSelf), emptyFuncClass); // ecma 19.2.3 The value of the name property of the Function prototype object is the empty String. JSHandle emptyString(thread_->GlobalConstants()->GetHandledEmptyString()); JSHandle undefinedString(thread_, JSTaggedValue::Undefined()); JSFunction::SetFunctionName(thread_, JSHandle(funcFuncPrototype), emptyString, undefinedString); // ecma 19.2.3 The value of the length property of the Function prototype object is 0. JSFunction::SetFunctionLength(thread_, funcFuncPrototype, JSTaggedValue(FunctionLength::ZERO)); JSHandle funcFuncPrototypeValue(funcFuncPrototype); // Function.prototype_or_hclass JSHandle funcFuncIntanceHClass = factory_->NewEcmaHClass(JSFunction::SIZE, JSType::JS_FUNCTION, funcFuncPrototypeValue); funcFuncIntanceHClass->SetConstructor(true); // Function = new Function() (forbidden use NewBuiltinConstructor) JSHandle funcFunc = factory_->NewJSFunctionByHClass(reinterpret_cast(Function::FunctionConstructor), funcFuncIntanceHClass, FunctionKind::BUILTIN_CONSTRUCTOR); auto funcFuncPrototypeObj = JSHandle(funcFuncPrototype); InitializeCtor(env, funcFuncPrototypeObj, funcFunc, "Function", FunctionLength::ONE); funcFunc->SetFunctionPrototype(thread_, funcFuncIntanceHClass.GetTaggedValue()); env->SetFunctionFunction(thread_, funcFunc); env->SetFunctionPrototype(thread_, funcFuncPrototype); JSHandle normalFuncClass = factory_->NewEcmaHClass(JSFunction::SIZE, JSType::JS_FUNCTION, env->GetFunctionPrototype()); env->SetNormalFunctionClass(thread_, normalFuncClass); JSHandle jSIntlBoundFunctionClass = factory_->CreateFunctionClass(FunctionKind::NORMAL_FUNCTION, JSIntlBoundFunction::SIZE, JSType::JS_INTL_BOUND_FUNCTION, env->GetFunctionPrototype()); env->SetJSIntlBoundFunctionClass(thread_, jSIntlBoundFunctionClass); JSHandle constructorFunctionClass = factory_->NewEcmaHClass(JSFunction::SIZE, JSType::JS_FUNCTION, env->GetFunctionPrototype()); constructorFunctionClass->SetConstructor(true); env->SetConstructorFunctionClass(thread_, constructorFunctionClass); StrictModeForbiddenAccessCallerArguments(env, funcFuncPrototypeObj); // Function.prototype method // 19.2.3.1 Function.prototype.apply ( thisArg, argArray ) SetFunction(env, funcFuncPrototypeObj, "apply", Function::FunctionPrototypeApply, FunctionLength::TWO); // 19.2.3.2 Function.prototype.bind ( thisArg , ...args) SetFunction(env, funcFuncPrototypeObj, "bind", Function::FunctionPrototypeBind, FunctionLength::ONE); // 19.2.3.3 Function.prototype.call (thisArg , ...args) SetFunction(env, funcFuncPrototypeObj, "call", Function::FunctionPrototypeCall, FunctionLength::ONE); // 19.2.3.5 Function.prototype.toString ( ) SetFunction(env, funcFuncPrototypeObj, thread_->GlobalConstants()->GetHandledToStringString(), Function::FunctionPrototypeToString, FunctionLength::ZERO); } void Builtins::InitializeObject(const JSHandle &env, const JSHandle &objFuncPrototype, const JSHandle &objFunc) { [[maybe_unused]] EcmaHandleScope scope(thread_); // Object method. // 19.1.2.1Object.assign ( target, ...sources ) SetFunction(env, objFunc, "assign", Object::Assign, FunctionLength::TWO); // 19.1.2.2Object.create ( O [ , Properties ] ) SetFunction(env, objFunc, "create", Object::Create, FunctionLength::TWO); // 19.1.2.3Object.defineProperties ( O, Properties ) SetFunction(env, objFunc, "defineProperties", Object::DefineProperties, FunctionLength::TWO); // 19.1.2.4Object.defineProperty ( O, P, Attributes ) SetFunction(env, objFunc, "defineProperty", Object::DefineProperty, FunctionLength::THREE); // 19.1.2.5Object.freeze ( O ) SetFunction(env, objFunc, "freeze", Object::Freeze, FunctionLength::ONE); // 19.1.2.6Object.getOwnPropertyDescriptor ( O, P ) SetFunction(env, objFunc, "getOwnPropertyDescriptor", Object::GetOwnPropertyDescriptor, FunctionLength::TWO); // 19.1.2.7Object.getOwnPropertyNames ( O ) SetFunction(env, objFunc, "getOwnPropertyNames", Object::GetOwnPropertyNames, FunctionLength::ONE); // 19.1.2.8Object.getOwnPropertySymbols ( O ) SetFunction(env, objFunc, "getOwnPropertySymbols", Object::GetOwnPropertySymbols, FunctionLength::ONE); // 19.1.2.9Object.getPrototypeOf ( O ) SetFunction(env, objFunc, "getPrototypeOf", Object::GetPrototypeOf, FunctionLength::ONE); // 19.1.2.10Object.is ( value1, value2 ) SetFunction(env, objFunc, "is", Object::Is, 2); // 19.1.2.11Object.isExtensible ( O ) SetFunction(env, objFunc, "isExtensible", Object::IsExtensible, FunctionLength::ONE); // 19.1.2.12Object.isFrozen ( O ) SetFunction(env, objFunc, "isFrozen", Object::IsFrozen, FunctionLength::ONE); // 19.1.2.13Object.isSealed ( O ) SetFunction(env, objFunc, "isSealed", Object::IsSealed, FunctionLength::ONE); // 19.1.2.14 Object.keys(O) SetFunction(env, objFunc, "keys", Object::Keys, FunctionLength::ONE); // 20.1.2.22 Object.values(O) SetFunction(env, objFunc, "values", Object::Values, FunctionLength::ONE); // 19.1.2.15 Object.preventExtensions(O) SetFunction(env, objFunc, "preventExtensions", Object::PreventExtensions, FunctionLength::ONE); // 19.1.2.17 Object.seal(O) SetFunction(env, objFunc, "seal", Object::Seal, FunctionLength::ONE); // 19.1.2.18 Object.setPrototypeOf(O, proto) SetFunction(env, objFunc, "setPrototypeOf", Object::SetPrototypeOf, FunctionLength::TWO); // 20.1.2.5 Object.entries ( O ) SetFunction(env, objFunc, "entries", Object::Entries, FunctionLength::ONE); // 20.1.2.7 Object.fromEntries ( iterable ) SetFunction(env, objFunc, "fromEntries", Object::FromEntries, FunctionLength::ONE); // Object.property method // 19.1.3.2 Object.prototype.hasOwnProperty(V) SetFunction(env, objFuncPrototype, "hasOwnProperty", Object::HasOwnProperty, FunctionLength::ONE); // 19.1.3.3 Object.prototype.isPrototypeOf(V) SetFunction(env, objFuncPrototype, "isPrototypeOf", Object::IsPrototypeOf, FunctionLength::ONE); // 19.1.3.4 Object.prototype.propertyIsEnumerable(V) SetFunction(env, objFuncPrototype, "propertyIsEnumerable", Object::PropertyIsEnumerable, FunctionLength::ONE); // 19.1.3.5 Object.prototype.toLocaleString([reserved1[, reserved2]]) SetFunction(env, objFuncPrototype, "toLocaleString", Object::ToLocaleString, FunctionLength::ZERO); // 19.1.3.6 Object.prototype.toString() SetFunction(env, objFuncPrototype, thread_->GlobalConstants()->GetHandledToStringString(), Object::ToString, FunctionLength::ZERO); // 19.1.3.7 Object.prototype.valueOf() SetFunction(env, objFuncPrototype, thread_->GlobalConstants()->GetHandledValueOfString(), Object::ValueOf, FunctionLength::ZERO); SetFunction(env, objFuncPrototype, "createRealm", Object::CreateRealm, FunctionLength::ZERO); // B.2.2.1 Object.prototype.__proto__ JSHandle protoKey(factory_->NewFromASCII("__proto__")); JSHandle protoGetter = CreateGetter(env, Object::ProtoGetter, "__proto__", FunctionLength::ZERO); JSHandle protoSetter = CreateSetter(env, Object::ProtoSetter, "__proto__", FunctionLength::ONE); SetAccessor(objFuncPrototype, protoKey, protoGetter, protoSetter); } void Builtins::InitializeSymbol(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); // Symbol.prototype JSHandle symbolFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle symbolFuncPrototypeValue(symbolFuncPrototype); // Symbol.prototype_or_hclass JSHandle symbolFuncInstanceHClass = factory_->NewEcmaHClass(JSPrimitiveRef::SIZE, JSType::JS_PRIMITIVE_REF, symbolFuncPrototypeValue); // Symbol = new Function() JSHandle symbolFunction( NewBuiltinConstructor(env, symbolFuncPrototype, Symbol::SymbolConstructor, "Symbol", FunctionLength::ZERO)); JSHandle(symbolFunction)->SetFunctionPrototype(thread_, symbolFuncInstanceHClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); PropertyDescriptor descriptor(thread_, JSHandle::Cast(symbolFunction), true, false, true); JSObject::DefineOwnProperty(thread_, symbolFuncPrototype, constructorKey, descriptor); SetFunction(env, symbolFunction, "for", Symbol::For, FunctionLength::ONE); SetFunction(env, symbolFunction, "keyFor", Symbol::KeyFor, FunctionLength::ONE); // Symbol attribute JSHandle hasInstanceSymbol(factory_->NewWellKnownSymbolWithChar("Symbol.hasInstance")); SetNoneAttributeProperty(symbolFunction, "hasInstance", hasInstanceSymbol); JSHandle isConcatSpreadableSymbol(factory_->NewWellKnownSymbolWithChar("Symbol.isConcatSpreadable")); SetNoneAttributeProperty(symbolFunction, "isConcatSpreadable", isConcatSpreadableSymbol); JSHandle toStringTagSymbol(factory_->NewWellKnownSymbolWithChar("Symbol.toStringTag")); SetNoneAttributeProperty(symbolFunction, "toStringTag", toStringTagSymbol); JSHandle iteratorSymbol(factory_->NewPublicSymbolWithChar("Symbol.iterator")); SetNoneAttributeProperty(symbolFunction, "iterator", iteratorSymbol); JSHandle asyncIteratorSymbol(factory_->NewPublicSymbolWithChar("Symbol.asyncIterator")); SetNoneAttributeProperty(symbolFunction, "asyncIterator", asyncIteratorSymbol); JSHandle matchSymbol(factory_->NewPublicSymbolWithChar("Symbol.match")); SetNoneAttributeProperty(symbolFunction, "match", matchSymbol); JSHandle matchAllSymbol(factory_->NewPublicSymbolWithChar("Symbol.matchAll")); SetNoneAttributeProperty(symbolFunction, "matchAll", matchAllSymbol); JSHandle replaceSymbol(factory_->NewPublicSymbolWithChar("Symbol.replace")); SetNoneAttributeProperty(symbolFunction, "replace", replaceSymbol); JSHandle searchSymbol(factory_->NewPublicSymbolWithChar("Symbol.search")); SetNoneAttributeProperty(symbolFunction, "search", searchSymbol); JSHandle speciesSymbol(factory_->NewPublicSymbolWithChar("Symbol.species")); SetNoneAttributeProperty(symbolFunction, "species", speciesSymbol); JSHandle splitSymbol(factory_->NewPublicSymbolWithChar("Symbol.split")); SetNoneAttributeProperty(symbolFunction, "split", splitSymbol); JSHandle toPrimitiveSymbol(factory_->NewPublicSymbolWithChar("Symbol.toPrimitive")); SetNoneAttributeProperty(symbolFunction, "toPrimitive", toPrimitiveSymbol); JSHandle unscopablesSymbol(factory_->NewPublicSymbolWithChar("Symbol.unscopables")); SetNoneAttributeProperty(symbolFunction, "unscopables", unscopablesSymbol); JSHandle attachSymbol(factory_->NewPublicSymbolWithChar("Symbol.attach")); SetNoneAttributeProperty(symbolFunction, "attach", attachSymbol); JSHandle detachSymbol(factory_->NewPublicSymbolWithChar("Symbol.detach")); SetNoneAttributeProperty(symbolFunction, "detach", detachSymbol); // symbol.prototype.description PropertyDescriptor descriptionDesc(thread_); JSHandle getterKey(factory_->NewFromASCII("description")); JSHandle getter(factory_->NewJSFunction(env, reinterpret_cast(Symbol::DescriptionGetter))); SetGetter(symbolFuncPrototype, getterKey, getter); // Setup symbol.prototype[@@toPrimitive] SetFunctionAtSymbol( env, symbolFuncPrototype, toPrimitiveSymbol, "[Symbol.toPrimitive]", Symbol::ToPrimitive, FunctionLength::ONE); // install the Symbol.prototype methods SetFunction(env, symbolFuncPrototype, thread_->GlobalConstants()->GetHandledToStringString(), Symbol::ToString, FunctionLength::ZERO); SetFunction(env, symbolFuncPrototype, thread_->GlobalConstants()->GetHandledValueOfString(), Symbol::ValueOf, FunctionLength::ZERO); env->SetSymbolFunction(thread_, symbolFunction); env->SetHasInstanceSymbol(thread_, hasInstanceSymbol); env->SetIsConcatSpreadableSymbol(thread_, isConcatSpreadableSymbol); env->SetToStringTagSymbol(thread_, toStringTagSymbol); env->SetIteratorSymbol(thread_, iteratorSymbol); env->SetAsyncIteratorSymbol(thread_, asyncIteratorSymbol); env->SetMatchSymbol(thread_, matchSymbol); env->SetMatchAllSymbol(thread_, matchAllSymbol); env->SetReplaceSymbol(thread_, replaceSymbol); env->SetSearchSymbol(thread_, searchSymbol); env->SetSpeciesSymbol(thread_, speciesSymbol); env->SetSplitSymbol(thread_, splitSymbol); env->SetToPrimitiveSymbol(thread_, toPrimitiveSymbol); env->SetUnscopablesSymbol(thread_, unscopablesSymbol); env->SetAttachSymbol(thread_, attachSymbol); env->SetDetachSymbol(thread_, detachSymbol); // Setup %SymbolPrototype% SetStringTagSymbol(env, symbolFuncPrototype, "Symbol"); JSHandle holeySymbol(factory_->NewPrivateNameSymbolWithChar("holey")); env->SetHoleySymbol(thread_, holeySymbol.GetTaggedValue()); JSHandle elementIcSymbol(factory_->NewPrivateNameSymbolWithChar("element-ic")); env->SetElementICSymbol(thread_, elementIcSymbol.GetTaggedValue()); // ecma 19.2.3.6 Function.prototype[@@hasInstance] ( V ) JSHandle funcFuncPrototypeObj = JSHandle(env->GetFunctionPrototype()); SetFunctionAtSymbol( env, funcFuncPrototypeObj, env->GetHasInstanceSymbol(), "[Symbol.hasInstance]", Function::FunctionPrototypeHasInstance, FunctionLength::ONE); } void Builtins::InitializeSymbolWithRealm(const JSHandle &realm, const JSHandle &objFuncInstanceHClass) { [[maybe_unused]] EcmaHandleScope scope(thread_); JSHandle env = vm_->GetGlobalEnv(); // Symbol.prototype JSHandle symbolFuncPrototype = factory_->NewJSObjectWithInit(objFuncInstanceHClass); JSHandle symbolFuncPrototypeValue(symbolFuncPrototype); // Symbol.prototype_or_hclass JSHandle symbolFuncInstanceHClass = factory_->NewEcmaHClass(JSPrimitiveRef::SIZE, JSType::JS_PRIMITIVE_REF, symbolFuncPrototypeValue); // Symbol = new Function() JSHandle symbolFunction( NewBuiltinConstructor(realm, symbolFuncPrototype, Symbol::SymbolConstructor, "Symbol", FunctionLength::ZERO)); JSHandle(symbolFunction)->SetFunctionPrototype(thread_, symbolFuncInstanceHClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = thread_->GlobalConstants()->GetHandledConstructorString(); PropertyDescriptor descriptor(thread_, JSHandle::Cast(symbolFunction), true, false, true); JSObject::DefineOwnProperty(thread_, symbolFuncPrototype, constructorKey, descriptor); SetFunction(realm, symbolFunction, "for", Symbol::For, FunctionLength::ONE); SetFunction(realm, symbolFunction, "keyFor", Symbol::KeyFor, FunctionLength::ONE); // Symbol attribute SetNoneAttributeProperty(symbolFunction, "hasInstance", env->GetHasInstanceSymbol()); SetNoneAttributeProperty(symbolFunction, "isConcatSpreadable", env->GetIsConcatSpreadableSymbol()); SetNoneAttributeProperty(symbolFunction, "toStringTag", env->GetToStringTagSymbol()); SetNoneAttributeProperty(symbolFunction, "iterator", env->GetIteratorSymbol()); SetNoneAttributeProperty(symbolFunction, "asyncIterator", env->GetAsyncIteratorSymbol()); SetNoneAttributeProperty(symbolFunction, "match", env->GetMatchSymbol()); SetNoneAttributeProperty(symbolFunction, "matchAll", env->GetMatchAllSymbol()); SetNoneAttributeProperty(symbolFunction, "replace", env->GetReplaceSymbol()); SetNoneAttributeProperty(symbolFunction, "search", env->GetSearchSymbol()); SetNoneAttributeProperty(symbolFunction, "species", env->GetSpeciesSymbol()); SetNoneAttributeProperty(symbolFunction, "split", env->GetSplitSymbol()); SetNoneAttributeProperty(symbolFunction, "toPrimitive", env->GetToPrimitiveSymbol()); SetNoneAttributeProperty(symbolFunction, "unscopables", env->GetUnscopablesSymbol()); SetNoneAttributeProperty(symbolFunction, "attach", env->GetAttachSymbol()); SetNoneAttributeProperty(symbolFunction, "detach", env->GetDetachSymbol()); // symbol.prototype.description PropertyDescriptor descriptionDesc(thread_); JSHandle getterKey(factory_->NewFromASCII("description")); JSHandle getter(factory_->NewJSFunction(realm, reinterpret_cast(Symbol::DescriptionGetter))); SetGetter(symbolFuncPrototype, getterKey, getter); // Setup symbol.prototype[@@toPrimitive] SetFunctionAtSymbol(realm, symbolFuncPrototype, env->GetToPrimitiveSymbol(), "[Symbol.toPrimitive]", Symbol::ToPrimitive, FunctionLength::ONE); // install the Symbol.prototype methods SetFunction(realm, symbolFuncPrototype, thread_->GlobalConstants()->GetHandledToStringString(), Symbol::ToString, FunctionLength::ZERO); SetFunction(realm, symbolFuncPrototype, thread_->GlobalConstants()->GetHandledValueOfString(), Symbol::ValueOf, FunctionLength::ZERO); realm->SetSymbolFunction(thread_, symbolFunction); realm->SetHasInstanceSymbol(thread_, env->GetHasInstanceSymbol()); realm->SetIsConcatSpreadableSymbol(thread_, env->GetIsConcatSpreadableSymbol()); realm->SetToStringTagSymbol(thread_, env->GetToStringTagSymbol()); realm->SetIteratorSymbol(thread_, env->GetIteratorSymbol()); realm->SetAsyncIteratorSymbol(thread_, env->GetAsyncIteratorSymbol()); realm->SetMatchSymbol(thread_, env->GetMatchSymbol()); realm->SetMatchAllSymbol(thread_, env->GetMatchAllSymbol()); realm->SetReplaceSymbol(thread_, env->GetReplaceSymbol()); realm->SetSearchSymbol(thread_, env->GetSearchSymbol()); realm->SetSpeciesSymbol(thread_, env->GetSpeciesSymbol()); realm->SetSplitSymbol(thread_, env->GetSplitSymbol()); realm->SetToPrimitiveSymbol(thread_, env->GetToPrimitiveSymbol()); realm->SetUnscopablesSymbol(thread_, env->GetUnscopablesSymbol()); realm->SetAttachSymbol(thread_, env->GetAttachSymbol()); realm->SetDetachSymbol(thread_, env->GetDetachSymbol()); // Setup %SymbolPrototype% SetStringTagSymbol(realm, symbolFuncPrototype, "Symbol"); JSHandle holeySymbol(factory_->NewPrivateNameSymbolWithChar("holey")); realm->SetHoleySymbol(thread_, holeySymbol.GetTaggedValue()); JSHandle elementIcSymbol(factory_->NewPrivateNameSymbolWithChar("element-ic")); realm->SetElementICSymbol(thread_, elementIcSymbol.GetTaggedValue()); // ecma 19.2.3.6 Function.prototype[@@hasInstance] ( V ) JSHandle funcFuncPrototypeObj = JSHandle(realm->GetFunctionPrototype()); SetFunctionAtSymbol( realm, funcFuncPrototypeObj, realm->GetHasInstanceSymbol(), "[Symbol.hasInstance]", Function::FunctionPrototypeHasInstance, FunctionLength::ONE); } void Builtins::InitializeNumber(const JSHandle &env, const JSHandle &globalObject, const JSHandle &primRefObjHClass) { [[maybe_unused]] EcmaHandleScope scope(thread_); // Number.prototype JSHandle toObject(thread_, JSTaggedValue(FunctionLength::ZERO)); JSHandle numFuncPrototype = JSHandle::Cast(factory_->NewJSPrimitiveRef(primRefObjHClass, toObject)); JSHandle numFuncPrototypeValue(numFuncPrototype); // Number.prototype_or_hclass JSHandle numFuncInstanceHClass = factory_->NewEcmaHClass(JSPrimitiveRef::SIZE, JSType::JS_PRIMITIVE_REF, numFuncPrototypeValue); // Number = new Function() JSHandle numFunction( NewBuiltinConstructor(env, numFuncPrototype, Number::NumberConstructor, "Number", FunctionLength::ONE)); numFunction.GetObject()->SetFunctionPrototype(thread_, numFuncInstanceHClass.GetTaggedValue()); // Number.prototype method SetFunction(env, numFuncPrototype, "toExponential", Number::ToExponential, FunctionLength::ONE); SetFunction(env, numFuncPrototype, "toFixed", Number::ToFixed, FunctionLength::ONE); SetFunction(env, numFuncPrototype, "toLocaleString", Number::ToLocaleString, FunctionLength::ZERO); SetFunction(env, numFuncPrototype, "toPrecision", Number::ToPrecision, FunctionLength::ONE); SetFunction(env, numFuncPrototype, thread_->GlobalConstants()->GetHandledToStringString(), Number::ToString, FunctionLength::ONE); SetFunction(env, numFuncPrototype, thread_->GlobalConstants()->GetHandledValueOfString(), Number::ValueOf, FunctionLength::ZERO); // Number method SetFunction(env, numFunction, "isFinite", Number::IsFinite, FunctionLength::ONE); SetFunction(env, numFunction, "isInteger", Number::IsInteger, FunctionLength::ONE); SetFunction(env, numFunction, "isNaN", Number::IsNaN, FunctionLength::ONE); SetFunction(env, numFunction, "isSafeInteger", Number::IsSafeInteger, FunctionLength::ONE); SetFuncToObjAndGlobal(env, globalObject, numFunction, "parseFloat", Number::ParseFloat, FunctionLength::ONE); SetFuncToObjAndGlobal(env, globalObject, numFunction, "parseInt", Number::ParseInt, FunctionLength::TWO); // Number constant const double epsilon = 2.220446049250313e-16; const double maxSafeInteger = 9007199254740991; const double maxValue = 1.7976931348623157e+308; const double minValue = 5e-324; const double positiveInfinity = std::numeric_limits::infinity(); SetConstant(numFunction, "MAX_VALUE", JSTaggedValue(maxValue)); SetConstant(numFunction, "MIN_VALUE", JSTaggedValue(minValue)); SetConstant(numFunction, "NaN", JSTaggedValue(NAN)); SetConstant(numFunction, "NEGATIVE_INFINITY", JSTaggedValue(-positiveInfinity)); SetConstant(numFunction, "POSITIVE_INFINITY", JSTaggedValue(positiveInfinity)); SetConstant(numFunction, "MAX_SAFE_INTEGER", JSTaggedValue(maxSafeInteger)); SetConstant(numFunction, "MIN_SAFE_INTEGER", JSTaggedValue(-maxSafeInteger)); SetConstant(numFunction, "EPSILON", JSTaggedValue(epsilon)); env->SetNumberFunction(thread_, numFunction); } void Builtins::InitializeBigIntWithRealm(const JSHandle &realm) const { [[maybe_unused]] EcmaHandleScope scope(thread_); JSHandle env = vm_->GetGlobalEnv(); realm->SetBigIntFunction(thread_, env->GetBigIntFunction()); JSHandle nameString(factory_->NewFromASCII("BigInt")); JSHandle globalObject(thread_, realm->GetGlobalObject()); PropertyDescriptor descriptor(thread_, env->GetBigIntFunction(), true, false, true); JSObject::DefineOwnProperty(thread_, globalObject, nameString, descriptor); } void Builtins::InitializeBigInt(const JSHandle &env, const JSHandle &primRefObjHClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // BigInt.prototype JSHandle bigIntFuncPrototype = factory_->NewJSObjectWithInit(primRefObjHClass); JSHandle bigIntFuncPrototypeValue(bigIntFuncPrototype); // BigInt.prototype_or_hclass JSHandle bigIntFuncInstanceHClass = factory_->NewEcmaHClass(JSPrimitiveRef::SIZE, JSType::JS_PRIMITIVE_REF, bigIntFuncPrototypeValue); // BigInt = new Function() JSHandle bigIntFunction( NewBuiltinConstructor(env, bigIntFuncPrototype, BuiltinsBigInt::BigIntConstructor, "BigInt", FunctionLength::ONE)); JSHandle(bigIntFunction)->SetFunctionPrototype(thread_, bigIntFuncInstanceHClass.GetTaggedValue()); // BigInt.prototype method SetFunction(env, bigIntFuncPrototype, "toLocaleString", BuiltinsBigInt::ToLocaleString, FunctionLength::ZERO); SetFunction(env, bigIntFuncPrototype, "toString", BuiltinsBigInt::ToString, FunctionLength::ZERO); SetFunction(env, bigIntFuncPrototype, "valueOf", BuiltinsBigInt::ValueOf, FunctionLength::ZERO); // BigInt method SetFunction(env, bigIntFunction, "asUintN", BuiltinsBigInt::AsUintN, FunctionLength::TWO); SetFunction(env, bigIntFunction, "asIntN", BuiltinsBigInt::AsIntN, FunctionLength::TWO); // @@ToStringTag SetStringTagSymbol(env, bigIntFuncPrototype, "BigInt"); env->SetBigIntFunction(thread_, bigIntFunction); } void Builtins::InitializeDate(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); constexpr int utcLength = 7; // Date.prototype JSHandle dateFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle dateFuncPrototypeValue(dateFuncPrototype); // Date.prototype_or_hclass JSHandle dateFuncInstanceHClass = factory_->NewEcmaHClass(JSDate::SIZE, JSType::JS_DATE, dateFuncPrototypeValue); // Date = new Function() JSHandle dateFunction( NewBuiltinConstructor(env, dateFuncPrototype, Date::DateConstructor, "Date", FunctionLength::ONE, BUILTINS_STUB_ID(DateConstructor))); JSHandle(dateFunction)->SetFunctionPrototype(thread_, dateFuncInstanceHClass.GetTaggedValue()); // Date.prototype method SetFunction(env, dateFuncPrototype, "getDate", Date::GetDate, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "getDay", Date::GetDay, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "getFullYear", Date::GetFullYear, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "getHours", Date::GetHours, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "getMilliseconds", Date::GetMilliseconds, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "getMinutes", Date::GetMinutes, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "getMonth", Date::GetMonth, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "getSeconds", Date::GetSeconds, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "getTime", Date::GetTime, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "getTimezoneOffset", Date::GetTimezoneOffset, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "getUTCDate", Date::GetUTCDate, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "getUTCDay", Date::GetUTCDay, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "getUTCFullYear", Date::GetUTCFullYear, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "getUTCHours", Date::GetUTCHours, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "getUTCMilliseconds", Date::GetUTCMilliseconds, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "getUTCMinutes", Date::GetUTCMinutes, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "getUTCMonth", Date::GetUTCMonth, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "getUTCSeconds", Date::GetUTCSeconds, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "setDate", Date::SetDate, FunctionLength::ONE); SetFunction(env, dateFuncPrototype, "setFullYear", Date::SetFullYear, FunctionLength::THREE); SetFunction(env, dateFuncPrototype, "setHours", Date::SetHours, FunctionLength::FOUR); SetFunction(env, dateFuncPrototype, "setMilliseconds", Date::SetMilliseconds, FunctionLength::ONE); SetFunction(env, dateFuncPrototype, "setMinutes", Date::SetMinutes, FunctionLength::THREE); SetFunction(env, dateFuncPrototype, "setMonth", Date::SetMonth, FunctionLength::TWO); SetFunction(env, dateFuncPrototype, "setSeconds", Date::SetSeconds, FunctionLength::TWO); SetFunction(env, dateFuncPrototype, "setTime", Date::SetTime, FunctionLength::ONE); SetFunction(env, dateFuncPrototype, "setUTCDate", Date::SetUTCDate, FunctionLength::ONE); SetFunction(env, dateFuncPrototype, "setUTCFullYear", Date::SetUTCFullYear, FunctionLength::THREE); SetFunction(env, dateFuncPrototype, "setUTCHours", Date::SetUTCHours, FunctionLength::FOUR); SetFunction(env, dateFuncPrototype, "setUTCMilliseconds", Date::SetUTCMilliseconds, FunctionLength::ONE); SetFunction(env, dateFuncPrototype, "setUTCMinutes", Date::SetUTCMinutes, FunctionLength::THREE); SetFunction(env, dateFuncPrototype, "setUTCMonth", Date::SetUTCMonth, FunctionLength::TWO); SetFunction(env, dateFuncPrototype, "setUTCSeconds", Date::SetUTCSeconds, FunctionLength::TWO); SetFunction(env, dateFuncPrototype, "toDateString", Date::ToDateString, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "toISOString", Date::ToISOString, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "toJSON", Date::ToJSON, FunctionLength::ONE); SetFunction(env, dateFuncPrototype, "toLocaleDateString", Date::ToLocaleDateString, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "toLocaleString", Date::ToLocaleString, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "toLocaleTimeString", Date::ToLocaleTimeString, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, thread_->GlobalConstants()->GetHandledToStringString(), Date::ToString, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "toTimeString", Date::ToTimeString, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, "toUTCString", Date::ToUTCString, FunctionLength::ZERO); SetFunction(env, dateFuncPrototype, thread_->GlobalConstants()->GetHandledValueOfString(), Date::ValueOf, FunctionLength::ZERO); SetFunctionAtSymbol(env, dateFuncPrototype, env->GetToPrimitiveSymbol(), "[Symbol.toPrimitive]", Date::ToPrimitive, FunctionLength::ONE); // Date method SetFunction(env, dateFunction, "now", Date::Now, FunctionLength::ZERO); SetFunction(env, dateFunction, "parse", Date::Parse, FunctionLength::ONE); SetFunction(env, dateFunction, "UTC", Date::UTC, utcLength); // Date.length SetConstant(dateFunction, "length", JSTaggedValue(utcLength)); env->SetDateFunction(thread_, dateFunction); } void Builtins::InitializeBoolean(const JSHandle &env, const JSHandle &primRefObjHClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Boolean.prototype JSHandle toObject(thread_, JSTaggedValue::False()); JSHandle booleanFuncPrototype = JSHandle::Cast(factory_->NewJSPrimitiveRef(primRefObjHClass, toObject)); JSHandle booleanFuncPrototypeValue(booleanFuncPrototype); // Boolean.prototype_or_hclass JSHandle booleanFuncInstanceHClass = factory_->NewEcmaHClass(JSPrimitiveRef::SIZE, JSType::JS_PRIMITIVE_REF, booleanFuncPrototypeValue); // new Boolean Function() JSHandle booleanFunction = NewBuiltinConstructor(env, booleanFuncPrototype, Boolean::BooleanConstructor, "Boolean", FunctionLength::ONE, BUILTINS_STUB_ID(BooleanConstructor)); booleanFunction->SetFunctionPrototype(thread_, booleanFuncInstanceHClass.GetTaggedValue()); // Boolean.prototype method SetFunction(env, booleanFuncPrototype, thread_->GlobalConstants()->GetHandledToStringString(), Boolean::BooleanPrototypeToString, FunctionLength::ZERO); SetFunction(env, booleanFuncPrototype, thread_->GlobalConstants()->GetHandledValueOfString(), Boolean::BooleanPrototypeValueOf, FunctionLength::ZERO); env->SetBooleanFunction(thread_, booleanFunction); } void Builtins::InitializeProxy(const JSHandle &env) { JSHandle proxyFunction(InitializeExoticConstructor(env, Proxy::ProxyConstructor, "Proxy", 2)); // Proxy method SetFunction(env, proxyFunction, "revocable", Proxy::Revocable, FunctionLength::TWO); env->SetProxyFunction(thread_, proxyFunction); } JSHandle Builtins::InitializeExoticConstructor(const JSHandle &env, EcmaEntrypoint ctorFunc, const char *name, int length) { JSHandle ctor = factory_->NewJSFunction(env, reinterpret_cast(ctorFunc), FunctionKind::BUILTIN_PROXY_CONSTRUCTOR); JSFunction::SetFunctionLength(thread_, ctor, JSTaggedValue(length)); JSHandle nameString(factory_->NewFromUtf8(name)); JSFunction::SetFunctionName(thread_, JSHandle(ctor), nameString, JSHandle(thread_, JSTaggedValue::Undefined())); JSHandle globalObject(thread_, env->GetGlobalObject()); PropertyDescriptor descriptor(thread_, JSHandle(ctor), true, false, true); JSObject::DefineOwnProperty(thread_, globalObject, nameString, descriptor); return ctor; } void Builtins::InitializeAsyncFunction(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); // AsyncFunction.prototype JSHandle asyncFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSObject::SetPrototype(thread_, asyncFuncPrototype, env->GetFunctionPrototype()); JSHandle async_func_prototype_value(asyncFuncPrototype); // AsyncFunction.prototype_or_hclass JSHandle asyncFuncInstanceHClass = factory_->NewEcmaHClass(JSAsyncFunction::SIZE, JSType::JS_ASYNC_FUNCTION, async_func_prototype_value); // AsyncFunction = new Function() JSHandle asyncFunction = NewBuiltinConstructor( env, asyncFuncPrototype, AsyncFunction::AsyncFunctionConstructor, "AsyncFunction", FunctionLength::ONE); JSObject::SetPrototype(thread_, JSHandle::Cast(asyncFunction), env->GetFunctionFunction()); JSHandle constructorKey = globalConst->GetHandledConstructorString(); PropertyDescriptor asyncDesc(thread_, JSHandle::Cast(asyncFunction), false, false, true); JSObject::DefineOwnProperty(thread_, asyncFuncPrototype, constructorKey, asyncDesc); asyncFunction->SetProtoOrHClass(thread_, asyncFuncInstanceHClass.GetTaggedValue()); // AsyncFunction.prototype property SetStringTagSymbol(env, asyncFuncPrototype, "AsyncFunction"); env->SetAsyncFunction(thread_, asyncFunction); env->SetAsyncFunctionPrototype(thread_, asyncFuncPrototype); } void Builtins::InitializeAllTypeError(const JSHandle &env, const JSHandle &objFuncClass) const { // Error.prototype JSHandle errorFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle errorFuncPrototypeValue(errorFuncPrototype); // Error.prototype_or_hclass JSHandle errorFuncInstanceHClass = factory_->NewEcmaHClass(JSObject::SIZE, JSType::JS_ERROR, errorFuncPrototypeValue); // Error() = new Function() JSHandle errorFunction( NewBuiltinConstructor(env, errorFuncPrototype, Error::ErrorConstructor, "Error", FunctionLength::ONE)); errorFunction->SetFunctionPrototype(thread_, errorFuncInstanceHClass.GetTaggedValue()); // Error.prototype method SetFunction(env, errorFuncPrototype, thread_->GlobalConstants()->GetHandledToStringString(), Error::ToString, FunctionLength::ZERO); // Error.prototype Attribute SetAttribute(errorFuncPrototype, "name", "Error"); SetAttribute(errorFuncPrototype, "message", ""); env->SetErrorFunction(thread_, errorFunction); JSHandle nativeErrorFuncClass = factory_->NewEcmaHClass(JSFunction::SIZE, JSType::JS_FUNCTION, env->GetErrorFunction()); nativeErrorFuncClass->SetConstructor(true); env->SetNativeErrorFunctionClass(thread_, nativeErrorFuncClass); JSHandle errorNativeFuncInstanceHClass = factory_->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, errorFuncPrototypeValue); InitializeError(env, errorNativeFuncInstanceHClass, JSType::JS_RANGE_ERROR); InitializeError(env, errorNativeFuncInstanceHClass, JSType::JS_REFERENCE_ERROR); InitializeError(env, errorNativeFuncInstanceHClass, JSType::JS_TYPE_ERROR); InitializeError(env, errorNativeFuncInstanceHClass, JSType::JS_AGGREGATE_ERROR); InitializeError(env, errorNativeFuncInstanceHClass, JSType::JS_URI_ERROR); InitializeError(env, errorNativeFuncInstanceHClass, JSType::JS_SYNTAX_ERROR); InitializeError(env, errorNativeFuncInstanceHClass, JSType::JS_EVAL_ERROR); InitializeError(env, errorNativeFuncInstanceHClass, JSType::JS_OOM_ERROR); } void Builtins::InitializeAllTypeErrorWithRealm(const JSHandle &realm) const { JSHandle env = vm_->GetGlobalEnv(); realm->SetErrorFunction(thread_, env->GetErrorFunction()); realm->SetNativeErrorFunctionClass(thread_, env->GetNativeErrorFunctionClass()); SetErrorWithRealm(realm, JSType::JS_RANGE_ERROR); SetErrorWithRealm(realm, JSType::JS_REFERENCE_ERROR); SetErrorWithRealm(realm, JSType::JS_TYPE_ERROR); SetErrorWithRealm(realm, JSType::JS_AGGREGATE_ERROR); SetErrorWithRealm(realm, JSType::JS_URI_ERROR); SetErrorWithRealm(realm, JSType::JS_SYNTAX_ERROR); SetErrorWithRealm(realm, JSType::JS_EVAL_ERROR); SetErrorWithRealm(realm, JSType::JS_OOM_ERROR); } void Builtins::SetErrorWithRealm(const JSHandle &realm, const JSType &errorTag) const { JSHandle env = vm_->GetGlobalEnv(); JSHandle globalObject(thread_, realm->GetGlobalObject()); JSHandle nameString; JSHandle nativeErrorFunction; switch (errorTag) { case JSType::JS_RANGE_ERROR: nativeErrorFunction = env->GetRangeErrorFunction(); nameString = JSHandle(thread_->GlobalConstants()->GetHandledRangeErrorString()); realm->SetRangeErrorFunction(thread_, nativeErrorFunction); break; case JSType::JS_EVAL_ERROR: nativeErrorFunction = env->GetEvalErrorFunction(); nameString = JSHandle(thread_->GlobalConstants()->GetHandledEvalErrorString()); realm->SetEvalErrorFunction(thread_, nativeErrorFunction); break; case JSType::JS_REFERENCE_ERROR: nativeErrorFunction = env->GetReferenceErrorFunction(); nameString = JSHandle(thread_->GlobalConstants()->GetHandledReferenceErrorString()); realm->SetReferenceErrorFunction(thread_, nativeErrorFunction); break; case JSType::JS_TYPE_ERROR: nativeErrorFunction = env->GetTypeErrorFunction(); nameString = JSHandle(thread_->GlobalConstants()->GetHandledTypeErrorString()); realm->SetTypeErrorFunction(thread_, nativeErrorFunction); realm->SetThrowTypeError(thread_, env->GetThrowTypeError()); break; case JSType::JS_AGGREGATE_ERROR: nativeErrorFunction = env->GetAggregateErrorFunction(); nameString = JSHandle(thread_->GlobalConstants()->GetHandledAggregateErrorString()); realm->SetAggregateErrorFunction(thread_, nativeErrorFunction); break; case JSType::JS_URI_ERROR: nativeErrorFunction = env->GetURIErrorFunction(); nameString = JSHandle(thread_->GlobalConstants()->GetHandledURIErrorString()); realm->SetURIErrorFunction(thread_, nativeErrorFunction); break; case JSType::JS_SYNTAX_ERROR: nativeErrorFunction = env->GetSyntaxErrorFunction(); nameString = JSHandle(thread_->GlobalConstants()->GetHandledSyntaxErrorString()); realm->SetSyntaxErrorFunction(thread_, nativeErrorFunction); break; case JSType::JS_OOM_ERROR: nativeErrorFunction = env->GetOOMErrorFunction(); nameString = JSHandle(thread_->GlobalConstants()->GetHandledOOMErrorString()); realm->SetOOMErrorFunction(thread_, nativeErrorFunction); break; default: break; } PropertyDescriptor descriptor(thread_, nativeErrorFunction, true, false, true); JSObject::DefineOwnProperty(thread_, globalObject, nameString, descriptor); } void Builtins::GeneralUpdateError(ErrorParameter *error, EcmaEntrypoint constructor, EcmaEntrypoint method, const char *name, JSType type) const { error->nativeConstructor = constructor; error->nativeMethod = method; error->nativePropertyName = name; error->nativeJstype = type; } void Builtins::InitializeError(const JSHandle &env, const JSHandle &objFuncClass, const JSType &errorTag) const { // NativeError.prototype JSHandle nativeErrorFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle nativeErrorFuncPrototypeValue(nativeErrorFuncPrototype); ErrorParameter errorParameter{RangeError::RangeErrorConstructor, RangeError::ToString, "RangeError", JSType::JS_RANGE_ERROR}; switch (errorTag) { case JSType::JS_RANGE_ERROR: GeneralUpdateError(&errorParameter, RangeError::RangeErrorConstructor, RangeError::ToString, "RangeError", JSType::JS_RANGE_ERROR); break; case JSType::JS_EVAL_ERROR: GeneralUpdateError(&errorParameter, EvalError::EvalErrorConstructor, EvalError::ToString, "EvalError", JSType::JS_EVAL_ERROR); break; case JSType::JS_REFERENCE_ERROR: GeneralUpdateError(&errorParameter, ReferenceError::ReferenceErrorConstructor, ReferenceError::ToString, "ReferenceError", JSType::JS_REFERENCE_ERROR); break; case JSType::JS_TYPE_ERROR: GeneralUpdateError(&errorParameter, TypeError::TypeErrorConstructor, TypeError::ToString, "TypeError", JSType::JS_TYPE_ERROR); break; case JSType::JS_AGGREGATE_ERROR: GeneralUpdateError(&errorParameter, AggregateError::AggregateErrorConstructor, AggregateError::ToString, "AggregateError", JSType::JS_AGGREGATE_ERROR); break; case JSType::JS_URI_ERROR: GeneralUpdateError(&errorParameter, URIError::URIErrorConstructor, URIError::ToString, "URIError", JSType::JS_URI_ERROR); break; case JSType::JS_SYNTAX_ERROR: GeneralUpdateError(&errorParameter, SyntaxError::SyntaxErrorConstructor, SyntaxError::ToString, "SyntaxError", JSType::JS_SYNTAX_ERROR); break; case JSType::JS_OOM_ERROR: GeneralUpdateError(&errorParameter, OOMError::OOMErrorConstructor, OOMError::ToString, "OutOfMemoryError", JSType::JS_OOM_ERROR); break; default: break; } // NativeError.prototype_or_hclass JSHandle nativeErrorFuncInstanceHClass = factory_->NewEcmaHClass(JSObject::SIZE, errorParameter.nativeJstype, nativeErrorFuncPrototypeValue); // NativeError() = new Error() FunctionLength functionLength = FunctionLength::ONE; if (errorTag == JSType::JS_AGGREGATE_ERROR) { functionLength = FunctionLength::TWO; } JSHandle nativeErrorFunction = factory_->NewJSNativeErrorFunction(env, reinterpret_cast(errorParameter.nativeConstructor)); InitializeCtor(env, nativeErrorFuncPrototype, nativeErrorFunction, errorParameter.nativePropertyName, functionLength); nativeErrorFunction->SetFunctionPrototype(thread_, nativeErrorFuncInstanceHClass.GetTaggedValue()); // NativeError.prototype method SetFunction(env, nativeErrorFuncPrototype, thread_->GlobalConstants()->GetHandledToStringString(), errorParameter.nativeMethod, FunctionLength::ZERO); // Error.prototype Attribute SetAttribute(nativeErrorFuncPrototype, "name", errorParameter.nativePropertyName); SetAttribute(nativeErrorFuncPrototype, "message", ""); if (errorTag == JSType::JS_RANGE_ERROR) { env->SetRangeErrorFunction(thread_, nativeErrorFunction); } else if (errorTag == JSType::JS_REFERENCE_ERROR) { env->SetReferenceErrorFunction(thread_, nativeErrorFunction); } else if (errorTag == JSType::JS_TYPE_ERROR) { env->SetTypeErrorFunction(thread_, nativeErrorFunction); JSHandle throwTypeErrorFunction = factory_->NewJSFunction(env, reinterpret_cast(TypeError::ThrowTypeError)); JSFunction::SetFunctionLength(thread_, throwTypeErrorFunction, JSTaggedValue(1), false); JSObject::PreventExtensions(thread_, JSHandle::Cast(throwTypeErrorFunction)); env->SetThrowTypeError(thread_, throwTypeErrorFunction); } else if (errorTag == JSType::JS_AGGREGATE_ERROR) { env->SetAggregateErrorFunction(thread_, nativeErrorFunction); } else if (errorTag == JSType::JS_URI_ERROR) { env->SetURIErrorFunction(thread_, nativeErrorFunction); } else if (errorTag == JSType::JS_SYNTAX_ERROR) { env->SetSyntaxErrorFunction(thread_, nativeErrorFunction); } else if (errorTag == JSType::JS_EVAL_ERROR) { env->SetEvalErrorFunction(thread_, nativeErrorFunction); } else { env->SetOOMErrorFunction(thread_, nativeErrorFunction); } } // namespace panda::ecmascript void Builtins::InitializeCtor(const JSHandle &env, const JSHandle &prototype, const JSHandle &ctor, const char *name, int length) const { const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); JSFunction::SetFunctionLength(thread_, ctor, JSTaggedValue(length)); JSHandle nameString(factory_->NewFromUtf8(name)); JSFunction::SetFunctionName(thread_, JSHandle(ctor), nameString, JSHandle(thread_, JSTaggedValue::Undefined())); JSHandle constructorKey = globalConst->GetHandledConstructorString(); PropertyDescriptor descriptor1(thread_, JSHandle::Cast(ctor), true, false, true); JSObject::DefineOwnProperty(thread_, prototype, constructorKey, descriptor1); /* set "prototype" in constructor */ ctor->SetFunctionPrototype(thread_, prototype.GetTaggedValue()); if (!JSTaggedValue::SameValue(nameString, thread_->GlobalConstants()->GetHandledAsyncFunctionString())) { JSHandle globalObject(thread_, env->GetGlobalObject()); PropertyDescriptor descriptor2(thread_, JSHandle::Cast(ctor), true, false, true); JSObject::DefineOwnProperty(thread_, globalObject, nameString, descriptor2); } } void Builtins::InitializeSet(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); // Set.prototype JSHandle setFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle setFuncPrototypeValue(setFuncPrototype); // Set.prototype_or_hclass JSHandle setFuncInstanceHClass = factory_->NewEcmaHClass(JSSet::SIZE, JSType::JS_SET, setFuncPrototypeValue); // Set() = new Function() JSHandle setFunction( NewBuiltinConstructor(env, setFuncPrototype, BuiltinsSet::SetConstructor, "Set", FunctionLength::ZERO)); JSHandle(setFunction)->SetFunctionPrototype(thread_, setFuncInstanceHClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); JSObject::SetProperty(thread_, JSHandle(setFuncPrototype), constructorKey, setFunction); // set.prototype.add() SetFunction(env, setFuncPrototype, "add", BuiltinsSet::Add, FunctionLength::ONE); // set.prototype.clear() SetFunction(env, setFuncPrototype, "clear", BuiltinsSet::Clear, FunctionLength::ZERO); // set.prototype.delete() SetFunction(env, setFuncPrototype, "delete", BuiltinsSet::Delete, FunctionLength::ONE); // set.prototype.has() SetFunction(env, setFuncPrototype, "has", BuiltinsSet::Has, FunctionLength::ONE); // set.prototype.forEach() SetFunction(env, setFuncPrototype, "forEach", BuiltinsSet::ForEach, FunctionLength::ONE); // set.prototype.entries() SetFunction(env, setFuncPrototype, "entries", BuiltinsSet::Entries, FunctionLength::ZERO); // set.prototype.keys() SetFunction(env, setFuncPrototype, "values", BuiltinsSet::Values, FunctionLength::ZERO); // set.prototype.values() JSHandle keys(factory_->NewFromASCII("keys")); JSHandle values(factory_->NewFromASCII("values")); JSHandle valuesFunc = JSObject::GetMethod(thread_, JSHandle::Cast(setFuncPrototype), values); PropertyDescriptor descriptor(thread_, valuesFunc, true, false, true); JSObject::DefineOwnProperty(thread_, setFuncPrototype, keys, descriptor); // @@ToStringTag SetStringTagSymbol(env, setFuncPrototype, "Set"); // 23.1.3.10get Set.prototype.size JSHandle sizeGetter = CreateGetter(env, BuiltinsSet::GetSize, "size", FunctionLength::ZERO); JSHandle sizeKey(factory_->NewFromASCII("size")); SetGetter(setFuncPrototype, sizeKey, sizeGetter); // 23.1.2.2get Set [ @@species ] JSHandle speciesSymbol = env->GetSpeciesSymbol(); JSHandle speciesGetter = CreateGetter(env, BuiltinsSet::Species, "[Symbol.species]", FunctionLength::ZERO); SetGetter(JSHandle(setFunction), speciesSymbol, speciesGetter); // %SetPrototype% [ @@iterator ] JSHandle iteratorSymbol = env->GetIteratorSymbol(); JSObject::DefineOwnProperty(thread_, setFuncPrototype, iteratorSymbol, descriptor); env->SetBuiltinsSetFunction(thread_, setFunction); } void Builtins::InitializeMap(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); // Map.prototype JSHandle mapFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle mapFuncPrototypeValue(mapFuncPrototype); // Map.prototype_or_hclass JSHandle mapFuncInstanceHClass = factory_->NewEcmaHClass(JSMap::SIZE, JSType::JS_MAP, mapFuncPrototypeValue); // Map() = new Function() JSHandle mapFunction( NewBuiltinConstructor(env, mapFuncPrototype, BuiltinsMap::MapConstructor, "Map", FunctionLength::ZERO)); // Map().prototype = Map.Prototype & Map.prototype.constructor = Map() JSFunction::Cast(mapFunction->GetTaggedObject()) ->SetFunctionPrototype(thread_, mapFuncInstanceHClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); JSObject::SetProperty(thread_, JSHandle(mapFuncPrototype), constructorKey, mapFunction); // map.prototype.set() SetFunction(env, mapFuncPrototype, globalConst->GetHandledSetString(), BuiltinsMap::Set, FunctionLength::TWO); // map.prototype.clear() SetFunction(env, mapFuncPrototype, "clear", BuiltinsMap::Clear, FunctionLength::ZERO); // map.prototype.delete() SetFunction(env, mapFuncPrototype, "delete", BuiltinsMap::Delete, FunctionLength::ONE); // map.prototype.has() SetFunction(env, mapFuncPrototype, "has", BuiltinsMap::Has, FunctionLength::ONE); // map.prototype.get() SetFunction(env, mapFuncPrototype, thread_->GlobalConstants()->GetHandledGetString(), BuiltinsMap::Get, FunctionLength::ONE); // map.prototype.forEach() SetFunction(env, mapFuncPrototype, "forEach", BuiltinsMap::ForEach, FunctionLength::ONE); // map.prototype.keys() SetFunction(env, mapFuncPrototype, "keys", BuiltinsMap::Keys, FunctionLength::ZERO); // map.prototype.values() SetFunction(env, mapFuncPrototype, "values", BuiltinsMap::Values, FunctionLength::ZERO); // map.prototype.entries() SetFunction(env, mapFuncPrototype, "entries", BuiltinsMap::Entries, FunctionLength::ZERO); // @@ToStringTag SetStringTagSymbol(env, mapFuncPrototype, "Map"); // 23.1.3.10get Map.prototype.size JSHandle sizeGetter = CreateGetter(env, BuiltinsMap::GetSize, "size", FunctionLength::ZERO); JSHandle sizeKey(factory_->NewFromASCII("size")); SetGetter(mapFuncPrototype, sizeKey, sizeGetter); // 23.1.2.2get Map [ @@species ] JSHandle speciesSymbol = env->GetSpeciesSymbol(); JSHandle speciesGetter = CreateGetter(env, BuiltinsMap::Species, "[Symbol.species]", FunctionLength::ZERO); SetGetter(JSHandle(mapFunction), speciesSymbol, speciesGetter); // %MapPrototype% [ @@iterator ] JSHandle iteratorSymbol = env->GetIteratorSymbol(); JSHandle entries(factory_->NewFromASCII("entries")); JSHandle entriesFunc = JSObject::GetMethod(thread_, JSHandle::Cast(mapFuncPrototype), entries); PropertyDescriptor descriptor(thread_, entriesFunc, true, false, true); JSObject::DefineOwnProperty(thread_, mapFuncPrototype, iteratorSymbol, descriptor); env->SetBuiltinsMapFunction(thread_, mapFunction); env->SetMapPrototype(thread_, mapFuncPrototype); } void Builtins::InitializeWeakMap(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); // WeakMap.prototype JSHandle weakMapFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle weakMapFuncPrototypeValue(weakMapFuncPrototype); // WeakMap.prototype_or_hclass JSHandle weakMapFuncInstanceHClass = factory_->NewEcmaHClass(JSWeakMap::SIZE, JSType::JS_WEAK_MAP, weakMapFuncPrototypeValue); // WeakMap() = new Function() JSHandle weakMapFunction(NewBuiltinConstructor( env, weakMapFuncPrototype, BuiltinsWeakMap::WeakMapConstructor, "WeakMap", FunctionLength::ZERO)); // WeakMap().prototype = WeakMap.Prototype & WeakMap.prototype.constructor = WeakMap() JSFunction::Cast(weakMapFunction->GetTaggedObject()) ->SetProtoOrHClass(thread_, weakMapFuncInstanceHClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); JSObject::SetProperty(thread_, JSHandle(weakMapFuncPrototype), constructorKey, weakMapFunction); // weakmap.prototype.set() SetFunction(env, weakMapFuncPrototype, globalConst->GetHandledSetString(), BuiltinsWeakMap::Set, FunctionLength::TWO); // weakmap.prototype.delete() SetFunction(env, weakMapFuncPrototype, "delete", BuiltinsWeakMap::Delete, FunctionLength::ONE); // weakmap.prototype.has() SetFunction(env, weakMapFuncPrototype, "has", BuiltinsWeakMap::Has, FunctionLength::ONE); // weakmap.prototype.get() SetFunction(env, weakMapFuncPrototype, thread_->GlobalConstants()->GetHandledGetString(), BuiltinsWeakMap::Get, FunctionLength::ONE); // @@ToStringTag SetStringTagSymbol(env, weakMapFuncPrototype, "WeakMap"); env->SetBuiltinsWeakMapFunction(thread_, weakMapFunction); } void Builtins::InitializeWeakSet(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); // Set.prototype JSHandle weakSetFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle weakSetFuncPrototypeValue(weakSetFuncPrototype); // Set.prototype_or_hclass JSHandle weakSetFuncInstanceHClass = factory_->NewEcmaHClass(JSWeakSet::SIZE, JSType::JS_WEAK_SET, weakSetFuncPrototypeValue); // Set() = new Function() JSHandle weakSetFunction(NewBuiltinConstructor( env, weakSetFuncPrototype, BuiltinsWeakSet::WeakSetConstructor, "WeakSet", FunctionLength::ZERO)); JSHandle(weakSetFunction)->SetProtoOrHClass(thread_, weakSetFuncInstanceHClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); JSObject::SetProperty(thread_, JSHandle(weakSetFuncPrototype), constructorKey, weakSetFunction); // set.prototype.add() SetFunction(env, weakSetFuncPrototype, "add", BuiltinsWeakSet::Add, FunctionLength::ONE); // set.prototype.delete() SetFunction(env, weakSetFuncPrototype, "delete", BuiltinsWeakSet::Delete, FunctionLength::ONE); // set.prototype.has() SetFunction(env, weakSetFuncPrototype, "has", BuiltinsWeakSet::Has, FunctionLength::ONE); // @@ToStringTag SetStringTagSymbol(env, weakSetFuncPrototype, "WeakSet"); env->SetBuiltinsWeakSetFunction(thread_, weakSetFunction); } void Builtins::InitializeAtomics(const JSHandle &env, const JSHandle &objFuncPrototypeVal) const { [[maybe_unused]] EcmaHandleScope scope(thread_); JSHandle atomicsHClass = factory_->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, objFuncPrototypeVal); JSHandle atomicsObject = factory_->NewJSObject(atomicsHClass); SetFunction(env, atomicsObject, "add", Atomics::Add, FunctionLength::THREE); SetFunction(env, atomicsObject, "and", Atomics::And, FunctionLength::THREE); SetFunction(env, atomicsObject, "sub", Atomics::Sub, FunctionLength::THREE); SetFunction(env, atomicsObject, "or", Atomics::Or, FunctionLength::THREE); SetFunction(env, atomicsObject, "xor", Atomics::Xor, FunctionLength::THREE); SetFunction(env, atomicsObject, "compareExchange", Atomics::CompareExchange, FunctionLength::FOUR); SetFunction(env, atomicsObject, "exchange", Atomics::Exchange, FunctionLength::THREE); SetFunction(env, atomicsObject, "isLockFree", Atomics::IsLockFree, FunctionLength::ONE); SetFunction(env, atomicsObject, "load", Atomics::Load, FunctionLength::TWO); SetFunction(env, atomicsObject, "store", Atomics::Store, FunctionLength::THREE); SetFunction(env, atomicsObject, "wait", Atomics::Wait, FunctionLength::FOUR); SetFunction(env, atomicsObject, "notify", Atomics::Notify, FunctionLength::THREE); JSHandle atomicsString(factory_->NewFromASCII("Atomics")); JSHandle globalObject(thread_, env->GetGlobalObject()); PropertyDescriptor atomicsDesc(thread_, JSHandle::Cast(atomicsObject), true, false, true); JSObject::DefineOwnProperty(thread_, globalObject, atomicsString, atomicsDesc); // @@ToStringTag SetStringTagSymbol(env, atomicsObject, "Atomics"); env->SetAtomicsFunction(thread_, atomicsObject); } void Builtins::InitializeWeakRef(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); // WeakRef.prototype JSHandle weakRefFuncPrototype = factory_->NewJSObject(objFuncClass); JSHandle weakRefFuncPrototypeValue(weakRefFuncPrototype); // WeakRef.prototype_or_hclass JSHandle weakRefFuncInstanceHClass = factory_->NewEcmaHClass(JSWeakRef::SIZE, JSType::JS_WEAK_REF, weakRefFuncPrototypeValue); // WeakRef() = new Function() JSHandle weakRefFunction(NewBuiltinConstructor( env, weakRefFuncPrototype, BuiltinsWeakRef::WeakRefConstructor, "WeakRef", FunctionLength::ONE)); JSHandle(weakRefFunction)->SetProtoOrHClass(thread_, weakRefFuncInstanceHClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); JSObject::SetProperty(thread_, JSHandle(weakRefFuncPrototype), constructorKey, weakRefFunction); // WeakRef.prototype.deref() SetFunction(env, weakRefFuncPrototype, "deref", BuiltinsWeakRef::Deref, FunctionLength::ZERO); // @@ToStringTag SetStringTagSymbol(env, weakRefFuncPrototype, "WeakRef"); env->SetBuiltinsWeakRefFunction(thread_, weakRefFunction); } void Builtins::InitializeFinalizationRegistry(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); // FinalizationRegistry.prototype JSHandle finalizationRegistryFuncPrototype = factory_->NewJSObject(objFuncClass); JSHandle finalizationRegistryFuncPrototypeValue(finalizationRegistryFuncPrototype); // FinalizationRegistry.prototype_or_hclass JSHandle finalizationRegistryFuncInstanceHClass = factory_->NewEcmaHClass(JSFinalizationRegistry::SIZE, JSType::JS_FINALIZATION_REGISTRY, finalizationRegistryFuncPrototypeValue); // FinalizationRegistry() = new Function() JSHandle finalizationRegistryFunction(NewBuiltinConstructor( env, finalizationRegistryFuncPrototype, BuiltinsFinalizationRegistry::FinalizationRegistryConstructor, "FinalizationRegistry", FunctionLength::ONE)); JSHandle(finalizationRegistryFunction)->SetProtoOrHClass( thread_, finalizationRegistryFuncInstanceHClass.GetTaggedValue()); // "constructor" property on the prototype JSHandle constructorKey = globalConst->GetHandledConstructorString(); JSObject::SetProperty(thread_, JSHandle(finalizationRegistryFuncPrototype), constructorKey, finalizationRegistryFunction); // FinalizationRegistry.prototype.deref() SetFunction(env, finalizationRegistryFuncPrototype, "register", BuiltinsFinalizationRegistry::Register, FunctionLength::TWO); SetFunction(env, finalizationRegistryFuncPrototype, "unregister", BuiltinsFinalizationRegistry::Unregister, FunctionLength::ONE); // @@ToStringTag SetStringTagSymbol(env, finalizationRegistryFuncPrototype, "FinalizationRegistry"); env->SetBuiltinsFinalizationRegistryFunction(thread_, finalizationRegistryFunction); } void Builtins::InitializeMath(const JSHandle &env, const JSHandle &objFuncPrototypeVal) const { [[maybe_unused]] EcmaHandleScope scope(thread_); JSHandle mathClass = factory_->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, objFuncPrototypeVal); JSHandle mathObject = factory_->NewJSObjectWithInit(mathClass); RandomGenerator::InitRandom(); SetFunction(env, mathObject, "abs", Math::Abs, FunctionLength::ONE, BUILTINS_STUB_ID(ABS)); SetFunction(env, mathObject, "acos", Math::Acos, FunctionLength::ONE, BUILTINS_STUB_ID(ACOS)); SetFunction(env, mathObject, "acosh", Math::Acosh, FunctionLength::ONE); SetFunction(env, mathObject, "asin", Math::Asin, FunctionLength::ONE); SetFunction(env, mathObject, "asinh", Math::Asinh, FunctionLength::ONE); SetFunction(env, mathObject, "atan", Math::Atan, FunctionLength::ONE, BUILTINS_STUB_ID(ATAN)); SetFunction(env, mathObject, "atanh", Math::Atanh, FunctionLength::ONE); SetFunction(env, mathObject, "atan2", Math::Atan2, FunctionLength::TWO); SetFunction(env, mathObject, "cbrt", Math::Cbrt, FunctionLength::ONE); SetFunction(env, mathObject, "ceil", Math::Ceil, FunctionLength::ONE); SetFunction(env, mathObject, "clz32", Math::Clz32, FunctionLength::ONE); SetFunction(env, mathObject, "cos", Math::Cos, FunctionLength::ONE, BUILTINS_STUB_ID(COS)); SetFunction(env, mathObject, "cosh", Math::Cosh, FunctionLength::ONE); SetFunction(env, mathObject, "exp", Math::Exp, FunctionLength::ONE); SetFunction(env, mathObject, "expm1", Math::Expm1, FunctionLength::ONE); SetFunction(env, mathObject, "floor", Math::Floor, FunctionLength::ONE, BUILTINS_STUB_ID(FLOOR)); SetFunction(env, mathObject, "fround", Math::Fround, FunctionLength::ONE); SetFunction(env, mathObject, "hypot", Math::Hypot, FunctionLength::TWO); SetFunction(env, mathObject, "imul", Math::Imul, FunctionLength::TWO); SetFunction(env, mathObject, "log", Math::Log, FunctionLength::ONE); SetFunction(env, mathObject, "log1p", Math::Log1p, FunctionLength::ONE); SetFunction(env, mathObject, "log10", Math::Log10, FunctionLength::ONE); SetFunction(env, mathObject, "log2", Math::Log2, FunctionLength::ONE); SetFunction(env, mathObject, "max", Math::Max, FunctionLength::TWO); SetFunction(env, mathObject, "min", Math::Min, FunctionLength::TWO); SetFunction(env, mathObject, "pow", Math::Pow, FunctionLength::TWO); SetFunction(env, mathObject, "random", Math::Random, FunctionLength::ZERO); SetFunction(env, mathObject, "round", Math::Round, FunctionLength::ONE); SetFunction(env, mathObject, "sign", Math::Sign, FunctionLength::ONE); SetFunction(env, mathObject, "sin", Math::Sin, FunctionLength::ONE, BUILTINS_STUB_ID(SIN)); SetFunction(env, mathObject, "sinh", Math::Sinh, FunctionLength::ONE); SetFunction(env, mathObject, "sqrt", Math::Sqrt, FunctionLength::ONE, BUILTINS_STUB_ID(SQRT)); SetFunction(env, mathObject, "tan", Math::Tan, FunctionLength::ONE); SetFunction(env, mathObject, "tanh", Math::Tanh, FunctionLength::ONE); SetFunction(env, mathObject, "trunc", Math::Trunc, FunctionLength::ONE); SetConstant(mathObject, "E", JSTaggedValue(Math::E)); SetConstant(mathObject, "LN10", JSTaggedValue(Math::LN10)); SetConstant(mathObject, "LN2", JSTaggedValue(Math::LN2)); SetConstant(mathObject, "LOG10E", JSTaggedValue(Math::LOG10E)); SetConstant(mathObject, "LOG2E", JSTaggedValue(Math::LOG2E)); SetConstant(mathObject, "PI", JSTaggedValue(Math::PI)); SetConstant(mathObject, "SQRT1_2", JSTaggedValue(Math::SQRT1_2)); SetConstant(mathObject, "SQRT2", JSTaggedValue(Math::SQRT2)); JSHandle mathString(factory_->NewFromASCII("Math")); JSHandle globalObject(thread_, env->GetGlobalObject()); PropertyDescriptor mathDesc(thread_, JSHandle::Cast(mathObject), true, false, true); JSObject::DefineOwnProperty(thread_, globalObject, mathString, mathDesc); // @@ToStringTag SetStringTagSymbol(env, mathObject, "Math"); env->SetMathFunction(thread_, mathObject); } void Builtins::InitializeJson(const JSHandle &env, const JSHandle &objFuncPrototypeVal) const { [[maybe_unused]] EcmaHandleScope scope(thread_); JSHandle jsonHClass = factory_->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, objFuncPrototypeVal); JSHandle jsonObject = factory_->NewJSObjectWithInit(jsonHClass); SetFunction(env, jsonObject, "parse", Json::Parse, FunctionLength::TWO); SetFunction(env, jsonObject, "stringify", Json::Stringify, FunctionLength::THREE); PropertyDescriptor jsonDesc(thread_, JSHandle::Cast(jsonObject), true, false, true); JSHandle jsonString(factory_->NewFromASCII("JSON")); JSHandle globalObject(thread_, env->GetGlobalObject()); JSObject::DefineOwnProperty(thread_, globalObject, jsonString, jsonDesc); // @@ToStringTag SetStringTagSymbol(env, jsonObject, "JSON"); env->SetJsonFunction(thread_, jsonObject); } void Builtins::InitializeString(const JSHandle &env, const JSHandle &primRefObjHClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // String.prototype JSHandle toObject(factory_->GetEmptyString()); JSHandle stringFuncPrototype = JSHandle::Cast(factory_->NewJSPrimitiveRef(primRefObjHClass, toObject)); JSHandle stringFuncPrototypeValue(stringFuncPrototype); // String.prototype_or_hclass JSHandle stringFuncInstanceHClass = factory_->NewEcmaHClass(JSPrimitiveRef::SIZE, JSType::JS_PRIMITIVE_REF, stringFuncPrototypeValue); // String = new Function() JSHandle stringFunction(NewBuiltinConstructor(env, stringFuncPrototype, BuiltinsString::StringConstructor, "String", FunctionLength::ONE)); stringFunction.GetObject()->SetFunctionPrototype(thread_, stringFuncInstanceHClass.GetTaggedValue()); // String.prototype method SetFunction(env, stringFuncPrototype, "charAt", BuiltinsString::CharAt, FunctionLength::ONE, BUILTINS_STUB_ID(CharAt)); SetFunction(env, stringFuncPrototype, "charCodeAt", BuiltinsString::CharCodeAt, FunctionLength::ONE, BUILTINS_STUB_ID(CharCodeAt)); SetFunction(env, stringFuncPrototype, "codePointAt", BuiltinsString::CodePointAt, FunctionLength::ONE); SetFunction(env, stringFuncPrototype, "concat", BuiltinsString::Concat, FunctionLength::ONE); SetFunction(env, stringFuncPrototype, "endsWith", BuiltinsString::EndsWith, FunctionLength::ONE); SetFunction(env, stringFuncPrototype, "includes", BuiltinsString::Includes, FunctionLength::ONE); SetFunction(env, stringFuncPrototype, "indexOf", BuiltinsString::IndexOf, FunctionLength::ONE, BUILTINS_STUB_ID(IndexOf)); SetFunction(env, stringFuncPrototype, "lastIndexOf", BuiltinsString::LastIndexOf, FunctionLength::ONE); SetFunction(env, stringFuncPrototype, "localeCompare", BuiltinsString::LocaleCompare, FunctionLength::ONE); SetFunction(env, stringFuncPrototype, "match", BuiltinsString::Match, FunctionLength::ONE); SetFunction(env, stringFuncPrototype, "matchAll", BuiltinsString::MatchAll, FunctionLength::ONE); SetFunction(env, stringFuncPrototype, "repeat", BuiltinsString::Repeat, FunctionLength::ONE); SetFunction(env, stringFuncPrototype, "normalize", BuiltinsString::Normalize, FunctionLength::ZERO); SetFunction(env, stringFuncPrototype, "padStart", BuiltinsString::PadStart, FunctionLength::ONE); SetFunction(env, stringFuncPrototype, "padEnd", BuiltinsString::PadEnd, FunctionLength::ONE); SetFunction(env, stringFuncPrototype, "replace", BuiltinsString::Replace, FunctionLength::TWO); SetFunction(env, stringFuncPrototype, "replaceAll", BuiltinsString::ReplaceAll, FunctionLength::TWO); SetFunction(env, stringFuncPrototype, "search", BuiltinsString::Search, FunctionLength::ONE); SetFunction(env, stringFuncPrototype, "slice", BuiltinsString::Slice, FunctionLength::TWO); SetFunction(env, stringFuncPrototype, "split", BuiltinsString::Split, FunctionLength::TWO); SetFunction(env, stringFuncPrototype, "startsWith", BuiltinsString::StartsWith, FunctionLength::ONE); SetFunction(env, stringFuncPrototype, "substring", BuiltinsString::Substring, FunctionLength::TWO, BUILTINS_STUB_ID(Substring)); SetFunction(env, stringFuncPrototype, "substr", BuiltinsString::SubStr, FunctionLength::TWO); SetFunction(env, stringFuncPrototype, "toLocaleLowerCase", BuiltinsString::ToLocaleLowerCase, FunctionLength::ZERO); SetFunction(env, stringFuncPrototype, "toLocaleUpperCase", BuiltinsString::ToLocaleUpperCase, FunctionLength::ZERO); SetFunction(env, stringFuncPrototype, "toLowerCase", BuiltinsString::ToLowerCase, FunctionLength::ZERO); SetFunction(env, stringFuncPrototype, thread_->GlobalConstants()->GetHandledToStringString(), BuiltinsString::ToString, FunctionLength::ZERO); SetFunction(env, stringFuncPrototype, "toUpperCase", BuiltinsString::ToUpperCase, FunctionLength::ZERO); SetFunction(env, stringFuncPrototype, "trim", BuiltinsString::Trim, FunctionLength::ZERO); SetFunction(env, stringFuncPrototype, "trimStart", BuiltinsString::TrimStart, FunctionLength::ZERO); SetFunction(env, stringFuncPrototype, "trimEnd", BuiltinsString::TrimEnd, FunctionLength::ZERO); SetFunction(env, stringFuncPrototype, "trimLeft", BuiltinsString::TrimLeft, FunctionLength::ZERO); SetFunction(env, stringFuncPrototype, "trimRight", BuiltinsString::TrimRight, FunctionLength::ZERO); SetFunction(env, stringFuncPrototype, thread_->GlobalConstants()->GetHandledValueOfString(), BuiltinsString::ValueOf, FunctionLength::ZERO); SetFunctionAtSymbol(env, stringFuncPrototype, env->GetIteratorSymbol(), "[Symbol.iterator]", BuiltinsString::GetStringIterator, FunctionLength::ZERO); // String method SetFunction(env, stringFunction, "fromCharCode", BuiltinsString::FromCharCode, FunctionLength::ONE); SetFunction(env, stringFunction, "fromCodePoint", BuiltinsString::FromCodePoint, FunctionLength::ONE); SetFunction(env, stringFunction, "raw", BuiltinsString::Raw, FunctionLength::ONE); // String.prototype.length JSHandle lengthGetter = CreateGetter(env, BuiltinsString::GetLength, "length", FunctionLength::ZERO); JSHandle lengthKey(factory_->NewFromASCII("length")); SetGetter(stringFuncPrototype, lengthKey, lengthGetter); env->SetStringFunction(thread_, stringFunction); } void Builtins::InitializeStringIterator(const JSHandle &env, const JSHandle &iteratorFuncClass) const { // StringIterator.prototype JSHandle strIterPrototype(factory_->NewJSObjectWithInit(iteratorFuncClass)); // StringIterator.prototype_or_hclass JSHandle strIterFuncInstanceHClass = factory_->NewEcmaHClass( JSStringIterator::SIZE, JSType::JS_STRING_ITERATOR, JSHandle(strIterPrototype)); JSHandle strIterFunction( factory_->NewJSFunction(env, static_cast(nullptr), FunctionKind::BASE_CONSTRUCTOR)); strIterFunction->SetFunctionPrototype(thread_, strIterFuncInstanceHClass.GetTaggedValue()); SetFunction(env, strIterPrototype, "next", StringIterator::Next, FunctionLength::ZERO); SetStringTagSymbol(env, strIterPrototype, "String Iterator"); env->SetStringIterator(thread_, strIterFunction); env->SetStringIteratorPrototype(thread_, strIterPrototype); } void Builtins::InitializeAsyncFromSyncIterator(const JSHandle &env, const JSHandle &iteratorFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); JSHandle asyncItPrototype = factory_->NewJSObjectWithInit(iteratorFuncClass); SetFunction(env, asyncItPrototype, "next", BuiltinsAsyncFromSyncIterator::Next, FunctionLength::ONE); SetFunction(env, asyncItPrototype, "return", BuiltinsAsyncFromSyncIterator::Return, FunctionLength::ONE); SetFunction(env, asyncItPrototype, "throw", BuiltinsAsyncFromSyncIterator::Throw, FunctionLength::ONE); JSHandle hclass = factory_->NewEcmaHClass(JSAsyncFromSyncIterator::SIZE, JSType::JS_ASYNC_FROM_SYNC_ITERATOR, JSHandle(asyncItPrototype)); JSHandle iterFunction( factory_->NewJSFunction(env, static_cast(nullptr), FunctionKind::BASE_CONSTRUCTOR)); iterFunction->SetFunctionPrototype(thread_, hclass.GetTaggedValue()); env->SetAsyncFromSyncIterator(thread_, iterFunction); env->SetAsyncFromSyncIteratorPrototype(thread_, asyncItPrototype); JSHandle asyncFromSyncIterUnwarpClass = factory_->NewEcmaHClass(JSAsyncFromSyncIterUnwarpFunction::SIZE, JSType::JS_ASYNC_FROM_SYNC_ITER_UNWARP_FUNCTION, env->GetFunctionPrototype()); asyncFromSyncIterUnwarpClass->SetCallable(true); asyncFromSyncIterUnwarpClass->SetExtensible(true); env->SetAsyncFromSyncIterUnwarpClass(thread_, asyncFromSyncIterUnwarpClass); } void Builtins::InitializeIterator(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Iterator.prototype JSHandle iteratorPrototype = factory_->NewJSObjectWithInit(objFuncClass); // Iterator.prototype.next() SetFunction(env, iteratorPrototype, "next", BuiltinsIterator::Next, FunctionLength::ONE); // Iterator.prototype.return() SetFunction(env, iteratorPrototype, "return", BuiltinsIterator::Return, FunctionLength::ONE); // Iterator.prototype.throw() SetFunction(env, iteratorPrototype, "throw", BuiltinsIterator::Throw, FunctionLength::ONE); // %IteratorPrototype% [ @@iterator ] SetFunctionAtSymbol(env, iteratorPrototype, env->GetIteratorSymbol(), "[Symbol.iterator]", BuiltinsIterator::GetIteratorObj, FunctionLength::ZERO); env->SetIteratorPrototype(thread_, iteratorPrototype); // Iterator.hclass JSHandle iteratorFuncClass = factory_->NewEcmaHClass(JSObject::SIZE, JSType::JS_ITERATOR, JSHandle(iteratorPrototype)); auto globalConst = const_cast(thread_->GlobalConstants()); globalConst->SetConstant(ConstantIndex::JS_API_ITERATOR_FUNC_CLASS_INDEX, iteratorFuncClass); // Iterator result hclass JSHandle iterResultHClass = factory_->CreateIteratorResultInstanceClass(); globalConst->SetConstant(ConstantIndex::ITERATOR_RESULT_CLASS, iterResultHClass); // ues for CloseIterator JSHandle record = factory_->NewCompletionRecord(CompletionRecordType::NORMAL, globalConst->GetHandledUndefined()); globalConst->SetConstant(ConstantIndex::UNDEFINED_COMPLRTION_RECORD_INDEX, record); InitializeForinIterator(env, iteratorFuncClass); InitializeSetIterator(env, iteratorFuncClass); InitializeMapIterator(env, iteratorFuncClass); InitializeArrayIterator(env, iteratorFuncClass); InitializeStringIterator(env, iteratorFuncClass); InitializeRegexpIterator(env, iteratorFuncClass); } void Builtins::InitializeAsyncIterator(const JSHandle &env, const JSHandle &objFuncDynclass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // AsyncIterator.prototype JSHandle asyncIteratorPrototype = factory_->NewJSObjectWithInit(objFuncDynclass); // AsyncIterator.prototype.next() SetFunction(env, asyncIteratorPrototype, "next", BuiltinsAsyncIterator::Next, FunctionLength::ONE); // AsyncIterator.prototype.return() SetFunction(env, asyncIteratorPrototype, "return", BuiltinsAsyncIterator::Return, FunctionLength::ONE); // AsyncIterator.prototype.throw() SetFunction(env, asyncIteratorPrototype, "throw", BuiltinsAsyncIterator::Throw, FunctionLength::ONE); // %AsyncIteratorPrototype% [ @@AsyncIterator ] SetFunctionAtSymbol(env, asyncIteratorPrototype, env->GetAsyncIteratorSymbol(), "[Symbol.asyncIterator]", BuiltinsAsyncIterator::GetAsyncIteratorObj, FunctionLength::ZERO); env->SetAsyncIteratorPrototype(thread_, asyncIteratorPrototype); // AsyncIterator.dynclass JSHandle asyncIteratorFuncDynclass = factory_->NewEcmaHClass(JSObject::SIZE, JSType::JS_ASYNCITERATOR, JSHandle(asyncIteratorPrototype)); auto globalConst = const_cast(thread_->GlobalConstants()); globalConst->SetConstant(ConstantIndex::JS_API_ASYNCITERATOR_FUNC_CLASS_INDEX, asyncIteratorFuncDynclass); } void Builtins::InitializeForinIterator(const JSHandle &env, const JSHandle &iteratorFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Iterator.prototype JSHandle forinIteratorPrototype = factory_->NewJSObjectWithInit(iteratorFuncClass); JSHandle hclass = factory_->NewEcmaHClass(JSForInIterator::SIZE, JSType::JS_FORIN_ITERATOR, JSHandle(forinIteratorPrototype)); // Iterator.prototype.next() SetFunction(env, forinIteratorPrototype, "next", JSForInIterator::Next, FunctionLength::ONE); env->SetForinIteratorPrototype(thread_, forinIteratorPrototype); env->SetForinIteratorClass(thread_, hclass); } void Builtins::InitializeSetIterator(const JSHandle &env, const JSHandle &iteratorFuncClass) const { // SetIterator.prototype JSHandle setIteratorPrototype(factory_->NewJSObjectWithInit(iteratorFuncClass)); // Iterator.prototype.next() SetFunction(env, setIteratorPrototype, "next", JSSetIterator::Next, FunctionLength::ZERO); SetStringTagSymbol(env, setIteratorPrototype, "Set Iterator"); env->SetSetIteratorPrototype(thread_, setIteratorPrototype); } void Builtins::InitializeMapIterator(const JSHandle &env, const JSHandle &iteratorFuncClass) const { // MapIterator.prototype JSHandle mapIteratorPrototype(factory_->NewJSObjectWithInit(iteratorFuncClass)); // Iterator.prototype.next() SetFunction(env, mapIteratorPrototype, "next", JSMapIterator::Next, FunctionLength::ZERO); SetStringTagSymbol(env, mapIteratorPrototype, "Map Iterator"); env->SetMapIteratorPrototype(thread_, mapIteratorPrototype); } void Builtins::InitializeArrayIterator(const JSHandle &env, const JSHandle &iteratorFuncClass) const { // ArrayIterator.prototype JSHandle arrayIteratorPrototype(factory_->NewJSObjectWithInit(iteratorFuncClass)); // Iterator.prototype.next() SetFunction(env, arrayIteratorPrototype, "next", JSArrayIterator::Next, FunctionLength::ZERO); SetStringTagSymbol(env, arrayIteratorPrototype, "Array Iterator"); env->SetArrayIteratorPrototype(thread_, arrayIteratorPrototype); } void Builtins::InitializeRegexpIterator(const JSHandle &env, const JSHandle &iteratorFuncClass) const { // RegExpIterator.prototype JSHandle regExpIteratorPrototype(factory_->NewJSObject(iteratorFuncClass)); // Iterator.prototype.next() SetFunction(env, regExpIteratorPrototype, "next", JSRegExpIterator::Next, FunctionLength::ZERO); SetStringTagSymbol(env, regExpIteratorPrototype, "RegExp String Iterator"); env->SetRegExpIteratorPrototype(thread_, regExpIteratorPrototype); } void Builtins::InitializeRegExp(const JSHandle &env) { [[maybe_unused]] EcmaHandleScope scope(thread_); // RegExp.prototype JSHandle objFun(env->GetObjectFunction()); JSHandle regPrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle regPrototypeValue(regPrototype); // RegExp.prototype_or_hclass JSHandle regexpFuncInstanceHClass = factory_->CreateJSRegExpInstanceClass(regPrototypeValue); // RegExp = new Function() JSHandle regexpFunction( NewBuiltinConstructor(env, regPrototype, RegExp::RegExpConstructor, "RegExp", FunctionLength::TWO)); // initialize RegExp.$1 .. $9 static and read-only attributes InitializeGlobalRegExp(regexpFunction); JSHandle(regexpFunction)->SetFunctionPrototype(thread_, regexpFuncInstanceHClass.GetTaggedValue()); const GlobalEnvConstants *globalConstants = thread_->GlobalConstants(); // RegExp.prototype method SetFunction(env, regPrototype, "exec", RegExp::Exec, FunctionLength::ONE); SetFunction(env, regPrototype, "test", RegExp::Test, FunctionLength::ONE); SetFunction(env, regPrototype, globalConstants->GetHandledToStringString(), RegExp::ToString, FunctionLength::ZERO); JSHandle flagsGetter = CreateGetter(env, RegExp::GetFlags, "flags", FunctionLength::ZERO); JSHandle flagsKey(globalConstants->GetHandledFlagsString()); SetGetter(regPrototype, flagsKey, flagsGetter); JSHandle sourceGetter = CreateGetter(env, RegExp::GetSource, "source", FunctionLength::ZERO); JSHandle sourceKey(globalConstants->GetHandledSourceString()); SetGetter(regPrototype, sourceKey, sourceGetter); JSHandle globalGetter = CreateGetter(env, RegExp::GetGlobal, "global", FunctionLength::ZERO); JSHandle globalKey(globalConstants->GetHandledGlobalString()); SetGetter(regPrototype, globalKey, globalGetter); JSHandle ignoreCaseGetter = CreateGetter(env, RegExp::GetIgnoreCase, "ignoreCase", FunctionLength::ZERO); JSHandle ignoreCaseKey(factory_->NewFromASCII("ignoreCase")); SetGetter(regPrototype, ignoreCaseKey, ignoreCaseGetter); JSHandle multilineGetter = CreateGetter(env, RegExp::GetMultiline, "multiline", FunctionLength::ZERO); JSHandle multilineKey(factory_->NewFromASCII("multiline")); SetGetter(regPrototype, multilineKey, multilineGetter); JSHandle dotAllGetter = CreateGetter(env, RegExp::GetDotAll, "dotAll", FunctionLength::ZERO); JSHandle dotAllKey(factory_->NewFromASCII("dotAll")); SetGetter(regPrototype, dotAllKey, dotAllGetter); JSHandle stickyGetter = CreateGetter(env, RegExp::GetSticky, "sticky", FunctionLength::ZERO); JSHandle stickyKey(globalConstants->GetHandledStickyString()); SetGetter(regPrototype, stickyKey, stickyGetter); JSHandle unicodeGetter = CreateGetter(env, RegExp::GetUnicode, "unicode", FunctionLength::ZERO); JSHandle unicodeKey(globalConstants->GetHandledUnicodeString()); SetGetter(regPrototype, unicodeKey, unicodeGetter); // Set RegExp [ @@species ] JSHandle speciesSymbol = env->GetSpeciesSymbol(); JSHandle speciesGetter = CreateGetter(env, BuiltinsMap::Species, "[Symbol.species]", FunctionLength::ZERO); SetGetter(JSHandle(regexpFunction), speciesSymbol, speciesGetter); // Set RegExp.prototype[@@split] SetFunctionAtSymbol(env, regPrototype, env->GetSplitSymbol(), "[Symbol.split]", RegExp::Split, FunctionLength::TWO); // Set RegExp.prototype[@@search] SetFunctionAtSymbol(env, regPrototype, env->GetSearchSymbol(), "[Symbol.search]", RegExp::Search, FunctionLength::ONE); // Set RegExp.prototype[@@match] SetFunctionAtSymbol(env, regPrototype, env->GetMatchSymbol(), "[Symbol.match]", RegExp::Match, FunctionLength::ONE); // Set RegExp.prototype[@@matchAll] SetFunctionAtSymbol(env, regPrototype, env->GetMatchAllSymbol(), "[Symbol.matchAll]", RegExp::MatchAll, FunctionLength::ONE); // Set RegExp.prototype[@@replace] SetFunctionAtSymbol(env, regPrototype, env->GetReplaceSymbol(), "[Symbol.replace]", RegExp::Replace, FunctionLength::TWO); env->SetRegExpFunction(thread_, regexpFunction); auto globalConst = const_cast(thread_->GlobalConstants()); globalConst->SetConstant(ConstantIndex::JS_REGEXP_CLASS_INDEX, regexpFuncInstanceHClass.GetTaggedValue()); } void Builtins::InitializeArray(const JSHandle &env, const JSHandle &objFuncPrototypeVal) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Arraybase.prototype JSHandle arrBaseFuncInstanceHClass = factory_->CreateJSArrayInstanceClass(objFuncPrototypeVal); // Array.prototype JSHandle arrFuncPrototype = factory_->NewJSObjectWithInit(arrBaseFuncInstanceHClass); JSHandle::Cast(arrFuncPrototype)->SetLength(thread_, JSTaggedValue(FunctionLength::ZERO)); auto accessor = thread_->GlobalConstants()->GetArrayLengthAccessor(); JSArray::Cast(*arrFuncPrototype)->SetPropertyInlinedProps(thread_, JSArray::LENGTH_INLINE_PROPERTY_INDEX, accessor); JSHandle arrFuncPrototypeValue(arrFuncPrototype); // Array.prototype_or_hclass JSHandle arrFuncInstanceHClass = factory_->CreateJSArrayInstanceClass(arrFuncPrototypeValue); // Array = new Function() JSHandle arrayFunction( NewBuiltinConstructor(env, arrFuncPrototype, BuiltinsArray::ArrayConstructor, "Array", FunctionLength::ONE, BUILTINS_STUB_ID(ArrayConstructor))); JSHandle arrayFuncFunction(arrayFunction); // Set the [[Realm]] internal slot of F to the running execution context's Realm JSHandle lexicalEnv = factory_->NewLexicalEnv(0); lexicalEnv->SetParentEnv(thread_, env.GetTaggedValue()); arrayFuncFunction->SetLexicalEnv(thread_, lexicalEnv.GetTaggedValue()); arrayFuncFunction->SetFunctionPrototype(thread_, arrFuncInstanceHClass.GetTaggedValue()); // Array.prototype method SetFunction(env, arrFuncPrototype, "concat", BuiltinsArray::Concat, FunctionLength::ONE); SetFunction(env, arrFuncPrototype, "copyWithin", BuiltinsArray::CopyWithin, FunctionLength::TWO); SetFunction(env, arrFuncPrototype, "entries", BuiltinsArray::Entries, FunctionLength::ZERO); SetFunction(env, arrFuncPrototype, "every", BuiltinsArray::Every, FunctionLength::ONE); SetFunction(env, arrFuncPrototype, "fill", BuiltinsArray::Fill, FunctionLength::ONE); SetFunction(env, arrFuncPrototype, "filter", BuiltinsArray::Filter, FunctionLength::ONE); SetFunction(env, arrFuncPrototype, "find", BuiltinsArray::Find, FunctionLength::ONE); SetFunction(env, arrFuncPrototype, "findIndex", BuiltinsArray::FindIndex, FunctionLength::ONE); SetFunction(env, arrFuncPrototype, "forEach", BuiltinsArray::ForEach, FunctionLength::ONE); SetFunction(env, arrFuncPrototype, "indexOf", BuiltinsArray::IndexOf, FunctionLength::ONE); SetFunction(env, arrFuncPrototype, "join", BuiltinsArray::Join, FunctionLength::ONE); SetFunction(env, arrFuncPrototype, "keys", BuiltinsArray::Keys, FunctionLength::ZERO); SetFunction(env, arrFuncPrototype, "lastIndexOf", BuiltinsArray::LastIndexOf, FunctionLength::ONE); SetFunction(env, arrFuncPrototype, "map", BuiltinsArray::Map, FunctionLength::ONE); SetFunction(env, arrFuncPrototype, "pop", BuiltinsArray::Pop, FunctionLength::ZERO); SetFunction(env, arrFuncPrototype, "push", BuiltinsArray::Push, FunctionLength::ONE); SetFunction(env, arrFuncPrototype, "reduce", BuiltinsArray::Reduce, FunctionLength::ONE); SetFunction(env, arrFuncPrototype, "reduceRight", BuiltinsArray::ReduceRight, FunctionLength::ONE); SetFunction(env, arrFuncPrototype, "reverse", BuiltinsArray::Reverse, FunctionLength::ZERO); SetFunction(env, arrFuncPrototype, "shift", BuiltinsArray::Shift, FunctionLength::ZERO); SetFunction(env, arrFuncPrototype, "slice", BuiltinsArray::Slice, FunctionLength::TWO); SetFunction(env, arrFuncPrototype, "some", BuiltinsArray::Some, FunctionLength::ONE); SetFunction(env, arrFuncPrototype, "sort", BuiltinsArray::Sort, FunctionLength::ONE); SetFunction(env, arrFuncPrototype, "splice", BuiltinsArray::Splice, FunctionLength::TWO); SetFunction(env, arrFuncPrototype, thread_->GlobalConstants()->GetHandledToLocaleStringString(), BuiltinsArray::ToLocaleString, FunctionLength::ZERO); SetFunction(env, arrFuncPrototype, thread_->GlobalConstants()->GetHandledToStringString(), BuiltinsArray::ToString, FunctionLength::ZERO); SetFunction(env, arrFuncPrototype, "unshift", BuiltinsArray::Unshift, FunctionLength::ONE); SetFunction(env, arrFuncPrototype, "values", BuiltinsArray::Values, FunctionLength::ZERO); SetFunction(env, arrFuncPrototype, "includes", BuiltinsArray::Includes, FunctionLength::ONE); SetFunction(env, arrFuncPrototype, "flat", BuiltinsArray::Flat, FunctionLength::ZERO); SetFunction(env, arrFuncPrototype, "flatMap", BuiltinsArray::FlatMap, FunctionLength::ONE); // %ArrayPrototype% [ @@iterator ] JSHandle values(factory_->NewFromASCII("values")); JSHandle iteratorSymbol = env->GetIteratorSymbol(); JSHandle valuesFunc = JSObject::GetMethod(thread_, JSHandle::Cast(arrFuncPrototype), values); PropertyDescriptor iteartorDesc(thread_, valuesFunc, true, false, true); JSObject::DefineOwnProperty(thread_, arrFuncPrototype, iteratorSymbol, iteartorDesc); // Array method SetFunction(env, arrayFunction, "from", BuiltinsArray::From, FunctionLength::ONE); SetFunction(env, arrayFunction, "isArray", BuiltinsArray::IsArray, FunctionLength::ONE); SetFunction(env, arrayFunction, "of", BuiltinsArray::Of, FunctionLength::ZERO); // 22.1.2.5 get %Array% [ @@species ] JSHandle speciesSymbol = env->GetSpeciesSymbol(); JSHandle speciesGetter = CreateGetter(env, BuiltinsArray::Species, "[Symbol.species]", FunctionLength::ZERO); SetGetter(JSHandle(arrayFunction), speciesSymbol, speciesGetter); constexpr int arrProtoLen = 0; JSHandle key_string = thread_->GlobalConstants()->GetHandledLengthString(); PropertyDescriptor descriptor(thread_, JSHandle(thread_, JSTaggedValue(arrProtoLen)), true, false, false); JSObject::DefineOwnProperty(thread_, arrFuncPrototype, key_string, descriptor); JSHandle valuesKey(factory_->NewFromASCII("values")); PropertyDescriptor desc(thread_); JSObject::GetOwnProperty(thread_, arrFuncPrototype, valuesKey, desc); // Array.prototype [ @@unscopables ] JSHandle unscopablesSymbol = env->GetUnscopablesSymbol(); JSHandle unscopablesGetter = CreateGetter(env, BuiltinsArray::Unscopables, "[Symbol.unscopables]", FunctionLength::ZERO); SetGetter(JSHandle(arrFuncPrototype), unscopablesSymbol, unscopablesGetter); env->SetArrayProtoValuesFunction(thread_, desc.GetValue()); env->SetArrayFunction(thread_, arrayFunction); env->SetArrayPrototype(thread_, arrFuncPrototype); } void Builtins::InitializeTypedArray(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // TypedArray.prototype JSHandle typedArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle typedArrFuncPrototypeValue(typedArrFuncPrototype); // TypedArray.prototype_or_hclass JSHandle typedArrFuncInstanceHClass = factory_->NewEcmaHClass( panda::ecmascript::JSTypedArray::SIZE, JSType::JS_TYPED_ARRAY, typedArrFuncPrototypeValue); // TypedArray = new Function() JSHandle typedArrayFunction(NewBuiltinConstructor( env, typedArrFuncPrototype, BuiltinsTypedArray::TypedArrayBaseConstructor, "TypedArray", FunctionLength::ZERO)); JSHandle(typedArrayFunction) ->SetProtoOrHClass(thread_, typedArrFuncInstanceHClass.GetTaggedValue()); // TypedArray.prototype method SetFunction(env, typedArrFuncPrototype, "copyWithin", BuiltinsTypedArray::CopyWithin, FunctionLength::TWO); SetFunction(env, typedArrFuncPrototype, "entries", BuiltinsTypedArray::Entries, FunctionLength::ZERO); SetFunction(env, typedArrFuncPrototype, "every", BuiltinsTypedArray::Every, FunctionLength::ONE); SetFunction(env, typedArrFuncPrototype, "fill", BuiltinsTypedArray::Fill, FunctionLength::ONE); SetFunction(env, typedArrFuncPrototype, "filter", BuiltinsTypedArray::Filter, FunctionLength::ONE); SetFunction(env, typedArrFuncPrototype, "find", BuiltinsTypedArray::Find, FunctionLength::ONE); SetFunction(env, typedArrFuncPrototype, "findIndex", BuiltinsTypedArray::FindIndex, FunctionLength::ONE); SetFunction(env, typedArrFuncPrototype, "forEach", BuiltinsTypedArray::ForEach, FunctionLength::ONE); SetFunction(env, typedArrFuncPrototype, "indexOf", BuiltinsTypedArray::IndexOf, FunctionLength::ONE); SetFunction(env, typedArrFuncPrototype, "join", BuiltinsTypedArray::Join, FunctionLength::ONE); SetFunction(env, typedArrFuncPrototype, "keys", BuiltinsTypedArray::Keys, FunctionLength::ZERO); SetFunction(env, typedArrFuncPrototype, "lastIndexOf", BuiltinsTypedArray::LastIndexOf, FunctionLength::ONE); SetFunction(env, typedArrFuncPrototype, "map", BuiltinsTypedArray::Map, FunctionLength::ONE); SetFunction(env, typedArrFuncPrototype, "reduce", BuiltinsTypedArray::Reduce, FunctionLength::ONE); SetFunction(env, typedArrFuncPrototype, "reduceRight", BuiltinsTypedArray::ReduceRight, FunctionLength::ONE); SetFunction(env, typedArrFuncPrototype, "reverse", BuiltinsTypedArray::Reverse, FunctionLength::ZERO); SetFunction(env, typedArrFuncPrototype, "set", BuiltinsTypedArray::Set, FunctionLength::ONE); SetFunction(env, typedArrFuncPrototype, "slice", BuiltinsTypedArray::Slice, FunctionLength::TWO); SetFunction(env, typedArrFuncPrototype, "some", BuiltinsTypedArray::Some, FunctionLength::ONE); SetFunction(env, typedArrFuncPrototype, "sort", BuiltinsTypedArray::Sort, FunctionLength::ONE); SetFunction(env, typedArrFuncPrototype, "subarray", BuiltinsTypedArray::Subarray, FunctionLength::TWO); SetFunction(env, typedArrFuncPrototype, thread_->GlobalConstants()->GetHandledToLocaleStringString(), BuiltinsTypedArray::ToLocaleString, FunctionLength::ZERO); SetFunction(env, typedArrFuncPrototype, "values", BuiltinsTypedArray::Values, FunctionLength::ZERO); SetFunction(env, typedArrFuncPrototype, "includes", BuiltinsTypedArray::Includes, FunctionLength::ONE); JSHandle bufferGetter = CreateGetter(env, BuiltinsTypedArray::GetBuffer, "buffer", FunctionLength::ZERO); JSHandle bufferKey(factory_->NewFromASCII("buffer")); SetGetter(typedArrFuncPrototype, bufferKey, bufferGetter); JSHandle byteLengthGetter = CreateGetter(env, BuiltinsTypedArray::GetByteLength, "byteLength", FunctionLength::ZERO); JSHandle byteLengthKey(factory_->NewFromASCII("byteLength")); SetGetter(typedArrFuncPrototype, byteLengthKey, byteLengthGetter); JSHandle byteOffsetGetter = CreateGetter(env, BuiltinsTypedArray::GetByteOffset, "byteOffset", FunctionLength::ZERO); JSHandle byteOffsetKey(factory_->NewFromASCII("byteOffset")); SetGetter(typedArrFuncPrototype, byteOffsetKey, byteOffsetGetter); JSHandle lengthGetter = CreateGetter(env, BuiltinsTypedArray::GetLength, "length", FunctionLength::ZERO); JSHandle lengthKey(factory_->NewFromASCII("length")); SetGetter(typedArrFuncPrototype, lengthKey, lengthGetter); // %TypedArray%.prototype.toString() JSHandle arrFuncPrototype = env->GetArrayPrototype(); JSHandle toStringFunc = JSObject::GetMethod(thread_, arrFuncPrototype, thread_->GlobalConstants()->GetHandledToStringString()); PropertyDescriptor toStringDesc(thread_, toStringFunc, true, false, true); JSObject::DefineOwnProperty(thread_, typedArrFuncPrototype, thread_->GlobalConstants()->GetHandledToStringString(), toStringDesc); // %TypedArray%.prototype [ @@iterator ] ( ) JSHandle values(factory_->NewFromASCII("values")); JSHandle iteratorSymbol = env->GetIteratorSymbol(); JSHandle valuesFunc = JSObject::GetMethod(thread_, JSHandle::Cast(typedArrFuncPrototype), values); PropertyDescriptor iteartorDesc(thread_, valuesFunc, true, false, true); JSObject::DefineOwnProperty(thread_, typedArrFuncPrototype, iteratorSymbol, iteartorDesc); // 22.2.3.31 get %TypedArray%.prototype [ @@toStringTag ] JSHandle toStringTagSymbol = env->GetToStringTagSymbol(); JSHandle toStringTagGetter = CreateGetter(env, BuiltinsTypedArray::ToStringTag, "[Symbol.toStringTag]", FunctionLength::ZERO); SetGetter(typedArrFuncPrototype, toStringTagSymbol, toStringTagGetter); // TypedArray method SetFunction(env, typedArrayFunction, "from", BuiltinsTypedArray::From, FunctionLength::ONE); SetFunction(env, typedArrayFunction, "of", BuiltinsTypedArray::Of, FunctionLength::ZERO); // 22.2.2.4 get %TypedArray% [ @@species ] JSHandle speciesSymbol = env->GetSpeciesSymbol(); JSHandle speciesGetter = CreateGetter(env, BuiltinsTypedArray::Species, "[Symbol.species]", FunctionLength::ZERO); SetGetter(JSHandle(typedArrayFunction), speciesSymbol, speciesGetter); env->SetTypedArrayFunction(thread_, typedArrayFunction.GetTaggedValue()); env->SetTypedArrayPrototype(thread_, typedArrFuncPrototype); JSHandle specificTypedArrayFuncClass = factory_->NewEcmaHClass(JSFunction::SIZE, JSType::JS_FUNCTION, env->GetTypedArrayFunction()); specificTypedArrayFuncClass->SetConstructor(true); env->SetSpecificTypedArrayFunctionClass(thread_, specificTypedArrayFuncClass); InitializeInt8Array(env, typedArrFuncInstanceHClass); InitializeUint8Array(env, typedArrFuncInstanceHClass); InitializeUint8ClampedArray(env, typedArrFuncInstanceHClass); InitializeInt16Array(env, typedArrFuncInstanceHClass); InitializeUint16Array(env, typedArrFuncInstanceHClass); InitializeInt32Array(env, typedArrFuncInstanceHClass); InitializeUint32Array(env, typedArrFuncInstanceHClass); InitializeFloat32Array(env, typedArrFuncInstanceHClass); InitializeFloat64Array(env, typedArrFuncInstanceHClass); InitializeBigInt64Array(env, typedArrFuncInstanceHClass); InitializeBigUint64Array(env, typedArrFuncInstanceHClass); } void Builtins::InitializeInt8Array(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Int8Array.prototype JSHandle int8ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle int8ArrFuncPrototypeValue(int8ArrFuncPrototype); // Int8Array.prototype_or_hclass JSHandle int8ArrFuncInstanceHClass = factory_->NewEcmaHClass( panda::ecmascript::JSTypedArray::SIZE, JSType::JS_INT8_ARRAY, int8ArrFuncPrototypeValue); // Int8Array = new Function() JSHandle int8ArrayFunction = factory_->NewSpecificTypedArrayFunction( env, reinterpret_cast(BuiltinsTypedArray::Int8ArrayConstructor)); InitializeCtor(env, int8ArrFuncPrototype, int8ArrayFunction, "Int8Array", FunctionLength::THREE); int8ArrayFunction->SetProtoOrHClass(thread_, int8ArrFuncInstanceHClass.GetTaggedValue()); constexpr int bytesPerElement = 1; SetConstant(int8ArrFuncPrototype, "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); SetConstant(JSHandle(int8ArrayFunction), "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); env->SetInt8ArrayFunction(thread_, int8ArrayFunction); } void Builtins::InitializeUint8Array(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Uint8Array.prototype JSHandle uint8ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle uint8ArrFuncPrototypeValue(uint8ArrFuncPrototype); // Uint8Array.prototype_or_hclass JSHandle uint8ArrFuncInstanceHClass = factory_->NewEcmaHClass( panda::ecmascript::JSTypedArray::SIZE, JSType::JS_UINT8_ARRAY, uint8ArrFuncPrototypeValue); // Uint8Array = new Function() JSHandle uint8ArrayFunction = factory_->NewSpecificTypedArrayFunction( env, reinterpret_cast(BuiltinsTypedArray::Uint8ArrayConstructor)); InitializeCtor(env, uint8ArrFuncPrototype, uint8ArrayFunction, "Uint8Array", FunctionLength::THREE); uint8ArrayFunction->SetProtoOrHClass(thread_, uint8ArrFuncInstanceHClass.GetTaggedValue()); constexpr int bytesPerElement = 1; SetConstant(uint8ArrFuncPrototype, "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); SetConstant(JSHandle(uint8ArrayFunction), "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); env->SetUint8ArrayFunction(thread_, uint8ArrayFunction); } void Builtins::InitializeUint8ClampedArray(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Uint8ClampedArray.prototype JSHandle uint8ClampedArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle uint8ClampedArrFuncPrototypeValue(uint8ClampedArrFuncPrototype); // Uint8ClampedArray.prototype_or_hclass JSHandle uint8ClampedArrFuncInstanceHClass = factory_->NewEcmaHClass(panda::ecmascript::JSTypedArray::SIZE, JSType::JS_UINT8_CLAMPED_ARRAY, uint8ClampedArrFuncPrototypeValue); // Uint8ClampedArray = new Function() JSHandle uint8ClampedArrayFunction = factory_->NewSpecificTypedArrayFunction( env, reinterpret_cast(BuiltinsTypedArray::Uint8ClampedArrayConstructor)); InitializeCtor(env, uint8ClampedArrFuncPrototype, uint8ClampedArrayFunction, "Uint8ClampedArray", FunctionLength::THREE); uint8ClampedArrayFunction->SetProtoOrHClass(thread_, uint8ClampedArrFuncInstanceHClass.GetTaggedValue()); constexpr int bytesPerElement = 1; SetConstant(uint8ClampedArrFuncPrototype, "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); SetConstant(JSHandle(uint8ClampedArrayFunction), "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); env->SetUint8ClampedArrayFunction(thread_, uint8ClampedArrayFunction); } void Builtins::InitializeInt16Array(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Int16Array.prototype JSHandle int16ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle int16ArrFuncPrototypeValue(int16ArrFuncPrototype); // Int16Array.prototype_or_hclass JSHandle int16ArrFuncInstanceHClass = factory_->NewEcmaHClass( panda::ecmascript::JSTypedArray::SIZE, JSType::JS_INT16_ARRAY, int16ArrFuncPrototypeValue); // Int16Array = new Function() JSHandle int16ArrayFunction = factory_->NewSpecificTypedArrayFunction( env, reinterpret_cast(BuiltinsTypedArray::Int16ArrayConstructor)); InitializeCtor(env, int16ArrFuncPrototype, int16ArrayFunction, "Int16Array", FunctionLength::THREE); int16ArrayFunction->SetProtoOrHClass(thread_, int16ArrFuncInstanceHClass.GetTaggedValue()); constexpr int bytesPerElement = 2; SetConstant(int16ArrFuncPrototype, "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); SetConstant(JSHandle(int16ArrayFunction), "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); env->SetInt16ArrayFunction(thread_, int16ArrayFunction); } void Builtins::InitializeUint16Array(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Uint16Array.prototype JSHandle uint16ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle uint16ArrFuncPrototypeValue(uint16ArrFuncPrototype); // Uint16Array.prototype_or_hclass JSHandle uint16ArrFuncInstanceHClass = factory_->NewEcmaHClass( panda::ecmascript::JSTypedArray::SIZE, JSType::JS_UINT16_ARRAY, uint16ArrFuncPrototypeValue); // Uint16Array = new Function() JSHandle uint16ArrayFunction = factory_->NewSpecificTypedArrayFunction( env, reinterpret_cast(BuiltinsTypedArray::Uint16ArrayConstructor)); InitializeCtor(env, uint16ArrFuncPrototype, uint16ArrayFunction, "Uint16Array", FunctionLength::THREE); uint16ArrayFunction->SetProtoOrHClass(thread_, uint16ArrFuncInstanceHClass.GetTaggedValue()); constexpr int bytesPerElement = 2; SetConstant(uint16ArrFuncPrototype, "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); SetConstant(JSHandle(uint16ArrayFunction), "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); env->SetUint16ArrayFunction(thread_, uint16ArrayFunction); } void Builtins::InitializeInt32Array(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Int32Array.prototype JSHandle int32ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle int32ArrFuncPrototypeValue(int32ArrFuncPrototype); // Int32Array.prototype_or_hclass JSHandle int32ArrFuncInstanceHClass = factory_->NewEcmaHClass( panda::ecmascript::JSTypedArray::SIZE, JSType::JS_INT32_ARRAY, int32ArrFuncPrototypeValue); // Int32Array = new Function() JSHandle int32ArrayFunction = factory_->NewSpecificTypedArrayFunction( env, reinterpret_cast(BuiltinsTypedArray::Int32ArrayConstructor)); InitializeCtor(env, int32ArrFuncPrototype, int32ArrayFunction, "Int32Array", FunctionLength::THREE); int32ArrayFunction->SetProtoOrHClass(thread_, int32ArrFuncInstanceHClass.GetTaggedValue()); constexpr int bytesPerElement = 4; SetConstant(int32ArrFuncPrototype, "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); SetConstant(JSHandle(int32ArrayFunction), "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); env->SetInt32ArrayFunction(thread_, int32ArrayFunction); } void Builtins::InitializeUint32Array(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Uint32Array.prototype JSHandle uint32ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle uint32ArrFuncPrototypeValue(uint32ArrFuncPrototype); // Uint32Array.prototype_or_hclass JSHandle uint32ArrFuncInstanceHClass = factory_->NewEcmaHClass( panda::ecmascript::JSTypedArray::SIZE, JSType::JS_UINT32_ARRAY, uint32ArrFuncPrototypeValue); // Uint32Array = new Function() JSHandle uint32ArrayFunction = factory_->NewSpecificTypedArrayFunction( env, reinterpret_cast(BuiltinsTypedArray::Uint32ArrayConstructor)); InitializeCtor(env, uint32ArrFuncPrototype, uint32ArrayFunction, "Uint32Array", FunctionLength::THREE); uint32ArrayFunction->SetProtoOrHClass(thread_, uint32ArrFuncInstanceHClass.GetTaggedValue()); constexpr int bytesPerElement = 4; SetConstant(uint32ArrFuncPrototype, "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); SetConstant(JSHandle(uint32ArrayFunction), "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); env->SetUint32ArrayFunction(thread_, uint32ArrayFunction); } void Builtins::InitializeFloat32Array(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Float32Array.prototype JSHandle float32ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle float32ArrFuncPrototypeValue(float32ArrFuncPrototype); // Float32Array.prototype_or_hclass JSHandle float32ArrFuncInstanceHClass = factory_->NewEcmaHClass( panda::ecmascript::JSTypedArray::SIZE, JSType::JS_FLOAT32_ARRAY, float32ArrFuncPrototypeValue); // Float32Array = new Function() JSHandle float32ArrayFunction = factory_->NewSpecificTypedArrayFunction( env, reinterpret_cast(BuiltinsTypedArray::Float32ArrayConstructor)); InitializeCtor(env, float32ArrFuncPrototype, float32ArrayFunction, "Float32Array", FunctionLength::THREE); float32ArrayFunction->SetProtoOrHClass(thread_, float32ArrFuncInstanceHClass.GetTaggedValue()); constexpr int bytesPerElement = 4; SetConstant(float32ArrFuncPrototype, "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); SetConstant(JSHandle(float32ArrayFunction), "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); env->SetFloat32ArrayFunction(thread_, float32ArrayFunction); } void Builtins::InitializeFloat64Array(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // Float64Array.prototype JSHandle float64ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle float64ArrFuncPrototypeValue(float64ArrFuncPrototype); // Float64Array.prototype_or_hclass JSHandle float64ArrFuncInstanceHClass = factory_->NewEcmaHClass( panda::ecmascript::JSTypedArray::SIZE, JSType::JS_FLOAT64_ARRAY, float64ArrFuncPrototypeValue); // Float64Array = new Function() JSHandle float64ArrayFunction = factory_->NewSpecificTypedArrayFunction( env, reinterpret_cast(BuiltinsTypedArray::Float64ArrayConstructor)); InitializeCtor(env, float64ArrFuncPrototype, float64ArrayFunction, "Float64Array", FunctionLength::THREE); float64ArrayFunction->SetProtoOrHClass(thread_, float64ArrFuncInstanceHClass.GetTaggedValue()); constexpr int bytesPerElement = 8; SetConstant(float64ArrFuncPrototype, "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); SetConstant(JSHandle(float64ArrayFunction), "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); env->SetFloat64ArrayFunction(thread_, float64ArrayFunction); } void Builtins::InitializeBigInt64Array(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // BigInt64Array.prototype JSHandle bigInt64ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle bigInt64ArrFuncPrototypeValue(bigInt64ArrFuncPrototype); // BigInt64Array.prototype_or_hclass JSHandle bigInt64ArrFuncInstanceHClass = factory_->NewEcmaHClass( panda::ecmascript::JSTypedArray::SIZE, JSType::JS_BIGINT64_ARRAY, bigInt64ArrFuncPrototypeValue); // BigInt64Array = new Function() JSHandle bigInt64ArrayFunction = factory_->NewSpecificTypedArrayFunction( env, reinterpret_cast(BuiltinsTypedArray::BigInt64ArrayConstructor)); InitializeCtor(env, bigInt64ArrFuncPrototype, bigInt64ArrayFunction, "BigInt64Array", FunctionLength::THREE); bigInt64ArrayFunction->SetProtoOrHClass(thread_, bigInt64ArrFuncInstanceHClass.GetTaggedValue()); constexpr int bytesPerElement = 8; SetConstant(bigInt64ArrFuncPrototype, "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); SetConstant(JSHandle(bigInt64ArrayFunction), "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); env->SetBigInt64ArrayFunction(thread_, bigInt64ArrayFunction); } void Builtins::InitializeBigUint64Array(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // BigUint64Array.prototype JSHandle bigUint64ArrFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle bigUint64ArrFuncPrototypeValue(bigUint64ArrFuncPrototype); // BigUint64Array.prototype_or_hclass JSHandle bigUint64ArrFuncInstanceHClass = factory_->NewEcmaHClass( panda::ecmascript::JSTypedArray::SIZE, JSType::JS_BIGUINT64_ARRAY, bigUint64ArrFuncPrototypeValue); // BigUint64Array = new Function() JSHandle bigUint64ArrayFunction = factory_->NewSpecificTypedArrayFunction( env, reinterpret_cast(BuiltinsTypedArray::BigUint64ArrayConstructor)); InitializeCtor(env, bigUint64ArrFuncPrototype, bigUint64ArrayFunction, "BigUint64Array", FunctionLength::THREE); bigUint64ArrayFunction->SetProtoOrHClass(thread_, bigUint64ArrFuncInstanceHClass.GetTaggedValue()); constexpr int bytesPerElement = 8; SetConstant(bigUint64ArrFuncPrototype, "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); SetConstant(JSHandle(bigUint64ArrayFunction), "BYTES_PER_ELEMENT", JSTaggedValue(bytesPerElement)); env->SetBigUint64ArrayFunction(thread_, bigUint64ArrayFunction); } void Builtins::InitializeArrayBuffer(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // ArrayBuffer.prototype JSHandle arrayBufferFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle arrayBufferFuncPrototypeValue(arrayBufferFuncPrototype); // ArrayBuffer.prototype_or_hclass JSHandle arrayBufferFuncInstanceHClass = factory_->NewEcmaHClass(JSArrayBuffer::SIZE, JSType::JS_ARRAY_BUFFER, arrayBufferFuncPrototypeValue); // ArrayBuffer = new Function() JSHandle arrayBufferFunction(NewBuiltinConstructor( env, arrayBufferFuncPrototype, ArrayBuffer::ArrayBufferConstructor, "ArrayBuffer", FunctionLength::ONE)); JSHandle(arrayBufferFunction) ->SetFunctionPrototype(thread_, arrayBufferFuncInstanceHClass.GetTaggedValue()); // ArrayBuffer prototype method SetFunction(env, arrayBufferFuncPrototype, "slice", ArrayBuffer::Slice, FunctionLength::TWO); // ArrayBuffer method SetFunction(env, arrayBufferFunction, "isView", ArrayBuffer::IsView, FunctionLength::ONE); // 24.1.3.3 get ArrayBuffer[@@species] JSHandle speciesSymbol = env->GetSpeciesSymbol(); JSHandle speciesGetter = CreateGetter(env, ArrayBuffer::Species, "[Symbol.species]", FunctionLength::ZERO); SetGetter(JSHandle(arrayBufferFunction), speciesSymbol, speciesGetter); // 24.1.4.1 get ArrayBuffer.prototype.byteLength JSHandle lengthGetter = CreateGetter(env, ArrayBuffer::GetByteLength, "byteLength", FunctionLength::ZERO); JSHandle lengthKey(factory_->NewFromASCII("byteLength")); SetGetter(arrayBufferFuncPrototype, lengthKey, lengthGetter); // 24.1.4.4 ArrayBuffer.prototype[@@toStringTag] SetStringTagSymbol(env, arrayBufferFuncPrototype, "ArrayBuffer"); env->SetArrayBufferFunction(thread_, arrayBufferFunction.GetTaggedValue()); } void Builtins::InitializeReflect(const JSHandle &env, const JSHandle &objFuncPrototypeVal) const { [[maybe_unused]] EcmaHandleScope scope(thread_); JSHandle reflectHClass = factory_->NewEcmaHClass(JSObject::SIZE, JSType::JS_OBJECT, objFuncPrototypeVal); JSHandle reflectObject = factory_->NewJSObjectWithInit(reflectHClass); SetFunction(env, reflectObject, "apply", Reflect::ReflectApply, FunctionLength::THREE); SetFunction(env, reflectObject, "construct", Reflect::ReflectConstruct, FunctionLength::TWO); SetFunction(env, reflectObject, "defineProperty", Reflect::ReflectDefineProperty, FunctionLength::THREE); SetFunction(env, reflectObject, "deleteProperty", Reflect::ReflectDeleteProperty, FunctionLength::TWO); SetFunction(env, reflectObject, "get", Reflect::ReflectGet, FunctionLength::TWO); SetFunction(env, reflectObject, "getOwnPropertyDescriptor", Reflect::ReflectGetOwnPropertyDescriptor, FunctionLength::TWO); SetFunction(env, reflectObject, "getPrototypeOf", Reflect::ReflectGetPrototypeOf, FunctionLength::ONE); SetFunction(env, reflectObject, "has", Reflect::ReflectHas, FunctionLength::TWO); SetFunction(env, reflectObject, "isExtensible", Reflect::ReflectIsExtensible, FunctionLength::ONE); SetFunction(env, reflectObject, "ownKeys", Reflect::ReflectOwnKeys, FunctionLength::ONE); SetFunction(env, reflectObject, "preventExtensions", Reflect::ReflectPreventExtensions, FunctionLength::ONE); SetFunction(env, reflectObject, "set", Reflect::ReflectSet, FunctionLength::THREE); SetFunction(env, reflectObject, "setPrototypeOf", Reflect::ReflectSetPrototypeOf, FunctionLength::TWO); JSHandle reflectString(factory_->NewFromASCII("Reflect")); JSHandle globalObject(thread_, env->GetGlobalObject()); PropertyDescriptor reflectDesc(thread_, JSHandle::Cast(reflectObject), true, false, true); JSObject::DefineOwnProperty(thread_, globalObject, reflectString, reflectDesc); // @@ToStringTag SetStringTagSymbol(env, reflectObject, "Reflect"); env->SetReflectFunction(thread_, reflectObject.GetTaggedValue()); } void Builtins::InitializeSharedArrayBuffer(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // SharedArrayBuffer.prototype JSHandle sharedArrayBufferFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle sharedArrayBufferFuncPrototypeValue(sharedArrayBufferFuncPrototype); // SharedArrayBuffer.prototype_or_hclass JSHandle sharedArrayBufferFuncInstanceHClass = factory_->NewEcmaHClass( JSArrayBuffer::SIZE, JSType::JS_SHARED_ARRAY_BUFFER, sharedArrayBufferFuncPrototypeValue); // SharedArrayBuffer = new Function() JSHandle SharedArrayBufferFunction(NewBuiltinConstructor(env, sharedArrayBufferFuncPrototype, SharedArrayBuffer::SharedArrayBufferConstructor, "SharedArrayBuffer", FunctionLength::ONE)); JSHandle(SharedArrayBufferFunction) ->SetFunctionPrototype(thread_, sharedArrayBufferFuncInstanceHClass.GetTaggedValue()); // SharedArrayBuffer prototype method SetFunction(env, sharedArrayBufferFuncPrototype, "slice", SharedArrayBuffer::Slice, FunctionLength::TWO); // SharedArrayBuffer method SetFunction(env, SharedArrayBufferFunction, "IsSharedArrayBuffer", SharedArrayBuffer::IsSharedArrayBuffer, FunctionLength::ONE); // 25.2.3.2 get SharedArrayBuffer [ @@species ] JSHandle speciesSymbol = env->GetSpeciesSymbol(); JSHandle speciesGetter = CreateGetter(env, SharedArrayBuffer::Species, "[Symbol.species]", FunctionLength::ZERO); SetGetter(JSHandle(SharedArrayBufferFunction), speciesSymbol, speciesGetter); // 25.2.4.1 get SharedArrayBuffer.prototype.byteLength JSHandle lengthGetter = CreateGetter(env, SharedArrayBuffer::GetByteLength, "byteLength", FunctionLength::ZERO); JSHandle lengthKey(factory_->NewFromASCII("byteLength")); SetGetter(sharedArrayBufferFuncPrototype, lengthKey, lengthGetter); // 25.2.4.4 SharedArrayBuffer.prototype [ @@toStringTag ] SetStringTagSymbol(env, sharedArrayBufferFuncPrototype, "SharedArrayBuffer"); env->SetSharedArrayBufferFunction(thread_, SharedArrayBufferFunction.GetTaggedValue()); } void Builtins::InitializePromise(const JSHandle &env, const JSHandle &promiseFuncClass) { [[maybe_unused]] EcmaHandleScope scope(thread_); // Promise.prototype JSHandle promiseFuncPrototype = factory_->NewJSObjectWithInit(promiseFuncClass); JSHandle promiseFuncPrototypeValue(promiseFuncPrototype); // Promise.prototype_or_hclass JSHandle promiseFuncInstanceHClass = factory_->NewEcmaHClass(JSPromise::SIZE, JSType::JS_PROMISE, promiseFuncPrototypeValue); // Promise() = new Function() JSHandle promiseFunction( NewBuiltinConstructor(env, promiseFuncPrototype, Promise::PromiseConstructor, "Promise", FunctionLength::ONE)); JSHandle(promiseFunction)->SetFunctionPrototype(thread_, promiseFuncInstanceHClass.GetTaggedValue()); // Promise method SetFunction(env, promiseFunction, "all", Promise::All, FunctionLength::ONE); SetFunction(env, promiseFunction, "race", Promise::Race, FunctionLength::ONE); SetFunction(env, promiseFunction, "resolve", Promise::Resolve, FunctionLength::ONE); SetFunction(env, promiseFunction, "reject", Promise::Reject, FunctionLength::ONE); SetFunction(env, promiseFunction, "any", Promise::Any, FunctionLength::ONE); SetFunction(env, promiseFunction, "allSettled", Promise::AllSettled, FunctionLength::ONE); // promise.prototype method SetFunction(env, promiseFuncPrototype, "catch", Promise::Catch, FunctionLength::ONE); SetFunction(env, promiseFuncPrototype, "then", Promise::Then, FunctionLength::TWO); SetFunction(env, promiseFuncPrototype, "finally", Promise::Finally, FunctionLength::ONE); // Promise.prototype [ @@toStringTag ] SetStringTagSymbol(env, promiseFuncPrototype, "Promise"); // Set Promise [@@species] JSHandle speciesSymbol(env->GetSpeciesSymbol()); JSHandle speciesGetter = CreateGetter(env, Promise::GetSpecies, "[Symbol.species]", FunctionLength::ZERO); SetGetter(promiseFunction, speciesSymbol, speciesGetter); env->SetPromiseFunction(thread_, promiseFunction); InitializeForPromiseFuncClass(env); } void Builtins::InitializeForPromiseFuncClass(const JSHandle &env) { vm_ = thread_->GetEcmaVM(); factory_ = vm_->GetFactory(); JSHandle promiseReactionFuncClass = factory_->NewEcmaHClass( JSPromiseReactionsFunction::SIZE, JSType::JS_PROMISE_REACTIONS_FUNCTION, env->GetFunctionPrototype()); promiseReactionFuncClass->SetCallable(true); promiseReactionFuncClass->SetExtensible(true); env->SetPromiseReactionFunctionClass(thread_, promiseReactionFuncClass); JSHandle promiseExecutorFuncClass = factory_->NewEcmaHClass( JSPromiseExecutorFunction::SIZE, JSType::JS_PROMISE_EXECUTOR_FUNCTION, env->GetFunctionPrototype()); promiseExecutorFuncClass->SetCallable(true); promiseExecutorFuncClass->SetExtensible(true); env->SetPromiseExecutorFunctionClass(thread_, promiseExecutorFuncClass); JSHandle promiseAllResolveElementFunctionClass = factory_->NewEcmaHClass(JSPromiseAllResolveElementFunction::SIZE, JSType::JS_PROMISE_ALL_RESOLVE_ELEMENT_FUNCTION, env->GetFunctionPrototype()); promiseAllResolveElementFunctionClass->SetCallable(true); promiseAllResolveElementFunctionClass->SetExtensible(true); env->SetPromiseAllResolveElementFunctionClass(thread_, promiseAllResolveElementFunctionClass); JSHandle promiseAnyRejectElementFunctionClass = factory_->NewEcmaHClass(JSPromiseAnyRejectElementFunction::SIZE, JSType::JS_PROMISE_ANY_REJECT_ELEMENT_FUNCTION, env->GetFunctionPrototype()); promiseAnyRejectElementFunctionClass->SetCallable(true); promiseAnyRejectElementFunctionClass->SetExtensible(true); env->SetPromiseAnyRejectElementFunctionClass(thread_, promiseAnyRejectElementFunctionClass); JSHandle promiseAllSettledElementFunctionClass = factory_->NewEcmaHClass(JSPromiseAllSettledElementFunction::SIZE, JSType::JS_PROMISE_ALL_SETTLED_ELEMENT_FUNCTION, env->GetFunctionPrototype()); promiseAllSettledElementFunctionClass->SetCallable(true); promiseAllSettledElementFunctionClass->SetExtensible(true); env->SetPromiseAllSettledElementFunctionClass(thread_, promiseAllSettledElementFunctionClass); JSHandle promiseFinallyFunctionClass = factory_->NewEcmaHClass(JSPromiseFinallyFunction::SIZE, JSType::JS_PROMISE_FINALLY_FUNCTION, env->GetFunctionPrototype()); promiseFinallyFunctionClass->SetCallable(true); promiseFinallyFunctionClass->SetExtensible(true); env->SetPromiseFinallyFunctionClass(thread_, promiseFinallyFunctionClass); JSHandle promiseValueThunkOrThrowerFunctionClass = factory_->NewEcmaHClass(JSPromiseValueThunkOrThrowerFunction::SIZE, JSType::JS_PROMISE_VALUE_THUNK_OR_THROWER_FUNCTION, env->GetFunctionPrototype()); promiseValueThunkOrThrowerFunctionClass->SetCallable(true); promiseValueThunkOrThrowerFunctionClass->SetExtensible(true); env->SetPromiseValueThunkOrThrowerFunctionClass(thread_, promiseValueThunkOrThrowerFunctionClass); } void Builtins::InitializePromiseJob(const JSHandle &env) { JSHandle keyString(thread_->GlobalConstants()->GetHandledEmptyString()); auto func = NewFunction(env, keyString, BuiltinsPromiseJob::PromiseReactionJob, FunctionLength::TWO); env->SetPromiseReactionJob(thread_, func); func = NewFunction(env, keyString, BuiltinsPromiseJob::PromiseResolveThenableJob, FunctionLength::THREE); env->SetPromiseResolveThenableJob(thread_, func); func = NewFunction(env, keyString, BuiltinsPromiseJob::DynamicImportJob, FunctionLength::FOUR); env->SetDynamicImportJob(thread_, func); } void Builtins::InitializeDataView(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // ArrayBuffer.prototype JSHandle dataViewFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle dataViewFuncPrototypeValue(dataViewFuncPrototype); // ArrayBuffer.prototype_or_hclass JSHandle dataViewFuncInstanceHClass = factory_->NewEcmaHClass(JSDataView::SIZE, JSType::JS_DATA_VIEW, dataViewFuncPrototypeValue); // ArrayBuffer = new Function() JSHandle dataViewFunction(NewBuiltinConstructor(env, dataViewFuncPrototype, DataView::DataViewConstructor, "DataView", FunctionLength::ONE)); JSHandle(dataViewFunction)->SetProtoOrHClass(thread_, dataViewFuncInstanceHClass.GetTaggedValue()); // DataView.prototype method SetFunction(env, dataViewFuncPrototype, "getFloat32", DataView::GetFloat32, FunctionLength::ONE); SetFunction(env, dataViewFuncPrototype, "getFloat64", DataView::GetFloat64, FunctionLength::ONE); SetFunction(env, dataViewFuncPrototype, "getInt8", DataView::GetInt8, FunctionLength::ONE); SetFunction(env, dataViewFuncPrototype, "getInt16", DataView::GetInt16, FunctionLength::ONE); SetFunction(env, dataViewFuncPrototype, "getInt32", DataView::GetInt32, FunctionLength::ONE); SetFunction(env, dataViewFuncPrototype, "getUint8", DataView::GetUint8, FunctionLength::ONE); SetFunction(env, dataViewFuncPrototype, "getUint16", DataView::GetUint16, FunctionLength::ONE); SetFunction(env, dataViewFuncPrototype, "getUint32", DataView::GetUint32, FunctionLength::ONE); SetFunction(env, dataViewFuncPrototype, "getBigInt64", DataView::GetBigInt64, FunctionLength::ONE); SetFunction(env, dataViewFuncPrototype, "getBigUint64", DataView::GetBigUint64, FunctionLength::ONE); SetFunction(env, dataViewFuncPrototype, "setFloat32", DataView::SetFloat32, FunctionLength::TWO); SetFunction(env, dataViewFuncPrototype, "setFloat64", DataView::SetFloat64, FunctionLength::TWO); SetFunction(env, dataViewFuncPrototype, "setInt8", DataView::SetInt8, FunctionLength::TWO); SetFunction(env, dataViewFuncPrototype, "setInt16", DataView::SetInt16, FunctionLength::TWO); SetFunction(env, dataViewFuncPrototype, "setInt32", DataView::SetInt32, FunctionLength::TWO); SetFunction(env, dataViewFuncPrototype, "setUint8", DataView::SetUint8, FunctionLength::TWO); SetFunction(env, dataViewFuncPrototype, "setUint16", DataView::SetUint16, FunctionLength::TWO); SetFunction(env, dataViewFuncPrototype, "setUint32", DataView::SetUint32, FunctionLength::TWO); SetFunction(env, dataViewFuncPrototype, "setBigInt64", DataView::SetBigInt64, FunctionLength::TWO); SetFunction(env, dataViewFuncPrototype, "setBigUint64", DataView::SetBigUint64, FunctionLength::TWO); // 24.2.4.1 get DataView.prototype.buffer JSHandle bufferGetter = CreateGetter(env, DataView::GetBuffer, "buffer", FunctionLength::ZERO); JSHandle bufferKey(factory_->NewFromASCII("buffer")); SetGetter(dataViewFuncPrototype, bufferKey, bufferGetter); // 24.2.4.2 get DataView.prototype.byteLength JSHandle lengthGetter = CreateGetter(env, DataView::GetByteLength, "byteLength", FunctionLength::ZERO); JSHandle lengthKey(factory_->NewFromASCII("byteLength")); SetGetter(dataViewFuncPrototype, lengthKey, lengthGetter); // 24.2.4.3 get DataView.prototype.byteOffset JSHandle offsetGetter = CreateGetter(env, DataView::GetOffset, "byteOffset", FunctionLength::ZERO); JSHandle offsetKey(factory_->NewFromASCII("byteOffset")); SetGetter(dataViewFuncPrototype, offsetKey, offsetGetter); // 24.2.4.21 DataView.prototype[ @@toStringTag ] SetStringTagSymbol(env, dataViewFuncPrototype, "DataView"); env->SetDataViewFunction(thread_, dataViewFunction.GetTaggedValue()); } JSHandle Builtins::NewBuiltinConstructor(const JSHandle &env, const JSHandle &prototype, EcmaEntrypoint ctorFunc, const char *name, int length, kungfu::BuiltinsStubCSigns::ID builtinId) const { JSHandle ctor = factory_->NewJSFunction(env, reinterpret_cast(ctorFunc), FunctionKind::BUILTIN_CONSTRUCTOR, builtinId); InitializeCtor(env, prototype, ctor, name, length); return ctor; } JSHandle Builtins::NewBuiltinCjsCtor(const JSHandle &env, const JSHandle &prototype, EcmaEntrypoint ctorFunc, const char *name, int length) const { JSHandle ctor = factory_->NewJSFunction(env, reinterpret_cast(ctorFunc), FunctionKind::BUILTIN_CONSTRUCTOR); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); JSFunction::SetFunctionLength(thread_, ctor, JSTaggedValue(length)); JSHandle nameString(factory_->NewFromUtf8(name)); JSFunction::SetFunctionName(thread_, JSHandle(ctor), nameString, JSHandle(thread_, JSTaggedValue::Undefined())); JSHandle constructorKey = globalConst->GetHandledConstructorString(); PropertyDescriptor descriptor(thread_, JSHandle::Cast(ctor), true, false, true); JSObject::DefineOwnProperty(thread_, prototype, constructorKey, descriptor); return ctor; } JSHandle Builtins::NewFunction(const JSHandle &env, const JSHandle &key, EcmaEntrypoint func, int length, kungfu::BuiltinsStubCSigns::ID builtinId) const { JSHandle function = factory_->NewJSFunction(env, reinterpret_cast(func), FunctionKind::NORMAL_FUNCTION, builtinId); JSFunction::SetFunctionLength(thread_, function, JSTaggedValue(length)); JSHandle baseFunction(function); JSHandle handleUndefine(thread_, JSTaggedValue::Undefined()); JSFunction::SetFunctionName(thread_, baseFunction, key, handleUndefine); return function; } void Builtins::SetFunction(const JSHandle &env, const JSHandle &obj, const char *key, EcmaEntrypoint func, int length, kungfu::BuiltinsStubCSigns::ID builtinId) const { JSHandle keyString(factory_->NewFromUtf8(key)); SetFunction(env, obj, keyString, func, length, builtinId); } void Builtins::SetFunction(const JSHandle &env, const JSHandle &obj, const JSHandle &key, EcmaEntrypoint func, int length, kungfu::BuiltinsStubCSigns::ID builtinId) const { JSHandle function(NewFunction(env, key, func, length, builtinId)); PropertyDescriptor descriptor(thread_, JSHandle(function), true, false, true); JSObject::DefineOwnProperty(thread_, obj, key, descriptor); } void Builtins::SetFrozenFunction(const JSHandle &env, const JSHandle &obj, const char *key, EcmaEntrypoint func, int length) const { JSHandle keyString(factory_->NewFromUtf8(key)); JSHandle function = NewFunction(env, keyString, func, length); PropertyDescriptor descriptor(thread_, JSHandle(function), false, false, false); JSObject::DefineOwnProperty(thread_, obj, keyString, descriptor); } template void Builtins::SetFunctionAtSymbol(const JSHandle &env, const JSHandle &obj, const JSHandle &symbol, const char *name, EcmaEntrypoint func, int length) const { JSHandle function = factory_->NewJSFunction(env, reinterpret_cast(func)); JSFunction::SetFunctionLength(thread_, function, JSTaggedValue(length)); JSHandle nameString(factory_->NewFromUtf8(name)); JSHandle baseFunction(function); JSHandle handleUndefine(thread_, JSTaggedValue::Undefined()); JSFunction::SetFunctionName(thread_, baseFunction, nameString, handleUndefine); // NOLINTNEXTLINE(readability-braces-around-statements, bugprone-suspicious-semicolon) if constexpr (flag == JSSymbol::SYMBOL_TO_PRIMITIVE_TYPE) { PropertyDescriptor descriptor(thread_, JSHandle::Cast(function), false, false, true); JSObject::DefineOwnProperty(thread_, obj, symbol, descriptor); return; } else if constexpr (flag == JSSymbol::SYMBOL_HAS_INSTANCE_TYPE) { // NOLINTE(readability-braces-around-statements) // ecma 19.2.3.6 Function.prototype[@@hasInstance] has the attributes // { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }. PropertyDescriptor descriptor(thread_, JSHandle::Cast(function), false, false, false); JSObject::DefineOwnProperty(thread_, obj, symbol, descriptor); return; } PropertyDescriptor descriptor(thread_, JSHandle::Cast(function), true, false, true); JSObject::DefineOwnProperty(thread_, obj, symbol, descriptor); } void Builtins::SetStringTagSymbol(const JSHandle &env, const JSHandle &obj, const char *key) const { JSHandle tag(factory_->NewFromUtf8(key)); JSHandle symbol = env->GetToStringTagSymbol(); PropertyDescriptor desc(thread_, tag, false, false, true); JSObject::DefineOwnProperty(thread_, obj, symbol, desc); } JSHandle Builtins::CreateGetter(const JSHandle &env, EcmaEntrypoint func, const char *name, int length) const { JSHandle function = factory_->NewJSFunction(env, reinterpret_cast(func)); JSFunction::SetFunctionLength(thread_, function, JSTaggedValue(length)); JSHandle funcName(factory_->NewFromUtf8(name)); JSHandle prefix = thread_->GlobalConstants()->GetHandledGetString(); JSFunction::SetFunctionName(thread_, JSHandle(function), funcName, prefix); return JSHandle(function); } JSHandle Builtins::CreateSetter(const JSHandle &env, EcmaEntrypoint func, const char *name, int length) { JSHandle function = factory_->NewJSFunction(env, reinterpret_cast(func)); JSFunction::SetFunctionLength(thread_, function, JSTaggedValue(length)); JSHandle funcName(factory_->NewFromUtf8(name)); JSHandle prefix = thread_->GlobalConstants()->GetHandledSetString(); JSFunction::SetFunctionName(thread_, JSHandle(function), funcName, prefix); return JSHandle(function); } void Builtins::SetConstant(const JSHandle &obj, const char *key, JSTaggedValue value) const { JSHandle keyString(factory_->NewFromUtf8(key)); PropertyDescriptor descriptor(thread_, JSHandle(thread_, value), false, false, false); JSObject::DefineOwnProperty(thread_, obj, keyString, descriptor); } void Builtins::SetConstantObject(const JSHandle &obj, const char *key, JSHandle &value) const { JSHandle keyString(factory_->NewFromUtf8(key)); PropertyDescriptor descriptor(thread_, value, false, false, false); JSObject::DefineOwnProperty(thread_, obj, keyString, descriptor); } void Builtins::SetNonConstantObject(const JSHandle &obj, const char *key, JSHandle &value) const { JSHandle keyString(factory_->NewFromUtf8(key)); PropertyDescriptor descriptor(thread_, value, true, true, true); JSObject::DefineOwnProperty(thread_, obj, keyString, descriptor); } void Builtins::SetGlobalThis(const JSHandle &obj, const char *key, const JSHandle &globalValue) { JSHandle keyString(factory_->NewFromUtf8(key)); PropertyDescriptor descriptor(thread_, globalValue, true, false, true); JSObject::DefineOwnProperty(thread_, obj, keyString, descriptor); } void Builtins::SetAttribute(const JSHandle &obj, const char *key, const char *value) const { JSHandle keyString(factory_->NewFromUtf8(key)); PropertyDescriptor descriptor(thread_, JSHandle(factory_->NewFromUtf8(value)), true, false, true); JSObject::DefineOwnProperty(thread_, obj, keyString, descriptor); } void Builtins::SetNoneAttributeProperty(const JSHandle &obj, const char *key, const JSHandle &value) const { JSHandle keyString(factory_->NewFromUtf8(key)); PropertyDescriptor des(thread_, value, false, false, false); JSObject::DefineOwnProperty(thread_, obj, keyString, des); } void Builtins::SetFuncToObjAndGlobal(const JSHandle &env, const JSHandle &globalObject, const JSHandle &obj, const char *key, EcmaEntrypoint func, int length) { JSHandle function = factory_->NewJSFunction(env, reinterpret_cast(func)); JSFunction::SetFunctionLength(thread_, function, JSTaggedValue(length)); JSHandle keyString(factory_->NewFromUtf8(key)); JSHandle baseFunction(function); JSHandle handleUndefine(thread_, JSTaggedValue::Undefined()); JSFunction::SetFunctionName(thread_, baseFunction, keyString, handleUndefine); PropertyDescriptor descriptor(thread_, JSHandle::Cast(function), true, false, true); JSObject::DefineOwnProperty(thread_, obj, keyString, descriptor); JSObject::DefineOwnProperty(thread_, globalObject, keyString, descriptor); } void Builtins::StrictModeForbiddenAccessCallerArguments(const JSHandle &env, const JSHandle &prototype) const { JSHandle function = factory_->NewJSFunction(env, reinterpret_cast(JSFunction::AccessCallerArgumentsThrowTypeError)); JSHandle caller(factory_->NewFromASCII("caller")); SetAccessor(prototype, caller, JSHandle::Cast(function), JSHandle::Cast(function)); JSHandle arguments(factory_->NewFromASCII("arguments")); SetAccessor(prototype, arguments, JSHandle::Cast(function), JSHandle::Cast(function)); } void Builtins::InitializeGeneratorFunction(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); JSHandle generatorFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle generatorFuncPrototypeValue(generatorFuncPrototype); // 26.3.3.1 GeneratorFunction.prototype.constructor // GeneratorFunction.prototype_or_hclass JSHandle generatorFuncInstanceHClass = factory_->NewEcmaHClass(JSFunction::SIZE, JSType::JS_GENERATOR_FUNCTION, generatorFuncPrototypeValue); generatorFuncInstanceHClass->SetCallable(true); generatorFuncInstanceHClass->SetExtensible(true); // GeneratorFunction = new GeneratorFunction() JSHandle generatorFunction = NewBuiltinConstructor(env, generatorFuncPrototype, GeneratorObject::GeneratorFunctionConstructor, "GeneratorFunction", FunctionLength::ONE); JSHandle constructorKey = globalConst->GetHandledConstructorString(); PropertyDescriptor generatorDesc(thread_, JSHandle::Cast(generatorFunction), false, false, true); JSObject::DefineOwnProperty(thread_, generatorFuncPrototype, constructorKey, generatorDesc); generatorFunction->SetProtoOrHClass(thread_, generatorFuncInstanceHClass.GetTaggedValue()); env->SetGeneratorFunctionFunction(thread_, generatorFunction); // 26.3.3.2 GeneratorFunction.prototype.prototype -> Generator prototype object. PropertyDescriptor descriptor(thread_, env->GetGeneratorPrototype(), false, false, true); JSObject::DefineOwnProperty(thread_, generatorFuncPrototype, globalConst->GetHandledPrototypeString(), descriptor); // 26.3.3.3 GeneratorFunction.prototype[@@toStringTag] SetStringTagSymbol(env, generatorFuncPrototype, "GeneratorFunction"); // GeneratorFunction prototype __proto__ -> Function. JSObject::SetPrototype(thread_, generatorFuncPrototype, env->GetFunctionPrototype()); // 26.5.1.1 Generator.prototype.constructor -> %GeneratorFunction.prototype%. PropertyDescriptor generatorObjDesc(thread_, generatorFuncPrototypeValue, false, false, true); JSObject::DefineOwnProperty(thread_, JSHandle(env->GetInitialGenerator()), globalConst->GetHandledConstructorString(), generatorObjDesc); // Generator instances prototype -> GeneratorFunction.prototype.prototype PropertyDescriptor generatorObjProtoDesc(thread_, generatorFuncPrototypeValue, true, false, false); JSObject::DefineOwnProperty(thread_, JSHandle(env->GetInitialGenerator()), globalConst->GetHandledPrototypeString(), generatorObjProtoDesc); env->SetGeneratorFunctionPrototype(thread_, generatorFuncPrototype); } void Builtins::InitializeAsyncGeneratorFunction(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); JSHandle asyncGeneratorFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle asyncGeneratorFuncPrototypeValue(asyncGeneratorFuncPrototype); // 27.4.3.1 AsyncGeneratorFunction.prototype.constructor JSHandle asyncGeneratorFuncInstanceHClass = factory_->NewEcmaHClass(JSFunction::SIZE, JSType::JS_ASYNC_GENERATOR_FUNCTION, asyncGeneratorFuncPrototypeValue); asyncGeneratorFuncInstanceHClass->SetCallable(true); asyncGeneratorFuncInstanceHClass->SetExtensible(true); JSHandle asyncGeneratorFunction = NewBuiltinConstructor(env, asyncGeneratorFuncPrototype, AsyncGeneratorObject::AsyncGeneratorFunctionConstructor, "AsyncGeneratorFunction", FunctionLength::ONE); JSHandle constructorKey = globalConst->GetHandledConstructorString(); PropertyDescriptor asyncGeneratorDesc(thread_, JSHandle::Cast(asyncGeneratorFunction), false, false, true); JSObject::DefineOwnProperty(thread_, asyncGeneratorFuncPrototype, constructorKey, asyncGeneratorDesc); asyncGeneratorFunction->SetProtoOrHClass(thread_, asyncGeneratorFuncInstanceHClass.GetTaggedValue()); env->SetAsyncGeneratorFunctionFunction(thread_, asyncGeneratorFunction); // 27.4.3.2 AsyncGeneratorFunction.prototype.prototype PropertyDescriptor descriptor(thread_, env->GetAsyncGeneratorPrototype(), false, false, true); JSObject::DefineOwnProperty(thread_, asyncGeneratorFuncPrototype, globalConst->GetHandledPrototypeString(), descriptor); // 27.4.3.3 AsyncGeneratorFunction.prototype [ @@toStringTag ] SetStringTagSymbol(env, asyncGeneratorFuncPrototype, "AsyncGeneratorFunction"); // AsyncGeneratorFunction prototype __proto__ -> Function. JSObject::SetPrototype(thread_, asyncGeneratorFuncPrototype, env->GetFunctionPrototype()); PropertyDescriptor asyncGeneratorObjDesc(thread_, asyncGeneratorFuncPrototypeValue, false, false, true); JSObject::DefineOwnProperty(thread_, JSHandle(env->GetInitialAsyncGenerator()), globalConst->GetHandledConstructorString(), asyncGeneratorObjDesc); PropertyDescriptor asyncGeneratorObjProtoDesc(thread_, asyncGeneratorFuncPrototypeValue, true, false, false); JSObject::DefineOwnProperty(thread_, JSHandle(env->GetInitialAsyncGenerator()), globalConst->GetHandledPrototypeString(), asyncGeneratorObjProtoDesc); env->SetAsyncGeneratorFunctionPrototype(thread_, asyncGeneratorFuncPrototype); } void Builtins::InitializeGenerator(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); JSHandle generatorFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); // GeneratorObject.prototype method // 26.5.1.2 Generator.prototype.next(value) SetFunction(env, generatorFuncPrototype, "next", GeneratorObject::GeneratorPrototypeNext, FunctionLength::ONE); // 26.5.1.3 Generator.prototype.return(value) SetFunction(env, generatorFuncPrototype, "return", GeneratorObject::GeneratorPrototypeReturn, FunctionLength::ONE); // 26.5.1.4 Generator.prototype.throw(exception) SetFunction(env, generatorFuncPrototype, "throw", GeneratorObject::GeneratorPrototypeThrow, FunctionLength::ONE); // 26.5.1.5 Generator.prototype[@@toStringTag] SetStringTagSymbol(env, generatorFuncPrototype, "Generator"); // Generator with constructor, symbolTag, next/return/throw etc. PropertyDescriptor descriptor(thread_, env->GetIteratorPrototype(), true, false, false); JSObject::DefineOwnProperty(thread_, generatorFuncPrototype, globalConst->GetHandledPrototypeString(), descriptor); env->SetGeneratorPrototype(thread_, generatorFuncPrototype); JSObject::SetPrototype(thread_, generatorFuncPrototype, env->GetIteratorPrototype()); // Generator {} JSHandle initialGeneratorFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSObject::SetPrototype(thread_, initialGeneratorFuncPrototype, JSHandle(generatorFuncPrototype)); env->SetInitialGenerator(thread_, initialGeneratorFuncPrototype); } void Builtins::InitializeAsyncGenerator(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); JSHandle asyncGeneratorFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); // GeneratorObject.prototype method // 27.6.1.2 AsyncGenerator.prototype.next ( value ) SetFunction(env, asyncGeneratorFuncPrototype, "next", AsyncGeneratorObject::AsyncGeneratorPrototypeNext, FunctionLength::ONE); // 27.6.1.3 AsyncGenerator.prototype.return ( value ) SetFunction(env, asyncGeneratorFuncPrototype, "return", AsyncGeneratorObject::AsyncGeneratorPrototypeReturn, FunctionLength::ONE); // 27.6.1.4 AsyncGenerator.prototype.throw ( exception ) SetFunction(env, asyncGeneratorFuncPrototype, "throw", AsyncGeneratorObject::AsyncGeneratorPrototypeThrow, FunctionLength::ONE); // 27.6.1.5 AsyncGenerator.prototype [ @@toStringTag ] SetStringTagSymbol(env, asyncGeneratorFuncPrototype, "AsyncGenerator"); PropertyDescriptor descriptor(thread_, env->GetAsyncIteratorPrototype(), true, false, false); JSObject::DefineOwnProperty(thread_, asyncGeneratorFuncPrototype, globalConst->GetHandledPrototypeString(), descriptor); env->SetAsyncGeneratorPrototype(thread_, asyncGeneratorFuncPrototype); JSObject::SetPrototype(thread_, asyncGeneratorFuncPrototype, env->GetAsyncIteratorPrototype()); JSHandle initialAsyncGeneratorFuncPrototype = factory_->NewJSObjectWithInit(objFuncClass); JSObject::SetPrototype(thread_, initialAsyncGeneratorFuncPrototype, JSHandle(asyncGeneratorFuncPrototype)); env->SetInitialAsyncGenerator(thread_, initialAsyncGeneratorFuncPrototype); } void Builtins::SetArgumentsSharedAccessor(const JSHandle &env) { JSHandle throwFunction = env->GetThrowTypeError(); JSHandle accessor = factory_->NewAccessorData(); accessor->SetGetter(thread_, throwFunction); accessor->SetSetter(thread_, throwFunction); env->SetArgumentsCallerAccessor(thread_, accessor); accessor = factory_->NewAccessorData(); accessor->SetGetter(thread_, throwFunction); accessor->SetSetter(thread_, throwFunction); env->SetArgumentsCalleeAccessor(thread_, accessor); } void Builtins::SetAccessor(const JSHandle &obj, const JSHandle &key, const JSHandle &getter, const JSHandle &setter) const { JSHandle accessor = factory_->NewAccessorData(); accessor->SetGetter(thread_, getter); accessor->SetSetter(thread_, setter); PropertyAttributes attr = PropertyAttributes::DefaultAccessor(false, false, true); JSObject::AddAccessor(thread_, JSHandle::Cast(obj), key, accessor, attr); } void Builtins::SetGetter(const JSHandle &obj, const JSHandle &key, const JSHandle &getter) const { JSHandle accessor = factory_->NewAccessorData(); accessor->SetGetter(thread_, getter); PropertyAttributes attr = PropertyAttributes::DefaultAccessor(false, false, true); JSObject::AddAccessor(thread_, JSHandle::Cast(obj), key, accessor, attr); } JSHandle Builtins::NewIntlConstructor(const JSHandle &env, const JSHandle &prototype, EcmaEntrypoint ctorFunc, const char *name, int length) { JSHandle ctor = factory_->NewJSFunction(env, reinterpret_cast(ctorFunc), FunctionKind::BUILTIN_CONSTRUCTOR); InitializeIntlCtor(env, prototype, ctor, name, length); return ctor; } void Builtins::InitializeIntlCtor(const JSHandle &env, const JSHandle &prototype, const JSHandle &ctor, const char *name, int length) { const GlobalEnvConstants *globalConst = thread_->GlobalConstants(); JSFunction::SetFunctionLength(thread_, ctor, JSTaggedValue(length)); JSHandle nameString(factory_->NewFromUtf8(name)); JSFunction::SetFunctionName(thread_, JSHandle(ctor), nameString, JSHandle(thread_, JSTaggedValue::Undefined())); JSHandle constructorKey = globalConst->GetHandledConstructorString(); PropertyDescriptor descriptor1(thread_, JSHandle::Cast(ctor), true, false, true); JSObject::DefineOwnProperty(thread_, prototype, constructorKey, descriptor1); // set "prototype" in constructor. ctor->SetFunctionPrototype(thread_, prototype.GetTaggedValue()); if (!JSTaggedValue::SameValue(nameString, thread_->GlobalConstants()->GetHandledAsyncFunctionString())) { JSHandle intlObject(thread_, env->GetIntlFunction().GetTaggedValue()); PropertyDescriptor descriptor2(thread_, JSHandle::Cast(ctor), true, false, true); JSObject::DefineOwnProperty(thread_, intlObject, nameString, descriptor2); } } void Builtins::InitializeIntl(const JSHandle &env, const JSHandle &objFuncPrototypeValue) { [[maybe_unused]] EcmaHandleScope scope(thread_); JSHandle intlHClass = factory_->NewEcmaHClass(JSIntl::SIZE, JSType::JS_INTL, objFuncPrototypeValue); JSHandle intlObject = factory_->NewJSObjectWithInit(intlHClass); JSHandle initIntlSymbol(factory_->NewPublicSymbolWithChar("Symbol.IntlLegacyConstructedSymbol")); SetNoneAttributeProperty(intlObject, "fallbackSymbol", initIntlSymbol); SetFunction(env, intlObject, "getCanonicalLocales", Intl::GetCanonicalLocales, FunctionLength::ONE); // initial value of the "Intl" property of the global object. JSHandle intlString(factory_->NewFromASCII("Intl")); JSHandle globalObject(thread_, env->GetGlobalObject()); PropertyDescriptor intlDesc(thread_, JSHandle::Cast(intlObject), true, false, true); JSObject::DefineOwnProperty(thread_, globalObject, intlString, intlDesc); SetStringTagSymbol(env, intlObject, "Intl"); env->SetIntlFunction(thread_, intlObject); } void Builtins::InitializeDateTimeFormat(const JSHandle &env) { [[maybe_unused]] EcmaHandleScope scope(thread_); // DateTimeFormat.prototype JSHandle objFun(env->GetObjectFunction()); JSHandle dtfPrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle dtfPrototypeValue(dtfPrototype); // DateTimeFormat.prototype_or_hclass JSHandle dtfFuncInstanceHClass = factory_->NewEcmaHClass(JSDateTimeFormat::SIZE, JSType::JS_DATE_TIME_FORMAT, dtfPrototypeValue); // DateTimeFormat = new Function() // 13.4.1 Intl.DateTimeFormat.prototype.constructor JSHandle dtfFunction(NewIntlConstructor(env, dtfPrototype, DateTimeFormat::DateTimeFormatConstructor, "DateTimeFormat", FunctionLength::ZERO)); JSHandle(dtfFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*dtfFuncInstanceHClass)); // 13.3.2 Intl.DateTimeFormat.supportedLocalesOf ( locales [ , options ] ) SetFunction(env, dtfFunction, "supportedLocalesOf", DateTimeFormat::SupportedLocalesOf, FunctionLength::ONE); // DateTimeFormat.prototype method // 13.4.2 Intl.DateTimeFormat.prototype [ @@toStringTag ] SetStringTagSymbol(env, dtfPrototype, "Intl.DateTimeFormat"); env->SetDateTimeFormatFunction(thread_, dtfFunction); // 13.4.3 get Intl.DateTimeFormat.prototype.format JSHandle formatGetter = CreateGetter(env, DateTimeFormat::Format, "format", FunctionLength::ZERO); JSHandle formatSetter(thread_, JSTaggedValue::Undefined()); SetAccessor(dtfPrototype, thread_->GlobalConstants()->GetHandledFormatString(), formatGetter, formatSetter); // 13.4.4 Intl.DateTimeFormat.prototype.formatToParts ( date ) SetFunction(env, dtfPrototype, "formatToParts", DateTimeFormat::FormatToParts, FunctionLength::ONE); // 13.4.5 Intl.DateTimeFormat.prototype.resolvedOptions () SetFunction(env, dtfPrototype, "resolvedOptions", DateTimeFormat::ResolvedOptions, FunctionLength::ZERO); SetFunction(env, dtfPrototype, "formatRange", DateTimeFormat::FormatRange, FunctionLength::TWO); SetFunction(env, dtfPrototype, "formatRangeToParts", DateTimeFormat::FormatRangeToParts, FunctionLength::TWO); } void Builtins::InitializeRelativeTimeFormat(const JSHandle &env) { [[maybe_unused]] EcmaHandleScope scope(thread_); // RelativeTimeFormat.prototype JSHandle objFun(env->GetObjectFunction()); JSHandle rtfPrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle rtfPrototypeValue(rtfPrototype); // RelativeTimeFormat.prototype_or_hclass JSHandle rtfFuncInstanceHClass = factory_->NewEcmaHClass(JSRelativeTimeFormat::SIZE, JSType::JS_RELATIVE_TIME_FORMAT, rtfPrototypeValue); // RelativeTimeFormat = new Function() // 14.2.1 Intl.RelativeTimeFormat.prototype.constructor JSHandle rtfFunction(NewIntlConstructor(env, rtfPrototype, RelativeTimeFormat::RelativeTimeFormatConstructor, "RelativeTimeFormat", FunctionLength::ZERO)); JSHandle(rtfFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*rtfFuncInstanceHClass)); // 14.3.2 Intl.RelativeTimeFormat.supportedLocalesOf ( locales [ , options ] ) SetFunction(env, rtfFunction, "supportedLocalesOf", RelativeTimeFormat::SupportedLocalesOf, FunctionLength::ONE); // RelativeTimeFormat.prototype method // 14.4.2 Intl.RelativeTimeFormat.prototype [ @@toStringTag ] SetStringTagSymbol(env, rtfPrototype, "Intl.RelativeTimeFormat"); env->SetRelativeTimeFormatFunction(thread_, rtfFunction); // 14.4.3 get Intl.RelativeTimeFormat.prototype.format SetFunction(env, rtfPrototype, "format", RelativeTimeFormat::Format, FunctionLength::TWO); // 14.4.4 Intl.RelativeTimeFormat.prototype.formatToParts( value, unit ) SetFunction(env, rtfPrototype, "formatToParts", RelativeTimeFormat::FormatToParts, FunctionLength::TWO); // 14.4.5 Intl.RelativeTimeFormat.prototype.resolvedOptions () SetFunction(env, rtfPrototype, "resolvedOptions", RelativeTimeFormat::ResolvedOptions, FunctionLength::ZERO); } void Builtins::InitializeNumberFormat(const JSHandle &env) { [[maybe_unused]] EcmaHandleScope scope(thread_); // NumberFormat.prototype JSHandle objFun(env->GetObjectFunction()); JSHandle nfPrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle nfPrototypeValue(nfPrototype); // NumberFormat.prototype_or_hclass JSHandle nfFuncInstanceHClass = factory_->NewEcmaHClass(JSNumberFormat::SIZE, JSType::JS_NUMBER_FORMAT, nfPrototypeValue); // NumberFormat = new Function() // 12.4.1 Intl.NumberFormat.prototype.constructor JSHandle nfFunction(NewIntlConstructor(env, nfPrototype, NumberFormat::NumberFormatConstructor, "NumberFormat", FunctionLength::ZERO)); JSHandle(nfFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*nfFuncInstanceHClass)); // 12.3.2 Intl.NumberFormat.supportedLocalesOf ( locales [ , options ] ) SetFunction(env, nfFunction, "supportedLocalesOf", NumberFormat::SupportedLocalesOf, FunctionLength::ONE); // NumberFormat.prototype method // 12.4.2 Intl.NumberFormat.prototype [ @@toStringTag ] SetStringTagSymbol(env, nfPrototype, "Intl.NumberFormat"); env->SetNumberFormatFunction(thread_, nfFunction); // 12.4.3 get Intl.NumberFormat.prototype.format JSHandle formatGetter = CreateGetter(env, NumberFormat::Format, "format", FunctionLength::ZERO); JSHandle formatSetter(thread_, JSTaggedValue::Undefined()); SetAccessor(nfPrototype, thread_->GlobalConstants()->GetHandledFormatString(), formatGetter, formatSetter); // 12.4.4 Intl.NumberFormat.prototype.formatToParts ( date ) SetFunction(env, nfPrototype, "formatToParts", NumberFormat::FormatToParts, FunctionLength::ONE); // 12.4.5 Intl.NumberFormat.prototype.resolvedOptions () SetFunction(env, nfPrototype, "resolvedOptions", NumberFormat::ResolvedOptions, FunctionLength::ZERO); } void Builtins::InitializeLocale(const JSHandle &env) { [[maybe_unused]] EcmaHandleScope scope(thread_); // Locale.prototype JSHandle objFun(env->GetObjectFunction()); JSHandle localePrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle localePrototypeValue(localePrototype); // Locale.prototype_or_hclass JSHandle localeFuncInstanceHClass = factory_->NewEcmaHClass(JSLocale::SIZE, JSType::JS_LOCALE, localePrototypeValue); // Locale = new Function() JSHandle localeFunction( NewIntlConstructor(env, localePrototype, Locale::LocaleConstructor, "Locale", FunctionLength::ONE)); JSHandle(localeFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*localeFuncInstanceHClass)); // Locale.prototype method SetFunction(env, localePrototype, "maximize", Locale::Maximize, FunctionLength::ZERO); SetFunction(env, localePrototype, "minimize", Locale::Minimize, FunctionLength::ZERO); SetFunction(env, localePrototype, "toString", Locale::ToString, FunctionLength::ZERO); JSHandle baseNameGetter = CreateGetter(env, Locale::GetBaseName, "baseName", FunctionLength::ZERO); SetGetter(localePrototype, thread_->GlobalConstants()->GetHandledBaseNameString(), baseNameGetter); JSHandle calendarGetter = CreateGetter(env, Locale::GetCalendar, "calendar", FunctionLength::ZERO); SetGetter(localePrototype, thread_->GlobalConstants()->GetHandledCalendarString(), calendarGetter); JSHandle caseFirstGetter = CreateGetter(env, Locale::GetCaseFirst, "caseFirst", FunctionLength::ZERO); SetGetter(localePrototype, thread_->GlobalConstants()->GetHandledCaseFirstString(), caseFirstGetter); JSHandle collationGetter = CreateGetter(env, Locale::GetCollation, "collation", FunctionLength::ZERO); SetGetter(localePrototype, thread_->GlobalConstants()->GetHandledCollationString(), collationGetter); JSHandle hourCycleGetter = CreateGetter(env, Locale::GetHourCycle, "hourCycle", FunctionLength::ZERO); SetGetter(localePrototype, thread_->GlobalConstants()->GetHandledHourCycleString(), hourCycleGetter); JSHandle numericGetter = CreateGetter(env, Locale::GetNumeric, "numeric", FunctionLength::ZERO); SetGetter(localePrototype, thread_->GlobalConstants()->GetHandledNumericString(), numericGetter); JSHandle numberingSystemGetter = CreateGetter(env, Locale::GetNumberingSystem, "numberingSystem", FunctionLength::ZERO); SetGetter(localePrototype, thread_->GlobalConstants()->GetHandledNumberingSystemString(), numberingSystemGetter); JSHandle languageGetter = CreateGetter(env, Locale::GetLanguage, "language", FunctionLength::ZERO); SetGetter(localePrototype, thread_->GlobalConstants()->GetHandledLanguageString(), languageGetter); JSHandle scriptGetter = CreateGetter(env, Locale::GetScript, "script", FunctionLength::ZERO); SetGetter(localePrototype, thread_->GlobalConstants()->GetHandledScriptString(), scriptGetter); JSHandle regionGetter = CreateGetter(env, Locale::GetRegion, "region", FunctionLength::ZERO); SetGetter(localePrototype, thread_->GlobalConstants()->GetHandledRegionString(), regionGetter); // 10.3.2 Intl.Locale.prototype[ @@toStringTag ] SetStringTagSymbol(env, localePrototype, "Intl.Locale"); env->SetLocaleFunction(thread_, localeFunction); } void Builtins::InitializeCollator(const JSHandle &env) { [[maybe_unused]] EcmaHandleScope scope(thread_); // Collator.prototype JSHandle objFun(env->GetObjectFunction()); JSHandle collatorPrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle collatorPrototypeValue(collatorPrototype); // Collator.prototype_or_hclass JSHandle collatorFuncInstanceHClass = factory_->NewEcmaHClass(JSCollator::SIZE, JSType::JS_COLLATOR, collatorPrototypeValue); // Collator = new Function() // 11.1.2 Intl.Collator.prototype.constructor JSHandle collatorFunction( NewIntlConstructor(env, collatorPrototype, Collator::CollatorConstructor, "Collator", FunctionLength::ZERO)); JSHandle(collatorFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*collatorFuncInstanceHClass)); // 11.2.2 Intl.Collator.supportedLocalesOf ( locales [ , options ] ) SetFunction(env, collatorFunction, "supportedLocalesOf", Collator::SupportedLocalesOf, FunctionLength::ONE); // Collator.prototype method // 11.3.2 Intl.Collator.prototype [ @@toStringTag ] SetStringTagSymbol(env, collatorPrototype, "Intl.Collator"); env->SetCollatorFunction(thread_, collatorFunction); // 11.3.3 get Intl.Collator.prototype.compare JSHandle compareGetter = CreateGetter(env, Collator::Compare, "compare", FunctionLength::ZERO); JSHandle compareSetter(thread_, JSTaggedValue::Undefined()); SetAccessor(collatorPrototype, thread_->GlobalConstants()->GetHandledCompareString(), compareGetter, compareSetter); // 11.3.4 Intl.Collator.prototype.resolvedOptions () SetFunction(env, collatorPrototype, "resolvedOptions", Collator::ResolvedOptions, FunctionLength::ZERO); } void Builtins::InitializePluralRules(const JSHandle &env) { [[maybe_unused]] EcmaHandleScope scope(thread_); // PluralRules.prototype JSHandle objFun(env->GetObjectFunction()); JSHandle prPrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle prPrototypeValue(prPrototype); // PluralRules.prototype_or_hclass JSHandle prFuncInstanceHClass = factory_->NewEcmaHClass(JSPluralRules::SIZE, JSType::JS_PLURAL_RULES, prPrototypeValue); // PluralRules = new Function() // 15.2.1 Intl.PluralRules.prototype.constructor JSHandle prFunction( NewIntlConstructor(env, prPrototype, PluralRules::PluralRulesConstructor, "PluralRules", FunctionLength::ZERO)); JSHandle(prFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*prFuncInstanceHClass)); // 15.3.2 Intl.PluralRules.supportedLocalesOf ( locales [ , options ] ) SetFunction(env, prFunction, "supportedLocalesOf", PluralRules::SupportedLocalesOf, FunctionLength::ONE); // PluralRules.prototype method // 15.4.2 Intl.PluralRules.prototype [ @@toStringTag ] SetStringTagSymbol(env, prPrototype, "Intl.PluralRules"); env->SetPluralRulesFunction(thread_, prFunction); // 15.4.3 get Intl.PluralRules.prototype.select SetFunction(env, prPrototype, "select", PluralRules::Select, FunctionLength::ONE); // 15.4.5 Intl.PluralRules.prototype.resolvedOptions () SetFunction(env, prPrototype, "resolvedOptions", PluralRules::ResolvedOptions, FunctionLength::ZERO); } void Builtins::InitializeDisplayNames(const JSHandle &env) { [[maybe_unused]] EcmaHandleScope scope(thread_); // DisplayNames.prototype JSHandle objFun(env->GetObjectFunction()); JSHandle dnPrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle dnPrototypeValue(dnPrototype); // DisplayNames.prototype_or_hclass JSHandle dnFuncInstanceHClass = factory_->NewEcmaHClass(JSDisplayNames::SIZE, JSType::JS_DISPLAYNAMES, dnPrototypeValue); // DisplayNames = new Function() // 12.4.1 Intl.DisplayNames.prototype.constructor JSHandle dnFunction(NewIntlConstructor(env, dnPrototype, DisplayNames::DisplayNamesConstructor, "DisplayNames", FunctionLength::TWO)); JSHandle(dnFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*dnFuncInstanceHClass)); // 12.3.2 Intl.DisplayNames.supportedLocalesOf ( locales [ , options ] ) SetFunction(env, dnFunction, "supportedLocalesOf", DisplayNames::SupportedLocalesOf, FunctionLength::ONE); // DisplayNames.prototype method // 12.4.2 Intl.DisplayNames.prototype[ @@toStringTag ] SetStringTagSymbol(env, dnPrototype, "Intl.DisplayNames"); env->SetDisplayNamesFunction(thread_, dnFunction); // 12.4.3 get Intl.DisplayNames.prototype.of SetFunction(env, dnPrototype, "of", DisplayNames::Of, FunctionLength::ONE); // 12.4.4 Intl.DisplayNames.prototype.resolvedOptions () SetFunction(env, dnPrototype, "resolvedOptions", DisplayNames::ResolvedOptions, FunctionLength::ZERO); } void Builtins::InitializeListFormat(const JSHandle &env) { [[maybe_unused]] EcmaHandleScope scope(thread_); // JSListFormat.prototype JSHandle objFun(env->GetObjectFunction()); JSHandle lfPrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle lfPrototypeValue(lfPrototype); // JSListFormat.prototype_or_hclass JSHandle lfFuncInstanceHClass = factory_->NewEcmaHClass(JSListFormat::SIZE, JSType::JS_LIST_FORMAT, lfPrototypeValue); // JSListFormat = new Function() // 13.4.1 Intl.ListFormat.prototype.constructor JSHandle lfFunction(NewIntlConstructor(env, lfPrototype, ListFormat::ListFormatConstructor, "ListFormat", FunctionLength::ZERO)); JSHandle(lfFunction)->SetFunctionPrototype(thread_, JSTaggedValue(*lfFuncInstanceHClass)); // 13.3.2 Intl.ListFormat.supportedLocalesOf ( locales [ , options ] ) SetFunction(env, lfFunction, "supportedLocalesOf", ListFormat::SupportedLocalesOf, FunctionLength::ONE); // ListFormat.prototype method // 13.4.2 Intl.ListFormat.prototype [ @@toStringTag ] SetStringTagSymbol(env, lfPrototype, "Intl.ListFormat"); env->SetListFormatFunction(thread_, lfFunction); // 13.4.3 get Intl.ListFormat.prototype.format( list ) SetFunction(env, lfPrototype, "format", ListFormat::Format, FunctionLength::ONE); // 13.4.4 Intl.ListFormat.prototype.formatToParts( list ) SetFunction(env, lfPrototype, "formatToParts", ListFormat::FormatToParts, FunctionLength::ONE); // 13.4.5 Intl.ListFormat.prototype.resolvedOptions() SetFunction(env, lfPrototype, "resolvedOptions", ListFormat::ResolvedOptions, FunctionLength::ZERO); } JSHandle Builtins::InitializeArkTools(const JSHandle &env) const { JSHandle tools = factory_->NewEmptyJSObject(); SetFunction(env, tools, "print", builtins::BuiltinsArkTools::ObjectDump, FunctionLength::ZERO); SetFunction(env, tools, "compareHClass", builtins::BuiltinsArkTools::CompareHClass, FunctionLength::TWO); SetFunction(env, tools, "dumpHClass", builtins::BuiltinsArkTools::DumpHClass, FunctionLength::ONE); SetFunction(env, tools, "isTSHClass", builtins::BuiltinsArkTools::IsTSHClass, FunctionLength::ONE); SetFunction(env, tools, "getHClass", builtins::BuiltinsArkTools::GetHClass, FunctionLength::ONE); SetFunction(env, tools, "forceFullGC", builtins::BuiltinsArkTools::ForceFullGC, FunctionLength::ZERO); SetFunction(env, tools, "removeAOTFlag", builtins::BuiltinsArkTools::RemoveAOTFlag, FunctionLength::ONE); #if defined(ECMASCRIPT_SUPPORT_CPUPROFILER) SetFunction(env, tools, "startCpuProf", builtins::BuiltinsArkTools::StartCpuProfiler, FunctionLength::ZERO); SetFunction(env, tools, "stopCpuProf", builtins::BuiltinsArkTools::StopCpuProfiler, FunctionLength::ZERO); #endif SetFunction(env, tools, "isPrototype", builtins::BuiltinsArkTools::IsPrototype, FunctionLength::ONE); return tools; } void Builtins::InitializeGlobalRegExp(JSHandle &obj) const { JSHandle emptyString = thread_->GlobalConstants()->GetHandledEmptyString(); JSHandle newBox1 = JSHandle(factory_->NewPropertyBox(emptyString)); SetConstantObject(obj, "$1", newBox1); JSHandle newBox2 = JSHandle(factory_->NewPropertyBox(emptyString)); SetConstantObject(obj, "$2", newBox2); JSHandle newBox3 = JSHandle(factory_->NewPropertyBox(emptyString)); SetConstantObject(obj, "$3", newBox3); JSHandle newBox4 = JSHandle(factory_->NewPropertyBox(emptyString)); SetConstantObject(obj, "$4", newBox4); JSHandle newBox5 = JSHandle(factory_->NewPropertyBox(emptyString)); SetConstantObject(obj, "$5", newBox5); JSHandle newBox6 = JSHandle(factory_->NewPropertyBox(emptyString)); SetConstantObject(obj, "$6", newBox6); JSHandle newBox7 = JSHandle(factory_->NewPropertyBox(emptyString)); SetConstantObject(obj, "$7", newBox7); JSHandle newBox8 = JSHandle(factory_->NewPropertyBox(emptyString)); SetConstantObject(obj, "$8", newBox8); JSHandle newBox9 = JSHandle(factory_->NewPropertyBox(emptyString)); SetConstantObject(obj, "$9", newBox9); } JSHandle Builtins::InitializeArkPrivate(const JSHandle &env) const { JSHandle arkPrivate = factory_->NewEmptyJSObject(); SetFrozenFunction(env, arkPrivate, "Load", ContainersPrivate::Load, FunctionLength::ZERO); // It is used to provide non ECMA standard jsapi containers. SetConstant(arkPrivate, "ArrayList", JSTaggedValue(static_cast(containers::ContainerTag::ArrayList))); SetConstant(arkPrivate, "Queue", JSTaggedValue(static_cast(containers::ContainerTag::Queue))); SetConstant(arkPrivate, "Deque", JSTaggedValue(static_cast(containers::ContainerTag::Deque))); SetConstant(arkPrivate, "Stack", JSTaggedValue(static_cast(containers::ContainerTag::Stack))); SetConstant(arkPrivate, "Vector", JSTaggedValue(static_cast(containers::ContainerTag::Vector))); SetConstant(arkPrivate, "List", JSTaggedValue(static_cast(containers::ContainerTag::List))); SetConstant(arkPrivate, "LinkedList", JSTaggedValue(static_cast(containers::ContainerTag::LinkedList))); SetConstant(arkPrivate, "TreeMap", JSTaggedValue(static_cast(containers::ContainerTag::TreeMap))); SetConstant(arkPrivate, "TreeSet", JSTaggedValue(static_cast(containers::ContainerTag::TreeSet))); SetConstant(arkPrivate, "HashMap", JSTaggedValue(static_cast(containers::ContainerTag::HashMap))); SetConstant(arkPrivate, "HashSet", JSTaggedValue(static_cast(containers::ContainerTag::HashSet))); SetConstant(arkPrivate, "LightWeightMap", JSTaggedValue(static_cast(containers::ContainerTag::LightWeightMap))); SetConstant(arkPrivate, "LightWeightSet", JSTaggedValue(static_cast(containers::ContainerTag::LightWeightSet))); SetConstant(arkPrivate, "PlainArray", JSTaggedValue(static_cast(containers::ContainerTag::PlainArray))); return arkPrivate; } void Builtins::InitializeModuleNamespace(const JSHandle &env, const JSHandle &objFuncClass) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // ModuleNamespace.prototype JSHandle moduleNamespacePrototype = factory_->NewJSObjectWithInit(objFuncClass); JSHandle moduleNamespacePrototypeValue(moduleNamespacePrototype); // ModuleNamespace.prototype_or_hclass JSHandle moduleNamespaceHClass = factory_->NewEcmaHClass(ModuleNamespace::SIZE, JSType::JS_MODULE_NAMESPACE, moduleNamespacePrototypeValue); moduleNamespaceHClass->SetPrototype(thread_, JSTaggedValue::Null()); env->SetModuleNamespaceClass(thread_, moduleNamespaceHClass.GetTaggedValue()); // moduleNamespace.prototype [ @@toStringTag ] SetStringTagSymbol(env, moduleNamespacePrototype, "Module"); } void Builtins::InitializeCjsModule(const JSHandle &env) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // CjsModule.prototype JSHandle objFun(env->GetObjectFunction()); JSHandle cjsModulePrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle cjsModulePrototypeValue(cjsModulePrototype); // CjsModule.prototype_or_hclass JSHandle cjsModuleHClass = factory_->NewEcmaHClass(CjsModule::SIZE, JSType::JS_CJS_MODULE, cjsModulePrototypeValue); // CjsModule.prototype.Constructor JSHandle cjsModuleFunction( NewBuiltinCjsCtor(env, cjsModulePrototype, BuiltinsCjsModule::CjsModuleConstructor, "Module", FunctionLength::TWO)); JSHandle(cjsModuleFunction)->SetFunctionPrototype(thread_, cjsModuleHClass.GetTaggedValue()); // CjsModule method SetFunction(env, cjsModuleFunction, "_load", BuiltinsCjsModule::Load, FunctionLength::ONE); SetFunction(env, cjsModuleFunction, "_resolveFilename", BuiltinsCjsModule::ResolveFilename, FunctionLength::ONE); // CjsModule.prototype method SetFunction(env, cjsModulePrototype, "require", BuiltinsCjsModule::Require, FunctionLength::ONE); SetFunction(env, cjsModulePrototype, "getExportsForCircularRequire", BuiltinsCjsModule::GetExportsForCircularRequire, FunctionLength::ONE); SetFunction(env, cjsModulePrototype, "updateChildren", BuiltinsCjsModule::UpdateChildren, FunctionLength::ONE); JSHandle id(thread_->GlobalConstants()->GetHandledEmptyString()); JSHandle path(thread_->GlobalConstants()->GetHandledEmptyString()); JSHandle exports(factory_->NewEmptyJSObject()); JSHandle parent(factory_->NewEmptyJSObject()); JSHandle filename(thread_->GlobalConstants()->GetHandledEmptyString()); JSHandle loaded(factory_->NewEmptyJSObject()); JSHandle children(factory_->NewEmptyJSObject()); JSHandle cache = JSHandle::Cast(CjsModuleCache::Create(thread_, CjsModuleCache::DEAULT_DICTIONART_CAPACITY)); // CjsModule.prototype members SetNonConstantObject(cjsModulePrototype, "id", id); SetNonConstantObject(cjsModulePrototype, "path", path); SetNonConstantObject(cjsModulePrototype, "exports", exports); SetNonConstantObject(cjsModulePrototype, "parent", parent); SetNonConstantObject(cjsModulePrototype, "filename", filename); SetNonConstantObject(cjsModulePrototype, "loaded", loaded); SetNonConstantObject(cjsModulePrototype, "children", children); // CjsModule members SetNonConstantObject(cjsModuleFunction, "_cache", cache); env->SetCjsModuleFunction(thread_, cjsModuleFunction); } void Builtins::InitializeCjsExports(const JSHandle &env) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // CjsExports.prototype JSHandle objFun(env->GetObjectFunction()); JSHandle cjsExportsPrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle cjsExportsPrototypeValue(cjsExportsPrototype); // CjsExports.prototype_or_hclass JSHandle cjsExportsHClass = factory_->NewEcmaHClass(CjsExports::SIZE, JSType::JS_CJS_EXPORTS, cjsExportsPrototypeValue); // CjsExports.prototype.Constructor JSHandle cjsExportsFunction( NewBuiltinCjsCtor(env, cjsExportsPrototype, BuiltinsCjsExports::CjsExportsConstructor, "Exports", FunctionLength::TWO)); JSHandle(cjsExportsFunction)->SetFunctionPrototype(thread_, cjsExportsHClass.GetTaggedValue()); env->SetCjsExportsFunction(thread_, cjsExportsFunction); } void Builtins::InitializeCjsRequire(const JSHandle &env) const { [[maybe_unused]] EcmaHandleScope scope(thread_); // CjsRequire.prototype JSHandle objFun(env->GetObjectFunction()); JSHandle cjsRequirePrototype = factory_->NewJSObjectByConstructor(objFun); JSHandle cjsRequirePrototypeValue(cjsRequirePrototype); // CjsExports.prototype_or_hclass JSHandle cjsRequireHClass = factory_->NewEcmaHClass(CjsRequire::SIZE, JSType::JS_CJS_REQUIRE, cjsRequirePrototypeValue); // CjsExports.prototype.Constructor JSHandle cjsRequireFunction = NewBuiltinCjsCtor(env, cjsRequirePrototype, BuiltinsCjsRequire::CjsRequireConstructor, "require", FunctionLength::ONE); JSHandle(cjsRequireFunction)->SetFunctionPrototype(thread_, cjsRequireHClass.GetTaggedValue()); // CjsModule.prototype method SetFunction(env, cjsRequirePrototype, "Main", BuiltinsCjsRequire::Main, FunctionLength::ONE); env->SetCjsRequireFunction(thread_, cjsRequireFunction); } void Builtins::InitializeDefaultExportOfScript(const JSHandle &env) const { JSHandle builtinObj(env->GetObjectFunction()); JSHandle emptyObj(factory_->NewJSObjectByConstructor(builtinObj)); JSHandle defaultKey(factory_->NewFromUtf8("default")); JSHandle props(factory_->NewTaggedArray(2)); // 2 : two propertise props->Set(thread_, 0, defaultKey); props->Set(thread_, 1, emptyObj); JSHandle hclass = factory_->CreateObjectClass(props, 1); JSHandle obj = factory_->NewJSObject(hclass); obj->SetPropertyInlinedProps(thread_, 0, props->Get(1)); env->SetExportOfScript(thread_, obj); return; } } // namespace panda::ecmascript