Rebase jasmin serialization on top of nth serialization.

.bazelrc

@@ -1,6 +1,7 @@
 common \
   --color=yes \
   --experimental_enable_bzlmod \
+  --registry=http://localhost:8000 \
   --registry=https://github.com/raw/asoffer/bazel-registry/main \
   --registry=https://bcr.bazel.build
 build \

MODULE.bazel

@@ -1,3 +1,3 @@
 bazel_dep(name = "abseil-cpp", repo_name = "com_google_absl", version = "20230125.1")
 bazel_dep(name = "bazel_skylib", repo_name = "bazel_skylib", version = "1.4.2")
-bazel_dep(name = "nth-cc", repo_name = "nth_cc", version = "20240130.00")
+bazel_dep(name = "nth-cc", repo_name = "nth_cc", version = "20240205.00")

examples/BUILD

@@ -52,15 +52,18 @@ cc_binary(
     name = "serialization",
     srcs = ["serialization.cc"],
     deps = [
+        "//jasmin/core:instruction",
+        "//jasmin/core:program",
+        "//jasmin/core:serialization",
         "//jasmin/instructions:arithmetic",
         "//jasmin/instructions:compare",
         "//jasmin/instructions:common",
-        "//jasmin/serialize:deserialize",
-        "//jasmin/serialize:serialize",
-        "//jasmin/serialize:string_reader",
-        "//jasmin/serialize:string_writer",
         "@nth_cc//nth/debug",
         "@nth_cc//nth/debug/log:stderr_log_sink",
+        "@nth_cc//nth/io/serialize",
+        "@nth_cc//nth/io/serialize:deserialize",
+        "@nth_cc//nth/io/serialize:string_reader",
+        "@nth_cc//nth/io/serialize:string_writer",
         "@com_google_absl//absl/container:flat_hash_set",
     ],
 )

examples/serialization.cc

@@ -2,16 +2,18 @@
 #include <cstdio>
 
 #include "jasmin/core/instruction.h"
+#include "jasmin/core/program.h"
+#include "jasmin/core/serialization.h"
 #include "jasmin/instructions/arithmetic.h"
 #include "jasmin/instructions/common.h"
 #include "jasmin/instructions/compare.h"
-#include "jasmin/serialize/deserialize.h"
-#include "jasmin/serialize/serialize.h"
-#include "jasmin/serialize/string_reader.h"
-#include "jasmin/serialize/string_writer.h"
 #include "nth/container/interval.h"
 #include "nth/debug/debug.h"
 #include "nth/debug/log/stderr_log_sink.h"
+#include "nth/io/serialize/deserialize.h"
+#include "nth/io/serialize/serialize.h"
+#include "nth/io/serialize/string_reader.h"
+#include "nth/io/serialize/string_writer.h"
 
 using Instructions = jasmin::MakeInstructionSet<
     jasmin::Duplicate, jasmin::Swap, jasmin::Push<uint64_t>,
