json 2.7.2 → 2.7.3.rc1

data/ext/json/ext/parser/parser.h

@@ -3,33 +3,11 @@
 
 #include "ruby.h"
 
-#ifndef HAVE_RUBY_RE_H
-#include "re.h"
-#endif
-
-#ifdef HAVE_RUBY_ST_H
-#include "ruby/st.h"
-#else
-#include "st.h"
-#endif
-
 #ifndef MAYBE_UNUSED
 # define MAYBE_UNUSED(x) x
 #endif
 
-#define option_given_p(opts, key) RTEST(rb_funcall(opts, i_key_p, 1, key))
-
-/* unicode */
-
-typedef unsigned long UTF32;  /* at least 32 bits */
-typedef unsigned short UTF16; /* at least 16 bits */
-typedef unsigned char UTF8;   /* typically 8 bits */
-
-#define UNI_REPLACEMENT_CHAR (UTF32)0x0000FFFD
-#define UNI_SUR_HIGH_START  (UTF32)0xD800
-#define UNI_SUR_HIGH_END    (UTF32)0xDBFF
-#define UNI_SUR_LOW_START   (UTF32)0xDC00
-#define UNI_SUR_LOW_END     (UTF32)0xDFFF
+#define option_given_p(opts, key) (rb_hash_lookup2(opts, key, Qundef) != Qundef)
 
 typedef struct JSON_ParserStruct {
     VALUE Vsource;
@@ -60,8 +38,8 @@ typedef struct JSON_ParserStruct {
 #define MinusInfinity "-Infinity"
 #define EVIL 0x666
 
-static UTF32 unescape_unicode(const unsigned char *p);
-static int convert_UTF32_to_UTF8(char *buf, UTF32 ch);
+static uint32_t unescape_unicode(const unsigned char *p);
+static int convert_UTF32_to_UTF8(char *buf, uint32_t ch);
 static char *JSON_parse_object(JSON_Parser *json, char *p, char *pe, VALUE *result, int current_nesting);
 static char *JSON_parse_value(JSON_Parser *json, char *p, char *pe, VALUE *result, int current_nesting);
 static char *JSON_parse_integer(JSON_Parser *json, char *p, char *pe, VALUE *result);
@@ -76,21 +54,7 @@ static void JSON_mark(void *json);
 static void JSON_free(void *json);
 static VALUE cJSON_parser_s_allocate(VALUE klass);
 static VALUE cParser_source(VALUE self);
-#ifndef ZALLOC
-#define ZALLOC(type) ((type *)ruby_zalloc(sizeof(type)))
-static inline void *ruby_zalloc(size_t n)
-{
-    void *p = ruby_xmalloc(n);
-    memset(p, 0, n);
-    return p;
-}
-#endif
-#ifdef TypedData_Make_Struct
+
 static const rb_data_type_t JSON_Parser_type;
-#define NEW_TYPEDDATA_WRAPPER 1
-#else
-#define TypedData_Make_Struct(klass, type, ignore, json) Data_Make_Struct(klass, type, NULL, JSON_free, json)
-#define TypedData_Get_Struct(self, JSON_Parser, ignore, json) Data_Get_Struct(self, JSON_Parser, json)
-#endif
 
 #endif

data/ext/json/ext/parser/parser.rl

@@ -1,28 +1,6 @@
 #include "../fbuffer/fbuffer.h"
 #include "parser.h"
 
-#if defined HAVE_RUBY_ENCODING_H
-# define EXC_ENCODING rb_utf8_encoding(),
-# ifndef HAVE_RB_ENC_RAISE
-static void
-enc_raise(rb_encoding *enc, VALUE exc, const char *fmt, ...)
-{
-    va_list args;
-    VALUE mesg;
-
-    va_start(args, fmt);
-    mesg = rb_enc_vsprintf(enc, fmt, args);
-    va_end(args);
-
-    rb_exc_raise(rb_exc_new3(exc, mesg));
-}
-#   define rb_enc_raise enc_raise
-# endif
-#else
-# define EXC_ENCODING /* nothing */
-# define rb_enc_raise rb_raise
-#endif
-
 /* unicode */
 
 static const signed char digit_values[256] = {
@@ -42,26 +20,28 @@ static const signed char digit_values[256] = {
     -1, -1, -1, -1, -1, -1, -1
 };
 
-static UTF32 unescape_unicode(const unsigned char *p)
+static uint32_t unescape_unicode(const unsigned char *p)
 {
+    const uint32_t replacement_char = 0xFFFD;
+
     signed char b;
-    UTF32 result = 0;
+    uint32_t result = 0;
     b = digit_values[p[0]];
-    if (b < 0) return UNI_REPLACEMENT_CHAR;
+    if (b < 0) return replacement_char;
     result = (result << 4) | (unsigned char)b;
     b = digit_values[p[1]];
-    if (b < 0) return UNI_REPLACEMENT_CHAR;
+    if (b < 0) return replacement_char;
     result = (result << 4) | (unsigned char)b;
     b = digit_values[p[2]];
-    if (b < 0) return UNI_REPLACEMENT_CHAR;
+    if (b < 0) return replacement_char;
     result = (result << 4) | (unsigned char)b;
     b = digit_values[p[3]];
-    if (b < 0) return UNI_REPLACEMENT_CHAR;
+    if (b < 0) return replacement_char;
     result = (result << 4) | (unsigned char)b;
     return result;
 }
 
-static int convert_UTF32_to_UTF8(char *buf, UTF32 ch)
+static int convert_UTF32_to_UTF8(char *buf, uint32_t ch)
 {
     int len = 1;
     if (ch <= 0x7F) {
@@ -87,15 +67,39 @@ static int convert_UTF32_to_UTF8(char *buf, UTF32 ch)
     return len;
 }
 
-static VALUE mJSON, mExt, cParser, eParserError, eNestingError;
+#define PARSE_ERROR_FRAGMENT_LEN 32
+#ifdef RBIMPL_ATTR_NORETURN
+RBIMPL_ATTR_NORETURN()
+#endif
+static void raise_parse_error(const char *format, const char *start)
+{
+    char buffer[PARSE_ERROR_FRAGMENT_LEN + 1];
+
+    size_t len = strnlen(start, PARSE_ERROR_FRAGMENT_LEN);
+    const char *ptr = start;
+
+    if (len == PARSE_ERROR_FRAGMENT_LEN) {
+        MEMCPY(buffer, start, char, PARSE_ERROR_FRAGMENT_LEN);
+        buffer[PARSE_ERROR_FRAGMENT_LEN] = '\0';
+        ptr = buffer;
+    }
+
+    rb_enc_raise(rb_utf8_encoding(), rb_path2class("JSON::ParserError"), format, ptr);
+}
+
+static VALUE mJSON, mExt, cParser, eNestingError;
 static VALUE CNaN, CInfinity, CMinusInfinity;
 
 static ID i_json_creatable_p, i_json_create, i_create_id, i_create_additions,
           i_chr, i_max_nesting, i_allow_nan, i_symbolize_names,
-          i_object_class, i_array_class, i_decimal_class, i_key_p,
+          i_object_class, i_array_class, i_decimal_class,
           i_deep_const_get, i_match, i_match_string, i_aset, i_aref,
           i_leftshift, i_new, i_try_convert, i_freeze, i_uminus;
 
+static int binary_encindex;
+static int utf8_encindex;
+
+
 %%{
     machine JSON_common;
 
@@ -222,14 +226,14 @@ static char *JSON_parse_object(JSON_Parser *json, char *p, char *pe, VALUE *resu
         if (json->allow_nan) {
             *result = CNaN;
         } else {
-            rb_enc_raise(EXC_ENCODING eParserError, "unexpected token at '%s'", p - 2);
+            raise_parse_error("unexpected token at '%s'", p - 2);
         }
     }
     action parse_infinity {
         if (json->allow_nan) {
             *result = CInfinity;
         } else {
-            rb_enc_raise(EXC_ENCODING eParserError, "unexpected token at '%s'", p - 7);
+            raise_parse_error("unexpected token at '%s'", p - 7);
         }
     }
     action parse_string {
@@ -245,7 +249,7 @@ static char *JSON_parse_object(JSON_Parser *json, char *p, char *pe, VALUE *resu
                 fexec p + 10;
                 fhold; fbreak;
             } else {
-                rb_enc_raise(EXC_ENCODING eParserError, "unexpected token at '%s'", p);
+                raise_parse_error("unexpected token at '%s'", p);
             }
         }
         np = JSON_parse_float(json, fpc, pe, result);
@@ -355,29 +359,31 @@ static char *JSON_parse_float(JSON_Parser *json, char *p, char *pe, VALUE *resul
     if (cs >= JSON_float_first_final) {
         VALUE mod = Qnil;
         ID method_id = 0;
-        if (rb_respond_to(json->decimal_class, i_try_convert)) {
-            mod = json->decimal_class;
-            method_id = i_try_convert;
-        } else if (rb_respond_to(json->decimal_class, i_new)) {
-            mod = json->decimal_class;
-            method_id = i_new;
-        } else if (RB_TYPE_P(json->decimal_class, T_CLASS)) {
-            VALUE name = rb_class_name(json->decimal_class);
-            const char *name_cstr = RSTRING_PTR(name);
-            const char *last_colon = strrchr(name_cstr, ':');
-            if (last_colon) {
-                const char *mod_path_end = last_colon - 1;
-                VALUE mod_path = rb_str_substr(name, 0, mod_path_end - name_cstr);
-                mod = rb_path_to_class(mod_path);
-
-                const char *method_name_beg = last_colon + 1;
-                long before_len = method_name_beg - name_cstr;
-                long len = RSTRING_LEN(name) - before_len;
-                VALUE method_name = rb_str_substr(name, before_len, len);
-                method_id = SYM2ID(rb_str_intern(method_name));
-            } else {
-                mod = rb_mKernel;
-                method_id = SYM2ID(rb_str_intern(name));
+        if (!NIL_P(json->decimal_class)) {
+            if (rb_respond_to(json->decimal_class, i_try_convert)) {
+                mod = json->decimal_class;
+                method_id = i_try_convert;
+            } else if (rb_respond_to(json->decimal_class, i_new)) {
+                mod = json->decimal_class;
+                method_id = i_new;
+            } else if (RB_TYPE_P(json->decimal_class, T_CLASS)) {
+                VALUE name = rb_class_name(json->decimal_class);
+                const char *name_cstr = RSTRING_PTR(name);
+                const char *last_colon = strrchr(name_cstr, ':');
+                if (last_colon) {
+                    const char *mod_path_end = last_colon - 1;
+                    VALUE mod_path = rb_str_substr(name, 0, mod_path_end - name_cstr);
+                    mod = rb_path_to_class(mod_path);
+
+                    const char *method_name_beg = last_colon + 1;
+                    long before_len = method_name_beg - name_cstr;
+                    long len = RSTRING_LEN(name) - before_len;
+                    VALUE method_name = rb_str_substr(name, before_len, len);
+                    method_id = SYM2ID(rb_str_intern(method_name));
+                } else {
+                    mod = rb_mKernel;
+                    method_id = SYM2ID(rb_str_intern(name));
+                }
             }
         }
 
@@ -447,7 +453,7 @@ static char *JSON_parse_array(JSON_Parser *json, char *p, char *pe, VALUE *resul
     if(cs >= JSON_array_first_final) {
         return p + 1;
     } else {
-        rb_enc_raise(EXC_ENCODING eParserError, "unexpected token at '%s'", p);
+        raise_parse_error("unexpected token at '%s'", p);
         return NULL;
     }
 }
@@ -510,26 +516,30 @@ static VALUE json_string_unescape(char *string, char *stringEnd, int intern, int
                       if (bufferSize > MAX_STACK_BUFFER_SIZE) {
                         ruby_xfree(bufferStart);
                       }
-                      rb_enc_raise(
-                        EXC_ENCODING eParserError,
-                        "incomplete unicode character escape sequence at '%s'", p
-                      );
+                      raise_parse_error("incomplete unicode character escape sequence at '%s'", p);
                     } else {
-                        UTF32 ch = unescape_unicode((unsigned char *) ++pe);
+                        uint32_t ch = unescape_unicode((unsigned char *) ++pe);
                         pe += 3;
-                        if (UNI_SUR_HIGH_START == (ch & 0xFC00)) {
+                        /* To handle values above U+FFFF, we take a sequence of
+                         * \uXXXX escapes in the U+D800..U+DBFF then
+                         * U+DC00..U+DFFF ranges, take the low 10 bits from each
+                         * to make a 20-bit number, then add 0x10000 to get the
+                         * final codepoint.
+                         *
+                         * See Unicode 15: 3.8 "Surrogates", 5.3 "Handling
+                         * Surrogate Pairs in UTF-16", and 23.6 "Surrogates
+                         * Area".
+                         */
+                        if ((ch & 0xFC00) == 0xD800) {
                             pe++;
                             if (pe > stringEnd - 6) {
                               if (bufferSize > MAX_STACK_BUFFER_SIZE) {
                                 ruby_xfree(bufferStart);
                               }
-                              rb_enc_raise(
-                                EXC_ENCODING eParserError,
-                                "incomplete surrogate pair at '%s'", p
-                                );
+                              raise_parse_error("incomplete surrogate pair at '%s'", p);
                             }
                             if (pe[0] == '\\' && pe[1] == 'u') {
-                                UTF32 sur = unescape_unicode((unsigned char *) pe + 2);
+                                uint32_t sur = unescape_unicode((unsigned char *) pe + 2);
                                 ch = (((ch & 0x3F) << 10) | ((((ch >> 6) & 0xF) + 1) << 16)
                                         | (sur & 0x3FF));
                                 pe += 5;
@@ -672,18 +682,20 @@ static char *JSON_parse_string(JSON_Parser *json, char *p, char *pe, VALUE *resu
 
 static VALUE convert_encoding(VALUE source)
 {
-#ifdef HAVE_RUBY_ENCODING_H
-  rb_encoding *enc = rb_enc_get(source);
-  if (enc == rb_ascii8bit_encoding()) {
-    if (OBJ_FROZEN(source)) {
-      source = rb_str_dup(source);
-    }
-    FORCE_UTF8(source);
-  } else {
-    source = rb_str_conv_enc(source, rb_enc_get(source), rb_utf8_encoding());
-  }
-#endif
+  int encindex = RB_ENCODING_GET(source);
+
+  if (encindex == utf8_encindex) {
     return source;
+  }
+
+ if (encindex == binary_encindex) {
+    // For historical reason, we silently reinterpret binary strings as UTF-8 if it would work.
+    // TODO: Deprecate in 2.8.0
+    // TODO: Remove in 3.0.0
+    return rb_enc_associate_index(rb_str_dup(source), utf8_encindex);
+  }
+
+  return rb_str_conv_enc(source, rb_enc_from_index(encindex), rb_utf8_encoding());
 }
 
 /*
@@ -708,8 +720,15 @@ static VALUE convert_encoding(VALUE source)
  * * *create_additions*: If set to false, the Parser doesn't create
  *   additions even if a matching class and create_id was found. This option
  *   defaults to false.
- * * *object_class*: Defaults to Hash
- * * *array_class*: Defaults to Array
+ * * *object_class*: Defaults to Hash. If another type is provided, it will be used
+ *   instead of Hash to represent JSON objects. The type must respond to
+ *   +new+ without arguments, and return an object that respond to +[]=+.
+ * * *array_class*: Defaults to Array If another type is provided, it will be used
+ *   instead of Hash to represent JSON arrays. The type must respond to
+ *   +new+ without arguments, and return an object that respond to +<<+.
+ * * *decimal_class*: Specifies which class to use instead of the default
+ *    (Float) when parsing decimal numbers. This class must accept a single
+ *    string argument in its constructor.
  */
 static VALUE cParser_initialize(int argc, VALUE *argv, VALUE self)
 {
@@ -719,80 +738,91 @@ static VALUE cParser_initialize(int argc, VALUE *argv, VALUE self)
     if (json->Vsource) {
         rb_raise(rb_eTypeError, "already initialized instance");
     }
-    rb_scan_args(argc, argv, "1:", &source, &opts);
+
+    rb_check_arity(argc, 1, 2);
+    source = argv[0];
+    opts = Qnil;
+    if (argc == 2) {
+        opts = argv[1];
+        Check_Type(argv[1], T_HASH);
+        if (RHASH_SIZE(argv[1]) > 0) {
+            opts = argv[1];
+        }
+    }
+
     if (!NIL_P(opts)) {
-	VALUE tmp = ID2SYM(i_max_nesting);
-	if (option_given_p(opts, tmp)) {
-	    VALUE max_nesting = rb_hash_aref(opts, tmp);
-	    if (RTEST(max_nesting)) {
-		Check_Type(max_nesting, T_FIXNUM);
-		json->max_nesting = FIX2INT(max_nesting);
-	    } else {
-		json->max_nesting = 0;
-	    }
-	} else {
-	    json->max_nesting = 100;
-	}
-	tmp = ID2SYM(i_allow_nan);
-	if (option_given_p(opts, tmp)) {
-	    json->allow_nan = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
-	} else {
-	    json->allow_nan = 0;
-	}
-	tmp = ID2SYM(i_symbolize_names);
-	if (option_given_p(opts, tmp)) {
-	    json->symbolize_names = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
-	} else {
-	    json->symbolize_names = 0;
-	}
-	tmp = ID2SYM(i_freeze);
-	if (option_given_p(opts, tmp)) {
-	    json->freeze = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
-	} else {
-	    json->freeze = 0;
-	}
-	tmp = ID2SYM(i_create_additions);
-	if (option_given_p(opts, tmp)) {
-	    json->create_additions = RTEST(rb_hash_aref(opts, tmp));
-	} else {
-	    json->create_additions = 0;
-	}
-	if (json->symbolize_names && json->create_additions) {
-	    rb_raise(rb_eArgError,
-		     "options :symbolize_names and :create_additions cannot be "
-		     " used in conjunction");
-	}
-	tmp = ID2SYM(i_create_id);
-	if (option_given_p(opts, tmp)) {
-	    json->create_id = rb_hash_aref(opts, tmp);
-	} else {
-	    json->create_id = rb_funcall(mJSON, i_create_id, 0);
-	}
-	tmp = ID2SYM(i_object_class);
-	if (option_given_p(opts, tmp)) {
-	    json->object_class = rb_hash_aref(opts, tmp);
-	} else {
-	    json->object_class = Qnil;
-	}
-	tmp = ID2SYM(i_array_class);
-	if (option_given_p(opts, tmp)) {
-	    json->array_class = rb_hash_aref(opts, tmp);
-	} else {
-	    json->array_class = Qnil;
-	}
-	tmp = ID2SYM(i_decimal_class);
-	if (option_given_p(opts, tmp)) {
-	    json->decimal_class = rb_hash_aref(opts, tmp);
-	} else {
-	    json->decimal_class = Qnil;
-	}
-	tmp = ID2SYM(i_match_string);
-	if (option_given_p(opts, tmp)) {
-	    VALUE match_string = rb_hash_aref(opts, tmp);
-	    json->match_string = RTEST(match_string) ? match_string : Qnil;
-	} else {
-	    json->match_string = Qnil;
-	}
+        VALUE tmp = ID2SYM(i_max_nesting);
+        if (option_given_p(opts, tmp)) {
+            VALUE max_nesting = rb_hash_aref(opts, tmp);
+            if (RTEST(max_nesting)) {
+                Check_Type(max_nesting, T_FIXNUM);
+                json->max_nesting = FIX2INT(max_nesting);
+            } else {
+                json->max_nesting = 0;
+            }
+        } else {
+            json->max_nesting = 100;
+        }
+        tmp = ID2SYM(i_allow_nan);
+        if (option_given_p(opts, tmp)) {
+            json->allow_nan = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
+        } else {
+            json->allow_nan = 0;
+        }
+        tmp = ID2SYM(i_symbolize_names);
+        if (option_given_p(opts, tmp)) {
+            json->symbolize_names = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
+        } else {
+            json->symbolize_names = 0;
+        }
+        tmp = ID2SYM(i_freeze);
+        if (option_given_p(opts, tmp)) {
+            json->freeze = RTEST(rb_hash_aref(opts, tmp)) ? 1 : 0;
+        } else {
+            json->freeze = 0;
+        }
+        tmp = ID2SYM(i_create_additions);
+        if (option_given_p(opts, tmp)) {
+            json->create_additions = RTEST(rb_hash_aref(opts, tmp));
+        } else {
+            json->create_additions = 0;
+        }
+        if (json->symbolize_names && json->create_additions) {
+            rb_raise(rb_eArgError,
+                "options :symbolize_names and :create_additions cannot be "
+                " used in conjunction");
+        }
+        tmp = ID2SYM(i_create_id);
+        if (option_given_p(opts, tmp)) {
+            json->create_id = rb_hash_aref(opts, tmp);
+        } else {
+            json->create_id = rb_funcall(mJSON, i_create_id, 0);
+        }
+        tmp = ID2SYM(i_object_class);
+        if (option_given_p(opts, tmp)) {
+            json->object_class = rb_hash_aref(opts, tmp);
+        } else {
+            json->object_class = Qnil;
+        }
+        tmp = ID2SYM(i_array_class);
+        if (option_given_p(opts, tmp)) {
+            json->array_class = rb_hash_aref(opts, tmp);
+        } else {
+            json->array_class = Qnil;
+        }
+        tmp = ID2SYM(i_decimal_class);
+        if (option_given_p(opts, tmp)) {
+            json->decimal_class = rb_hash_aref(opts, tmp);
+        } else {
+            json->decimal_class = Qnil;
+        }
+        tmp = ID2SYM(i_match_string);
+        if (option_given_p(opts, tmp)) {
+            VALUE match_string = rb_hash_aref(opts, tmp);
+            json->match_string = RTEST(match_string) ? match_string : Qnil;
+        } else {
+            json->match_string = Qnil;
+        }
     } else {
         json->max_nesting = 100;
         json->allow_nan = 0;
@@ -836,33 +866,33 @@ static VALUE cParser_initialize(int argc, VALUE *argv, VALUE self)
  */
 static VALUE cParser_parse(VALUE self)
 {
-  char *p, *pe;
-  int cs = EVIL;
-  VALUE result = Qnil;
-  GET_PARSER;
+    char *p, *pe;
+    int cs = EVIL;
+    VALUE result = Qnil;
+    GET_PARSER;
 
-  %% write init;
-  p = json->source;
-  pe = p + json->len;
-  %% write exec;
+    %% write init;
+    p = json->source;
+    pe = p + json->len;
+    %% write exec;
 
-  if (cs >= JSON_first_final && p == pe) {
-    return result;
-  } else {
-    rb_enc_raise(EXC_ENCODING eParserError, "unexpected token at '%s'", p);
-    return Qnil;
-  }
+    if (cs >= JSON_first_final && p == pe) {
+        return result;
+    } else {
+        raise_parse_error("unexpected token at '%s'", p);
+        return Qnil;
+    }
 }
 
 static void JSON_mark(void *ptr)
 {
     JSON_Parser *json = ptr;
-    rb_gc_mark_maybe(json->Vsource);
-    rb_gc_mark_maybe(json->create_id);
-    rb_gc_mark_maybe(json->object_class);
-    rb_gc_mark_maybe(json->array_class);
-    rb_gc_mark_maybe(json->decimal_class);
-    rb_gc_mark_maybe(json->match_string);
+    rb_gc_mark(json->Vsource);
+    rb_gc_mark(json->create_id);
+    rb_gc_mark(json->object_class);
+    rb_gc_mark(json->array_class);
+    rb_gc_mark(json->decimal_class);
+    rb_gc_mark(json->match_string);
 }
 
 static void JSON_free(void *ptr)
@@ -878,16 +908,12 @@ static size_t JSON_memsize(const void *ptr)
     return sizeof(*json) + FBUFFER_CAPA(json->fbuffer);
 }
 
-#ifdef NEW_TYPEDDATA_WRAPPER
 static const rb_data_type_t JSON_Parser_type = {
     "JSON/Parser",
     {JSON_mark, JSON_free, JSON_memsize,},
-#ifdef RUBY_TYPED_FREE_IMMEDIATELY
     0, 0,
     RUBY_TYPED_FREE_IMMEDIATELY,
-#endif
 };
-#endif
 
 static VALUE cJSON_parser_s_allocate(VALUE klass)
 {
@@ -920,9 +946,7 @@ void Init_parser(void)
     mJSON = rb_define_module("JSON");
     mExt = rb_define_module_under(mJSON, "Ext");
     cParser = rb_define_class_under(mExt, "Parser", rb_cObject);
-    eParserError = rb_path2class("JSON::ParserError");
     eNestingError = rb_path2class("JSON::NestingError");
-    rb_gc_register_mark_object(eParserError);
     rb_gc_register_mark_object(eNestingError);
     rb_define_alloc_func(cParser, cJSON_parser_s_allocate);
     rb_define_method(cParser, "initialize", cParser_initialize, -1);
@@ -951,7 +975,6 @@ void Init_parser(void)
     i_decimal_class = rb_intern("decimal_class");
     i_match = rb_intern("match");
     i_match_string = rb_intern("match_string");
-    i_key_p = rb_intern("key?");
     i_deep_const_get = rb_intern("deep_const_get");
     i_aset = rb_intern("[]=");
     i_aref = rb_intern("[]");
@@ -960,6 +983,9 @@ void Init_parser(void)
     i_try_convert = rb_intern("try_convert");
     i_freeze = rb_intern("freeze");
     i_uminus = rb_intern("-@");
+
+    binary_encindex = rb_ascii8bit_encindex();
+    utf8_encindex = rb_utf8_encindex();
 }
 
 /*