From 83f1cc97b9c13388464b5d6bd85aafc2bd637497 Mon Sep 17 00:00:00 2001 From: bog Date: Tue, 12 Sep 2023 17:37:52 +0200 Subject: [PATCH] FIX: now using unique addresses. --- meson.build | 1 + src/Addr.cpp | 19 +++++++++++++++++++ src/Addr.hpp | 22 ++++++++++++++++++++++ src/Compiler.cpp | 19 ++++++++----------- src/Compiler.hpp | 5 +++-- src/Function.cpp | 4 +++- src/Function.hpp | 5 ++++- src/VM.cpp | 18 ++++++++++++++---- src/Value.cpp | 5 +++-- src/Value.hpp | 4 +++- src/main.cpp | 5 ++++- 11 files changed, 84 insertions(+), 23 deletions(-) create mode 100644 src/Addr.cpp create mode 100644 src/Addr.hpp diff --git a/meson.build b/meson.build index 3ab52f5..809474b 100644 --- a/meson.build +++ b/meson.build @@ -31,6 +31,7 @@ grino_src = static_library('grino', 'src/StaticFunction.cpp', 'src/SymTable.cpp', 'src/Loader.cpp', + 'src/Addr.cpp', ]) grino_dep = declare_dependency(link_with: grino_src) diff --git a/src/Addr.cpp b/src/Addr.cpp new file mode 100644 index 0000000..2c76677 --- /dev/null +++ b/src/Addr.cpp @@ -0,0 +1,19 @@ +#include "Addr.hpp" + +namespace grino +{ + /*explicit*/ Addr::Addr() + { + } + + /*virtual*/ Addr::~Addr() + { + } + + size_t Addr::gen() + { + size_t addr = m_addr; + m_addr++; + return addr; + } +} diff --git a/src/Addr.hpp b/src/Addr.hpp new file mode 100644 index 0000000..725998b --- /dev/null +++ b/src/Addr.hpp @@ -0,0 +1,22 @@ +#ifndef grino_ADDR_HPP +#define grino_ADDR_HPP + +#include "commons.hpp" + +namespace grino +{ + class Addr + { + public: + explicit Addr(); + virtual ~Addr(); + + size_t current() const { return m_addr; } + size_t gen(); + + private: + size_t m_addr = 1; + }; +} + +#endif diff --git a/src/Compiler.cpp b/src/Compiler.cpp index 677d2eb..f7dfedc 100644 --- a/src/Compiler.cpp +++ b/src/Compiler.cpp @@ -6,8 +6,9 @@ namespace grino { - /*explicit*/ Compiler::Compiler(Logger& logger) + /*explicit*/ Compiler::Compiler(Logger& logger, Addr& addr) : m_logger { logger } + , m_addr { addr } { enter_scope(); } @@ -85,12 +86,13 @@ namespace grino auto params = node->child(0).lock(); enter_scope(true); + size_t base_addr = m_addr.current(); for (size_t i=0; isize(); i++) { auto param = params->child(i).lock(); std::string ident = param->repr(); - sym.declare(param->loc(), ident, get_local_address(), + sym.declare(param->loc(), ident, m_addr.gen(), m_scope.size()); } @@ -101,11 +103,12 @@ namespace grino name = m_decl_context.back(); } - sym.declare(node->loc(), name, get_local_address(), + sym.declare(node->loc(), name, m_addr.gen(), m_scope.size()); auto prog = std::make_shared(); auto body = node->child(1).lock(); + compile(body, *prog, sym); prog->push_instr(OPCODE_RET); @@ -114,7 +117,7 @@ namespace grino sym.purge(m_scope.size()); program.push_value(Value::make_program(node->loc(), prog)); - program.push_instr(OPCODE_MK_FUN); + program.push_instr(OPCODE_MK_FUN, base_addr); } break; case NODE_BOOL: { @@ -136,7 +139,7 @@ namespace grino case NODE_VARDECL: { std::string ident = node->child(0).lock()->repr(); auto expr = node->child(1).lock(); - size_t address = get_local_address(); + size_t address = m_addr.gen(); m_decl_context.push_back(ident); compile(expr, program, sym); @@ -186,12 +189,6 @@ namespace grino m_statics[name] = fun; } - size_t Compiler::get_local_address() - { - m_scope.back() += 1; - return m_scope.back() - 1; - } - void Compiler::enter_scope(bool reset) { if (m_scope.empty() || reset) diff --git a/src/Compiler.hpp b/src/Compiler.hpp index 5b505d2..629654e 100644 --- a/src/Compiler.hpp +++ b/src/Compiler.hpp @@ -5,6 +5,7 @@ #include "Logger.hpp" #include "Node.hpp" #include "src/mutils.hpp" +#include "Addr.hpp" namespace grino { @@ -17,7 +18,7 @@ namespace grino class Compiler { public: - explicit Compiler(Logger& logger); + explicit Compiler(Logger& logger, Addr& addr); virtual ~Compiler(); size_t scope() const { return m_scope.size(); } @@ -31,13 +32,13 @@ namespace grino private: Logger& m_logger; + Addr& m_addr; std::unordered_map> m_statics; std::vector m_scope; std::vector m_decl_context; - size_t get_local_address(); void enter_scope(bool reset=false); void leave_scope(); }; diff --git a/src/Function.cpp b/src/Function.cpp index e4d7638..27931cc 100644 --- a/src/Function.cpp +++ b/src/Function.cpp @@ -9,8 +9,10 @@ namespace grino { } - /*explicit*/ Function::Function(std::shared_ptr prog) + /*explicit*/ Function::Function(std::shared_ptr prog, + size_t base_addr) : m_prog { prog } + , m_base_addr { base_addr } { } diff --git a/src/Function.hpp b/src/Function.hpp index 326ee0d..bceaf66 100644 --- a/src/Function.hpp +++ b/src/Function.hpp @@ -16,9 +16,11 @@ namespace grino { public: explicit Function(native_t native); - explicit Function(std::shared_ptr prog); + explicit Function(std::shared_ptr prog, size_t base_addr); virtual ~Function(); + size_t base_addr() const { return m_base_addr; } + bool is_native() const; std::shared_ptr program() const; value_t call(args_t args); @@ -30,6 +32,7 @@ namespace grino native_t m_native; std::shared_ptr m_prog; std::unordered_map> m_env; + size_t m_base_addr = 0; }; } diff --git a/src/VM.cpp b/src/VM.cpp index b6c9dfa..ec2673c 100644 --- a/src/VM.cpp +++ b/src/VM.cpp @@ -47,7 +47,8 @@ namespace grino auto prog_val = program().constant(pop()); auto prog = prog_val->as_program(); - auto fun_val = Value::make_function(prog_val->loc(), prog); + auto fun_val = Value::make_function(prog_val->loc(), + prog, *instr.param); // closure if (m_frames.size() > 0) @@ -172,12 +173,14 @@ namespace grino frame.program = fun->program().get(); m_frames.push_back(frame); + size_t base_addr = fun->base_addr(); + for (size_t i=0; i VM::local(size_t addr) const { - return m_frames.back().locals.at(addr); + auto itr = m_frames.back().locals.find(addr); + + if (itr == std::end(m_frames.back().locals)) + { + std::cout << "cannot find address " << addr << std::endl; + } + + return itr->second; } void VM::set_local(size_t addr, diff --git a/src/Value.cpp b/src/Value.cpp index 83c2089..4f2c471 100644 --- a/src/Value.cpp +++ b/src/Value.cpp @@ -38,11 +38,12 @@ namespace grino /*static*/ std::shared_ptr Value::make_function(Loc const& loc, - std::shared_ptr val) + std::shared_ptr val, + size_t base_addr) { auto value = std::make_shared(loc); value->m_type = TYPE_FUNCTION; - value->m_function_val = std::make_shared(val); + value->m_function_val = std::make_shared(val, base_addr); return value; } diff --git a/src/Value.hpp b/src/Value.hpp index 1680582..90318ed 100644 --- a/src/Value.hpp +++ b/src/Value.hpp @@ -19,7 +19,9 @@ namespace grino static std::shared_ptr make_native_function(Loc const& loc, native_t val); static std::shared_ptr make_function(Loc const& loc, - std::shared_ptr val); + std::shared_ptr val, + size_t base_addr); + static std::shared_ptr make_ref(Loc const& loc, size_t val); diff --git a/src/main.cpp b/src/main.cpp index 342c882..bfdce7e 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -10,6 +10,7 @@ #include "Logger.hpp" #include "src/SymTable.hpp" #include "Loader.hpp" +#include "Addr.hpp" void run(char** argv, bool debug_mode) { @@ -37,8 +38,10 @@ void run(char** argv, bool debug_mode) grino::SymTable sym_table {logger}; grino::Program program; + + grino::Addr addr; grino::VM vm {logger, program}; - grino::Compiler compiler {logger}; + grino::Compiler compiler {logger, addr}; grino::Loader loader {vm, compiler, sym_table}; loader.load_libraries();