@@ -46,29 +48,30 @@ jasmin::Program<Instructions> MakeProgram() {
 
 int main() {
   // The string which is going to hold the serialized program.
-  std::string s;
+  std::string content;
 
   {
-    // Construct a program and serialize it into `s`.
+    // Construct a program and serialize it into `content`.
     jasmin::Program<Instructions> p = MakeProgram();
-    jasmin::StringWriter w(p.functions(), s);
-    jasmin::Serialize(p, w);
+    jasmin::Serializer<nth::io::string_writer> serializer(content);
+    if (not nth::io::serialize(serializer, p)) { return 1; }
   }
 
   // At this point the constructed program has been destroyed. The only remnants
   // of it are this serialization.
   std::puts("Serialized program:");
-  for (size_t i = 0; i < s.size(); ++i) {
-    std::printf(" %0.2x", s[i]);
+  for (size_t i = 0; i < content.size(); ++i) {
+    std::printf(" %0.2x", content[i]);
     if (i % 8 == 7) { std::putchar('\n'); }
   }
   std::putchar('\n');
 
   {
-    // Reconstitute the program previously serialized into `s` back into `p`.
+    // Reconstitute the program previously serialized into `content` back into
+    // the program `p`.
     jasmin::Program<Instructions> p;
-    jasmin::StringReader r(s);
-    if (not jasmin::Deserialize(r, p)) { return 1; }
+    jasmin::Deserializer<nth::io::string_reader> deserializer(content);
+    if (not nth::io::deserialize(deserializer, p)) { return 1; }
 
     uint64_t n                      = 15;
     nth::stack<jasmin::Value> stack = {n};

jasmin/core/BUILD

@@ -22,10 +22,13 @@ cc_library(
     deps = [
         ":instruction",
         ":instruction_index",
+        ":metadata",
         ":value",
         "//jasmin/core/internal:function_base",
         "//jasmin/core/internal:instruction_traits",
         "@nth_cc//nth/container:interval",
+        "@nth_cc//nth/io/serialize",
+        "@nth_cc//nth/io/serialize:deserialize",
     ],
 )
 
@@ -148,10 +151,39 @@ cc_library(
         ":instruction",
         ":value",
         "@nth_cc//nth/debug",
+        "@nth_cc//nth/io/serialize",
+        "@nth_cc//nth/io/serialize:deserialize",
         "@nth_cc//nth/utility:iterator_range",
     ],
 )
 
+cc_library(
+    name = "serialization",
+    hdrs = ["serialization.h"],
+    visibility = ["//visibility:public"],
+    deps = [
+        ":function",
+        ":instruction",
+        ":metadata",
+        ":program",
+        ":value",
+        "@nth_cc//nth/io/serialize",
+        "@nth_cc//nth/io/serialize:deserialize",
+        "@nth_cc//nth/io/serialize:string_reader",
+        "@nth_cc//nth/io/serialize:string_writer",
+    ],
+)
+
+cc_test(
+    name = "serialization_test",
+    srcs = ["serialization_test.cc"],
+    deps = [
+        ":serialization",
+        "//jasmin/instructions:common",
+        "@nth_cc//nth/test:main",
+    ],
+)
+
 cc_library(
     name = "value",
     hdrs = ["value.h"],

jasmin/core/function.h

@@ -6,6 +6,7 @@
 #include "jasmin/core/internal/frame.h"
 #include "jasmin/core/internal/function_base.h"
 #include "jasmin/core/internal/instruction_traits.h"
+#include "jasmin/core/metadata.h"
 #include "nth/container/interval.h"
 #include "nth/meta/type.h"
 
@@ -33,6 +34,9 @@ struct Function : Function<> {
 
   static_assert(InstructionSetType<Set>);
 
+  // Constructs an empty function to be used only for overwriting.
+  explicit Function();
+
   // Constructs an empty `Function` given a `parameter_count` representing
   // the number of parameters to the function, and a `return_count`
   // representing the number of return values for the function.
@@ -93,6 +97,10 @@ Function<Set>::Function(uint32_t parameter_count, uint32_t return_count)
     : Function<>(parameter_count, return_count,
                  internal::Invoke<instruction_set>) {}
 
+template <typename Set>
+Function<Set>::Function()
+    : Function<>(0, 0, internal::Invoke<instruction_set>) {}
+
 template <typename Set>
 template <typename I>
 requires(Set::instructions.template contains<nth::type<I>>())  //
@@ -105,7 +113,8 @@ requires(Set::instructions.template contains<nth::type<I>>())  //
     return internal::FunctionBase::append({&I::template ExecuteImpl<Set>});
   } else if constexpr (nth::type<I> == nth::type<jasmin::JumpIf>) {
     static_assert(sizeof...(vs) == 1);
-    return internal::FunctionBase::append({&I::template ExecuteImpl<Set>, static_cast<size_t>(vs)...});
+    return internal::FunctionBase::append(
+        {&I::template ExecuteImpl<Set>, static_cast<size_t>(vs)...});
   } else {
     constexpr size_t DropCount = internal::HasFunctionState<I> ? 3 : 2;
     return internal::InstructionFunctionType<I>()

jasmin/core/internal/BUILD

@@ -47,6 +47,8 @@ cc_library(
         "//jasmin/core:value",
         "@nth_cc//nth/meta:concepts",
         "@nth_cc//nth/meta:type",
+        "@nth_cc//nth/io/serialize",
+        "@nth_cc//nth/io/serialize:deserialize",
     ],
 )
 

jasmin/core/internal/instruction_traits.h

@@ -5,6 +5,8 @@
 #include "jasmin/core/internal/function_state.h"
 #include "jasmin/core/output.h"
 #include "jasmin/core/value.h"
+#include "nth/io/serialize/deserialize.h"
+#include "nth/io/serialize/serialize.h"
 #include "nth/meta/concepts.h"
 #include "nth/meta/type.h"
 
@@ -21,6 +23,13 @@ struct Return;
 struct InstructionSpecification {
   uint32_t parameters;
   uint32_t returns;
+
+  friend bool NthSerialize(auto& s, InstructionSpecification spec) {
+    return nth::io::serialize(s, spec.parameters, spec.returns);
+  }
+  friend bool NthDeserialize(auto& d, InstructionSpecification& spec) {
+    return nth::io::deserialize(d, spec.parameters, spec.returns);
+  }
 };
 
 namespace internal {

jasmin/core/program.h

@@ -9,6 +9,8 @@
 #include "jasmin/core/instruction.h"
 #include "nth/container/flyweight_map.h"
 #include "nth/debug/debug.h"
+#include "nth/io/serialize/deserialize.h"
+#include "nth/io/serialize/serialize.h"
 #include "nth/utility/iterator_range.h"
 
 namespace jasmin {
@@ -58,13 +60,59 @@ struct Program {
   [[nodiscard]] Function<Set> const& function(function_identifier id) const;
   [[nodiscard]] Function<Set>& function(function_identifier id);
 
+  friend bool NthSerialize(auto& s, Program const& p) {
+    if (not nth::io::serialize_integer(s, p.functions_.size())) {
+      return false;
+    }
+    for (auto const& [name, fn] : p.functions_) {
+      s.register_function(fn);
+      if (not nth::io::serialize_integer(s, name.size())) { return false; }
+      if (not s.write(std::span<std::byte const>(
+              reinterpret_cast<std::byte const*>(name.data()), name.size()))) {
+        return false;
+      }
+    }
+
+    for (auto const& [name, fn] : p.functions_) {
+      if (not nth::io::serialize(s, fn)) { return false; }
+    }
+    return true;
+  }
+
+  friend bool NthDeserialize(auto& d, Program& p) {
+    size_t size;
+    if (not nth::io::deserialize_integer(d, size)) { return false; }
+
+    for (uint32_t i = 0; i < size; ++i) {
+      size_t name_size;
+      if (not nth::io::deserialize_integer(d, name_size)) { return false; }
+      std::string name(name_size, '\0');
+      if (not d.read(std::span<std::byte>(
+              reinterpret_cast<std::byte*>(name.data()), name.size()))) {
+        return false;
+      }
+
+      auto [iter, inserted] = p.functions_.try_emplace(name);
+      if (not inserted) { return false; }
+      d.register_function(iter->second);
+    }
+
+    for (Function<>*& fn : d.registered_functions()) {
+      if (not nth::io::deserialize(d, static_cast<Function<Set>&>(*fn))) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   // Returns the number of functions managed by this `Program`.
   size_t function_count() const { return functions_.size(); }
 
   auto functions() const {
     return nth::iterator_range(functions_.begin(), functions_.end());
   }
 
+
  private:
   nth::flyweight_map<std::string, Function<Set>> functions_;
 };