feat: implement module loading

I couldn't care less to commit all the changes separately after fight
with this stupid codebase.
Also I am closing the issue since serializing contexts meant doing
something like jars which I don't want to do right now. I'll reopen the
issue though for sure clueless.

Closes: #23

furvm/src/detail/serialization.cpp

@@ -1,49 +1,127 @@
 #include "furvm/detail/serialization.hpp"
 
+#include <istream>
 #include <ostream>
 
 namespace furvm::detail {
 
+namespace {
+
+template <typename T, std::size_t... I>
+void serialize_integral_impl(std::ostream& os, std::make_unsigned_t<T> u_value, std::index_sequence<I...>) {
+    ((os << static_cast<char>((u_value >> (I * 8)) & 0xFF)), ...);
+}
+
+template <typename T, std::size_t... I>
+void load_integral_impl(const char* bs, std::make_unsigned_t<T>& u_value, std::index_sequence<I...>) {
+    using UnsignedT = std::make_unsigned_t<T>;
+    ((u_value |= (static_cast<UnsignedT>(static_cast<std::uint8_t>(bs[I])) << (I * 8))), ...);
+}
+
+template <typename T>
+std::ostream& serialize_integral(std::ostream& os, T value) {
+    static_assert(std::is_integral_v<T>, "Type must be an integral type.");
+    using UnsignedT = std::make_unsigned_t<T>;
+
+    serialize_integral_impl<T>(os, static_cast<UnsignedT>(value), std::make_index_sequence<sizeof(T)>{});
+    return os;
+}
+
+template <typename T>
+std::istream& load_integral(std::istream& is, T& value) {
+    static_assert(std::is_integral_v<T>, "Type must be an integral type.");
+
+    char bs[sizeof(T)];
+    if (!is.read(bs, sizeof(T))) {
+        return is;
+    }
+
+    using UnsignedT = std::make_unsigned_t<T>;
+    UnsignedT uVal  = 0;
+
+    load_integral_impl<T>(bs, uVal, std::make_index_sequence<sizeof(T)>{});
+
+    value = static_cast<T>(uVal);
+    return is;
+}
+
+} // namespace
+
 std::ostream& serialize(std::ostream& os, std::int8_t value) {
-    return os << (char)((value >> 0ULL) & 0xFF);
+    return serialize_integral(os, value);
 }
 
 std::ostream& serialize(std::ostream& os, std::int16_t value) {
-    return os << (char)((value >> 0ULL) & 0xFF) << (char)((value >> 8ULL) & 0xFF);
+    return serialize_integral(os, value);
 }
 
 std::ostream& serialize(std::ostream& os, std::int32_t value) {
-    return os << (char)((value >> 0ULL) & 0xFF) << (char)((value >> 8ULL) & 0xFF) << (char)((value >> 16ULL) & 0xFF)
-              << (char)((value >> 24ULL) & 0xFF);
+    return serialize_integral(os, value);
 }
 
 std::ostream& serialize(std::ostream& os, std::int64_t value) {
-    return os << (char)((value >> 0ULL) & 0xFF) << (char)((value >> 8ULL) & 0xFF) << (char)((value >> 16ULL) & 0xFF)
-              << (char)((value >> 24ULL) & 0xFF) << (char)((value >> 32ULL) & 0xFF) << (char)((value >> 40ULL) & 0xFF)
-              << (char)((value >> 48ULL) & 0xFF) << (char)((value >> 56ULL) & 0xFF);
+    return serialize_integral(os, value);
 }
 
 std::ostream& serialize(std::ostream& os, std::uint8_t value) {
-    return os << (char)((value >> 0ULL) & 0xFF);
+    return serialize_integral(os, value);
 }
 
 std::ostream& serialize(std::ostream& os, std::uint16_t value) {
-    return os << (char)((value >> 0ULL) & 0xFF) << (char)((value >> 8ULL) & 0xFF);
+    return serialize_integral(os, value);
 }
 
 std::ostream& serialize(std::ostream& os, std::uint32_t value) {
-    return os << (char)((value >> 0ULL) & 0xFF) << (char)((value >> 8ULL) & 0xFF) << (char)((value >> 16ULL) & 0xFF)
-              << (char)((value >> 24ULL) & 0xFF);
+    return serialize_integral(os, value);
 }
 
 std::ostream& serialize(std::ostream& os, std::uint64_t value) {
-    return os << (char)((value >> 0ULL) & 0xFF) << (char)((value >> 8ULL) & 0xFF) << (char)((value >> 16ULL) & 0xFF)
-              << (char)((value >> 24ULL) & 0xFF) << (char)((value >> 32ULL) & 0xFF) << (char)((value >> 40ULL) & 0xFF)
-              << (char)((value >> 48ULL) & 0xFF) << (char)((value >> 56ULL) & 0xFF);
+    return serialize_integral(os, value);
 }
 
 std::ostream& serialize(std::ostream& os, const std::string& value) {
-    return serialize(os, std::uint16_t(value.size())).write(value.data(), static_cast<std::streamsize>(value.size()));
+    return serialize(os, static_cast<std::uint16_t>(value.size()))
+        .write(value.data(), static_cast<std::streamsize>(value.size()));
+}
+
+std::istream& load(std::istream& is, std::int8_t& value) {
+    return load_integral(is, value);
+}
+
+std::istream& load(std::istream& is, std::int16_t& value) {
+    return load_integral(is, value);
+}
+
+std::istream& load(std::istream& is, std::int32_t& value) {
+    return load_integral(is, value);
+}
+
+std::istream& load(std::istream& is, std::int64_t& value) {
+    return load_integral(is, value);
+}
+
+std::istream& load(std::istream& is, std::uint8_t& value) {
+    return load_integral(is, value);
+}
+
+std::istream& load(std::istream& is, std::uint16_t& value) {
+    return load_integral(is, value);
+}
+
+std::istream& load(std::istream& is, std::uint32_t& value) {
+    return load_integral(is, value);
+}
+
+std::istream& load(std::istream& is, std::uint64_t& value) {
+    return load_integral(is, value);
+}
+
+std::istream& load(std::istream& is, std::string& value) {
+    std::uint16_t length = 0;
+    load(is, length);
+
+    value.resize(length);
+    return is.read(value.data(), static_cast<std::streamsize>(length));
 }
 
 } // namespace furvm::detail

