json 1.8.3 → 2.3.0

data/ext/json/ext/generator/generator.c

@@ -7,14 +7,20 @@ static ID i_encoding, i_encode;
 #endif
 
 static VALUE mJSON, mExt, mGenerator, cState, mGeneratorMethods, mObject,
-             mHash, mArray, mFixnum, mBignum, mFloat, mString, mString_Extend,
+             mHash, mArray,
+#ifdef RUBY_INTEGER_UNIFICATION
+             mInteger,
+#else
+             mFixnum, mBignum,
+#endif
+             mFloat, mString, mString_Extend,
              mTrueClass, mFalseClass, mNilClass, eGeneratorError,
-             eNestingError, CRegexp_MULTILINE, CJSON_SAFE_STATE_PROTOTYPE,
+             eNestingError,
              i_SAFE_STATE_PROTOTYPE;
 
 static ID i_to_s, i_to_json, i_new, i_indent, i_space, i_space_before,
           i_object_nl, i_array_nl, i_max_nesting, i_allow_nan, i_ascii_only,
-          i_quirks_mode, i_pack, i_unpack, i_create_id, i_extend, i_key_p,
+          i_pack, i_unpack, i_create_id, i_extend, i_key_p,
           i_aref, i_send, i_respond_to_p, i_match, i_keys, i_depth,
           i_buffer_initial_length, i_dup;
 
@@ -216,6 +222,7 @@ static void convert_UTF8_to_JSON_ASCII(FBuffer *buffer, VALUE string)
             unicode_escape_to_buffer(buffer, buf, (UTF16)((ch & halfMask) + UNI_SUR_LOW_START));
         }
     }
