decoding works

include/yorel/yomm2/detail.hpp

@@ -1064,7 +1064,7 @@ void decode_dispatch_data(Data& init) {
                     more = !(*dtbl_iter & stop_bit);
                     auto spec_index = *dtbl_iter & ~stop_bit;
                     trace << " " << spec_index;
-                    *dtbl_iter = defs[spec_index];
+                    *dtbl_iter++ = defs[spec_index];
                 };
 
                 trace << "\n";
@@ -1078,13 +1078,13 @@ void decode_dispatch_data(Data& init) {
 
     auto encode_iter = init.encoded.vtbls;
     auto decode_iter = init.vtbls;
+    bool last;
 
-    auto emit = [&](std::uintptr_t value) {
-        assert((char*)(decode_iter + 1) <= (char*)encode_iter);
-        assert(
-            (char*)(decode_iter + 1) <=
-            (char*)(decode_iter + sizeof(init.dtbls) / sizeof(*init.dtbls)));
-        *decode_iter++ = value;
+    auto fetch = [&]() {
+        assert((char*)(encode_iter + 1) >= (char*)decode_iter);
+        auto code = *encode_iter++;
+        last = code & stop_bit;
+        return code & ~stop_bit;
     };
 
     for (auto& cls : Policy::classes) {
@@ -1097,41 +1097,42 @@ void decode_dispatch_data(Data& init) {
 
         indent _2(trace);
 
-        auto first_slot = *encode_iter++;
+        auto first_slot = fetch();
         ++trace << "first slot: " << first_slot << "\n";
 
         *cls.static_vptr = decode_iter - first_slot;
 
         do {
-            auto entry = *encode_iter & ~stop_bit;
+            auto code = fetch();
 
-            if (entry & index_bit) {
-                auto index = *encode_iter & ~index_bit;
+            if (code & index_bit) {
+                auto index = code & ~index_bit;
                 ++trace << "multi-method group " << index << "\n";
-                emit(index);
+                *decode_iter++ = index;
             } else {
-                auto method_index = entry;
+                auto method_index = code;
                 auto method = methods[method_index];
-                auto group_index = *++encode_iter & ~stop_bit; // spec or group
+                auto group_index = fetch(); // spec or group
 
                 if (method->arity() == 1) {
                     ++trace << "uni-method " << method_index << " spec "
                             << group_index;
-                    emit(method_defs[method_index][group_index]);
+                    *decode_iter++ = method_defs[method_index][group_index];
                 } else {
                     ++trace << "multi-method " << method_index << " group "
                             << group_index;
                     indent _(trace);
-                    trace << type_name(method->method_type) << "\n";
-                    emit((std::uintptr_t)(dispatch_tables[method_index] +
-                                          group_index));
+                    trace << type_name(method->method_type);
+                    *decode_iter++ =
+                        (std::uintptr_t)(dispatch_tables[method_index] +
+                                         group_index);
                 }
 
                 trace << "\n";
                 indent _(trace);
                 ++trace << type_name(method->method_type) << "\n";
             }
-        } while (!(*encode_iter++ & stop_bit));
+        } while (!last);
     }
 
     ++trace << decode_iter << " " << encode_iter << "\n";

include/yorel/yomm2/generator.hpp

@@ -305,22 +305,21 @@ void generator::encode_dispatch_data(
     size_t encode_vtbl_size = 0, decode_vtbl_size = 0;
 
     for (auto& cls : compiler.classes) {
-        size_t encode_size = 1; // for first slot index
+        ++encode_vtbl_size; // for first slot index
 
         for (auto& entry :
              range(cls.vtbl.begin() + cls.first_used_slot, cls.vtbl.end())) {
-            if (entry.vp_index > 1) {
+            if (entry.vp_index != 0) {
                 // It's a multi-method, and not the first virtual parameter.
                 // Encode the index, it will be decoded as is.
-                ++encode_size;
+                ++encode_vtbl_size;
             } else {
                 // It's a uni-method, or the first virtual parameter of a
                 // multi-method. Encode the method index and the spec index;
-                encode_size += 2;
+                encode_vtbl_size += 2;
             }
         }
 
-        encode_vtbl_size += encode_size;
         decode_vtbl_size += cls.vtbl.size() - cls.first_used_slot;
     }
 
@@ -341,28 +340,20 @@ void generator::encode_dispatch_data(
     } yomm2_dispatch_data = { { { {}, {
 )";
 
-    const auto decode_bytes = sizeof(uintptr_t);
-    const auto encode_bytes = sizeof(uint16_t);
+    const auto decode_size = sizeof(uintptr_t);
+    const auto encode_size = sizeof(uint16_t);
 
-    const auto total_decode_size = dispatch_tables_size + decode_vtbl_size;
-    const auto total_encode_size =
-        slots_and_strides_size + dispatch_tables_size + encode_vtbl_size;
+    const auto total_decode_size = decode_vtbl_size;
+    const auto total_encode_size = slots_and_strides_size + encode_vtbl_size;
 
-    auto headroom = total_decode_size * sizeof(uintptr_t) -
-        total_encode_size * sizeof(uint16_t);
-
-    const auto dispatch_and_vtbl_bytes =
-        (dispatch_tables_size + encode_vtbl_size) * encode_bytes;
-    const auto total_decode_bytes = total_decode_size * decode_bytes;
-
-    if (dispatch_and_vtbl_bytes < total_decode_bytes) {
-        headroom +=
-            (total_decode_bytes - dispatch_and_vtbl_bytes) / encode_bytes;
-    }
+    const auto headroom =
+        (decode_vtbl_size * decode_size -
+         (encode_vtbl_size - slots_and_strides_size) * encode_size) /
+        encode_size;
 
     char prelude[sizeof(prelude_format) + 5 * 6];
     std::snprintf(
-        prelude, sizeof(prelude), prelude_format, headroom / sizeof(uint16_t),
+        prelude, sizeof(prelude), prelude_format, headroom,
         slots_and_strides_size, encode_vtbl_size, decode_vtbl_size,
         dispatch_tables_size);
     os << prelude;