attach additional pointer to decoder/token_rewriter, pass it to decode/token_rewrite function

iliabylich · iliabylich · commit bfc11002baae · 2021-11-26T13:43:27.000+03:00
diff --git a/decoder.c b/decoder.c
@@ -76,13 +76,13 @@ static void test_decoder_fields(void)
     const char *ALWAYS_ERR = "always_err";
 
     d = lib_ruby_parser__test__always_ok_decoder();
-    decoder_result = (d.f)(LIB_RUBY_PARSER_new_string_from_cstr("utf-8"), LIB_RUBY_PARSER_new_bytes_from_cstr("2 + 2", 5));
+    decoder_result = (d.f)(d.state, LIB_RUBY_PARSER_new_string_from_cstr("utf-8"), LIB_RUBY_PARSER_new_bytes_from_cstr("2 + 2", 5));
     assert_eq(decoder_result.tag, LIB_RUBY_PARSER_DECODER_RESULT_OK);
     assert_byte_list(decoder_result.as.ok, ALWAYS_OK);
     LIB_RUBY_PARSER_drop_decoder_result(&decoder_result);
 
     d = lib_ruby_parser__test__always_err_decoder();
-    decoder_result = (d.f)(LIB_RUBY_PARSER_new_string_from_cstr("utf-8"), LIB_RUBY_PARSER_new_bytes_from_cstr("2 + 2", 5));
+    decoder_result = (d.f)(d.state, LIB_RUBY_PARSER_new_string_from_cstr("utf-8"), LIB_RUBY_PARSER_new_bytes_from_cstr("2 + 2", 5));
     assert_eq(decoder_result.as.err.tag, LIB_RUBY_PARSER_INPUT_ERROR_DECODING_ERROR);
     assert_string_eq(decoder_result.as.err.as.unsupported_encoding, ALWAYS_ERR);
     LIB_RUBY_PARSER_drop_decoder_result(&decoder_result);
diff --git a/decoder.h b/decoder.h
@@ -38,10 +38,11 @@ typedef struct LIB_RUBY_PARSER_DecoderResult
 void LIB_RUBY_PARSER_drop_decoder_result(LIB_RUBY_PARSER_DecoderResult *decoder_result);
 
 struct LIB_RUBY_PARSER_Decoder;
-typedef LIB_RUBY_PARSER_DecoderResult (*LIB_RUBY_PARSER_Decoder_Function)(LIB_RUBY_PARSER_String, LIB_RUBY_PARSER_ByteList);
+typedef LIB_RUBY_PARSER_DecoderResult (*LIB_RUBY_PARSER_Decoder_Function)(void *state, LIB_RUBY_PARSER_String encoding, LIB_RUBY_PARSER_ByteList input);
 typedef struct LIB_RUBY_PARSER_Decoder
 {
     LIB_RUBY_PARSER_Decoder_Function f;
+    void *state;
 } LIB_RUBY_PARSER_Decoder;
 
 typedef struct LIB_RUBY_PARSER_MaybeDecoder