+    RB_GC_GUARD(string);
 }
 
 /* Converts string to a JSON string in FBuffer buffer, where only the
@@ -230,6 +237,7 @@ static void convert_UTF8_to_JSON(FBuffer *buffer, VALUE string)
     int escape_len;
     unsigned char c;
     char buf[6] = { '\\', 'u' };
+    int ascii_only = rb_enc_str_asciionly_p(string);
 
     for (start = 0, end = 0; end < len;) {
         p = ptr + end;
@@ -274,14 +282,17 @@ static void convert_UTF8_to_JSON(FBuffer *buffer, VALUE string)
                     break;
                 default:
                     {
-                        unsigned short clen = trailingBytesForUTF8[c] + 1;
-                        if (end + clen > len) {
-                            rb_raise(rb_path2class("JSON::GeneratorError"),
-                                    "partial character in source, but hit end");
-                        }
-                        if (!isLegalUTF8((UTF8 *) p, clen)) {
-                            rb_raise(rb_path2class("JSON::GeneratorError"),
-                                    "source sequence is illegal/malformed utf-8");
+                        unsigned short clen = 1;
+                        if (!ascii_only) {
+                            clen += trailingBytesForUTF8[c];
+                            if (end + clen > len) {
+                                rb_raise(rb_path2class("JSON::GeneratorError"),
+                                        "partial character in source, but hit end");
+                            }
+                            if (!isLegalUTF8((UTF8 *) p, clen)) {
+                                rb_raise(rb_path2class("JSON::GeneratorError"),
+                                        "source sequence is illegal/malformed utf-8");
+                            }
                         }
                         end += clen;
                     }
@@ -301,7 +312,7 @@ static char *fstrndup(const char *ptr, unsigned long len) {
   char *result;
   if (len <= 0) return NULL;
   result = ALLOC_N(char, len);
-  memccpy(result, ptr, 0, len);
+  memcpy(result, ptr, len);
   return result;
 }
 
@@ -342,6 +353,18 @@ static VALUE mArray_to_json(int argc, VALUE *argv, VALUE self) {
     GENERATE_JSON(array);
 }
 
+#ifdef RUBY_INTEGER_UNIFICATION
+/*
+ * call-seq: to_json(*)
+ *
+ * Returns a JSON string representation for this Integer number.
+ */
+static VALUE mInteger_to_json(int argc, VALUE *argv, VALUE self)
+{
+    GENERATE_JSON(integer);
+}
+
+#else
 /*
  * call-seq: to_json(*)
  *
@@ -361,6 +384,7 @@ static VALUE mBignum_to_json(int argc, VALUE *argv, VALUE self)
 {
     GENERATE_JSON(bignum);
 }
+#endif
 
 /*
  * call-seq: to_json(*)
@@ -622,8 +646,6 @@ static VALUE cState_configure(VALUE self, VALUE opts)
     state->allow_nan = RTEST(tmp);
     tmp = rb_hash_aref(opts, ID2SYM(i_ascii_only));
     state->ascii_only = RTEST(tmp);
-    tmp = rb_hash_aref(opts, ID2SYM(i_quirks_mode));
-    state->quirks_mode = RTEST(tmp);
     return self;
 }
 
@@ -657,7 +679,6 @@ static VALUE cState_to_h(VALUE self)
     rb_hash_aset(result, ID2SYM(i_array_nl), rb_str_new(state->array_nl, state->array_nl_len));
     rb_hash_aset(result, ID2SYM(i_allow_nan), state->allow_nan ? Qtrue : Qfalse);
     rb_hash_aset(result, ID2SYM(i_ascii_only), state->ascii_only ? Qtrue : Qfalse);
-    rb_hash_aset(result, ID2SYM(i_quirks_mode), state->quirks_mode ? Qtrue : Qfalse);
     rb_hash_aset(result, ID2SYM(i_max_nesting), LONG2FIX(state->max_nesting));
     rb_hash_aset(result, ID2SYM(i_depth), LONG2FIX(state->depth));
     rb_hash_aset(result, ID2SYM(i_buffer_initial_length), LONG2FIX(state->buffer_initial_length));
@@ -675,7 +696,7 @@ static VALUE cState_aref(VALUE self, VALUE name)
     if (RTEST(rb_funcall(self, i_respond_to_p, 1, name))) {
         return rb_funcall(self, i_send, 1, name);
     } else {
-        return rb_ivar_get(self, rb_intern_str(rb_str_concat(rb_str_new2("@"), name)));
+        return rb_attr_get(self, rb_intern_str(rb_str_concat(rb_str_new2("@"), name)));
     }
 }
 
@@ -698,43 +719,83 @@ static VALUE cState_aset(VALUE self, VALUE name, VALUE value)
     return Qnil;
 }
 
-static void generate_json_object(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
+struct hash_foreach_arg {
+    FBuffer *buffer;
+    JSON_Generator_State *state;
+    VALUE Vstate;
+    int iter;
+};
+
+static int
+json_object_i(VALUE key, VALUE val, VALUE _arg)
 {
+    struct hash_foreach_arg *arg = (struct hash_foreach_arg *)_arg;
+    FBuffer *buffer = arg->buffer;
+    JSON_Generator_State *state = arg->state;
+    VALUE Vstate = arg->Vstate;
+
     char *object_nl = state->object_nl;
     long object_nl_len = state->object_nl_len;
     char *indent = state->indent;
     long indent_len = state->indent_len;
-    long max_nesting = state->max_nesting;
     char *delim = FBUFFER_PTR(state->object_delim);
     long delim_len = FBUFFER_LEN(state->object_delim);
     char *delim2 = FBUFFER_PTR(state->object_delim2);
     long delim2_len = FBUFFER_LEN(state->object_delim2);
+    long depth = state->depth;
+    int j;
+    VALUE klass, key_to_s;
+
+    if (arg->iter > 0) fbuffer_append(buffer, delim, delim_len);
+    if (object_nl) {
+        fbuffer_append(buffer, object_nl, object_nl_len);
+    }
+    if (indent) {
+        for (j = 0; j < depth; j++) {
+            fbuffer_append(buffer, indent, indent_len);
+        }
+    }
+
+    klass = CLASS_OF(key);
+    if (klass == rb_cString) {
+        key_to_s = key;
+    } else if (klass == rb_cSymbol) {
+        key_to_s = rb_id2str(SYM2ID(key));
+    } else {
+        key_to_s = rb_funcall(key, i_to_s, 0);
+    }
+    Check_Type(key_to_s, T_STRING);
+    generate_json(buffer, Vstate, state, key_to_s);
+    fbuffer_append(buffer, delim2, delim2_len);
+    generate_json(buffer, Vstate, state, val);
+
+    arg->iter++;
+    return ST_CONTINUE;
+}
+
+static void generate_json_object(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
+{
+    char *object_nl = state->object_nl;
+    long object_nl_len = state->object_nl_len;
+    char *indent = state->indent;
+    long indent_len = state->indent_len;
+    long max_nesting = state->max_nesting;
     long depth = ++state->depth;
-    int i, j;
-    VALUE key, key_to_s, keys;
+    int j;
+    struct hash_foreach_arg arg;
+
     if (max_nesting != 0 && depth > max_nesting) {
         fbuffer_free(buffer);
         rb_raise(eNestingError, "nesting of %ld is too deep", --state->depth);
     }
     fbuffer_append_char(buffer, '{');
-    keys = rb_funcall(obj, i_keys, 0);
-    for(i = 0; i < RARRAY_LEN(keys); i++) {
-        if (i > 0) fbuffer_append(buffer, delim, delim_len);
-        if (object_nl) {
-            fbuffer_append(buffer, object_nl, object_nl_len);
-        }
-        if (indent) {
-            for (j = 0; j < depth; j++) {
-                fbuffer_append(buffer, indent, indent_len);
-            }
-        }
-        key = rb_ary_entry(keys, i);
-        key_to_s = rb_funcall(key, i_to_s, 0);
-        Check_Type(key_to_s, T_STRING);
-        generate_json(buffer, Vstate, state, key_to_s);
-        fbuffer_append(buffer, delim2, delim2_len);
-        generate_json(buffer, Vstate, state, rb_hash_aref(obj, key));
-    }
+
+    arg.buffer = buffer;
+    arg.state = state;
+    arg.Vstate = Vstate;
+    arg.iter = 0;
+    rb_hash_foreach(obj, json_object_i, (VALUE)&arg);
+
     depth = --state->depth;
     if (object_nl) {
         fbuffer_append(buffer, object_nl, object_nl_len);
@@ -785,11 +846,22 @@ static void generate_json_array(FBuffer *buffer, VALUE Vstate, JSON_Generator_St
     fbuffer_append_char(buffer, ']');
 }
 
+#ifdef HAVE_RUBY_ENCODING_H
+static int enc_utf8_compatible_p(rb_encoding *enc)
+{
+    if (enc == rb_usascii_encoding()) return 1;
+    if (enc == rb_utf8_encoding()) return 1;
+    return 0;
+}
+#endif
+
 static void generate_json_string(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
 {
     fbuffer_append_char(buffer, '"');
 #ifdef HAVE_RUBY_ENCODING_H
-    obj = rb_funcall(obj, i_encode, 1, CEncoding_UTF_8);
+    if (!enc_utf8_compatible_p(rb_enc_get(obj))) {
+        obj = rb_str_encode(obj, CEncoding_UTF_8, 0, Qnil);
+    }
 #endif
     if (state->ascii_only) {
         convert_UTF8_to_JSON_ASCII(buffer, obj);
@@ -825,6 +897,15 @@ static void generate_json_bignum(FBuffer *buffer, VALUE Vstate, JSON_Generator_S
     fbuffer_append_str(buffer, tmp);
 }
 
+#ifdef RUBY_INTEGER_UNIFICATION
+static void generate_json_integer(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
+{
+    if (FIXNUM_P(obj))
+        generate_json_fixnum(buffer, Vstate, state, obj);
+    else
+        generate_json_bignum(buffer, Vstate, state, obj);
+}
+#endif
 static void generate_json_float(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
 {
     double value = RFLOAT_VALUE(obj);
@@ -858,9 +939,9 @@ static void generate_json(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *s
         generate_json_false(buffer, Vstate, state, obj);
     } else if (obj == Qtrue) {
         generate_json_true(buffer, Vstate, state, obj);
-    } else if (klass == rb_cFixnum) {
+    } else if (FIXNUM_P(obj)) {
         generate_json_fixnum(buffer, Vstate, state, obj);
-    } else if (klass == rb_cBignum) {
+    } else if (RB_TYPE_P(obj, T_BIGNUM)) {
         generate_json_bignum(buffer, Vstate, state, obj);
     } else if (klass == rb_cFloat) {
         generate_json_float(buffer, Vstate, state, obj);
@@ -871,7 +952,7 @@ static void generate_json(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *s
     } else {
         tmp = rb_funcall(obj, i_to_s, 0);
         Check_Type(tmp, T_STRING);
-        generate_json(buffer, Vstate, state, tmp);
+        generate_json_string(buffer, Vstate, state, tmp);
     }
 }
 
@@ -914,21 +995,6 @@ static VALUE cState_partial_generate(VALUE self, VALUE obj)
     return fbuffer_to_s(buffer);
 }
 
-/*
- * This function returns true if string is either a JSON array or JSON object.
- * It might suffer from false positives, e. g. syntactically incorrect JSON in
- * the string or certain UTF-8 characters on the right hand side.
- */
-static int isArrayOrObject(VALUE string)
-{
-    long string_len = RSTRING_LEN(string);
-    char *p = RSTRING_PTR(string), *q = p + string_len - 1;
-    if (string_len < 2) return 0;
-    for (; p < q && isspace((unsigned char)*p); p++);
-    for (; q > p && isspace((unsigned char)*q); q--);
-    return (*p == '[' && *q == ']') || (*p == '{' && *q == '}');
-}
-
 /*
  * call-seq: generate(obj)
  *
@@ -940,9 +1006,7 @@ static VALUE cState_generate(VALUE self, VALUE obj)
 {
     VALUE result = cState_partial_generate(self, obj);
     GET_STATE(self);
-    if (!state->quirks_mode && !isArrayOrObject(result)) {
-        rb_raise(eGeneratorError, "only generation of JSON objects or arrays allowed");
-    }
+    (void)state;
     return result;
 }
 
@@ -961,8 +1025,8 @@ static VALUE cState_generate(VALUE self, VALUE obj)
  * * *allow_nan*: true if NaN, Infinity, and -Infinity should be
  *   generated, otherwise an exception is thrown, if these values are
  *   encountered. This options defaults to false.
- * * *quirks_mode*: Enables quirks_mode for parser, that is for example
- *   generating single JSON values instead of documents is possible.
+ * * *ascii_only*: true if only ASCII characters should be generated. This
+ *   ontions defaults to false.
  * * *buffer_initial_length*: sets the initial length of the generator's
  *   internal buffer.
  */
