From 70a4782913d981b5346146f8f36992b71e88ee86 Mon Sep 17 00:00:00 2001 From: Spartan322 Date: Tue, 6 Aug 2024 10:18:58 -0400 Subject: More WIP --- src/openvic-simulation/vm/Codegen.cpp | 676 ++++++++++++++++++++++++++++------ src/openvic-simulation/vm/Codegen.hpp | 45 ++- 2 files changed, 597 insertions(+), 124 deletions(-) diff --git a/src/openvic-simulation/vm/Codegen.cpp b/src/openvic-simulation/vm/Codegen.cpp index 675bc2c..34a1093 100644 --- a/src/openvic-simulation/vm/Codegen.cpp +++ b/src/openvic-simulation/vm/Codegen.cpp @@ -1,19 +1,34 @@ #include "Codegen.hpp" +#include // IWYU pragma: keep #include +#include #include #include +#include +#include +#include +#include #include #include +#include #include #include #include +#include +#include "InstanceManager.hpp" +#include "types/fixed_point/FixedPoint.hpp" #include +#include +#include +#include +#include +#include using namespace OpenVic::Vm; using namespace ovdl::v2script::ast; @@ -25,160 +40,418 @@ bool ichar_equals(char a, char b) { return std::tolower(static_cast(a)) == std::tolower(static_cast(b)); } -Codegen::Codegen(ovdl::v2script::Parser const& parser, const char* module_name, lauf_asm_build_options options) - : _parser(parser), _module(module_name), _builder(options) { - intern_scopes(); +using scope_variant = std::variant; +using argument_variant = std::variant; +using argument_map = std::unordered_map; + +static constexpr auto argument_size = 32; + +struct ov_asm_argument { + const char* key; + + union { + const char* as_cstr; + const scope_variant* as_scope; + std::uint64_t as_uint; + std::int64_t as_int; + const void* as_ptr; + } value; + + enum class type_t : std::uint8_t { // + cstring, + scope, + uint, + int_, + ptr, + fixed_point + } type; + + const char* val_cstr() const { + if (type != type_t::cstring) { + return nullptr; + } + return value.as_cstr; + } + + const scope_variant* val_scope() const { + if (type != type_t::scope) { + return nullptr; + } + return value.as_scope; + } + + std::uint64_t val_uint() const { + if (type != type_t::uint) { + return 0; + } + return value.as_uint; + } + + std::int64_t val_int() const { + if (type != type_t::int_) { + return 0; + } + return value.as_int; + } + + const void* val_ptr() const { + if (type != type_t::ptr) { + return nullptr; + } + return value.as_ptr; + } + + OpenVic::fixed_point_t val_fixed() const { + if (type != type_t::fixed_point) { + return 0; + } + return OpenVic::fixed_point_t(value.as_int); + } +}; + +bool execute_effect( + OpenVic::InstanceManager* instance_manager, const char* effect_id, scope_variant& scope, ov_asm_argument*, + std::size_t arg_count +) { + return true; } -Codegen::Codegen(ovdl::v2script::Parser const& parser, Module&& module, AsmBuilder&& builder) - : _parser(parser), _module(std::move(module)), _builder(std::move(builder)) { - intern_scopes(); +ov_asm_argument arguments[argument_size]; + +// This builtin takes three arguments: +// * vstack_ptr[0] is an address of the name of the effect +// * vstack_ptr[1] is an address of the scope reference to apply the effect by +// * vstack_ptr[2] is an address to an array of pointers to the arguments for the effect +LAUF_RUNTIME_BUILTIN(call_effect, 3, 0, LAUF_RUNTIME_BUILTIN_DEFAULT, "call_effect", nullptr) { + auto user_data = lauf_runtime_get_vm_user_data(process); + if (user_data == nullptr) { + return lauf_runtime_panic(process, "invalid user data"); + } + + auto effect_name_addr = vstack_ptr[0].as_address; + auto scope_addr = vstack_ptr[1].as_address; + auto argument_array_addr = vstack_ptr[2].as_address; + + auto effect_name = lauf_runtime_get_cstr(process, effect_name_addr); + if (effect_name == nullptr) { + return lauf_runtime_panic(process, "invalid effect name address"); + } + + auto scope_ptr = lauf_runtime_get_mut_ptr(process, scope_addr, { 0, 1 }); + if (scope_ptr == nullptr) { + return lauf_runtime_panic(process, "invalid scope address"); + } + + lauf_runtime_allocation array_allocation; + if (!lauf_runtime_get_allocation(process, argument_array_addr, &array_allocation)) { + return lauf_runtime_panic(process, "invalid arguments address"); + } + + std::size_t count = array_allocation.size / lauf_asm_type_value.layout.size; + if (count > argument_size) { + return lauf_runtime_panic(process, "too many arguments"); + } + + auto argument_array = static_cast(lauf_runtime_get_mut_ptr(process, argument_array_addr, { 1, 1 })); + + if (!execute_effect( + static_cast(user_data), effect_name, *static_cast(scope_ptr), + argument_array, count + )) { + return lauf_runtime_panic(process, "effect could not be found"); + } + + vstack_ptr += 3; + LAUF_RUNTIME_BUILTIN_DISPATCH; } -void Codegen::intern_scopes() { - _has_top_level_province_scopes = static_cast(_parser.find_intern("province_event"sv)); - _has_top_level_country_scopes = static_cast(_parser.find_intern("country_event"sv)) || - static_cast(_parser.find_intern("political_decisions"sv)); +// This builtin takes three arguments: +// * vstack_ptr[0] is an address of the name of the trigger +// * vstack_ptr[1] is an address of the scope to apply the trigger by +// * vstack_ptr[2] is an address to an array of pointers to the arguments for the trigger +// Returns whether the trigger evaluated to true +LAUF_RUNTIME_BUILTIN(call_trigger, 3, 1, LAUF_RUNTIME_BUILTIN_DEFAULT, "call_trigger", &call_effect) { + auto effect_name_addr = vstack_ptr[0].as_address; + auto scope_addr = vstack_ptr[1].as_address; + auto argument_array_addr = vstack_ptr[2].as_address; -#define PUSH_INTERN(CONTAINTER, NAME) \ - [&](auto&& scope_name) { \ - if (scope_name) \ - CONTAINTER.insert(scope_name); \ - }(_parser.find_intern(#NAME##sv)) + auto effect_name = lauf_runtime_get_cstr(process, effect_name_addr); + if (effect_name == nullptr) { + return lauf_runtime_panic(process, "invalid address"); + } - PUSH_INTERN(_all_scopes, THIS); - PUSH_INTERN(_all_scopes, FROM); - PUSH_INTERN(_all_scopes, from); - PUSH_INTERN(_all_scopes, cultural_union); - // Country Scope - PUSH_INTERN(_country_scopes, capital_scope); - PUSH_INTERN(_country_scopes, overlord); - PUSH_INTERN(_country_scopes, sphere_owner); - // Country Scope Random - PUSH_INTERN(_country_scopes, random_country); - PUSH_INTERN(_country_scopes, random_owned); - PUSH_INTERN(_country_scopes, random_pop); - // Country Scope Iterative - PUSH_INTERN(_country_scopes, all_core); - PUSH_INTERN(_country_scopes, any_country); - PUSH_INTERN(_country_scopes, any_core); - PUSH_INTERN(_country_scopes, any_greater_power); - PUSH_INTERN(_country_scopes, any_neighbor_country); - PUSH_INTERN(_country_scopes, any_owned_province); - PUSH_INTERN(_country_scopes, any_pop); - PUSH_INTERN(_country_scopes, any_sphere_member); - PUSH_INTERN(_country_scopes, any_state); - PUSH_INTERN(_country_scopes, any_substate); - PUSH_INTERN(_country_scopes, war_countries); + auto argument_addresses = + static_cast(lauf_runtime_get_mut_ptr(process, argument_array_addr, { 1, 1 })); - // Province Scope - PUSH_INTERN(_province_scopes, controller); - PUSH_INTERN(_province_scopes, owner); - PUSH_INTERN(_province_scopes, state_scope); - // Province Scope Random - PUSH_INTERN(_province_scopes, random_neighbor_province); - PUSH_INTERN(_province_scopes, random_empty_neighbor_province); - // Province Scope Iterative - PUSH_INTERN(_province_scopes, any_core); - PUSH_INTERN(_province_scopes, any_neighbor_province); - PUSH_INTERN(_province_scopes, any_pop); + // TODO: call trigger by name - // Pop Scope - PUSH_INTERN(_pop_scopes, country); - PUSH_INTERN(_pop_scopes, location); + vstack_ptr[0].as_sint = 1; + vstack_ptr += 2; + LAUF_RUNTIME_BUILTIN_DISPATCH; +} -#undef PUSH_INTERN +// Translates a lauf address into the native pointer representation. +// It takes one argument, which is the address, and returns one argument, which is the pointer. +LAUF_RUNTIME_BUILTIN( + translate_address_to_pointer, 1, 1, LAUF_RUNTIME_BUILTIN_DEFAULT, "translate_address_to_pointer", &call_trigger +) { + auto address = vstack_ptr[0].as_address; + + auto ptr = lauf_runtime_get_const_ptr(process, address, { 0, 1 }); + if (ptr == nullptr) { + return lauf_runtime_panic(process, "invalid address"); + } + vstack_ptr[0].as_native_ptr = (void*)ptr; + + LAUF_RUNTIME_BUILTIN_DISPATCH; } +// As above, but translates to a C string. +LAUF_RUNTIME_BUILTIN( + translate_address_to_string, 1, 1, LAUF_RUNTIME_BUILTIN_DEFAULT, "translate_address_to_string", + &translate_address_to_pointer +) { + auto address = vstack_ptr[0].as_address; + + auto ptr = lauf_runtime_get_cstr(process, address); + if (ptr == nullptr) { + return lauf_runtime_panic(process, "invalid address"); + } + vstack_ptr[0].as_native_ptr = (void*)ptr; + + LAUF_RUNTIME_BUILTIN_DISPATCH; +} + +Codegen::Codegen(ovdl::v2script::Parser const& parser, const char* module_name, lauf_asm_build_options options) + : _parser(parser), _module(module_name), _builder(options) {} -constexpr auto any_ = "any_"sv; -constexpr auto all_ = "all_"sv; -constexpr auto war_countries = "war_countries"sv; +Codegen::Codegen(ovdl::v2script::Parser const& parser, Module&& module, AsmBuilder&& builder) + : _parser(parser), _module(std::move(module)), _builder(std::move(builder)) {} + +static constexpr auto any_ = "any_"sv; +static constexpr auto all_ = "all_"sv; +static constexpr auto war_countries = "war_countries"sv; -bool Codegen::is_iterative_scope(scope_execution_type execution_type, scope_type active_scope, ovdl::symbol name) const { +bool Codegen::is_iterative_scope(scope_execution_type execution_type, scope_type active_scope_type, ovdl::symbol name) + const { return std::strncmp(name.c_str(), any_.data(), any_.size()) == 0 || std::strncmp(name.c_str(), all_.data(), all_.size()) == 0 || std::strncmp(name.c_str(), war_countries.data(), war_countries.size()) == 0; } -bool Codegen::is_scope_for(scope_execution_type execution_type, scope_type active_scope, ovdl::symbol name) const { - if (_all_scopes.contains(name)) { - return true; - } +Codegen::scope_type Codegen::get_scope_type_for(scope_execution_type execution_type, ovdl::symbol name) const { + using enum scope_type; - switch (active_scope) { - case scope_type::Country: - if (_country_scopes.contains(name)) { - return true; - } - break; - case scope_type::State: break; - case scope_type::Province: - if (_province_scopes.contains(name)) { - return true; - } - break; - case scope_type::Pop: - if (_pop_scopes.contains(name)) { - return true; - } - break; - } +#define FIND_SCOPE(SCOPE_TYPE, NAME) \ + if (_parser.find_intern(#NAME##sv) == name) \ + return SCOPE_TYPE - return false; + FIND_SCOPE(Generic, THIS); + FIND_SCOPE(Generic, FROM); + FIND_SCOPE(Generic, from); + + // Country and Pop Scope + FIND_SCOPE(Country | Pop, cultural_union); + + // Country Scope + FIND_SCOPE(Country, capital_scope); + FIND_SCOPE(Country, overlord); + FIND_SCOPE(Country, sphere_owner); + // Country Scope Random + FIND_SCOPE(Country, random_country); + FIND_SCOPE(Country, random_owned); + FIND_SCOPE(Country, random_pop); + // Country Scope Iterative + FIND_SCOPE(Country, all_core); + FIND_SCOPE(Country, any_country); + FIND_SCOPE(Country, any_core); + FIND_SCOPE(Country, any_greater_power); + FIND_SCOPE(Country, any_neighbor_country); + FIND_SCOPE(Country, any_owned_province); + FIND_SCOPE(Country, any_pop); + FIND_SCOPE(Country, any_sphere_member); + FIND_SCOPE(Country, any_state); + FIND_SCOPE(Country, any_substate); + FIND_SCOPE(Country, war_countries); + + // Province Scope + FIND_SCOPE(Province, controller); + FIND_SCOPE(Province, owner); + FIND_SCOPE(Province, state_scope); + // Province Scope Random + FIND_SCOPE(Province, random_neighbor_province); + FIND_SCOPE(Province, random_empty_neighbor_province); + // Province Scope Iterative + FIND_SCOPE(Province, any_core); + FIND_SCOPE(Province, any_neighbor_province); + FIND_SCOPE(Province, any_pop); + + // Pop Scope + FIND_SCOPE(Pop, country); + FIND_SCOPE(Pop, location); + +#undef FIND_SCOPE + return None; } -void Codegen::generate_effect_from(Codegen::scope_type type, Node* node) { - bool is_prepping_args = false; - Codegen::scope_type current_scope = type; - tsl::ordered_map prepped_arguments; +void Codegen::generate_effect_from(scope_type type, Node* node) { + struct current_scope_t { + scope_type type; + ovdl::symbol symbol; + } current_scope { .type = type, .symbol = {} }; + + bool is_arguments = false; + std::unordered_map, FlatValue const*, symbol_hash> named_arguments; + ov_asm_argument::type_t ov_asm_type; dryad::visit_tree( node, // - [&](dryad::child_visitor visitor, AssignStatement* statement) { + [&](dryad::child_visitor visitor, const AssignStatement* statement) { auto const* left = dryad::node_try_cast(statement->left()); if (!left) { return; } - if (is_prepping_args) { - visitor(statement->right()); + auto const* right = dryad::node_try_cast(statement->right()); + if (is_arguments) { + if (right) { + named_arguments.insert_or_assign(left->value(), right); + return; + } + + // Boils war's attacker_goal = { casus_belli = [casus belli] } down to attacker_goal = [casus belli] + if (auto right_list = dryad::node_try_cast(statement->right())) { + if (right_list->statements().empty()) { + return; + } + if (auto right_statement = dryad::node_try_cast(right_list->statements().front())) { + if (auto right_flat_value = dryad::node_try_cast(right_statement->right())) { + named_arguments.insert_or_assign(left->value(), right_flat_value); + } + } + } return; } - auto const* right = dryad::node_try_cast(statement->right()); + bool is_iterative = false; + lauf_asm_local* arguments = nullptr; + if (!right) { using enum Codegen::scope_execution_type; - bool is_iterative = is_iterative_scope(Effect, current_scope, left->value()); - if (is_iterative) {} - is_prepping_args = is_scope_for(Effect, current_scope, left->value()); + is_arguments = current_scope.type >> get_scope_type_for(Effect, left->value()); + if (!is_arguments) { + current_scope_t previous_scope = current_scope; + current_scope.symbol = left->value(); + visitor(right); + current_scope = previous_scope; + return; + } + + is_iterative = is_iterative_scope(Effect, current_scope.type, current_scope.symbol); + if (is_iterative) { + // TODO: loop header + } + + // TODO: build arguments from named_arguments + + arguments = lauf_asm_build_local( + _builder, lauf_asm_array_layout(LAUF_ASM_NATIVE_LAYOUT_OF(ov_asm_argument), named_arguments.size()) + ); + + std::size_t index = 0; + for (auto&& [key, value] : named_arguments) { + inst_store_ov_asm_key(arguments, index, key); + + visitor(value); + inst_store_ov_asm_value_from_vstack(arguments, index, ovdl::detail::to_underlying(ov_asm_type)); + + inst_store_ov_asm_type(arguments, index, ovdl::detail::to_underlying(ov_asm_type)); + index++; + } + + named_arguments.clear(); + is_arguments = false; + } else if (auto yes_symbol = _parser.find_intern("yes"sv); yes_symbol && right->value() == yes_symbol) { + // Build empty arguments + arguments = lauf_asm_build_local(_builder, lauf_asm_array_layout(lauf_asm_type_value.layout, 0)); + } else if (_parser.find_intern("no"sv) != right->value()) { + arguments = lauf_asm_build_local(_builder, lauf_asm_array_layout(lauf_asm_type_value.layout, 1)); + inst_store_ov_asm_key_null(arguments, 0); + visitor(right); - if (is_iterative) {} - } else if (ranges::equal(right->value().view(), "yes"sv, ichar_equals)) { - // TODO: insert vic2 bytecode scope object address here - // TODO: calls a builtin for Victoria 2 effects? - } else if (!ranges::equal(right->value().view(), "no"sv, ichar_equals)) { - // TODO: single argument execution + inst_store_ov_asm_value_from_vstack(arguments, 0, ovdl::detail::to_underlying(ov_asm_type)); + + inst_store_ov_asm_type(arguments, 0, ovdl::detail::to_underlying(ov_asm_type)); + } + + // Load arguments address (vstack[2]) + lauf_asm_inst_local_addr(_builder, arguments); + // Load scope address in lauf (vstack[1]) + push_instruction_for_scope(current_scope.type, current_scope.symbol); + // Create effect name literal (vstack[0]) + auto effect_name = lauf_asm_build_string_literal(_builder, left->value().c_str()); + lauf_asm_inst_global_addr(_builder, effect_name); + // Consumes vstack[0], vstack[1], and vstack[2] + lauf_asm_inst_call_builtin(_builder, call_effect); + + if (is_iterative) { + // TODO: loop footer } }, - [&](FlatValue* value) { - // TODO: handle right side - }, - [&](dryad::traverse_event ev, ListValue* value) { - if (is_prepping_args && ev == dryad::traverse_event::exit) { - // TODO: arguments have been prepared, call effect function - is_prepping_args = false; - } else if (!is_prepping_args && ev == dryad::traverse_event::enter) { - // TODO: this is a scope + [&](const FlatValue* value) { + using enum ov_asm_argument::type_t; + if (!is_arguments) { + return; + } + + if (push_instruction_for_scope(current_scope.type, value->value())) { + ov_asm_type = scope; + return; } + + auto view = value->value().view(); + if (view[0] == '-') { + if (std::int64_t value; std::from_chars(view.begin(), view.end(), value).ptr == view.end()) { + lauf_asm_inst_sint(_builder, value); + ov_asm_type = int_; + return; + } + } + + if (std::uint64_t value; std::from_chars(view.begin(), view.end(), value).ptr == view.end()) { + lauf_asm_inst_uint(_builder, value); + ov_asm_type = uint; + return; + } + + { + bool success; + auto value = fixed_point_t::parse(view, &success); + if (success) { + lauf_asm_inst_sint(_builder, value.get_raw_value()); + ov_asm_type = fixed_point; + return; + } + } + + // Create argument string literal + auto argument_str = lauf_asm_build_string_literal(_builder, value->value().c_str()); + lauf_asm_inst_global_addr(_builder, argument_str); + ov_asm_type = cstring; + + // TODO: find/create and insert value here } ); } -void Codegen::generate_condition_from(Codegen::scope_type type, Node* node) { +void Codegen::generate_condition_from(scope_type type, Node* node) { + struct current_scope_t { + scope_type type; + ovdl::symbol symbol; + } current_scope { .type = type, .symbol = {} }; + bool is_prepping_args = false; - Codegen::scope_type current_scope = type; tsl::ordered_map prepped_arguments; dryad::visit_tree( @@ -192,15 +465,15 @@ void Codegen::generate_condition_from(Codegen::scope_type type, Node* node) { auto const* right = dryad::node_try_cast(statement->right()); if (!right) { using enum Codegen::scope_execution_type; - bool is_iterative = is_iterative_scope(Trigger, current_scope, left->value()); + bool is_iterative = is_iterative_scope(Trigger, current_scope.type, current_scope.symbol); if (is_iterative) {} - is_prepping_args = is_scope_for(Trigger, current_scope, left->value()); + is_prepping_args = current_scope.type >> get_scope_type_for(Trigger, current_scope.symbol); visitor(right); if (is_iterative) {} - } else if (ranges::equal(right->value().view(), "yes"sv, ichar_equals)) { + } else if (auto yes_symbol = _parser.find_intern("yes"sv); yes_symbol && right->value() == yes_symbol) { // TODO: insert vic2 bytecode scope object address here // TODO: calls a builtin for Victoria 2 triggers? - } else if (!ranges::equal(right->value().view(), "no"sv, ichar_equals)) { + } else if (_parser.find_intern("no"sv) != right->value()) { // TODO: single argument execution } }, @@ -209,3 +482,180 @@ void Codegen::generate_condition_from(Codegen::scope_type type, Node* node) { } ); } + +bool Codegen::push_instruction_for_scope(scope_type type, ovdl::symbol scope_symbol) { + + auto is_scope = [&](std::string_view name) -> bool { + auto intern = _parser.find_intern(name); + return intern && intern == scope_symbol; + }; + + if (is_scope("this"sv)) { + inst_push_scope_this(); + return true; + } else if (is_scope("from"sv)) { + inst_push_scope_from(); + return true; + } else if (is_scope("cultural_union"sv)) { + DRYAD_PRECONDITION(std::has_single_bit(ovdl::detail::to_underlying(type))); + switch (type) { + case scope_type::Country: // + inst_push_get_country_cultural_union(); + return true; + case scope_type::State: // + inst_push_get_state_cultural_union(); + return true; + case scope_type::Province: // + DRYAD_ASSERT(false, "province scope does not support cultural_union scope"); + break; + case scope_type::Pop: // + inst_push_get_pop_cultural_union(); + return true; + default: return false; + } + } else { + DRYAD_PRECONDITION(std::has_single_bit(ovdl::detail::to_underlying(type))); + switch (type) { + case scope_type::Country: + if (is_scope("capital_scope"sv)) { + inst_push_get_country_capital(); + return true; + } else if (is_scope("overlord"sv)) { + inst_push_get_country_overlord(); + return true; + } else if (is_scope("sphere_owner"sv)) { + inst_push_get_country_sphere_owner(); + return true; + } else if (is_scope("random_country"sv)) { + inst_push_get_random_country(); + return true; + } else if (is_scope("random_owned"sv)) { + inst_push_get_random_owned(); + return true; + } else if (is_scope("random_pop"sv)) { + } + break; + case scope_type::State: break; + case scope_type::Province: + if (is_scope("controller"sv)) { + inst_push_get_province_controller(); + return true; + } else if (is_scope("owner"sv)) { + inst_push_get_province_owner(); + return true; + } else if (is_scope("state_scope"sv)) { + inst_push_get_province_state(); + return true; + } else if (is_scope("random_neighbor_province"sv)) { + inst_push_get_random_neighbor_province(); + return true; + } else if (is_scope("random_empty_neighbor_province"sv)) { + inst_push_get_random_empty_neighbor_province(); + return true; + } + break; + case scope_type::Pop: + if (is_scope("country"sv)) { + inst_push_get_pop_country(); + return true; + } else if (is_scope("location"sv)) { + inst_push_get_pop_location(); + return true; + } + break; + default: return false; + } + } + return false; +} + +static constexpr lauf_asm_layout aggregate_layouts[] = { LAUF_ASM_NATIVE_LAYOUT_OF(ov_asm_argument::key), + LAUF_ASM_NATIVE_LAYOUT_OF(ov_asm_argument::type), + LAUF_ASM_NATIVE_LAYOUT_OF(ov_asm_argument::value) }; + +bool Codegen::inst_store_ov_asm_key_null(lauf_asm_local* local, std::size_t index) { + lauf_asm_inst_null(_builder); + // Start Load arguments // + // vstack[1] + lauf_asm_inst_local_addr(_builder, local); + // vstack[0] + lauf_asm_inst_uint(_builder, index); + // Consumes vstack[0] = arguments_index, vstack[1] = argument_key_address, produces array address as + // vstack[0] + lauf_asm_inst_array_element(_builder, lauf_asm_type_value.layout); + // End Load arguments // + lauf_asm_inst_aggregate_member(_builder, 0, aggregate_layouts, 3); + // Consumes vstack[0] and vstack[1] + lauf_asm_inst_store_field(_builder, lauf_asm_type_value, 0); + return true; +} + +bool Codegen::inst_store_ov_asm_key(lauf_asm_local* local, std::size_t index, ovdl::symbol key) { + // Create key literal + auto argument_key = lauf_asm_build_string_literal(_builder, key.c_str()); + lauf_asm_inst_global_addr(_builder, argument_key); + // Translate key literal to cstring + lauf_asm_inst_call_builtin(_builder, translate_address_to_string); + // Start Load arguments // + // vstack[1] + lauf_asm_inst_local_addr(_builder, local); + // vstack[0] + lauf_asm_inst_uint(_builder, index); + // Consumes vstack[0] = arguments_index, vstack[1] = argument_key_address, produces array address as + // vstack[0] + lauf_asm_inst_array_element(_builder, lauf_asm_type_value.layout); + // End Load arguments // + lauf_asm_inst_aggregate_member(_builder, 0, aggregate_layouts, 3); + // Consumes vstack[0] and vstack[1] + lauf_asm_inst_store_field(_builder, lauf_asm_type_value, 0); + return true; +} + +bool Codegen::inst_store_ov_asm_value_from_vstack(lauf_asm_local* local, std::size_t index, std::uint8_t type) { + switch (ovdl::detail::from_underlying(type)) { + using enum ov_asm_argument::type_t; + case cstring: + // Translate key literal to cstring + lauf_asm_inst_call_builtin(_builder, translate_address_to_string); + case scope: + case ptr: + // Translate address to pointer + lauf_asm_inst_call_builtin(_builder, translate_address_to_pointer); + case uint: + case int_: + case fixed_point: + // needs no translation + break; + } + + // Start Load arguments // + // vstack[1] + lauf_asm_inst_local_addr(_builder, local); + // vstack[0] + lauf_asm_inst_uint(_builder, index); + // Consumes vstack[0] = arguments_index, vstack[1] = argument_key_address, produces array address as + // vstack[0] + lauf_asm_inst_array_element(_builder, lauf_asm_type_value.layout); + // End Load arguments // + lauf_asm_inst_aggregate_member(_builder, 2, aggregate_layouts, 3); + // Consumes vstack[0] and vstack[1] + lauf_asm_inst_store_field(_builder, lauf_asm_type_value, 0); + return true; +} + +bool Codegen::inst_store_ov_asm_type(lauf_asm_local* local, std::size_t index, std::uint8_t type) { + lauf_asm_inst_uint(_builder, static_cast(type)); + // Start Load arguments // + // vstack[1] + lauf_asm_inst_local_addr(_builder, local); + // vstack[0] + lauf_asm_inst_uint(_builder, index); + // Consumes vstack[0] = arguments_index, vstack[1] = argument_key_address, produces array address as + // vstack[0] + lauf_asm_inst_array_element(_builder, lauf_asm_type_value.layout); + // End Load arguments // + lauf_asm_inst_aggregate_member(_builder, 1, aggregate_layouts, 3); + // Consumes vstack[0] and vstack[1] + lauf_asm_inst_store_field(_builder, lauf_asm_type_value, 0); + return true; +} diff --git a/src/openvic-simulation/vm/Codegen.hpp b/src/openvic-simulation/vm/Codegen.hpp index b50e5f7..c63ab9e 100644 --- a/src/openvic-simulation/vm/Codegen.hpp +++ b/src/openvic-simulation/vm/Codegen.hpp @@ -1,13 +1,12 @@ #pragma once -#include - #include #include #include #include "AsmBuilder.hpp" #include "Module.hpp" +#include "types/EnumBitfield.hpp" #include namespace OpenVic::Vm { @@ -51,8 +50,6 @@ namespace OpenVic::Vm { return _builder; } - void intern_scopes(); - lauf_asm_block* create_block(size_t input_count) { return lauf_asm_declare_block(_builder, input_count); } @@ -62,10 +59,25 @@ namespace OpenVic::Vm { } enum class scope_execution_type : std::uint8_t { Effect, Trigger }; - enum class scope_type : std::uint8_t { Country, State, Province, Pop }; + enum class scope_type : std::uint8_t { + None = 0, + Country = 1 << 0, + State = 1 << 1, + Province = 1 << 2, + Pop = 1 << 3, + + Generic = Country | State | Province | Pop, + }; + + enum class trigger_modifier : std::uint8_t { // + Not = 1 << 0, + And = 1 << 1, + Or = 1 << 2, + }; - bool is_iterative_scope(scope_execution_type execution_type, scope_type active_scope, ovdl::symbol name) const; - bool is_scope_for(scope_execution_type execution_type, scope_type active_scope, ovdl::symbol name) const; + bool + is_iterative_scope(scope_execution_type execution_type, scope_type active_scope_type, ovdl::symbol name) const; + scope_type get_scope_type_for(scope_execution_type execution_type, ovdl::symbol 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); @@ -73,6 +85,13 @@ namespace OpenVic::Vm { void generate_effect_from(scope_type type, ovdl::v2script::ast::Node* node); void generate_condition_from(scope_type type, 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 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_scope(scope_type type, ovdl::symbol scope_symbol); + // Bytecode instructions // void inst_push_scope_this(); void inst_push_scope_from(); @@ -86,6 +105,8 @@ namespace OpenVic::Vm { void inst_push_get_province_owner(); void inst_push_get_province_state(); + void inst_push_get_state_cultural_union(); + void inst_push_get_pop_location(); void inst_push_get_pop_country(); void inst_push_get_pop_cultural_union(); @@ -158,11 +179,13 @@ namespace OpenVic::Vm { Module _module; AsmBuilder _builder; ovdl::v2script::Parser const& _parser; - std::unordered_set, symbol_hash> _all_scopes; - std::unordered_set, symbol_hash> _country_scopes; - std::unordered_set, symbol_hash> _province_scopes; - std::unordered_set, symbol_hash> _pop_scopes; bool _has_top_level_country_scopes; bool _has_top_level_province_scopes; }; } + +template<> +struct OpenVic::enable_bitfield : std::true_type {}; + +template<> +struct OpenVic::enable_bitfield : std::true_type {}; -- cgit v1.2.3-56-ga3b1