diff --git a/ruby-parser-c/src/decoder.rs b/ruby-parser-c/src/decoder.rs
@@ -50,14 +50,20 @@ pub extern "C" fn LIB_RUBY_PARSER_drop_decoder_result(decoder_result: *mut Decod
 
 #[repr(C)]
 pub struct Decoder {
-    pub f: extern "C" fn(encoding: StringBlob, input: ByteListBlob) -> DecoderResultBlob,
+    pub f: extern "C" fn(
+        state: *mut std::ffi::c_void,
+        encoding: StringBlob,
+        input: ByteListBlob,
+    ) -> DecoderResultBlob,
+    pub state: *mut std::ffi::c_void,
 }
 
 #[cfg(feature = "tests")]
 #[no_mangle]
 pub extern "C" fn lib_ruby_parser__test__always_ok_decoder() -> Decoder {
     #[no_mangle]
     pub extern "C" fn lib_ruby_parser__test__always_ok_decoder_fn(
+        _state: *mut std::ffi::c_void,
         encoding: StringBlob,
         input: ByteListBlob,
     ) -> DecoderResultBlob {
@@ -69,6 +75,7 @@ pub extern "C" fn lib_ruby_parser__test__always_ok_decoder() -> Decoder {
     }
     Decoder {
         f: lib_ruby_parser__test__always_ok_decoder_fn,
+        state: std::ptr::null_mut(),
     }
 }
 
@@ -77,6 +84,7 @@ pub extern "C" fn lib_ruby_parser__test__always_ok_decoder() -> Decoder {
 pub extern "C" fn lib_ruby_parser__test__always_err_decoder() -> Decoder {
     #[no_mangle]
     pub extern "C" fn lib_ruby_parser__test__always_err_decoder_fn(
+        _state: *mut std::ffi::c_void,
         encoding: StringBlob,
         input: ByteListBlob,
     ) -> DecoderResultBlob {
@@ -90,6 +98,7 @@ pub extern "C" fn lib_ruby_parser__test__always_err_decoder() -> Decoder {
     }
     Decoder {
         f: lib_ruby_parser__test__always_err_decoder_fn,
+        state: std::ptr::null_mut(),
     }
 }
 
diff --git a/ruby-parser-c/src/parser_options.rs b/ruby-parser-c/src/parser_options.rs
@@ -21,15 +21,17 @@ impl From<CParserOptions> for lib_ruby_parser::ParserOptions {
 
         let decoder = decoder.map(|decoder| {
             lib_ruby_parser::source::Decoder::new(Box::new(move |encoding, input| {
-                (decoder.f)(encoding.into(), input.into()).into()
+                let Decoder { f, state } = decoder;
+                f(state, encoding.into(), input.into()).into()
             }))
         });
 
         let token_rewriter = token_rewriter.map(|token_rewriter| {
             lib_ruby_parser::source::token_rewriter::TokenRewriter::new(Box::new(
                 move |token, input| {
                     let input: &'static [u8] = unsafe { std::mem::transmute(input) };
-                    (token_rewriter.f)(Box::leak(token), input.into())
+                    let TokenRewriter { f, state } = token_rewriter;
+                    f(state, Box::leak(token), input.into())
                 },
             ))
         });
diff --git a/ruby-parser-c/src/token_rewriter.rs b/ruby-parser-c/src/token_rewriter.rs
@@ -59,14 +59,20 @@ pub extern "C" fn LIB_RUBY_PARSER_drop_token_rewriter_result(
 
 #[repr(C)]
 pub struct TokenRewriter {
-    pub f: extern "C" fn(token: *mut Token, input: SharedByteListBlob) -> TokenRewriterResult,
+    pub f: extern "C" fn(
+        *mut std::ffi::c_void,
+        token: *mut Token,
+        input: SharedByteListBlob,
+    ) -> TokenRewriterResult,
+    pub state: *mut std::ffi::c_void,
 }
 
 #[cfg(feature = "tests")]
 #[no_mangle]
 pub extern "C" fn lib_ruby_parser__test__always_keep_token_rewriter() -> TokenRewriter {
     #[no_mangle]
     pub extern "C" fn lib_ruby_parser__test__always_keep_token_rewriter_fn(
+        _state: *mut std::ffi::c_void,
         token: *mut Token,
         _input: SharedByteListBlob,
     ) -> TokenRewriterResult {
@@ -79,6 +85,7 @@ pub extern "C" fn lib_ruby_parser__test__always_keep_token_rewriter() -> TokenRe
     }
     TokenRewriter {
         f: lib_ruby_parser__test__always_keep_token_rewriter_fn,
+        state: std::ptr::null_mut(),
     }
 }
 
@@ -87,6 +94,7 @@ pub extern "C" fn lib_ruby_parser__test__always_keep_token_rewriter() -> TokenRe
 pub extern "C" fn lib_ruby_parser__test__always_rewrite_token_rewriter() -> TokenRewriter {
     #[no_mangle]
     pub extern "C" fn lib_ruby_parser__test__always_rewrite_token_rewriter_fn(
+        _state: *mut std::ffi::c_void,
         token: *mut Token,
         _input: SharedByteListBlob,
     ) -> TokenRewriterResult {
@@ -107,6 +115,7 @@ pub extern "C" fn lib_ruby_parser__test__always_rewrite_token_rewriter() -> Toke
     }
     TokenRewriter {
         f: lib_ruby_parser__test__always_rewrite_token_rewriter_fn,
+        state: std::ptr::null_mut(),
     }
 }
 
diff --git a/token_rewriter.c b/token_rewriter.c
@@ -76,15 +76,15 @@ static void test_token_rewriter(void)
     token = (LIB_RUBY_PARSER_Token *)malloc(sizeof(LIB_RUBY_PARSER_Token));
     token->token_type = 396; // tPLUS
     token->token_value.raw = (LIB_RUBY_PARSER_ByteList){.ptr = NULL, .len = 0, .capacity = 0};
-    result = (token_rewriter.f)(token, input);
+    result = (token_rewriter.f)(token_rewriter.state, token, input);
     assert_token(*(result.rewritten_token), "tPLUS");
     LIB_RUBY_PARSER_drop_token_rewriter_result(&result);
 
     token_rewriter = lib_ruby_parser__test__always_rewrite_token_rewriter();
     token = (LIB_RUBY_PARSER_Token *)malloc(sizeof(LIB_RUBY_PARSER_Token));
     token->token_type = 396; // tPLUS
     token->token_value.raw = (LIB_RUBY_PARSER_ByteList){.ptr = NULL, .len = 0, .capacity = 0};
-    result = (token_rewriter.f)(token, input);
+    result = (token_rewriter.f)(token_rewriter.state, token, input);
     assert_token(*(result.rewritten_token), "tMINUS");
     LIB_RUBY_PARSER_drop_token_rewriter_result(&result);
 }
diff --git a/token_rewriter.h b/token_rewriter.h
@@ -34,10 +34,11 @@ typedef struct LIB_RUBY_PARSER_TokenRewriterResult
 void LIB_RUBY_PARSER_drop_token_rewriter_result(LIB_RUBY_PARSER_TokenRewriterResult *);
 
 struct LIB_RUBY_PARSER_TokenRewriter;
-typedef LIB_RUBY_PARSER_TokenRewriterResult (*LIB_RUBY_PARSER_TokenRewriter_Function)(LIB_RUBY_PARSER_Token *, LIB_RUBY_PARSER_SharedByteList);
+typedef LIB_RUBY_PARSER_TokenRewriterResult (*LIB_RUBY_PARSER_TokenRewriter_Function)(void *state, LIB_RUBY_PARSER_Token *token, LIB_RUBY_PARSER_SharedByteList input);
 typedef struct LIB_RUBY_PARSER_TokenRewriter
 {
     LIB_RUBY_PARSER_TokenRewriter_Function f;
+    void *state;
 } LIB_RUBY_PARSER_TokenRewriter;
 
 typedef struct LIB_RUBY_PARSER_MaybeTokenRewriter

Original file line number	Diff line number	Diff line change
`@@ -50,14 +50,20 @@ pub extern "C" fn LIB_RUBY_PARSER_drop_decoder_result(decoder_result: *mut Decod`
`50`	`50`
`51`	`51`	`#[repr(C)]`
`52`	`52`	`pub struct Decoder {`
`53`		`- pub f: extern "C" fn(encoding: StringBlob, input: ByteListBlob) -> DecoderResultBlob,`
	`53`	`+ pub f: extern "C" fn(`
	`54`	`+ state: *mut std::ffi::c_void,`
	`55`	`+ encoding: StringBlob,`
	`56`	`+ input: ByteListBlob,`
	`57`	`+ ) -> DecoderResultBlob,`
	`58`	`+ pub state: *mut std::ffi::c_void,`
`54`	`59`	`}`
`55`	`60`
`56`	`61`	`#[cfg(feature = "tests")]`
`57`	`62`	`#[no_mangle]`
`58`	`63`	`pub extern "C" fn lib_ruby_parser__test__always_ok_decoder() -> Decoder {`
`59`	`64`	`#[no_mangle]`
`60`	`65`	`pub extern "C" fn lib_ruby_parser__test__always_ok_decoder_fn(`
	`66`	`+ _state: *mut std::ffi::c_void,`
`61`	`67`	`encoding: StringBlob,`
`62`	`68`	`input: ByteListBlob,`
`63`	`69`	`) -> DecoderResultBlob {`
`@@ -69,6 +75,7 @@ pub extern "C" fn lib_ruby_parser__test__always_ok_decoder() -> Decoder {`
`69`	`75`	`}`
`70`	`76`	`Decoder {`
`71`	`77`	`f: lib_ruby_parser__test__always_ok_decoder_fn,`
	`78`	`+ state: std::ptr::null_mut(),`
`72`	`79`	`}`
`73`	`80`	`}`
`74`	`81`
`@@ -77,6 +84,7 @@ pub extern "C" fn lib_ruby_parser__test__always_ok_decoder() -> Decoder {`
`77`	`84`	`pub extern "C" fn lib_ruby_parser__test__always_err_decoder() -> Decoder {`
`78`	`85`	`#[no_mangle]`
`79`	`86`	`pub extern "C" fn lib_ruby_parser__test__always_err_decoder_fn(`
	`87`	`+ _state: *mut std::ffi::c_void,`
`80`	`88`	`encoding: StringBlob,`
`81`	`89`	`input: ByteListBlob,`
`82`	`90`	`) -> DecoderResultBlob {`
`@@ -90,6 +98,7 @@ pub extern "C" fn lib_ruby_parser__test__always_err_decoder() -> Decoder {`
`90`	`98`	`}`
`91`	`99`	`Decoder {`
`92`	`100`	`f: lib_ruby_parser__test__always_err_decoder_fn,`
	`101`	`+ state: std::ptr::null_mut(),`
`93`	`102`	`}`
`94`	`103`	`}`
`95`	`104`
Original file line number	Diff line number	Diff line change
`@@ -59,14 +59,20 @@ pub extern "C" fn LIB_RUBY_PARSER_drop_token_rewriter_result(`
`59`	`59`
`60`	`60`	`#[repr(C)]`
`61`	`61`	`pub struct TokenRewriter {`
`62`		`- pub f: extern "C" fn(token: *mut Token, input: SharedByteListBlob) -> TokenRewriterResult,`
	`62`	`+ pub f: extern "C" fn(`
	`63`	`+ *mut std::ffi::c_void,`
	`64`	`+ token: *mut Token,`
	`65`	`+ input: SharedByteListBlob,`
	`66`	`+ ) -> TokenRewriterResult,`
	`67`	`+ pub state: *mut std::ffi::c_void,`
`63`	`68`	`}`
`64`	`69`
`65`	`70`	`#[cfg(feature = "tests")]`
`66`	`71`	`#[no_mangle]`
`67`	`72`	`pub extern "C" fn lib_ruby_parser__test__always_keep_token_rewriter() -> TokenRewriter {`
`68`	`73`	`#[no_mangle]`
`69`	`74`	`pub extern "C" fn lib_ruby_parser__test__always_keep_token_rewriter_fn(`
	`75`	`+ _state: *mut std::ffi::c_void,`
`70`	`76`	`token: *mut Token,`
`71`	`77`	`_input: SharedByteListBlob,`
`72`	`78`	`) -> TokenRewriterResult {`
`@@ -79,6 +85,7 @@ pub extern "C" fn lib_ruby_parser__test__always_keep_token_rewriter() -> TokenRe`
`79`	`85`	`}`
`80`	`86`	`TokenRewriter {`
`81`	`87`	`f: lib_ruby_parser__test__always_keep_token_rewriter_fn,`
	`88`	`+ state: std::ptr::null_mut(),`
`82`	`89`	`}`
`83`	`90`	`}`
`84`	`91`
`@@ -87,6 +94,7 @@ pub extern "C" fn lib_ruby_parser__test__always_keep_token_rewriter() -> TokenRe`
`87`	`94`	`pub extern "C" fn lib_ruby_parser__test__always_rewrite_token_rewriter() -> TokenRewriter {`
`88`	`95`	`#[no_mangle]`
`89`	`96`	`pub extern "C" fn lib_ruby_parser__test__always_rewrite_token_rewriter_fn(`
	`97`	`+ _state: *mut std::ffi::c_void,`
`90`	`98`	`token: *mut Token,`
`91`	`99`	`_input: SharedByteListBlob,`
`92`	`100`	`) -> TokenRewriterResult {`
`@@ -107,6 +115,7 @@ pub extern "C" fn lib_ruby_parser__test__always_rewrite_token_rewriter() -> Toke`
`107`	`115`	`}`
`108`	`116`	`TokenRewriter {`
`109`	`117`	`f: lib_ruby_parser__test__always_rewrite_token_rewriter_fn,`
	`118`	`+ state: std::ptr::null_mut(),`
`110`	`119`	`}`
`111`	`120`	`}`
`112`	`121`