From 03d68fa562fb5a8d287f41c0c326c2fa3a89c935 Mon Sep 17 00:00:00 2001
From: Theis Pieter Hollebeek <tphollebeek@gmail.com>
Date: Wed, 27 Nov 2024 13:28:45 +0100
Subject: [PATCH] parse actions
---
runtime/actions.hpp | 45 ++++++++++
runtime/json.hpp | 2 +-
runtime/main.cpp | 192 +----------------------------------------
runtime/rpc_server.hpp | 1 -
4 files changed, 49 insertions(+), 191 deletions(-)
create mode 100644 runtime/actions.hpp
diff --git a/runtime/actions.hpp b/runtime/actions.hpp
new file mode 100644
index 0000000..d39a50f
--- /dev/null
+++ b/runtime/actions.hpp
@@ -0,0 +1,45 @@
+#include "rpc_server.hpp"
+#include <memory>
+
+namespace sliger::rpc::action {
+
+struct Action {
+ virtual auto perform_action(
+ std::unique_ptr<sliger::rpc::BufferedWriter> writer) -> void = 0;
+ virtual ~Action() = default;
+};
+
+class RunDebug : public Action {
+public:
+ RunDebug(std::vector<uint32_t> instructions)
+ : instructions(instructions)
+ {
+ }
+ auto perform_action(
+ std::unique_ptr<sliger::rpc::BufferedWriter> writer) -> void;
+
+private:
+ std::vector<uint32_t> instructions;
+};
+
+static auto action_from_json(
+ std::unique_ptr<json::Value> value) -> std::unique_ptr<Action>
+{
+ auto& obj = value->as<sliger::json::Object>();
+ auto type = obj.fields.at("type")->as<sliger::json::String>();
+
+ if (type.value == "run-debug") {
+ sliger::json::ArrayValues values = std::move(
+ obj.fields.at("program")->as<sliger::json::Array>().values);
+ auto instructions = std::vector<uint32_t>();
+ for (auto& v : values) {
+ std::unique_ptr<json::Value> moved = std::move(v);
+ auto value = moved->as<sliger::json::Number>().value;
+ instructions.push_back((uint32_t)value);
+ }
+ auto action = RunDebug(instructions);
+ return std::make_unique<RunDebug>(action);
+ }
+ throw "todo";
+};
+}
diff --git a/runtime/json.hpp b/runtime/json.hpp
index a340232..e0bc595 100644
--- a/runtime/json.hpp
+++ b/runtime/json.hpp
@@ -95,7 +95,7 @@ struct Value {
requires std::derived_from<T, Value>
inline auto as() & -> T&
{
- return static_cast<T&>(this);
+ return static_cast<T&>(*this);
}
};
diff --git a/runtime/main.cpp b/runtime/main.cpp
index 2fb866c..2c697b4 100644
--- a/runtime/main.cpp
+++ b/runtime/main.cpp
@@ -1,200 +1,14 @@
-#include "arch.hpp"
+#include "actions.hpp"
#include "json.hpp"
#include "rpc_server.hpp"
-#include "vm.hpp"
-#include <format>
-#include <iostream>
-#include <string>
-#include <utility>
-#include <variant>
-
-enum class AsmLineType {
- Op,
- Lit,
- Loc,
- Ref,
-};
-
-struct Loc {
- explicit Loc(std::string value)
- : value(value)
- {
- }
-
- std::string value;
-};
-
-struct Ref {
- explicit Ref(std::string value)
- : value(value)
- {
- }
-
- std::string value;
-};
-
-struct AsmLine {
- /* clang-format off */
- AsmLine(sliger::Op value) : type(AsmLineType::Op), value(value) {}
- AsmLine(uint32_t value) : type(AsmLineType::Lit), value(value) {}
- AsmLine(Loc value) : type(AsmLineType::Loc), value(value) {}
- AsmLine(Ref value) : type(AsmLineType::Ref), value(value) {}
- /* clang-format on */
-
- AsmLineType type;
- std::variant<sliger::Op, uint32_t, Loc, Ref> value;
-};
-
-auto compile_asm(const std::vector<AsmLine>& lines) -> std::vector<uint32_t>
-{
- size_t ip = 0;
- auto output = std::vector<uint32_t>();
- auto locs = std::unordered_map<std::string, size_t>();
- auto refs = std::unordered_map<size_t, std::string>();
- for (const auto& line : lines) {
- switch (line.type) {
- case AsmLineType::Op: {
- output.push_back(
- std::to_underlying(std::get<sliger::Op>(line.value)));
- ip += 1;
- break;
- }
- case AsmLineType::Lit: {
- output.push_back(std::get<uint32_t>(line.value));
- ip += 1;
- break;
- }
- case AsmLineType::Loc: {
- locs.insert_or_assign(std::get<Loc>(line.value).value, ip);
- break;
- }
- case AsmLineType::Ref: {
- output.push_back(0);
- refs.insert_or_assign(ip, std::get<Ref>(line.value).value);
- ip += 1;
- break;
- }
- }
- }
- for (size_t i = 0; i < output.size(); ++i) {
- if (!refs.contains(i)) {
- continue;
- }
- if (!locs.contains(refs.at(i))) {
- std::cerr << std::format(
- "error: label \"{}\" used at {} not defined\n", refs.at(i), i);
- continue;
- }
- output.at(i) = static_cast<uint32_t>(locs.at(refs.at(i)));
- }
- return output;
-}
-
-auto execute_action(std::unique_ptr<sliger::json::Value> req,
- std::unique_ptr<sliger::rpc::BufferedWriter> writer)
-{
- auto node = req->as<sliger::json::Object>();
- auto& type = node.fields.at("type")->as<sliger::json::String>();
- if (type.value == "some_type") {
- /* etc. */
- } else {
- /* unrecognized action */
- }
-}
int main()
{
- using R = Ref;
- using L = Loc;
- using enum sliger::Op;
-
auto rpc = sliger::rpc::RpcServer(
[&](std::unique_ptr<sliger::json::Value> req,
std::unique_ptr<sliger::rpc::BufferedWriter> writer) {
- execute_action(std::move(req), std::move(writer));
+ auto action = sliger::rpc::action::action_from_json(std::move(req));
+ action->perform_action(std::move(writer));
});
rpc.listen();
-
- // fn add(a, b) {
- // + a b
- // }
- //
- // fn main() {
- // let result = 0;
- // let i = 0;
- // loop {
- // if i >= 10 {
- // break;
- // }
- // result = add(result, 5);
- // i = + i 1;
- // }
- // result
- // }
- auto program_asm = std::vector<AsmLine> {
- // clang-format off
- SourceMap, 0, 0, 0,
- PushPtr, R("main"),
- Call, 0,
- PushPtr, R("_exit"),
- Jump,
- Pop,
- L("add"),
- SourceMap, 19, 2, 5,
- Add,
- Return,
- L("main"),
- SourceMap, 28, 5, 1,
- PushInt, 0,
- PushInt, 0,
- SourceMap, 44, 6, 1,
- PushInt, 0,
- SourceMap, 55, 7, 1,
- L("0"),
- SourceMap, 66, 8, 5,
- LoadLocal, 2,
- PushInt, 10,
- LessThan,
- Not,
- PushPtr, R("1"),
- JumpIfFalse,
- SourceMap, 87, 9, 9,
- PushPtr, R("2"),
- Jump,
- L("1"),
- SourceMap, 104, 11, 5,
- LoadLocal, 1,
- PushInt, 5,
- PushPtr, R("add"),
- Call, 2,
- StoreLocal, 1,
- SourceMap, 133, 12, 5,
- LoadLocal, 2,
- PushInt, 1,
- Add,
- StoreLocal, 2,
- PushPtr, R("0"),
- Jump,
- L("2"),
- LoadLocal, 1,
- StoreLocal, 0,
- Pop,
- Pop,
- Return,
- L("_exit"),
- SourceMap, 147, 15, 1
- // clang-format on
- };
- auto program = compile_asm(program_asm);
- auto vm = sliger::VM(program,
- {
- .flame_graph = true,
- .code_coverage = true,
- });
- vm.run_until_done();
- std::cout << std::format("done\n{}\n", vm.stack_repr_string(4));
- auto flame_graph = vm.flame_graph_json();
- std::cout << std::format("flame graph: {}\n", flame_graph);
- auto code_coverage = vm.code_coverage_json();
- std::cout << std::format("code coverage: {}\n", code_coverage);
}
diff --git a/runtime/rpc_server.hpp b/runtime/rpc_server.hpp
index ca1d417..52ff542 100644
--- a/runtime/rpc_server.hpp
+++ b/runtime/rpc_server.hpp
@@ -56,7 +56,6 @@ private:
};
struct Unit { };
-struct Req { };
class BufferedWriter {
public: