���� JFIF �� � ( %"1"%)+...383,7(-.-
![]() Server : Apache/2.4.6 (CentOS) OpenSSL/1.0.2k-fips PHP/7.4.20 System : Linux st2.domain.com 3.10.0-1127.10.1.el7.x86_64 #1 SMP Wed Jun 3 14:28:03 UTC 2020 x86_64 User : apache ( 48) PHP Version : 7.4.20 Disable Function : NONE Directory : /home/real/node-v13.0.1/deps/v8/src/builtins/ |
// Copyright 2016 the V8 project authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "src/builtins/builtins-utils-inl.h" #include "src/builtins/builtins.h" #include "src/codegen/code-factory.h" #include "src/codegen/compiler.h" #include "src/logging/counters.h" #include "src/numbers/conversions.h" #include "src/objects/api-callbacks.h" #include "src/objects/lookup.h" #include "src/objects/objects-inl.h" #include "src/strings/string-builder-inl.h" namespace v8 { namespace internal { namespace { // ES6 section 19.2.1.1.1 CreateDynamicFunction MaybeHandle<Object> CreateDynamicFunction(Isolate* isolate, BuiltinArguments args, const char* token) { // Compute number of arguments, ignoring the receiver. DCHECK_LE(1, args.length()); int const argc = args.length() - 1; Handle<JSFunction> target = args.target(); Handle<JSObject> target_global_proxy(target->global_proxy(), isolate); if (!Builtins::AllowDynamicFunction(isolate, target, target_global_proxy)) { isolate->CountUsage(v8::Isolate::kFunctionConstructorReturnedUndefined); return isolate->factory()->undefined_value(); } // Build the source string. Handle<String> source; int parameters_end_pos = kNoSourcePosition; { IncrementalStringBuilder builder(isolate); builder.AppendCharacter('('); builder.AppendCString(token); builder.AppendCString(" anonymous("); bool parenthesis_in_arg_string = false; if (argc > 1) { for (int i = 1; i < argc; ++i) { if (i > 1) builder.AppendCharacter(','); Handle<String> param; ASSIGN_RETURN_ON_EXCEPTION( isolate, param, Object::ToString(isolate, args.at(i)), Object); param = String::Flatten(isolate, param); builder.AppendString(param); } } builder.AppendCharacter('\n'); parameters_end_pos = builder.Length(); builder.AppendCString(") {\n"); if (argc > 0) { Handle<String> body; ASSIGN_RETURN_ON_EXCEPTION( isolate, body, Object::ToString(isolate, args.at(argc)), Object); builder.AppendString(body); } builder.AppendCString("\n})"); ASSIGN_RETURN_ON_EXCEPTION(isolate, source, builder.Finish(), Object); // The SyntaxError must be thrown after all the (observable) ToString // conversions are done. if (parenthesis_in_arg_string) { THROW_NEW_ERROR(isolate, NewSyntaxError(MessageTemplate::kParenthesisInArgString), Object); } } // Compile the string in the constructor and not a helper so that errors to // come from here. Handle<JSFunction> function; { ASSIGN_RETURN_ON_EXCEPTION( isolate, function, Compiler::GetFunctionFromString( handle(target->native_context(), isolate), source, ONLY_SINGLE_FUNCTION_LITERAL, parameters_end_pos), Object); Handle<Object> result; ASSIGN_RETURN_ON_EXCEPTION( isolate, result, Execution::Call(isolate, function, target_global_proxy, 0, nullptr), Object); function = Handle<JSFunction>::cast(result); function->shared().set_name_should_print_as_anonymous(true); } // The spec says that we have to wrap code created via the function // constructor in e.g. 'function anonymous(' as above, including with extra // line breaks. Ths is confusing when reporting stack traces from the eval'd // code as the line number of the error is always reported with 2 extra line // breaks e.g. line 1 is reported as line 3. We fix this up here by setting // line_offset which is read by stack trace code. Handle<Script> script(Script::cast(function->shared().script()), isolate); if (script->line_offset() == 0) { script->set_line_offset(-2); } // If new.target is equal to target then the function created // is already correctly setup and nothing else should be done // here. But if new.target is not equal to target then we are // have a Function builtin subclassing case and therefore the // function has wrong initial map. To fix that we create a new // function object with correct initial map. Handle<Object> unchecked_new_target = args.new_target(); if (!unchecked_new_target->IsUndefined(isolate) && !unchecked_new_target.is_identical_to(target)) { Handle<JSReceiver> new_target = Handle<JSReceiver>::cast(unchecked_new_target); Handle<Map> initial_map; ASSIGN_RETURN_ON_EXCEPTION( isolate, initial_map, JSFunction::GetDerivedMap(isolate, target, new_target), Object); Handle<SharedFunctionInfo> shared_info(function->shared(), isolate); Handle<Map> map = Map::AsLanguageMode(isolate, initial_map, shared_info); Handle<Context> context(function->context(), isolate); function = isolate->factory()->NewFunctionFromSharedFunctionInfo( map, shared_info, context, AllocationType::kYoung); } return function; } } // namespace // ES6 section 19.2.1.1 Function ( p1, p2, ... , pn, body ) BUILTIN(FunctionConstructor) { HandleScope scope(isolate); Handle<Object> result; ASSIGN_RETURN_FAILURE_ON_EXCEPTION( isolate, result, CreateDynamicFunction(isolate, args, "function")); return *result; } // ES6 section 25.2.1.1 GeneratorFunction (p1, p2, ... , pn, body) BUILTIN(GeneratorFunctionConstructor) { HandleScope scope(isolate); RETURN_RESULT_OR_FAILURE(isolate, CreateDynamicFunction(isolate, args, "function*")); } BUILTIN(AsyncFunctionConstructor) { HandleScope scope(isolate); Handle<Object> maybe_func; ASSIGN_RETURN_FAILURE_ON_EXCEPTION( isolate, maybe_func, CreateDynamicFunction(isolate, args, "async function")); if (!maybe_func->IsJSFunction()) return *maybe_func; // Do not lazily compute eval position for AsyncFunction, as they may not be // determined after the function is resumed. Handle<JSFunction> func = Handle<JSFunction>::cast(maybe_func); Handle<Script> script = handle(Script::cast(func->shared().script()), isolate); int position = Script::GetEvalPosition(isolate, script); USE(position); return *func; } BUILTIN(AsyncGeneratorFunctionConstructor) { HandleScope scope(isolate); Handle<Object> maybe_func; ASSIGN_RETURN_FAILURE_ON_EXCEPTION( isolate, maybe_func, CreateDynamicFunction(isolate, args, "async function*")); if (!maybe_func->IsJSFunction()) return *maybe_func; // Do not lazily compute eval position for AsyncFunction, as they may not be // determined after the function is resumed. Handle<JSFunction> func = Handle<JSFunction>::cast(maybe_func); Handle<Script> script = handle(Script::cast(func->shared().script()), isolate); int position = Script::GetEvalPosition(isolate, script); USE(position); return *func; } namespace { Object DoFunctionBind(Isolate* isolate, BuiltinArguments args) { HandleScope scope(isolate); DCHECK_LE(1, args.length()); if (!args.receiver()->IsCallable()) { THROW_NEW_ERROR_RETURN_FAILURE( isolate, NewTypeError(MessageTemplate::kFunctionBind)); } // Allocate the bound function with the given {this_arg} and {args}. Handle<JSReceiver> target = args.at<JSReceiver>(0); Handle<Object> this_arg = isolate->factory()->undefined_value(); ScopedVector<Handle<Object>> argv(std::max(0, args.length() - 2)); if (args.length() > 1) { this_arg = args.at(1); for (int i = 2; i < args.length(); ++i) { argv[i - 2] = args.at(i); } } Handle<JSBoundFunction> function; ASSIGN_RETURN_FAILURE_ON_EXCEPTION( isolate, function, isolate->factory()->NewJSBoundFunction(target, this_arg, argv)); LookupIterator length_lookup(target, isolate->factory()->length_string(), target, LookupIterator::OWN); // Setup the "length" property based on the "length" of the {target}. // If the targets length is the default JSFunction accessor, we can keep the // accessor that's installed by default on the JSBoundFunction. It lazily // computes the value from the underlying internal length. if (!target->IsJSFunction() || length_lookup.state() != LookupIterator::ACCESSOR || !length_lookup.GetAccessors()->IsAccessorInfo()) { Handle<Object> length(Smi::kZero, isolate); Maybe<PropertyAttributes> attributes = JSReceiver::GetPropertyAttributes(&length_lookup); if (attributes.IsNothing()) return ReadOnlyRoots(isolate).exception(); if (attributes.FromJust() != ABSENT) { Handle<Object> target_length; ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, target_length, Object::GetProperty(&length_lookup)); if (target_length->IsNumber()) { length = isolate->factory()->NewNumber(std::max( 0.0, DoubleToInteger(target_length->Number()) - argv.length())); } } LookupIterator it(function, isolate->factory()->length_string(), function); DCHECK_EQ(LookupIterator::ACCESSOR, it.state()); RETURN_FAILURE_ON_EXCEPTION(isolate, JSObject::DefineOwnPropertyIgnoreAttributes( &it, length, it.property_attributes())); } // Setup the "name" property based on the "name" of the {target}. // If the target's name is the default JSFunction accessor, we can keep the // accessor that's installed by default on the JSBoundFunction. It lazily // computes the value from the underlying internal name. LookupIterator name_lookup(target, isolate->factory()->name_string(), target); if (!target->IsJSFunction() || name_lookup.state() != LookupIterator::ACCESSOR || !name_lookup.GetAccessors()->IsAccessorInfo() || (name_lookup.IsFound() && !name_lookup.HolderIsReceiver())) { Handle<Object> target_name; ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, target_name, Object::GetProperty(&name_lookup)); Handle<String> name; if (target_name->IsString()) { ASSIGN_RETURN_FAILURE_ON_EXCEPTION( isolate, name, Name::ToFunctionName(isolate, Handle<String>::cast(target_name))); ASSIGN_RETURN_FAILURE_ON_EXCEPTION( isolate, name, isolate->factory()->NewConsString( isolate->factory()->bound__string(), name)); } else { name = isolate->factory()->bound__string(); } LookupIterator it(isolate, function, isolate->factory()->name_string()); DCHECK_EQ(LookupIterator::ACCESSOR, it.state()); RETURN_FAILURE_ON_EXCEPTION(isolate, JSObject::DefineOwnPropertyIgnoreAttributes( &it, name, it.property_attributes())); } return *function; } } // namespace // ES6 section 19.2.3.2 Function.prototype.bind ( thisArg, ...args ) BUILTIN(FunctionPrototypeBind) { return DoFunctionBind(isolate, args); } // ES6 section 19.2.3.5 Function.prototype.toString ( ) BUILTIN(FunctionPrototypeToString) { HandleScope scope(isolate); Handle<Object> receiver = args.receiver(); if (receiver->IsJSBoundFunction()) { return *JSBoundFunction::ToString(Handle<JSBoundFunction>::cast(receiver)); } if (receiver->IsJSFunction()) { return *JSFunction::ToString(Handle<JSFunction>::cast(receiver)); } // With the revised toString behavior, all callable objects are valid // receivers for this method. if (receiver->IsJSReceiver() && JSReceiver::cast(*receiver).map().is_callable()) { return ReadOnlyRoots(isolate).function_native_code_string(); } THROW_NEW_ERROR_RETURN_FAILURE( isolate, NewTypeError(MessageTemplate::kNotGeneric, isolate->factory()->NewStringFromAsciiChecked( "Function.prototype.toString"), isolate->factory()->Function_string())); } } // namespace internal } // namespace v8