@@ -1018,10 +1082,8 @@ static VALUE cState_from_state_s(VALUE self, VALUE opts)
     } else if (rb_obj_is_kind_of(opts, rb_cHash)) {
         return rb_funcall(self, i_new, 1, opts);
     } else {
-        if (NIL_P(CJSON_SAFE_STATE_PROTOTYPE)) {
-            CJSON_SAFE_STATE_PROTOTYPE = rb_const_get(mJSON, i_SAFE_STATE_PROTOTYPE);
-        }
-        return rb_funcall(CJSON_SAFE_STATE_PROTOTYPE, i_dup, 0);
+        VALUE prototype = rb_const_get(mJSON, i_SAFE_STATE_PROTOTYPE);
+        return rb_funcall(prototype, i_dup, 0);
     }
 }
 
@@ -1055,7 +1117,7 @@ static VALUE cState_indent_set(VALUE self, VALUE indent)
         }
     } else {
         if (state->indent) ruby_xfree(state->indent);
-        state->indent = strdup(RSTRING_PTR(indent));
+        state->indent = fstrndup(RSTRING_PTR(indent), len);
         state->indent_len = len;
     }
     return Qnil;
@@ -1093,7 +1155,7 @@ static VALUE cState_space_set(VALUE self, VALUE space)
         }
     } else {
         if (state->space) ruby_xfree(state->space);
-        state->space = strdup(RSTRING_PTR(space));
+        state->space = fstrndup(RSTRING_PTR(space), len);
         state->space_len = len;
     }
     return Qnil;
