oj 3.16.0 → 3.17.3

data/ext/oj/parser.c

@@ -75,7 +75,7 @@ enum {
 
 /*
 0123456789abcdef0123456789abcdef */
-static const char value_map[257] = "\
+static const char value_map[258] = "\
 X........ab..a..................\
 a.i..........f..ghhhhhhhhh......\
 ...........................k.m..\
@@ -85,7 +85,7 @@ a.i..........f..ghhhhhhhhh......\
 ................................\
 ................................v";
 
-static const char null_map[257] = "\
+static const char null_map[258] = "\
 ................................\
 ............o...................\
 ................................\
@@ -95,7 +95,7 @@ static const char null_map[257] = "\
 ................................\
 ................................N";
 
-static const char true_map[257] = "\
+static const char true_map[258] = "\
 ................................\
 ............o...................\
 ................................\
@@ -105,7 +105,7 @@ static const char true_map[257] = "\
 ................................\
 ................................T";
 
-static const char false_map[257] = "\
+static const char false_map[258] = "\
 ................................\
 ............o...................\
 ................................\
@@ -115,7 +115,7 @@ static const char false_map[257] = "\
 ................................\
 ................................F";
 
-static const char comma_map[257] = "\
+static const char comma_map[258] = "\
 .........ab..a..................\
 a.i..........f..ghhhhhhhhh......\
 ...........................k....\
@@ -125,7 +125,7 @@ a.i..........f..ghhhhhhhhh......\
 ................................\
 ................................,";
 
-static const char after_map[257] = "\
+static const char after_map[258] = "\
 X........ab..a..................\
 a...........o...................\
 .............................m..\
@@ -135,7 +135,7 @@ a...........o...................\
 ................................\
 ................................a";
 
-static const char key1_map[257] = "\
+static const char key1_map[258] = "\
 .........ab..a..................\
 a.p.............................\
 ................................\
@@ -145,7 +145,7 @@ a.p.............................\
 ................................\
 ................................K";
 
-static const char key_map[257] = "\
+static const char key_map[258] = "\
 .........ab..a..................\
 a.p.............................\
 ................................\
@@ -155,7 +155,7 @@ a.p.............................\
 ................................\
 ................................k";
 
-static const char colon_map[257] = "\
+static const char colon_map[258] = "\
 .........ab..a..................\
 a.........................q.....\
 ................................\
@@ -165,7 +165,7 @@ a.........................q.....\
 ................................\
 ................................:";
 
-static const char neg_map[257] = "\
+static const char neg_map[258] = "\
 ................................\
 ................O---------......\
 ................................\
@@ -175,7 +175,7 @@ static const char neg_map[257] = "\
 ................................\
 ................................-";
 
-static const char zero_map[257] = "\
+static const char zero_map[258] = "\
 .........rs..r..................\
 r...........u.t.................\
 .............................H..\
@@ -185,7 +185,7 @@ r...........u.t.................\
 ................................\
 ................................0";
 
-static const char digit_map[257] = "\
+static const char digit_map[258] = "\
 .........rs..r..................\
 r...........u.t.NNNNNNNNNN......\
 .....w.......................H..\
@@ -195,7 +195,7 @@ r...........u.t.NNNNNNNNNN......\
 ................................\
 ................................d";
 
-static const char dot_map[257] = "\
+static const char dot_map[258] = "\
 ................................\
 ................vvvvvvvvvv......\
 ................................\
@@ -205,7 +205,7 @@ static const char dot_map[257] = "\
 ................................\
 .................................";
 
-static const char frac_map[257] = "\
+static const char frac_map[258] = "\
 .........rs..r..................\
 r...........u...vvvvvvvvvv......\
 .....w.......................H..\
@@ -215,7 +215,7 @@ r...........u...vvvvvvvvvv......\
 ................................\
 ................................f";
 
-static const char exp_sign_map[257] = "\
+static const char exp_sign_map[258] = "\
 ................................\
 ...........x.x..yyyyyyyyyy......\
 ................................\
@@ -225,7 +225,7 @@ static const char exp_sign_map[257] = "\
 ................................\
 ................................x";
 
-static const char exp_zero_map[257] = "\
+static const char exp_zero_map[258] = "\
 ................................\
 ................yyyyyyyyyy......\
 ................................\
@@ -235,7 +235,7 @@ static const char exp_zero_map[257] = "\
 ................................\
 ................................z";
 
-static const char exp_map[257] = "\
+static const char exp_map[258] = "\
 .........rs..r..................\
 r...........u...yyyyyyyyyy......\
 .............................H..\
@@ -245,7 +245,7 @@ r...........u...yyyyyyyyyy......\
 ................................\
 ................................X";
 
-static const char big_digit_map[257] = "\
+static const char big_digit_map[258] = "\
 .........rs..r..................\
 r...........u.D.CCCCCCCCCC......\
 .....J.......................H..\
@@ -255,7 +255,7 @@ r...........u.D.CCCCCCCCCC......\
 ................................\
 ................................D";
 
-static const char big_dot_map[257] = "\
+static const char big_dot_map[258] = "\
 ................................\
 ................IIIIIIIIII......\
 ................................\
@@ -265,7 +265,7 @@ static const char big_dot_map[257] = "\
 ................................\
 ................................o";
 
-static const char big_frac_map[257] = "\
+static const char big_frac_map[258] = "\
 .........rs..r..................\
 r...........u...IIIIIIIIII......\
 .....J.......................H..\
@@ -275,7 +275,7 @@ r...........u...IIIIIIIIII......\
 ................................\
 ................................g";
 
-static const char big_exp_sign_map[257] = "\
+static const char big_exp_sign_map[258] = "\
 ................................\
 ...........K.K..LLLLLLLLLL......\
 ................................\
@@ -285,7 +285,7 @@ static const char big_exp_sign_map[257] = "\
 ................................\
 ................................B";
 
-static const char big_exp_zero_map[257] = "\
+static const char big_exp_zero_map[258] = "\
 ................................\
 ................LLLLLLLLLL......\
 ................................\
@@ -295,7 +295,7 @@ static const char big_exp_zero_map[257] = "\
 ................................\
 ................................Z";
 
-static const char big_exp_map[257] = "\
+static const char big_exp_map[258] = "\
 .........rs..r..................\
 r...........u...LLLLLLLLLL......\
 .............................H..\
@@ -305,7 +305,7 @@ r...........u...LLLLLLLLLL......\
 ................................\
 ................................Y";
 
-static const char string_map[257] = "\
+static const char string_map[258] = "\
 ................................\
 RRzRRRRRRRRRRRRRRRRRRRRRRRRRRRRR\
 RRRRRRRRRRRRRRRRRRRRRRRRRRRRARRR\
@@ -315,7 +315,7 @@ RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR\
 MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM\
 PPPPPPPPPPPPPPPPQQQQQQQQ........s";
 
-static const char esc_map[257] = "\
+static const char esc_map[258] = "\
 ................................\
 ..B............B................\
 ............................B...\
@@ -325,7 +325,7 @@ static const char esc_map[257] = "\
 ................................\
 ................................~";
 
-static const char esc_byte_map[257] = "\
+static const char esc_byte_map[258] = "\
 ................................\
 ..\"............/................\
 ............................\\...\
@@ -335,7 +335,7 @@ static const char esc_byte_map[257] = "\
 ................................\
 ................................b";
 
-static const char u_map[257] = "\
+static const char u_map[258] = "\
 ................................\
 ................EEEEEEEEEE......\
 .EEEEEE.........................\
@@ -345,7 +345,7 @@ static const char u_map[257] = "\
 ................................\
 ................................u";
 
-static const char utf_map[257] = "\
+static const char utf_map[258] = "\
 ................................\
 ................................\
 ................................\
@@ -355,7 +355,7 @@ SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS\
 ................................\
 ................................8";
 
-static const char space_map[257] = "\
+static const char space_map[258] = "\
 .........ab..a..................\
 a...............................\
 ................................\
@@ -365,7 +365,7 @@ a...............................\
 ................................\
 ................................S";
 
-static const char trail_map[257] = "\
+static const char trail_map[258] = "\
 .........ab..a..................\
 a...............................\
 ................................\
@@ -375,7 +375,7 @@ a...............................\
 ................................\
 ................................R";
 
-static const byte hex_map[256] = "\
+static const byte hex_map[257] = "\
 ................................\
 ................\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09......\
 .\x0a\x0b\x0c\x0d\x0e\x0f.........................\
@@ -594,7 +594,7 @@ static void big_change(ojParser p) {
     }
 }
 
