fix custom decoder dispatching by taking and passing blobs to decode fn

Author: iliabylich

.github/workflows/test.yml

@@ -22,6 +22,7 @@ jobs:
       TARGET: ${{ matrix.build.target }}
       CXX: ${{ matrix.build.cxx }}
       AR: ${{ matrix.build.ar }}
+      RUST_BACKTRACE: "1"
     strategy:
       fail-fast: false
       matrix:

api.cpp

@@ -5,7 +5,6 @@ namespace lib_ruby_parser
 {
     BLOB(ParserResult);
     BLOB(ParserOptions);
-    BLOB(ByteList);
 
     extern "C"
     {

bytes.cpp

@@ -3,7 +3,6 @@
 
 namespace lib_ruby_parser
 {
-    BLOB(ByteList);
     BLOB(Bytes);
 
     extern "C"

bytes.hpp

@@ -2,6 +2,7 @@
 #define LIB_RUBY_PARSER_BYTES_HPP
 
 #include <cstddef>
+#include <cstdint>
 
 namespace lib_ruby_parser
 {
@@ -33,6 +34,14 @@ namespace lib_ruby_parser
         static ByteList Copied(const char *s, size_t len);
     };
 
+    extern "C"
+    {
+        struct ByteListBlob
+        {
+            uint8_t bytes[sizeof(ByteList)];
+        };
+    }
+
     /// Rerpresentation of `Bytes` struct from lib-ruby-parser.
     class Bytes
     {

decoder.cpp

@@ -66,6 +66,12 @@ namespace lib_ruby_parser
         std::memset(&other, 0, sizeof(Value));
     }
     DecoderResult::Value::~Value() {}
+    DecoderResult::Value &DecoderResult::Value::operator=(DecoderResult::Value &&other)
+    {
+        std::memcpy(this, &other, sizeof(Value));
+        std::memset(&other, 0, sizeof(Value));
+        return *this;
+    }
 
     DecoderResult::DecoderResult(Tag tag_,
                                  Value as_) : tag(tag_),
@@ -89,6 +95,52 @@ namespace lib_ruby_parser
     }
 
     // decoder
+    String string_from_string_blob(StringBlob blob)
+    {
+        union U
+        {
+            String t;
+            StringBlob b;
+
+            U() { std::memset(this, 0, sizeof(U)); }
+            ~U() {}
+        };
+
+        U u;
+        u.b = blob;
+        return std::move(u.t);
+    }
+    ByteList byte_list_from_byte_list_blob(ByteListBlob blob)
+    {
+        union U
+        {
+            ByteList t;
+            ByteListBlob b;
+
+            U() { std::memset(this, 0, sizeof(U)); }
+            ~U() {}
+        };
+
+        U u;
+        u.b = blob;
+        return std::move(u.t);
+    }
+    DecoderResultBlob decoder_result_to_blob(DecoderResult decoder_result)
+    {
+        union U
+        {
+            DecoderResult t;
+            DecoderResultBlob b;
+
+            U() { std::memset(this, 0, sizeof(U)); }
+            ~U() {}
+        };
+
+        U u;
+        u.t = std::move(decoder_result);
+        return u.b;
+    }
+
     Decoder::Decoder(DecoderFunction f_, void *state_) : f(f_), state(state_) {}
 
     // maybe decoder

decoder.hpp

@@ -2,6 +2,7 @@
 #define LIB_RUBY_PARSER_DECODER_HPP
 
 #include <cstdbool>
+#include <cstring>
 #include "string.hpp"
 #include "bytes.hpp"
 
@@ -41,9 +42,8 @@ namespace lib_ruby_parser
         static InputError DecodingError(String decoding_error);
     };
 
-    class DecoderResult
+    struct DecoderResult
     {
-    public:
         enum class Tag
         {
             OK,
@@ -57,6 +57,7 @@ namespace lib_ruby_parser
 
             Value();
             Value(Value &&);
+            Value &operator=(Value &&);
             ~Value();
         };
 
@@ -65,13 +66,29 @@ namespace lib_ruby_parser
 
         DecoderResult(Tag tag, Value as);
         DecoderResult(DecoderResult &&) = default;
+        DecoderResult &operator=(DecoderResult &&) = default;
         ~DecoderResult();
 
         static DecoderResult Ok(ByteList decoded);
         static DecoderResult Err(InputError err);
     };
 
-    typedef DecoderResult (*DecoderFunction)(String, ByteList, void *);
+    extern "C"
+    {
+        struct DecoderResultBlob
+        {
+            uint8_t bytes[sizeof(DecoderResult)];
+        };
+    }
+
+    String string_from_string_blob(StringBlob blob);
+    ByteList byte_list_from_byte_list_blob(ByteListBlob blob);
+    DecoderResultBlob decoder_result_to_blob(DecoderResult decoder_result);
+
+    extern "C"
+    {
+        typedef DecoderResultBlob (*DecoderFunction)(void *, StringBlob, ByteListBlob);
+    }
     class Decoder
     {
     public:

ruby-parser-cpp/src/decoder.rs

@@ -53,9 +53,9 @@ pub extern "C" fn LIB_RUBY_PARSER_drop_decoder_result(decoder_result: *mut Decod
 #[derive(Debug)]
 pub struct Decoder {
     pub f: extern "C" fn(
+        state: *const std::ffi::c_void,
         encoding: StringBlob,
         input: ByteListBlob,
-        state: *const std::ffi::c_void,
     ) -> DecoderResultBlob,
     pub state: *const std::ffi::c_void,
 }
@@ -65,9 +65,9 @@ pub struct Decoder {
 pub extern "C" fn lib_ruby_parser__test__always_ok_decoder(output: *const u8) -> Decoder {
     #[no_mangle]
     pub extern "C" fn lib_ruby_parser__test__always_ok_decoder_fn(
+        state: *const std::ffi::c_void,
         encoding: StringBlob,
         input: ByteListBlob,
-        state: *const std::ffi::c_void,
     ) -> DecoderResultBlob {
         // do cleanup
         drop(String::from(encoding));
@@ -89,9 +89,9 @@ pub extern "C" fn lib_ruby_parser__test__always_ok_decoder(output: *const u8) ->
 pub extern "C" fn lib_ruby_parser__test__always_err_decoder(output: *const u8) -> Decoder {
     #[no_mangle]
     pub extern "C" fn lib_ruby_parser__test__always_err_decoder_fn(
+        state: *const std::ffi::c_void,
         encoding: StringBlob,
         input: ByteListBlob,
-        state: *const std::ffi::c_void,
     ) -> DecoderResultBlob {
         // do cleanup
         drop(String::from(encoding));

ruby-parser-cpp/src/parser_options.rs

@@ -21,9 +21,9 @@ impl From<CParserOptions> for lib_ruby_parser::ParserOptions {
         } = options;
 
         let decoder = decoder.map(|decoder| {
-            let Decoder { f, state } = decoder;
             lib_ruby_parser::source::Decoder::new(Box::new(move |encoding, input| {
-                f(encoding.into(), input.into(), state).into()
+                let Decoder { f, state } = decoder;
+                f(state, encoding.into(), input.into()).into()
             }))
         });
 

string.cpp

@@ -4,8 +4,6 @@
 
 namespace lib_ruby_parser
 {
-    BLOB(String);
-
     extern "C"
     {
         StringBlob LIB_RUBY_PARSER_new_string_owned(char *s, size_t len);

string.hpp

@@ -32,6 +32,14 @@ namespace lib_ruby_parser
         static String Copied(const char *s);
     };
 
+    extern "C"
+    {
+        struct StringBlob
+        {
+            uint8_t bytes[sizeof(String)];
+        };
+    }
+
     /// Rerpresentation of Option<String>.
     /// Rust has a Option<non-null ptr> optimization that None is NULL on the byte level.
     /// Thus, it's not a tagged enum.