@@ -1129,7 +1191,7 @@ static VALUE cState_space_before_set(VALUE self, VALUE space_before)
         }
     } else {
         if (state->space_before) ruby_xfree(state->space_before);
-        state->space_before = strdup(RSTRING_PTR(space_before));
+        state->space_before = fstrndup(RSTRING_PTR(space_before), len);
         state->space_before_len = len;
     }
     return Qnil;
@@ -1166,7 +1228,7 @@ static VALUE cState_object_nl_set(VALUE self, VALUE object_nl)
         }
     } else {
         if (state->object_nl) ruby_xfree(state->object_nl);
-        state->object_nl = strdup(RSTRING_PTR(object_nl));
+        state->object_nl = fstrndup(RSTRING_PTR(object_nl), len);
         state->object_nl_len = len;
     }
     return Qnil;
@@ -1201,7 +1263,7 @@ static VALUE cState_array_nl_set(VALUE self, VALUE array_nl)
         }
     } else {
         if (state->array_nl) ruby_xfree(state->array_nl);
-        state->array_nl = strdup(RSTRING_PTR(array_nl));
+        state->array_nl = fstrndup(RSTRING_PTR(array_nl), len);
         state->array_nl_len = len;
     }
     return Qnil;
@@ -1260,7 +1322,7 @@ static VALUE cState_allow_nan_p(VALUE self)
 /*
  * call-seq: ascii_only?
  *
- * Returns true, if NaN, Infinity, and -Infinity should be generated, otherwise
+ * Returns true, if only ASCII characters should be generated. Otherwise
  * returns false.
  */
 static VALUE cState_ascii_only_p(VALUE self)
