diff options
| -rw-r--r-- | src/openvic-simulation/vm/Builtin.cpp | 117 | ||||
| -rw-r--r-- | src/openvic-simulation/vm/Builtin.hpp | 77 | ||||
| -rw-r--r-- | src/openvic-simulation/vm/Codegen.cpp | 143 | ||||
| -rw-r--r-- | src/openvic-simulation/vm/Codegen.hpp | 34 | ||||
| -rw-r--r-- | src/openvic-simulation/vm/VirtualMachine.hpp | 8 |
5 files changed, 309 insertions, 70 deletions
diff --git a/src/openvic-simulation/vm/Builtin.cpp b/src/openvic-simulation/vm/Builtin.cpp index c5c62e9..2ba8457 100644 --- a/src/openvic-simulation/vm/Builtin.cpp +++ b/src/openvic-simulation/vm/Builtin.cpp @@ -1,20 +1,21 @@ #include "vm/Builtin.hpp" -#include "InstanceManager.hpp" -#include "vm/Codegen.hpp" +#include "GameManager.hpp" +#include <lauf/asm/type.h> #include <lauf/runtime/builtin.h> #include <lauf/runtime/memory.h> #include <lauf/runtime/process.h> #include <lauf/runtime/value.h> -OpenVic::Asm::scope_variant* -get_keyword_scope(OpenVic::InstanceManager* instance_manager, const char* keyword, OpenVic::Vm::Codegen::scope_type type) { - // TODO: get scope native pointer from name and type +OpenVic::Asm::scope_store_variant* create_scope( // + OpenVic::GameManager* instance_manager, const char* scope_name, OpenVic::Asm::scope_store_variant* relative_scope +) { + // TODO: create scope based on scope_name and relative_scope return nullptr; } bool execute_effect( - OpenVic::InstanceManager* instance_manager, const char* effect_id, OpenVic::Asm::scope_variant& scope, + OpenVic::GameManager* instance_manager, const char* effect_id, OpenVic::Asm::scope_store_variant& scope, OpenVic::Asm::argument* arguments, std::size_t arg_count ) { // TODO: execute effect based on id, scope, and arguments @@ -22,7 +23,7 @@ bool execute_effect( } bool execute_trigger( - OpenVic::InstanceManager* instance_manager, const char* trigger_id, OpenVic::Asm::scope_variant& scope, + OpenVic::GameManager* instance_manager, const char* trigger_id, OpenVic::Asm::scope_store_variant& scope, OpenVic::Asm::argument* arguments, std::size_t arg_count, bool* result ) { // TODO: execute trigger based on id, scope, and arguments @@ -37,7 +38,7 @@ LAUF_RUNTIME_BUILTIN(call_effect, 3, 0, LAUF_RUNTIME_BUILTIN_DEFAULT, "call_effe auto vm_data = static_cast<OpenVic::Vm::VmUserData*>(user_data); auto effect_name_addr = vstack_ptr[0].as_address; - auto scope_ptr = static_cast<OpenVic::Asm::scope_variant*>(vstack_ptr[1].as_native_ptr); + auto scope_def_ptr = static_cast<OpenVic::Asm::scope_store_variant*>(vstack_ptr[1].as_native_ptr); auto argument_array_addr = vstack_ptr[2].as_address; auto effect_name = lauf_runtime_get_cstr(process, effect_name_addr); @@ -55,7 +56,7 @@ LAUF_RUNTIME_BUILTIN(call_effect, 3, 0, LAUF_RUNTIME_BUILTIN_DEFAULT, "call_effe auto argument_array = static_cast<OpenVic::Asm::argument*>(lauf_runtime_get_mut_ptr(process, argument_array_addr, { 1, 1 })); - if (!execute_effect(vm_data->instance_manager, effect_name, *scope_ptr, argument_array, count)) { + if (!execute_effect(vm_data->game_manager, effect_name, *scope_def_ptr, argument_array, count)) { return lauf_runtime_panic(process, "effect could not be found"); } @@ -92,8 +93,8 @@ LAUF_RUNTIME_BUILTIN(call_trigger, 3, 1, LAUF_RUNTIME_BUILTIN_DEFAULT, "call_tri bool trigger_result; if (!execute_trigger( - static_cast<OpenVic::InstanceManager*>(user_data), effect_name, - *static_cast<OpenVic::Asm::scope_variant*>(scope_ptr), argument_array, count, &trigger_result + vm_data->game_manager, effect_name, *static_cast<OpenVic::Asm::scope_store_variant*>(scope_ptr), argument_array, + count, &trigger_result )) { return lauf_runtime_panic(process, "trigger could not be found"); } @@ -134,7 +135,9 @@ LAUF_RUNTIME_BUILTIN( LAUF_RUNTIME_BUILTIN_DISPATCH; } -LAUF_RUNTIME_BUILTIN(load_scope_ptr, 1, 1, LAUF_RUNTIME_BUILTIN_DEFAULT, "load_scope_ptr", &translate_address_to_string) { +LAUF_RUNTIME_BUILTIN( + load_static_scope_ptr, 1, 1, LAUF_RUNTIME_BUILTIN_DEFAULT, "load_static_scope_ptr", &translate_address_to_string +) { auto user_data = lauf_runtime_get_vm_user_data(process); if (user_data == nullptr) { return lauf_runtime_panic(process, "invalid user data"); @@ -143,11 +146,97 @@ LAUF_RUNTIME_BUILTIN(load_scope_ptr, 1, 1, LAUF_RUNTIME_BUILTIN_DEFAULT, "load_s auto scope_ref_position = vstack_ptr[0].as_uint; - if (scope_ref_position >= vm_data->scope_references.size()) { + if (scope_ref_position >= vm_data->scope_refs.size()) { return lauf_runtime_panic(process, "invalid scope reference value"); } - vstack_ptr[0].as_native_ptr = &vm_data->scope_references[scope_ref_position]; + vstack_ptr[0].as_native_ptr = &vm_data->scope_refs[scope_ref_position]; + + LAUF_RUNTIME_BUILTIN_DISPATCH; +} + +LAUF_RUNTIME_BUILTIN( + load_relative_scope_ptr, 2, 1, LAUF_RUNTIME_BUILTIN_DEFAULT, "load_relative_scope_ptr", &load_static_scope_ptr +) { + auto user_data = lauf_runtime_get_vm_user_data(process); + if (user_data == nullptr) { + return lauf_runtime_panic(process, "invalid user data"); + } + auto vm_data = static_cast<OpenVic::Vm::VmUserData*>(user_data); + + auto scope_name_addr = vstack_ptr[0].as_address; + auto vstack_1 = vstack_ptr[1]; + auto relative_scope = static_cast<OpenVic::Asm::scope_store_variant*>(vstack_ptr[1].as_native_ptr); + + auto scope_name = lauf_runtime_get_cstr(process, scope_name_addr); + if (scope_name == nullptr) { + return lauf_runtime_panic(process, "invalid scope name address"); + } + + vstack_ptr++; + + auto scope = create_scope(vm_data->game_manager, scope_name, relative_scope); + + if (scope == nullptr) { + return lauf_runtime_panic(process, "could not create scope"); + } + + vm_data->scope_refs.emplace_back(std::move(*scope)); + delete scope; + + vstack_ptr[0].as_native_ptr = &vm_data->scope_refs.back(); + + LAUF_RUNTIME_BUILTIN_DISPATCH; +} + +LAUF_RUNTIME_BUILTIN(push_current_scope, 1, 0, LAUF_RUNTIME_BUILTIN_DEFAULT, "push_current_scope", &load_relative_scope_ptr) { + auto user_data = lauf_runtime_get_vm_user_data(process); + if (user_data == nullptr) { + return lauf_runtime_panic(process, "invalid user data"); + } + auto vm_data = static_cast<OpenVic::Vm::VmUserData*>(user_data); + + auto current_scope = static_cast<OpenVic::Asm::scope_store_variant*>(vstack_ptr[0].as_native_ptr); + + vm_data->scope_stack.push(current_scope); + + vstack_ptr++; + LAUF_RUNTIME_BUILTIN_DISPATCH; +} + +LAUF_RUNTIME_BUILTIN(pop_current_scope, 0, 0, LAUF_RUNTIME_BUILTIN_DEFAULT, "pop_current_scope", &push_current_scope) { + auto user_data = lauf_runtime_get_vm_user_data(process); + if (user_data == nullptr) { + return lauf_runtime_panic(process, "invalid user data"); + } + auto vm_data = static_cast<OpenVic::Vm::VmUserData*>(user_data); + + if (vm_data->scope_stack.empty()) { + return lauf_runtime_panic(process, "scope stack empty"); + } + + if (vm_data->scope_stack.size() == 1) { + return lauf_runtime_panic(process, "attempt to pop last scope in stack"); + } + + vm_data->scope_stack.pop(); + + LAUF_RUNTIME_BUILTIN_DISPATCH; +} + +LAUF_RUNTIME_BUILTIN(load_current_scope, 0, 1, LAUF_RUNTIME_BUILTIN_DEFAULT, "load_current_scope", &pop_current_scope) { + auto user_data = lauf_runtime_get_vm_user_data(process); + if (user_data == nullptr) { + return lauf_runtime_panic(process, "invalid user data"); + } + auto vm_data = static_cast<OpenVic::Vm::VmUserData*>(user_data); + + if (vm_data->scope_stack.empty()) { + return lauf_runtime_panic(process, "scope stack empty"); + } + + vstack_ptr--; + vstack_ptr[0].as_native_ptr = vm_data->scope_stack.top(); LAUF_RUNTIME_BUILTIN_DISPATCH; } diff --git a/src/openvic-simulation/vm/Builtin.hpp b/src/openvic-simulation/vm/Builtin.hpp index 9f72350..342acee 100644 --- a/src/openvic-simulation/vm/Builtin.hpp +++ b/src/openvic-simulation/vm/Builtin.hpp @@ -1,10 +1,31 @@ #pragma once #include <cstdint> +#include <stack> #include <variant> -#include "InstanceManager.hpp" +#include "GameManager.hpp" +#include "country/CountryDefinition.hpp" +#include "economy/BuildingType.hpp" +#include "map/Crime.hpp" +#include "map/ProvinceDefinition.hpp" +#include "map/State.hpp" +#include "military/Leader.hpp" +#include "military/LeaderTrait.hpp" +#include "military/UnitType.hpp" +#include "misc/Event.hpp" +#include "misc/Modifier.hpp" +#include "politics/Government.hpp" +#include "politics/Ideology.hpp" +#include "politics/Issue.hpp" +#include "politics/NationalValue.hpp" +#include "pop/Culture.hpp" +#include "pop/Pop.hpp" +#include "pop/Religion.hpp" +#include "research/Technology.hpp" #include "types/fixed_point/FixedPoint.hpp" +#include <lauf/runtime/memory.h> +#include <lauf/runtime/value.h> extern "C" { typedef struct lauf_runtime_builtin lauf_runtime_builtin; @@ -28,24 +49,55 @@ extern "C" { // As above, but translates to a C string. extern const lauf_runtime_builtin translate_address_to_string; - // This builtin takes three arguments: + // This builtin takes one argument: // * vstack_ptr[0] is a uint for the position of the pointer variant in scope_references // Returns scope native pointer - extern const lauf_runtime_builtin load_scope_ptr; + extern const lauf_runtime_builtin load_static_scope_ptr; + + // This builtin takes two arguments: + // * vstack_ptr[0] is an address for the name of the scope + // * vstack_ptr[1] is the native pointer for the relative scope + // Returns scope native pointer + extern const lauf_runtime_builtin load_relative_scope_ptr; + + // This builtin takes one argument: + // * vstack_ptr[0] is the native pointer to push to the scope stack + extern const lauf_runtime_builtin push_current_scope; + + // This builtin takes no arguments and pops the current off the stack + extern const lauf_runtime_builtin pop_current_scope; + + // This builtin takes no arguments + // Returns scope native pointer + extern const lauf_runtime_builtin load_current_scope; } namespace OpenVic::Asm { - using scope_variant = std::variant<std::monostate>; + using scope_store_variant = std::variant< + std::monostate, // + // Actual scopes + const OpenVic::CountryDefinition*, const OpenVic::Region*, const OpenVic::ProvinceDefinition*, OpenVic::Pop*, // + // Variant data for scope-like behavior + const OpenVic::Continent*, const OpenVic::PopType*, const OpenVic::UnitType*, const OpenVic::BuildingType*, // + const OpenVic::Crime*, const OpenVic::Culture*, const OpenVic::Religion*, const OpenVic::ReformGroup*, + const OpenVic::IssueGroup*, const OpenVic::Issue*, const OpenVic::Ideology*, const OpenVic::CountryParty*, + OpenVic::LeaderBase*, const OpenVic::LeaderTrait*, const OpenVic::Event* /*, trade good, resource*/, // + const OpenVic::Technology*, const OpenVic::GovernmentType* /*, casus belli */, + const OpenVic::NationalValue* + /*, variable, global flag, country flag */, + const OpenVic::Modifier* /*, province flag */ + >; struct argument { const char* key; union { const char* as_cstr; - const scope_variant* as_scope; + const scope_store_variant* as_scope; std::uint64_t as_uint; std::int64_t as_int; const void* as_ptr; + lauf_runtime_function_address as_function_address; } value; enum class type_t : std::uint8_t { // @@ -54,6 +106,7 @@ namespace OpenVic::Asm { uint, int_, ptr, + function_address, fixed_point } type; @@ -64,7 +117,7 @@ namespace OpenVic::Asm { return value.as_cstr; } - const scope_variant* val_scope() const { + const scope_store_variant* val_scope() const { if (type != type_t::scope) { return nullptr; } @@ -92,6 +145,13 @@ namespace OpenVic::Asm { return value.as_ptr; } + lauf_runtime_function_address val_func_addr() const { + if (type != type_t::function_address) { + return lauf_runtime_function_address_null; + } + return value.as_function_address; + } + OpenVic::fixed_point_t val_fixed() const { if (type != type_t::fixed_point) { return 0; @@ -103,7 +163,8 @@ namespace OpenVic::Asm { namespace OpenVic::Vm { struct VmUserData { - std::vector<Asm::scope_variant> scope_references; - InstanceManager* instance_manager; + std::vector<Asm::scope_store_variant> scope_refs; + std::stack<Asm::scope_store_variant*> scope_stack; + GameManager* game_manager; }; } diff --git a/src/openvic-simulation/vm/Codegen.cpp b/src/openvic-simulation/vm/Codegen.cpp index a31f6c5..a754e53 100644 --- a/src/openvic-simulation/vm/Codegen.cpp +++ b/src/openvic-simulation/vm/Codegen.cpp @@ -6,6 +6,7 @@ #include <cstring> #include <string_view> #include <unordered_map> +#include <variant> #include <openvic-dataloader/detail/SymbolIntern.hpp> #include <openvic-dataloader/detail/Utility.hpp> @@ -20,6 +21,7 @@ #include <range/v3/algorithm/equal.hpp> #include <range/v3/algorithm/reverse.hpp> +#include "GameManager.hpp" #include "types/fixed_point/FixedPoint.hpp" #include "vm/Builtin.hpp" #include <lauf/asm/builder.h> @@ -40,15 +42,15 @@ bool ichar_equals(char a, char b) { } Codegen::Codegen( - ovdl::v2script::Parser const& parser, OpenVic::InstanceManager* instance_manager, const char* module_name, + ovdl::v2script::Parser const& parser, OpenVic::GameManager* game_manager, const char* module_name, lauf_asm_build_options options ) - : _parser(parser), _instance_manager(instance_manager), _module(module_name), _builder(options) {} + : _parser(parser), _game_manager(game_manager), _module(module_name), _builder(options) {} Codegen::Codegen( - ovdl::v2script::Parser const& parser, OpenVic::InstanceManager* instance_manager, Module&& module, AsmBuilder&& builder + ovdl::v2script::Parser const& parser, OpenVic::GameManager* game_manager, Module&& module, AsmBuilder&& builder ) - : _parser(parser), _instance_manager(instance_manager), _module(std::move(module)), _builder(std::move(builder)) {} + : _parser(parser), _game_manager(game_manager), _module(std::move(module)), _builder(std::move(builder)) {} static constexpr auto any_ = "any_"sv; static constexpr auto all_ = "all_"sv; @@ -72,8 +74,7 @@ Codegen::scope_type Codegen::get_scope_type_for(scope_execution_type execution_t if (_parser.find_intern(#NAME##sv) == name) \ return SCOPE_TYPE - FIND_SCOPE(Generic, THIS); - FIND_SCOPE(Generic, FROM); + FIND_SCOPE(Generic, this); FIND_SCOPE(Generic, from); // Country and Pop Scope @@ -120,29 +121,74 @@ Codegen::scope_type Codegen::get_scope_type_for(scope_execution_type execution_t return None; } -void Codegen::generate_effect_from(scope_type type, Node* node) { +OpenVic::Asm::scope_store_variant Codegen::get_static_scope( // + scope_execution_type execution_type, scope_type active_scope_type, ovdl::symbol<char> name +) const { + auto name_sv = name.view(); + + auto country = + _game_manager->get_definition_manager().get_country_definition_manager().get_country_definition_by_identifier(name_sv); + if (country != nullptr) { + return country; + } + + auto state_region = _game_manager->get_definition_manager().get_map_definition().get_region_by_identifier(name_sv); + if (state_region != nullptr) { + return state_region; + } + + auto province = _game_manager->get_definition_manager().get_map_definition().get_province_definition_by_identifier(name_sv); + if (province != nullptr) { + return province; + } + + return {}; +} + +static constexpr auto random_ = "random_"sv; + +bool Codegen::supports_limit(scope_execution_type execution_type, scope_type active_scope_type, ovdl::symbol<char> name) const { + if (is_iterative_scope(execution_type, active_scope_type, name)) { + return true; + } + + if (std::strncmp(name.c_str(), random_.data(), random_.size()) == 0) { + return true; + } + + // TODO: decide limit support + return false; +} + +void Codegen::generate_effect_from(scope_type type, const Node* node) { struct current_scope_t { scope_type type; ovdl::symbol<char> symbol; } current_scope { .type = type, .symbol = {} }; bool is_arguments = false; - std::unordered_map<ovdl::symbol<char>, FlatValue const*, symbol_hash> named_arguments; + std::unordered_map<ovdl::symbol<char>, const Node*, symbol_hash> named_arguments; Asm::argument::type_t ov_asm_type; dryad::visit_tree( node, // [&](dryad::child_visitor<NodeKind> visitor, const AssignStatement* statement) { - auto const* left = dryad::node_try_cast<FlatValue>(statement->left()); + using enum Codegen::scope_execution_type; + + const auto* left = dryad::node_try_cast<FlatValue>(statement->left()); if (!left) { return; } - auto const* right = dryad::node_try_cast<FlatValue>(statement->right()); + const auto* right = dryad::node_try_cast<FlatValue>(statement->right()); if (is_arguments) { if (right) { named_arguments.insert_or_assign(left->value(), right); return; + } else if (supports_limit(Effect, current_scope.type, current_scope.symbol) && + _parser.find_intern("limit"sv) == left->value()) { + named_arguments.insert_or_assign(left->value(), statement->right()); + return; } // Boils war's attacker_goal = { casus_belli = [casus belli] } down to attacker_goal = [casus belli] @@ -163,7 +209,16 @@ void Codegen::generate_effect_from(scope_type type, Node* node) { lauf_asm_local* arguments = nullptr; if (!right) { - using enum Codegen::scope_execution_type; + if (_parser.find_intern("random"sv) == left->value()) { + // TODO: implement random + return; + } + + if (_parser.find_intern("random_list"sv) == left->value()) { + // TODO: implement random_list + return; + } + is_arguments = current_scope.type >> get_scope_type_for(Effect, left->value()); if (!is_arguments) { current_scope_t previous_scope = current_scope; @@ -211,7 +266,7 @@ void Codegen::generate_effect_from(scope_type type, Node* node) { // Load arguments address (vstack[2]) lauf_asm_inst_local_addr(*this, arguments); // Load scope address in lauf (vstack[1]) - push_instruction_for_keyword_scope(scope_execution_type::Effect, current_scope.type, current_scope.symbol); + push_instruction_for_scope(scope_execution_type::Effect, current_scope.type, current_scope.symbol); // Create effect name literal (vstack[0]) auto effect_name = lauf_asm_build_string_literal(*this, left->value().c_str()); lauf_asm_inst_global_addr(*this, effect_name); @@ -228,7 +283,7 @@ void Codegen::generate_effect_from(scope_type type, Node* node) { return; } - if (push_instruction_for_keyword_scope(scope_execution_type::Effect, current_scope.type, value->value())) { + if (push_instruction_for_scope(scope_execution_type::Effect, current_scope.type, value->value())) { ov_asm_type = scope; return; } @@ -259,16 +314,25 @@ void Codegen::generate_effect_from(scope_type type, Node* node) { } // Create argument string literal - auto argument_str = lauf_asm_build_string_literal(*this, value->value().c_str()); + auto argument_str = + lauf_asm_build_data_literal(*this, reinterpret_cast<const unsigned char*>(view.data()), view.size()); lauf_asm_inst_global_addr(*this, argument_str); ov_asm_type = cstring; + }, + [&](dryad::child_visitor<NodeKind> visitor, const ListValue* value) { + if (!is_arguments) { + visitor(value); + return; + } - // TODO: find/create and insert value here + auto limit_function = create_condition_function(current_scope.type, value); + lauf_asm_inst_function_addr(*this, limit_function); + ov_asm_type = Asm::argument::type_t::function_address; } ); } -void Codegen::generate_condition_from(scope_type type, Node* node) { +void Codegen::generate_condition_from(scope_type type, const Node* node) { struct current_scope_t { scope_type type; ovdl::symbol<char> symbol; @@ -306,25 +370,47 @@ void Codegen::generate_condition_from(scope_type type, Node* node) { ); } -bool Codegen::push_instruction_for_keyword_scope( +bool Codegen::push_instruction_for_scope( scope_execution_type execution_type, scope_type type, ovdl::symbol<char> scope_symbol ) { if (type >> get_scope_type_for(execution_type, scope_symbol)) { - lauf_asm_inst_uint(*this, _scope_references.size()); - _scope_references.push_back(get_scope_for(execution_type, type, scope_symbol)); - // TODO: push scope into _scope_references - lauf_asm_inst_call_builtin(*this, load_scope_ptr); + if (auto static_scope = get_static_scope(execution_type, type, scope_symbol); + !std::holds_alternative<std::monostate>(static_scope)) { + lauf_asm_inst_uint(*this, _scope_definitions.size()); + _scope_definitions.push_back(std::move(static_scope)); + lauf_asm_inst_call_builtin(*this, load_static_scope_ptr); + return true; + } + +#define SCOPE_LIST(END) \ + X(from) \ + X(this) \ + X(year) \ + X(month) \ + X(has_global_flag) \ + X(is_canal_enabled) \ + END + +#define X(SCOPE_NAME) _parser.find_intern(#SCOPE_NAME##sv) == scope_symbol || + + if (SCOPE_LIST(false)) { + lauf_asm_inst_null(*this); + } else { + lauf_asm_inst_call_builtin(*this, load_current_scope); + } + +#undef X +#undef SCOPE_LIST + + auto scope_str = lauf_asm_build_string_literal(*this, scope_symbol.c_str()); + lauf_asm_inst_global_addr(*this, scope_str); + lauf_asm_inst_call_builtin(*this, load_relative_scope_ptr); + return true; } return false; } -OpenVic::Asm::scope_variant Codegen::get_scope_for( // - scope_execution_type execution_type, scope_type type, ovdl::symbol<char> scope_symbol -) const { - return {}; -} - static constexpr lauf_asm_layout ov_asm_argument_layout[] = { LAUF_ASM_NATIVE_LAYOUT_OF(OpenVic::Asm::argument::key), LAUF_ASM_NATIVE_LAYOUT_OF(OpenVic::Asm::argument::type), LAUF_ASM_NATIVE_LAYOUT_OF(OpenVic::Asm::argument::value) }; @@ -373,11 +459,14 @@ bool Codegen::inst_store_ov_asm_value_from_vstack(lauf_asm_local* local, std::si case cstring: // Translate key literal to cstring lauf_asm_inst_call_builtin(*this, translate_address_to_string); + break; case ptr: // Translate address to pointer lauf_asm_inst_call_builtin(*this, translate_address_to_pointer); + break; case scope: // Scope pointer is already native + case function_address: case uint: case int_: case fixed_point: diff --git a/src/openvic-simulation/vm/Codegen.hpp b/src/openvic-simulation/vm/Codegen.hpp index e7caee0..f8629e8 100644 --- a/src/openvic-simulation/vm/Codegen.hpp +++ b/src/openvic-simulation/vm/Codegen.hpp @@ -7,7 +7,7 @@ #include <openvic-dataloader/v2script/Parser.hpp> #include "AsmBuilder.hpp" -#include "InstanceManager.hpp" +#include "GameManager.hpp" #include "Module.hpp" #include "types/EnumBitfield.hpp" #include "vm/Builtin.hpp" @@ -18,11 +18,11 @@ namespace OpenVic::Vm { struct Codegen { Codegen( - ovdl::v2script::Parser const& parser, InstanceManager* instance_manager, const char* module_name, + ovdl::v2script::Parser const& parser, GameManager* instance_manager, const char* module_name, lauf_asm_build_options options = lauf_asm_default_build_options ); - Codegen(ovdl::v2script::Parser const& parser, InstanceManager* instance_manager, Module&& module, AsmBuilder&& builder); + Codegen(ovdl::v2script::Parser const& parser, GameManager* instance_manager, Module&& module, AsmBuilder&& builder); operator lauf_asm_module*() { return _module; @@ -57,7 +57,7 @@ namespace OpenVic::Vm { } OpenVicVirtualMachine create_virtual_machine() && { - return { _instance_manager, std::move(_scope_references) }; + return { _game_manager, std::move(_scope_definitions) }; } lauf_asm_block* create_block(size_t input_count) { @@ -89,24 +89,24 @@ namespace OpenVic::Vm { is_iterative_scope(scope_execution_type execution_type, scope_type active_scope_type, ovdl::symbol<char> name) const; scope_type get_scope_type_for(scope_execution_type execution_type, ovdl::symbol<char> name) const; - lauf_asm_function* create_effect_function(scope_type type, ovdl::v2script::ast::Node* node); - lauf_asm_function* create_condition_function(scope_type type, ovdl::v2script::ast::Node* node); + OpenVic::Asm::scope_store_variant get_static_scope( // + scope_execution_type execution_type, scope_type active_scope_type, ovdl::symbol<char> name + ) const; + + bool supports_limit(scope_execution_type execution_type, scope_type active_scope_type, ovdl::symbol<char> name) const; + + lauf_asm_function* create_effect_function(scope_type type, const ovdl::v2script::ast::Node* node); + lauf_asm_function* create_condition_function(scope_type type, const ovdl::v2script::ast::Node* node); - void generate_effect_from(scope_type type, ovdl::v2script::ast::Node* node); - void generate_condition_from(scope_type type, ovdl::v2script::ast::Node* node); + void generate_effect_from(scope_type type, const ovdl::v2script::ast::Node* node); + void generate_condition_from(scope_type type, const ovdl::v2script::ast::Node* node); bool inst_store_ov_asm_key_null(lauf_asm_local* local, std::size_t index); bool inst_store_ov_asm_key(lauf_asm_local* local, std::size_t index, ovdl::symbol<char> key); bool inst_store_ov_asm_value_from_vstack(lauf_asm_local* local, std::size_t index, std::uint8_t type); bool inst_store_ov_asm_type(lauf_asm_local* local, std::size_t index, std::uint8_t type); - bool push_instruction_for_keyword_scope( - scope_execution_type execution_type, scope_type type, ovdl::symbol<char> scope_symbol - ); - - Asm::scope_variant get_scope_for( // - scope_execution_type execution_type, scope_type type, ovdl::symbol<char> scope_symbol - ) const; + bool push_instruction_for_scope(scope_execution_type execution_type, scope_type type, ovdl::symbol<char> scope_symbol); // Bytecode instructions // void inst_push_scope_this(); @@ -193,8 +193,8 @@ namespace OpenVic::Vm { }; private: - std::vector<OpenVic::Asm::scope_variant> _scope_references; - InstanceManager* _instance_manager; + std::vector<OpenVic::Asm::scope_store_variant> _scope_definitions; + GameManager* _game_manager; Module _module; AsmBuilder _builder; ovdl::v2script::Parser const& _parser; diff --git a/src/openvic-simulation/vm/VirtualMachine.hpp b/src/openvic-simulation/vm/VirtualMachine.hpp index b92fb6c..482c649 100644 --- a/src/openvic-simulation/vm/VirtualMachine.hpp +++ b/src/openvic-simulation/vm/VirtualMachine.hpp @@ -2,7 +2,7 @@ #include <vector> -#include "InstanceManager.hpp" +#include "GameManager.hpp" #include "RuntimeProcess.hpp" #include "Utility.hpp" #include "vm/Builtin.hpp" @@ -33,15 +33,15 @@ namespace OpenVic::Vm { using VirtualMachine::operator=; OpenVicVirtualMachine( - InstanceManager* instance_manager, std::vector<Asm::scope_variant>&& scope_references, + GameManager* game_manager, std::vector<Asm::scope_store_variant>&& scope_references, lauf_vm_options options = lauf_default_vm_options ) : VirtualMachine([&] { options.user_data = &user_data; return options; }()) { - user_data.scope_references = std::move(scope_references); - user_data.instance_manager = instance_manager; + user_data.scope_dict_refs = std::move(scope_references); + user_data.game_manager = game_manager; } private: |