diff options
Diffstat (limited to 'Libraries/LibJS/Runtime/VM.cpp')
| -rw-r--r-- | Libraries/LibJS/Runtime/VM.cpp | 285 |
1 files changed, 283 insertions, 2 deletions
diff --git a/Libraries/LibJS/Runtime/VM.cpp b/Libraries/LibJS/Runtime/VM.cpp index 37c7341872..9989ca9172 100644 --- a/Libraries/LibJS/Runtime/VM.cpp +++ b/Libraries/LibJS/Runtime/VM.cpp @@ -24,10 +24,18 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +#include <AK/StringBuilder.h> +#include <AK/ScopeGuard.h> #include <LibJS/Interpreter.h> +#include <LibJS/Runtime/Error.h> +#include <LibJS/Runtime/GlobalObject.h> +#include <LibJS/Runtime/Reference.h> +#include <LibJS/Runtime/ScriptFunction.h> #include <LibJS/Runtime/Symbol.h> #include <LibJS/Runtime/VM.h> +//#define VM_DEBUG + namespace JS { NonnullRefPtr<VM> VM::create() @@ -90,8 +98,19 @@ void VM::gather_roots(HashTable<Cell*>& roots) roots.set(m_empty_string); if (m_exception) roots.set(m_exception); - for (auto* interpreter : m_interpreters) - interpreter->gather_roots(roots); + + if (m_last_value.is_cell()) + roots.set(m_last_value.as_cell()); + + for (auto& call_frame : m_call_stack) { + if (call_frame.this_value.is_cell()) + roots.set(call_frame.this_value.as_cell()); + for (auto& argument : call_frame.arguments) { + if (argument.is_cell()) + roots.set(argument.as_cell()); + } + roots.set(call_frame.environment); + } #define __JS_ENUMERATE(SymbolName, snake_name) \ roots.set(well_known_symbol_##snake_name()); @@ -113,4 +132,266 @@ Symbol* VM::get_global_symbol(const String& description) return new_global_symbol; } +bool VM::in_strict_mode() const +{ + if (m_scope_stack.is_empty()) + return true; + return m_scope_stack.last().scope_node->in_strict_mode(); +} + +void VM::enter_scope(const ScopeNode& scope_node, ArgumentVector arguments, ScopeType scope_type, GlobalObject& global_object) +{ + for (auto& declaration : scope_node.functions()) { + auto* function = ScriptFunction::create(global_object, declaration.name(), declaration.body(), declaration.parameters(), declaration.function_length(), current_environment()); + set_variable(declaration.name(), function, global_object); + } + + if (scope_type == ScopeType::Function) { + m_scope_stack.append({ scope_type, scope_node, false }); + return; + } + + HashMap<FlyString, Variable> scope_variables_with_declaration_kind; + scope_variables_with_declaration_kind.ensure_capacity(16); + + for (auto& declaration : scope_node.variables()) { + for (auto& declarator : declaration.declarations()) { + if (scope_node.is_program()) { + global_object.put(declarator.id().string(), js_undefined()); + if (exception()) + return; + } else { + scope_variables_with_declaration_kind.set(declarator.id().string(), { js_undefined(), declaration.declaration_kind() }); + } + } + } + + for (auto& argument : arguments) { + scope_variables_with_declaration_kind.set(argument.name, { argument.value, DeclarationKind::Var }); + } + + bool pushed_lexical_environment = false; + + if (!scope_variables_with_declaration_kind.is_empty()) { + auto* block_lexical_environment = heap().allocate<LexicalEnvironment>(global_object, move(scope_variables_with_declaration_kind), current_environment()); + m_call_stack.last().environment = block_lexical_environment; + pushed_lexical_environment = true; + } + + m_scope_stack.append({ scope_type, scope_node, pushed_lexical_environment }); +} + +void VM::exit_scope(const ScopeNode& scope_node) +{ + while (!m_scope_stack.is_empty()) { + auto popped_scope = m_scope_stack.take_last(); + if (popped_scope.pushed_environment) + m_call_stack.last().environment = m_call_stack.last().environment->parent(); + if (popped_scope.scope_node.ptr() == &scope_node) + break; + } + + // If we unwind all the way, just reset m_unwind_until so that future "return" doesn't break. + if (m_scope_stack.is_empty()) + m_unwind_until = ScopeType::None; +} + +void VM::set_variable(const FlyString& name, Value value, GlobalObject& global_object, bool first_assignment) +{ + if (m_call_stack.size()) { + for (auto* environment = current_environment(); environment; environment = environment->parent()) { + if (environment->type() == LexicalEnvironment::EnvironmentRecordType::Global) + break; + auto possible_match = environment->get(name); + if (possible_match.has_value()) { + if (!first_assignment && possible_match.value().declaration_kind == DeclarationKind::Const) { + throw_exception<TypeError>(global_object, ErrorType::InvalidAssignToConst); + return; + } + + environment->set(name, { value, possible_match.value().declaration_kind }); + return; + } + } + } + + global_object.put(move(name), move(value)); +} + +Value VM::get_variable(const FlyString& name, GlobalObject& global_object) +{ + if (m_call_stack.size()) { + for (auto* environment = current_environment(); environment; environment = environment->parent()) { + if (environment->type() == LexicalEnvironment::EnvironmentRecordType::Global) + break; + auto possible_match = environment->get(name); + if (possible_match.has_value()) + return possible_match.value().value; + } + } + auto value = global_object.get(name); + if (m_underscore_is_last_value && name == "_" && value.is_empty()) + return m_last_value; + return value; +} + +Reference VM::get_reference(const FlyString& name) +{ + if (m_call_stack.size()) { + for (auto* environment = current_environment(); environment; environment = environment->parent()) { + if (environment->type() == LexicalEnvironment::EnvironmentRecordType::Global) + break; + auto possible_match = environment->get(name); + if (possible_match.has_value()) + return { Reference::LocalVariable, name }; + } + } + return { Reference::GlobalVariable, name }; +} + +Value VM::execute_statement(GlobalObject& global_object, const Statement& statement, ArgumentVector arguments, ScopeType scope_type) +{ + if (!statement.is_scope_node()) + return statement.execute(interpreter(), global_object); + + auto& block = static_cast<const ScopeNode&>(statement); + enter_scope(block, move(arguments), scope_type, global_object); + + if (block.children().is_empty()) + m_last_value = js_undefined(); + + for (auto& node : block.children()) { + m_last_value = node.execute(interpreter(), global_object); + if (should_unwind()) { + if (!block.label().is_null() && should_unwind_until(ScopeType::Breakable, block.label())) + stop_unwind(); + break; + } + } + + bool did_return = m_unwind_until == ScopeType::Function; + + if (m_unwind_until == scope_type) + m_unwind_until = ScopeType::None; + + exit_scope(block); + + return did_return ? m_last_value : js_undefined(); +} + +Value VM::construct(Function& function, Function& new_target, Optional<MarkedValueList> arguments, GlobalObject& global_object) +{ + auto& call_frame = push_call_frame(); + + ArmedScopeGuard call_frame_popper = [&] { + pop_call_frame(); + }; + + call_frame.function_name = function.name(); + call_frame.arguments = function.bound_arguments(); + if (arguments.has_value()) + call_frame.arguments.append(arguments.value().values()); + call_frame.environment = function.create_environment(); + + current_environment()->set_new_target(&new_target); + + Object* new_object = nullptr; + if (function.constructor_kind() == Function::ConstructorKind::Base) { + new_object = Object::create_empty(global_object); + current_environment()->bind_this_value(new_object); + if (exception()) + return {}; + auto prototype = new_target.get("prototype"); + if (exception()) + return {}; + if (prototype.is_object()) { + new_object->set_prototype(&prototype.as_object()); + if (exception()) + return {}; + } + } + + // If we are a Derived constructor, |this| has not been constructed before super is called. + Value this_value = function.constructor_kind() == Function::ConstructorKind::Base ? new_object : Value {}; + call_frame.this_value = this_value; + auto result = function.construct(interpreter(), new_target); + + this_value = current_environment()->get_this_binding(); + pop_call_frame(); + call_frame_popper.disarm(); + + // If we are constructing an instance of a derived class, + // set the prototype on objects created by constructors that return an object (i.e. NativeFunction subclasses). + if (function.constructor_kind() == Function::ConstructorKind::Base && new_target.constructor_kind() == Function::ConstructorKind::Derived && result.is_object()) { + current_environment()->replace_this_binding(result); + auto prototype = new_target.get("prototype"); + if (exception()) + return {}; + if (prototype.is_object()) { + result.as_object().set_prototype(&prototype.as_object()); + if (exception()) + return {}; + } + return result; + } + + if (exception()) + return {}; + + if (result.is_object()) + return result; + + return this_value; +} + +void VM::throw_exception(Exception* exception) +{ +#ifdef VM_DEBUG + if (exception->value().is_object() && exception->value().as_object().is_error()) { + auto& error = static_cast<Error&>(exception->value().as_object()); + dbg() << "Throwing JavaScript Error: " << error.name() << ", " << error.message(); + + for (ssize_t i = m_call_stack.size() - 1; i >= 0; --i) { + auto function_name = m_call_stack[i].function_name; + if (function_name.is_empty()) + function_name = "<anonymous>"; + dbg() << " " << function_name; + } + } +#endif + m_exception = exception; + unwind(ScopeType::Try); +} + +String VM::join_arguments() const +{ + StringBuilder joined_arguments; + for (size_t i = 0; i < argument_count(); ++i) { + joined_arguments.append(argument(i).to_string_without_side_effects().characters()); + if (i != argument_count() - 1) + joined_arguments.append(' '); + } + return joined_arguments.build(); +} + +Value VM::resolve_this_binding() const +{ + return get_this_environment()->get_this_binding(); +} + +const LexicalEnvironment* VM::get_this_environment() const +{ + // We will always return because the Global environment will always be reached, which has a |this| binding. + for (const LexicalEnvironment* environment = current_environment(); environment; environment = environment->parent()) { + if (environment->has_this_binding()) + return environment; + } + ASSERT_NOT_REACHED(); +} + +Value VM::get_new_target() const +{ + return get_this_environment()->new_target(); +} + } |