@@ -1269,29 +1331,6 @@ static VALUE cState_ascii_only_p(VALUE self)
     return state->ascii_only ? Qtrue : Qfalse;
 }
 
-/*
- * call-seq: quirks_mode?
- *
- * Returns true, if quirks mode is enabled. Otherwise returns false.
- */
-static VALUE cState_quirks_mode_p(VALUE self)
-{
-    GET_STATE(self);
-    return state->quirks_mode ? Qtrue : Qfalse;
-}
-
-/*
- * call-seq: quirks_mode=(enable)
- *
- * If set to true, enables the quirks_mode mode.
- */
-static VALUE cState_quirks_mode_set(VALUE self, VALUE enable)
-{
-    GET_STATE(self);
-    state->quirks_mode = RTEST(enable);
-    return Qnil;
-}
-
 /*
  * call-seq: depth
  *
@@ -1351,6 +1390,7 @@ static VALUE cState_buffer_initial_length_set(VALUE self, VALUE buffer_initial_l
  */
 void Init_generator(void)
 {
+#undef rb_intern
     rb_require("json/common");
 
     mJSON = rb_define_module("JSON");
@@ -1359,6 +1399,8 @@ void Init_generator(void)
 
     eGeneratorError = rb_path2class("JSON::GeneratorError");
     eNestingError = rb_path2class("JSON::NestingError");
+    rb_gc_register_mark_object(eGeneratorError);
+    rb_gc_register_mark_object(eNestingError);
 
     cState = rb_define_class_under(mGenerator, "State", rb_cObject);
     rb_define_alloc_func(cState, cState_s_allocate);
@@ -1380,9 +1422,6 @@ void Init_generator(void)
     rb_define_method(cState, "check_circular?", cState_check_circular_p, 0);
     rb_define_method(cState, "allow_nan?", cState_allow_nan_p, 0);
     rb_define_method(cState, "ascii_only?", cState_ascii_only_p, 0);
-    rb_define_method(cState, "quirks_mode?", cState_quirks_mode_p, 0);
-    rb_define_method(cState, "quirks_mode", cState_quirks_mode_p, 0);
-    rb_define_method(cState, "quirks_mode=", cState_quirks_mode_set, 1);
     rb_define_method(cState, "depth", cState_depth, 0);
     rb_define_method(cState, "depth=", cState_depth_set, 1);
     rb_define_method(cState, "buffer_initial_length", cState_buffer_initial_length, 0);
@@ -1402,10 +1441,15 @@ void Init_generator(void)
     rb_define_method(mHash, "to_json", mHash_to_json, -1);
     mArray = rb_define_module_under(mGeneratorMethods, "Array");
     rb_define_method(mArray, "to_json", mArray_to_json, -1);
+#ifdef RUBY_INTEGER_UNIFICATION
+    mInteger = rb_define_module_under(mGeneratorMethods, "Integer");
+    rb_define_method(mInteger, "to_json", mInteger_to_json, -1);
+#else
     mFixnum = rb_define_module_under(mGeneratorMethods, "Fixnum");
     rb_define_method(mFixnum, "to_json", mFixnum_to_json, -1);
     mBignum = rb_define_module_under(mGeneratorMethods, "Bignum");
     rb_define_method(mBignum, "to_json", mBignum_to_json, -1);
+#endif
     mFloat = rb_define_module_under(mGeneratorMethods, "Float");
     rb_define_method(mFloat, "to_json", mFloat_to_json, -1);
     mString = rb_define_module_under(mGeneratorMethods, "String");
@@ -1422,7 +1466,6 @@ void Init_generator(void)
     mNilClass = rb_define_module_under(mGeneratorMethods, "NilClass");
     rb_define_method(mNilClass, "to_json", mNilClass_to_json, -1);
 
-    CRegexp_MULTILINE = rb_const_get(rb_cRegexp, rb_intern("MULTILINE"));
     i_to_s = rb_intern("to_s");
     i_to_json = rb_intern("to_json");
     i_new = rb_intern("new");
@@ -1434,7 +1477,6 @@ void Init_generator(void)
     i_max_nesting = rb_intern("max_nesting");
     i_allow_nan = rb_intern("allow_nan");
     i_ascii_only = rb_intern("ascii_only");
-    i_quirks_mode = rb_intern("quirks_mode");
     i_depth = rb_intern("depth");
     i_buffer_initial_length = rb_intern("buffer_initial_length");
     i_pack = rb_intern("pack");
@@ -1454,5 +1496,4 @@ void Init_generator(void)
     i_encode = rb_intern("encode");
 #endif
     i_SAFE_STATE_PROTOTYPE = rb_intern("SAFE_STATE_PROTOTYPE");
-    CJSON_SAFE_STATE_PROTOTYPE = Qnil;
 }