furvm/src/executor.cpp

@@ -31,7 +31,7 @@ void executor::push_frame(const mod_h& mod, function function) {
     } break;
     case function_t::Native: {
         m_frames.emplace((struct executor::frame){ mod, 0, m_stack.size(), std::move(args) });
-        modInst->get_native_function(function.name())(*this);
+        modInst->get_native_function(function.native())(*this);
         m_frames.pop();
     } break;
     default: throw std::runtime_error("unexpected function type");

furvm/src/main.cpp

@@ -1,5 +1,6 @@
 #ifndef LIBFURVM
 
+#include "furvm/detail/serialization.hpp"
 #include "furvm/furvm.hpp"
 
 #include <array>
@@ -7,33 +8,30 @@
 #include <fstream>
 #include <iostream>
 #include <memory>
+#include <sstream>
 
-static constexpr std::array<furvm::byte, 9> s_bytecode = {
-    furvm::byte(furvm::instruction_t::PushB2I),
-    67,
-    furvm::byte(furvm::instruction_t::Duplicate),
-    furvm::byte(furvm::instruction_t::Reference),
-    furvm::byte(furvm::instruction_t::Add),
-    furvm::byte(furvm::instruction_t::Call),
-    1,
-    0,
-    furvm::byte(furvm::instruction_t::Return),
-};
+int main(int argc, char** argv) {
+    if (argc != 2) {
+        std::cerr << "Usage: " << argv[0] << " <mod.fmod>\n";
+        return 1;
+    }
 
-int main(void) {
     auto context = std::make_shared<furvm::context>();
 
-    furvm::mod_h      furlangModule = context->emplace("furlang");
-    furvm::function_h printFunc     = furlangModule->emplace_function("print", 1, "print");
-    furlangModule->set_native_function("print",
+    std::ifstream file(argv[1]);
+    if (!file.is_open()) {
+        std::cerr << "Failed to open " << argv[1] << '\n';
+        return 1;
+    }
+
+    furvm::mod_h      mod  = context->emplace("main", furvm::mod::load(file));
+    furvm::function_h func = mod->function_at("main");
+
+    mod->set_native_function("print",
         [](furvm::executor& executor) { std::cout << executor.load_thing(0)->integer() << '\n'; });
 
-    furvm::mod_h      mainModule = context->emplace("main", s_bytecode.begin(), s_bytecode.end());
-    furvm::function_h mainFunc   = mainModule->emplace_function("main", 0, 0);
-    mainModule->emplace_function(furlangModule, printFunc).dispatch();
-
     furvm::executor_h executor = context->emplace_executor(context);
-    executor->push_frame(mainModule, *mainFunc);
+    executor->push_frame(mod, *func);
 
     while ((executor->flags() & furvm::executor_flags::Done) != furvm::executor_flags::Done) {
         executor->step();

furvm/src/module.cpp

@@ -4,19 +4,25 @@
 #include "furvm/fwd.hpp"
 #include "furvm/type.hpp"
 
+#include <cstdint>
+#include <cstring>
 #include <ios>
+#include <memory>
 #include <stdexcept>
+#include <utility>
 
 namespace furvm {
 
 std::ostream& mod::serialize(std::ostream& os) const {
-    os << MAGIC;
+    os.write(MAGIC, sizeof(MAGIC));
     detail::serialize(os, std::uint32_t(0)); // version
 
-    detail::serialize(os, function_id(m_functionMap.size()));
-    for (function_id id = 0; id < m_functions.cend() - m_functions.cbegin(); ++id) {
+    function_id funcCount = m_functions.cend() - m_functions.cbegin();
+    detail::serialize(os, funcCount);
+    for (function_id id = 0; id < funcCount; ++id) {
         if (!m_functions.contains(id)) {
             detail::serialize(os, "");
+            detail::serialize(os, 0);
             detail::serialize(os, std::uint8_t(0xFF)); // null function
             continue;
         }
@@ -24,12 +30,15 @@ std::ostream& mod::serialize(std::ostream& os) const {
         function_h func     = m_functions.at(id);
         bool       isPublic = m_publicFunctions.find(func->name()) != m_publicFunctions.end();
         detail::serialize(os, isPublic ? func->name() : ""); // private functions have empty names
+        detail::serialize(os, func->param_count());
         detail::serialize(os, std::uint8_t(func->type()));
         switch (func->type()) {
         case function_t::Normal: {
             detail::serialize(os, func->position());
         } break;
-        case function_t::Native: break;
+        case function_t::Native: {
+            detail::serialize(os, func->native());
+        } break;
         case function_t::Import: {
             detail::serialize(os, func->imp().mod);
             detail::serialize(os, func->imp().function);
@@ -60,4 +69,86 @@ std::ostream& mod::serialize(std::ostream& os) const {
     detail::serialize(os, std::uint64_t(m_bytecode.size()));
     return os.write(reinterpret_cast<const char*>(m_bytecode.data()), static_cast<std::streamsize>(m_bytecode.size()));
 }
+
+mod mod::load(std::istream& is) {
+    std::uint32_t magic = 0;
+    detail::load(is, magic);
+    std::uint32_t version = 0;
+    detail::load(is, version);
+    if (std::memcmp(&magic, MAGIC, sizeof(MAGIC)) != 0) throw std::runtime_error("invalid magic");
+    if (version != 0) throw std::runtime_error("unsupported version");
+
+    mod mod;
+
+    function_id functionCount = 0;
+    detail::load(is, functionCount);
+    for (function_id id = 0; id < functionCount; ++id) {
+        std::string name;
+        detail::load(is, name);
+        std::uint32_t paramCount = 0;
+        detail::load(is, paramCount);
+        std::uint8_t type = 0;
+        detail::load(is, type);
+        if (type == 0xFF) continue;
+
+        switch ((function_t)type) {
+        case function_t::Normal: {
+            decltype(std::declval<function>().position()) offset = 0;
+            detail::load(is, offset);
+            mod.emplace_function(id, std::move(name), paramCount, offset).dispatch();
+        } break;
+        case function_t::Native: {
+            std::string native;
+            detail::load(is, native);
+            mod.emplace_function(id, std::move(name), paramCount, std::move(native)).dispatch();
+        } break;
+        case function_t::Import: {
+            std::string modName;
+            detail::load(is, modName);
+            function_id function = 0;
+            detail::load(is, function);
+            mod.emplace_function(id, std::move(modName), function).dispatch();
+        } break;
+        default: throw std::runtime_error("unknown function type");
+        }
+    }
+
+    type_id typeCount = 0;
+    detail::load(is, typeCount);
+    for (type_id id = 0; id < typeCount; ++id) {
+        std::uint8_t type = 0;
+        detail::load(is, type);
+        if (type == 0xFF) continue;
+
+        switch ((type_t)type) {
+        case type_t::Primitive: {
+            primitive_type primitive = 0;
+            detail::load(is, primitive);
+            mod.emplace_type(id, std::make_shared<class type>(primitive)).dispatch();
+        } break;
+        case type_t::Reference: throw std::runtime_error("reference type serialization is unimplemented");
+        case type_t::List: {
+            type_id typeId = 0;
+            detail::load(is, typeId);
+            mod.emplace_type(id, std::make_shared<class type>(mod.type_at(typeId))).dispatch();
+        } break;
+        case type_t::Import: {
+            std::string modName;
+            detail::load(is, modName);
+            type_id typeId = 0;
+            detail::load(is, typeId);
+            mod.emplace_type(id, std::make_shared<class type>(import_type{ std::move(modName), typeId })).dispatch();
+        } break;
+        default: throw std::runtime_error("unknown type type");
+        }
+    }
+
+    std::uint64_t bytecodeLength = 0;
+    detail::load(is, bytecodeLength);
+    mod.bytecode().resize(bytecodeLength);
+    is.read(reinterpret_cast<char*>(mod.bytecode().data()), static_cast<std::streamsize>(bytecodeLength));
+
+    return mod;
+}
+
 } // namespace furvm