-static void parse(ojParser p, const byte *json) {
+static void parse(ojParser p, const byte *json, bool more) {
     const byte *start;
     const byte *b = json;
     int         i;
@@ -635,6 +635,9 @@ static void parse(ojParser p, const byte *json) {
             if ('"' == *b) {
                 p->map = colon_map;
                 break;
+            } else if ('\0' == *b && !more) {
+                parse_error(p, "quoted string not terminated");
+                break;
             }
             b--;
             p->map      = string_map;
@@ -659,6 +662,9 @@ static void parse(ojParser p, const byte *json) {
                 p->funcs[p->stack[p->depth]].add_str(p);
                 p->map = (0 == p->depth) ? value_map : after_map;
                 break;
+            } else if ('\0' == *b && !more) {
+                parse_error(p, "quoted string not terminated");
+                break;
             }
             b--;
             p->map      = string_map;
@@ -668,6 +674,10 @@ static void parse(ojParser p, const byte *json) {
             p->cur = b - json;
             p->funcs[p->stack[p->depth]].open_object(p);
             p->depth++;
+            if ((int)sizeof(p->stack) <= p->depth) {
+                parse_error(p, "too deeply nested");
+                break;
+            }
             p->stack[p->depth] = OBJECT_FUN;
             p->map             = key1_map;
             break;
@@ -690,6 +700,10 @@ static void parse(ojParser p, const byte *json) {
             p->cur = b - json;
             p->funcs[p->stack[p->depth]].open_array(p);
             p->depth++;
+            if ((int)sizeof(p->stack) <= p->depth) {
+                parse_error(p, "too deeply nested");
+                break;
+            }
             p->stack[p->depth] = ARRAY_FUN;
             p->map             = value_map;
             break;
@@ -1114,9 +1128,6 @@ static void parse(ojParser p, const byte *json) {
             p->map = trail_map;
         }
     }
-    if (0 < p->depth) {
-        parse_error(p, "parse error, not closed");
-    }
     if (0 == p->depth) {
         switch (p->map[256]) {
         case '0':
@@ -1164,10 +1175,23 @@ static void parser_mark(void *ptr) {
     }
 }
 
+const rb_data_type_t oj_parser_type = {
+    "Oj/parser",
+    {
+        parser_mark,
+        parser_free,
+        NULL,
+    },
+    0,
+    0,
+};
+
 extern void oj_set_parser_validator(ojParser p);
 extern void oj_set_parser_saj(ojParser p);
 extern void oj_set_parser_usual(ojParser p);
 extern void oj_set_parser_debug(ojParser p);
+extern void oj_set_parser_safe(ojParser p, VALUE options);
+extern void oj_safe_init(VALUE parser_class);
 
 static int opt_cb(VALUE rkey, VALUE value, VALUE ptr) {
     ojParser    p   = (ojParser)ptr;
@@ -1255,7 +1279,7 @@ static VALUE parser_new(int argc, VALUE *argv, VALUE self) {
             rb_hash_foreach(ropts, opt_cb, (VALUE)p);
         }
     }
-    return Data_Wrap_Struct(parser_class, parser_mark, parser_free, p);
+    return TypedData_Wrap_Struct(parser_class, &oj_parser_type, p);
 }
 
 // Create a new parser without setting the delegate. The parser is
@@ -1275,7 +1299,7 @@ VALUE oj_parser_new(void) {
     buf_init(&p->buf);
     p->map = value_map;
 
-    return Data_Wrap_Struct(parser_class, parser_mark, parser_free, p);
+    return TypedData_Wrap_Struct(parser_class, &oj_parser_type, p);
 }
 
 // Set set the options from a hash (ropts).
@@ -1294,53 +1318,41 @@ void oj_parser_set_option(ojParser p, VALUE ropts) {
  *   - no options
  *
  * - *:saj*
- *   - _cache_keys=_ sets the value of the _cache_keys_ flag.
- *   - _cache_keys_ returns the value of the _cache_keys_ flag.
- *   - _cache_strings=_ sets the value of the _cache_strings_ to an positive integer less than 35. Strings shorter than
- * that length are cached.
- *   - _cache_strings_ returns the value of the _cache_strings_ integer value.
- *   - _handler=_ sets the SAJ handler
- *   - _handler_ returns the SAJ handler
+ *   - _cache_keys_ is a flag indicating hash keys should be cached.
+ *   - _cache_strings_ is a positive integer less than 35. Strings shorter than that length are cached.
+ *   - _handler_ is the SAJ handler
  *
  * - *:usual*
- *   - _cache_keys=_ sets the value of the _cache_keys_ flag.
- *   - _cache_keys_ returns the value of the _cache_keys_ flag.
- *   - _cache_strings=_ sets the value of the _cache_strings_ to a positive integer less than 35. Strings shorter than
- * that length are cached.
- *   - _cache_strings_ returns the value of the _cache_strings_ integer value.
- *   - _cache_expunge=_ sets the value of the _cache_expunge_ where 0 never expunges, 1 expunges slowly, 2 expunges
- * faster, and 3 or higher expunges agressively.
- *   - _cache_expunge_ returns the value of the _cache_expunge_ integer value.
- *   - _capacity=_ sets the capacity of the parser. The parser grows automatically but can be updated directly with this
- * call.
- *   - _capacity_ returns the current capacity of the parser's internal stack.
- *   - _create_id_ returns the value _create_id_ or _nil_ if there is no _create_id_.
- *   - _create_id=_ sets the value _create_id_ or if _nil_ unsets it. Parsed JSON objects that include the specified
- * element use the element value as the name of the class to create an object from instead of a Hash.
- *   - _decimal=_ sets the approach to how decimals are parser. If _:auto_ then the decimals with significant digits are
- * 16 or less are Floats and long ones are BigDecimal. _:ruby_ uses a call to Ruby to convert a string to a Float.
- * _:float_ always generates a Float. _:bigdecimal_ always results in a BigDecimal.
- *   - _decimal_ returns the value of the decimal conversion option which can be :auto (default), :ruby, :float, or
- * :bigdecimal.
- *   - _ignore_json_create_ returns the value of the _ignore_json_create_ flag.
- *   - _ignore_json_create=_ sets the value of the _ignore_json_create_ flag. When set the class json_create method is
- * ignored on parsing in favor of creating an instance and populating directly.
- *   - _missing_class_ return the value of the _missing_class_ indicator.
- *   - _missing_class=_ sets the value of the _missing_class_ flag. Valid values are _:auto_ which creates any missing
- * classes on parse, :ignore which ignores and continues as a Hash (default), and :raise which raises an exception if
- * the class is not found.
- *   - _omit_null=_ sets the _omit_null_ flag. If true then null values in a map or object are omitted from the
- * resulting Hash or Object.
- *   - _omit_null_ returns the value of the _omit_null_ flag.
- *   - _symbol_keys=_ sets the flag that indicates Hash keys should be parsed to Symbols versus Strings.
- *   - _symbol_keys_ returns the value of the _symbol_keys_ flag.
+ *   - _cache_keys_ is a flag indicating hash keys should be cached.
+ *   - _cache_strings_ is a positive integer less than 35. Strings shorter than that length are cached.
+ *   - _cache_expunge_ dictates when the cache will be expunged where 0 never expunges,
+ *     1 expunges slowly, 2 expunges faster, and 3 or higher expunges agressively.
+ *   - _capacity_ is the capacity of the parser's internal stack. The parser grows automatically
+ *     but can be updated directly with this call.
+ *   - _create_id_ if non-nil is the key that is used to specify the type of object to create
+ *     when parsing. Parsed JSON objects that include the specified element use the element
+ *     value as the name of the class to create an object from instead of a Hash.
+ *   - _decimal_ is the approach to how decimals are parsed. If _:auto_ then
+ *     the decimals with significant digits are 16 or less are Floats and long
+ *     ones are BigDecimal. _:ruby_ uses a call to Ruby to convert a string to a Float.
+ *     _:float_ always generates a Float. _:bigdecimal_ always results in a BigDecimal.
+ *   - _ignore_json_create_ is a flag that when set the class json_create method is
+ *     ignored on parsing in favor of creating an instance and populating directly.
+ *   - _missing_class_ is an indicator that determines how unknown class names are handled.
+ *     Valid values are _:auto_ which creates any missing classes on parse, :ignore which ignores
+ *     and continues as a Hash (default), and :raise which raises an exception if the class is not found.
+ *   - _omit_null_ is a flag that if true then null values in a map or object are omitted
+ *     from the resulting Hash or Object.
+ *   - _symbol_keys_ is a flag that indicates Hash keys should be parsed to Symbols versus Strings.
  */
 static VALUE parser_missing(int argc, VALUE *argv, VALUE self) {
-    ojParser       p    = (ojParser)DATA_PTR(self);
+    ojParser       p;
     const char    *key  = NULL;
     volatile VALUE rkey = *argv;
     volatile VALUE rv   = Qnil;
 
+    TypedData_Get_Struct(self, struct _ojParser, &oj_parser_type, p);
+
 #if HAVE_RB_EXT_RACTOR_SAFE
     // This doesn't seem to do anything.
     rb_ext_ractor_safe(true);
@@ -1358,6 +1370,34 @@ static VALUE parser_missing(int argc, VALUE *argv, VALUE self) {
     return p->option(p, key, rv);
 }
 
+static void validate_primitives_are_complete(ojParser p) {
+    if (0 >= p->ri) {
+        return;
+    }
+
+    switch (p->map[256]) {
+    case 'N': parse_error(p, "expected null"); break;
+    case 'F': parse_error(p, "expected false"); break;
+    case 'T': parse_error(p, "expected true"); break;
+    }
+}
+
+static void validate_non_primitives_are_complete(ojParser p) {
+    if (0 >= p->depth) {
+        return;
+    }
+    if (OBJECT_FUN == p->stack[p->depth]) {
+        parse_error(p, "Object is not closed");
+    } else {
+        parse_error(p, "Array is not closed");
+    }
+}
+
+static void validate_document_end(ojParser p) {
+    validate_primitives_are_complete(p);
+    validate_non_primitives_are_complete(p);
+}
+
 /* Document-method: parse(json)
  * call-seq: parse(json)
  *
@@ -1366,12 +1406,21 @@ static VALUE parser_missing(int argc, VALUE *argv, VALUE self) {
  * Returns the result according to the delegate of the parser.
  */
 static VALUE parser_parse(VALUE self, VALUE json) {
-    ojParser    p   = (ojParser)DATA_PTR(self);
-    const byte *ptr = (const byte *)StringValuePtr(json);
+    ojParser    p;
+    int         frozen = OBJ_FROZEN(json);
+    const byte *ptr;
+
+    if (!frozen) {
+        rb_str_freeze(json);
+    }
+    ptr = (const byte *)StringValuePtr(json);
+
+    TypedData_Get_Struct(self, struct _ojParser, &oj_parser_type, p);
 
     parser_reset(p);
     p->start(p);
-    parse(p, ptr);
+    parse(p, ptr, false);
+    validate_document_end(p);
 
     return p->result(p);
 }
@@ -1382,14 +1431,22 @@ static VALUE load_rescue(VALUE self, VALUE x) {
 }
 
 static VALUE load(VALUE self) {
-    ojParser       p    = (ojParser)DATA_PTR(self);
+    ojParser       p;
     volatile VALUE rbuf = rb_str_new2("");
 
+    TypedData_Get_Struct(self, struct _ojParser, &oj_parser_type, p);
+
     p->start(p);
     while (true) {
         rb_funcall(p->reader, oj_readpartial_id, 2, INT2NUM(16385), rbuf);
         if (0 < RSTRING_LEN(rbuf)) {
-            parse(p, (byte *)StringValuePtr(rbuf));
+            parse(p, (byte *)StringValuePtr(rbuf), true);
+        }
+        if (Qtrue == rb_funcall(p->reader, oj_eofq_id, 0)) {
+            if (0 < p->depth) {
+                parse_error(p, "parse error, not closed");
+            }
+            break;
         }
     }
     return Qtrue;
@@ -1403,7 +1460,9 @@ static VALUE load(VALUE self) {
  * Returns the result according to the delegate of the parser.
  */
 static VALUE parser_load(VALUE self, VALUE reader) {
-    ojParser p = (ojParser)DATA_PTR(self);
+    ojParser p;
+
+    TypedData_Get_Struct(self, struct _ojParser, &oj_parser_type, p);
 
     parser_reset(p);
     p->reader = reader;
@@ -1420,10 +1479,12 @@ static VALUE parser_load(VALUE self, VALUE reader) {
  * Returns the result according to the delegate of the parser.
  */
 static VALUE parser_file(VALUE self, VALUE filename) {
-    ojParser    p = (ojParser)DATA_PTR(self);
+    ojParser    p;
     const char *path;
     int         fd;
 
+    TypedData_Get_Struct(self, struct _ojParser, &oj_parser_type, p);
+
     path = StringValuePtr(filename);
 
     parser_reset(p);
@@ -1449,7 +1510,7 @@ static VALUE parser_file(VALUE self, VALUE filename) {
     while (true) {
         if (0 < (rsize = read(fd, buf, size))) {
             buf[rsize] = '\0';
-            parse(p, buf);
+            parse(p, buf, true);
         }
         if (rsize <= 0) {
             if (0 != rsize) {
@@ -1467,7 +1528,9 @@ static VALUE parser_file(VALUE self, VALUE filename) {
  * Returns the current state of the just_one [_Boolean_] option.
  */
 static VALUE parser_just_one(VALUE self) {
-    ojParser p = (ojParser)DATA_PTR(self);
+    ojParser p;
+
+    TypedData_Get_Struct(self, struct _ojParser, &oj_parser_type, p);
 
     return p->just_one ? Qtrue : Qfalse;
 }
@@ -1481,7 +1544,9 @@ static VALUE parser_just_one(VALUE self) {
  * Returns the current state of the just_one [_Boolean_] option.
  */
 static VALUE parser_just_one_set(VALUE self, VALUE v) {
-    ojParser p = (ojParser)DATA_PTR(self);
+    ojParser p;
+
+    TypedData_Get_Struct(self, struct _ojParser, &oj_parser_type, p);
 
     p->just_one = (Qtrue == v);
 
@@ -1505,7 +1570,7 @@ static VALUE parser_usual(VALUE self) {
         buf_init(&p->buf);
         p->map = value_map;
         oj_set_parser_usual(p);
-        usual_parser = Data_Wrap_Struct(parser_class, parser_mark, parser_free, p);
+        usual_parser = TypedData_Wrap_Struct(parser_class, &oj_parser_type, p);
         rb_gc_register_address(&usual_parser);
     }
     return usual_parser;
@@ -1528,7 +1593,7 @@ static VALUE parser_saj(VALUE self) {
         buf_init(&p->buf);
         p->map = value_map;
         oj_set_parser_saj(p);
-        saj_parser = Data_Wrap_Struct(parser_class, parser_mark, parser_free, p);
+        saj_parser = TypedData_Wrap_Struct(parser_class, &oj_parser_type, p);
         rb_gc_register_address(&saj_parser);
     }
     return saj_parser;
@@ -1550,12 +1615,34 @@ static VALUE parser_validate(VALUE self) {
         buf_init(&p->buf);
         p->map = value_map;
         oj_set_parser_validator(p);
-        validate_parser = Data_Wrap_Struct(parser_class, parser_mark, parser_free, p);
+        validate_parser = TypedData_Wrap_Struct(parser_class, &oj_parser_type, p);
         rb_gc_register_address(&validate_parser);
     }
     return validate_parser;
 }
 
+static VALUE parser_safe(int argc, VALUE *argv, VALUE self) {
+    VALUE options;
+
+    if (1 == argc) {
+        options = argv[0];
+
+        Check_Type(options, T_HASH);
+    } else {
+        options = rb_hash_new();
+    }
+
+    ojParser p = OJ_R_ALLOC(struct _ojParser);
+
+    memset(p, 0, sizeof(struct _ojParser));
+    buf_init(&p->key);
+    buf_init(&p->buf);
+    p->map = value_map;
+    oj_set_parser_safe(p, options);
+
+    return TypedData_Wrap_Struct(parser_class, &oj_parser_type, p);
+}
+
 /* Document-class: Oj::Parser
  *
  * A reusable parser that makes use of named delegates to determine the
@@ -1583,4 +1670,7 @@ void oj_parser_init(void) {
     rb_define_module_function(parser_class, "usual", parser_usual, 0);
     rb_define_module_function(parser_class, "saj", parser_saj, 0);
     rb_define_module_function(parser_class, "validate", parser_validate, 0);
+    rb_define_module_function(parser_class, "safe", parser_safe, -1);
+
+    oj_safe_init(parser_class);
 }

data/ext/oj/parser.h

@@ -32,9 +32,9 @@ typedef struct _num {
     long double dub;
     int64_t     fixnum;  // holds all digits
     uint32_t    len;
-    int16_t     div;     // 10^div
+    int16_t     div;  // 10^div
     int16_t     exp;
-    uint8_t     shift;   // shift of fixnum to get decimal
+    uint8_t     shift;  // shift of fixnum to get decimal
     bool        neg;
     bool        exp_neg;
     // for numbers as strings, reuse buf
@@ -42,6 +42,8 @@ typedef struct _num {
 
 struct _ojParser;
 
+extern const rb_data_type_t oj_parser_type;
+
 typedef struct _funcs {
     void (*add_null)(struct _ojParser *p);
     void (*add_true)(struct _ojParser *p);