data/ext/json/ext/generator/generator.h

@@ -1,7 +1,6 @@
 #ifndef _GENERATOR_H_
 #define _GENERATOR_H_
 
-#include <string.h>
 #include <math.h>
 #include <ctype.h>
 
@@ -73,7 +72,6 @@ typedef struct JSON_Generator_StateStruct {
     long max_nesting;
     char allow_nan;
     char ascii_only;
-    char quirks_mode;
     long depth;
     long buffer_initial_length;
 } JSON_Generator_State;
@@ -99,8 +97,12 @@ typedef struct JSON_Generator_StateStruct {
 
 static VALUE mHash_to_json(int argc, VALUE *argv, VALUE self);
 static VALUE mArray_to_json(int argc, VALUE *argv, VALUE self);
+#ifdef RUBY_INTEGER_UNIFICATION
+static VALUE mInteger_to_json(int argc, VALUE *argv, VALUE self);
+#else
 static VALUE mFixnum_to_json(int argc, VALUE *argv, VALUE self);
 static VALUE mBignum_to_json(int argc, VALUE *argv, VALUE self);
+#endif
 static VALUE mFloat_to_json(int argc, VALUE *argv, VALUE self);
 static VALUE mString_included_s(VALUE self, VALUE modul);
 static VALUE mString_to_json(int argc, VALUE *argv, VALUE self);
@@ -122,6 +124,9 @@ static void generate_json_string(FBuffer *buffer, VALUE Vstate, JSON_Generator_S
 static void generate_json_null(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
 static void generate_json_false(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
 static void generate_json_true(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
+#ifdef RUBY_INTEGER_UNIFICATION
+static void generate_json_integer(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
+#endif
 static void generate_json_fixnum(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
 static void generate_json_bignum(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
 static void generate_json_float(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);

data/ext/json/ext/parser/extconf.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: false
 require 'mkmf'
 
+have_func("rb_enc_raise", "ruby.h")
+
 create_makefile 'json/ext/parser'