oj 3.13.21 → 3.13.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca812104ece12895a17969eea5c870837070875b8c59917220adea228f24cab2
-  data.tar.gz: c46bd5d0d161b9e8e0337daf5af42f9fcc37ec41401a2d9fb3c5416e2ce2fccc
+  metadata.gz: d90ba7b2698041767008afd20cef0dbd6ba1af0d97affa2253b12e199e6c528d
+  data.tar.gz: f9a8219f0b6f66ef0608136068d78cbc6c8b1ee765bfaa68eeb828cae1401fd8
 SHA512:
-  metadata.gz: 860134683a2d535fc9dfd17eb6ad369855ede35c0474dd386d9a8a3fb80e1a5d9cf2133d04c6ebea84d65ad127b62a2e83adf4f5166db8cbdf0dadf50f9d3984
-  data.tar.gz: cac281da136cf4a336245105eb847ec369e36b09ec8f48e80e3e48bacd0aacc6052d88b1cdca3a912f82f329444fa6c74e02e3ee5f9c56b6002afafbd65611ca
+  metadata.gz: e72d7030911b6609946437de78aaf4fa9003a598c77dca472c2998f9af6115436e817fb4c46ec0ead55cb1ccb0ba80298c2ab060fab9fe37d0ec825d0ec6e5e4
+  data.tar.gz: 4aacdb9f034a2548a3eb942b4a29fb66a9839a63770bd10d0b8b62d93d944070d78ee53ca26881f05108047cc9c120efb3a732048b0be51a608f144f2ad0a374

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # CHANGELOG
 
+## 3.13.22 - 2022-11-01
+
+- Reorganized Oj::Parser code to allow for parser extensions in C.
+
 ## 3.13.21 - 2022-08-19
 
 - Bug parsing big numbers fixed in the SAJ parser.

data/README.md

@@ -109,6 +109,8 @@ Follow [@peterohler on Twitter](http://twitter.com/peterohler) for announcements
 
  - *Agoo-C, a high performance C web server supporting GraphQL on GitHub*: https://github.com/ohler55/agoo-c
 
+ - *oj-introspect, an example of creating an Oj parser extension in C*: https://github.com/meinac/oj-introspect
+
 #### Contributing
 
 + Provide a Pull Request off the `develop` branch.

data/ext/oj/custom.c

@@ -31,14 +31,14 @@ static void dump_obj_str(VALUE obj, int depth, Out out) {
 
 static void dump_obj_as_str(VALUE obj, int depth, Out out) {
     volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
-    const char *   str  = RSTRING_PTR(rstr);
+    const char    *str  = RSTRING_PTR(rstr);
 
     oj_dump_cstr(str, RSTRING_LEN(rstr), 0, 0, out);
 }
 
 static void bigdecimal_dump(VALUE obj, int depth, Out out) {
     volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
-    const char *   str  = RSTRING_PTR(rstr);
+    const char    *str  = RSTRING_PTR(rstr);
     int            len  = (int)RSTRING_LEN(rstr);
 
     if (0 == strcasecmp("Infinity", str)) {
@@ -82,8 +82,7 @@ static VALUE complex_load(VALUE clas, VALUE args) {
         real_id = rb_intern("real");
         imag_id = rb_intern("imag");
     }
-    return rb_complex_new(rb_hash_aref(args, rb_id2str(real_id)),
-                          rb_hash_aref(args, rb_id2str(imag_id)));
+    return rb_complex_new(rb_hash_aref(args, rb_id2str(real_id)), rb_hash_aref(args, rb_id2str(imag_id)));
 }
 
 static void time_dump(VALUE obj, int depth, Out out) {
@@ -246,8 +245,7 @@ static VALUE rational_load(VALUE clas, VALUE args) {
         numerator_id   = rb_intern("numerator");
         denominator_id = rb_intern("denominator");
     }
-    return rb_rational_new(rb_hash_aref(args, rb_id2str(numerator_id)),
-                           rb_hash_aref(args, rb_id2str(denominator_id)));
+    return rb_rational_new(rb_hash_aref(args, rb_id2str(numerator_id)), rb_hash_aref(args, rb_id2str(denominator_id)));
 }
 
 static VALUE regexp_load(VALUE clas, VALUE args) {
@@ -292,8 +290,7 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
         assure_size(out, depth * out->indent + 1);
         fill_indent(out, depth);
     } else {
-        assure_size(out,
-                    depth * out->opts->dump_opts.indent_size + out->opts->dump_opts.hash_size + 1);
+        assure_size(out, depth * out->opts->dump_opts.indent_size + out->opts->dump_opts.hash_size + 1);
         if (0 < out->opts->dump_opts.hash_size) {
             APPEND_CHARS(out->cur, out->opts->dump_opts.hash_nl, out->opts->dump_opts.hash_size);
         }
@@ -352,9 +349,7 @@ static void dump_hash(VALUE obj, int depth, Out out, bool as_ok) {
             assure_size(out, depth * out->indent + 2);
             fill_indent(out, depth);
         } else {
-            assure_size(
-                out,
-                depth * out->opts->dump_opts.indent_size + out->opts->dump_opts.hash_size + 1);
+            assure_size(out, depth * out->opts->dump_opts.indent_size + out->opts->dump_opts.hash_size + 1);
             if (0 < out->opts->dump_opts.hash_size) {
                 APPEND_CHARS(out->cur, out->opts->dump_opts.hash_nl, out->opts->dump_opts.hash_size);
             }
@@ -372,10 +367,10 @@ static void dump_hash(VALUE obj, int depth, Out out, bool as_ok) {
 }
 
 static void dump_odd(VALUE obj, Odd odd, VALUE clas, int depth, Out out) {
-    ID *           idp;
-    AttrGetFunc *  fp;
+    ID            *idp;
+    AttrGetFunc   *fp;
     volatile VALUE v;
-    const char *   name;
+    const char    *name;
     size_t         size;
     int            d2 = depth + 1;
 
@@ -384,7 +379,7 @@ static void dump_odd(VALUE obj, Odd odd, VALUE clas, int depth, Out out) {
     if (NULL != out->opts->create_id && Yes == out->opts->create_ok) {
         const char *classname = rb_class2name(clas);
         int         clen      = (int)strlen(classname);
-        size_t sep_len = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
+        size_t      sep_len   = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
 
         size = d2 * out->indent + 10 + clen + out->opts->create_id_len + sep_len;
         assure_size(out, size);
@@ -481,7 +476,7 @@ static VALUE dump_common(VALUE obj, int depth, Out out) {
         oj_dump_raw_json(obj, depth, out);
     } else if (Yes == out->opts->to_json && rb_respond_to(obj, oj_to_json_id)) {
         volatile VALUE rs;
-        const char *   s;
+        const char    *s;
         int            len;
 
         if (RB_UNLIKELY(Yes == out->opts->trace)) {
@@ -521,11 +516,7 @@ static VALUE dump_common(VALUE obj, int depth, Out out) {
         if (aj == obj) {
             volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
 
-            oj_dump_cstr(RSTRING_PTR(rstr),
-                         (int)RSTRING_LEN(rstr),
-                         false,
-                         false,
-                         out);
+            oj_dump_cstr(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), false, false, out);
         } else {
             oj_dump_custom_val(aj, depth, out, true);
         }
@@ -609,7 +600,7 @@ static void dump_obj_attrs(VALUE obj, VALUE clas, slot_t id, int depth, Out out)
     assure_size(out, 2);
     *out->cur++ = '{';
     if (Qundef != clas && NULL != out->opts->create_id && Yes == out->opts->create_ok) {
-        size_t sep_len = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
+        size_t      sep_len   = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
         const char *classname = rb_obj_classname(obj);
         size_t      len       = strlen(classname);
 
@@ -911,7 +902,7 @@ void oj_dump_custom_val(VALUE obj, int depth, Out out, bool as_ok) {
 ///// load functions /////
 
 static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, const char *orig) {
-    const char *   key    = kval->key;
+    const char    *key    = kval->key;
     int            klen   = kval->klen;
     Val            parent = stack_peek(&pi->stack);
     volatile VALUE rkey   = kval->key_val;
@@ -928,14 +919,14 @@ static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, c
             }
         }
     } else {
-	volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
-        //volatile VALUE rstr = rb_utf8_str_new(str, len);
+        volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
+        // volatile VALUE rstr = rb_utf8_str_new(str, len);
 
         if (Qundef == rkey) {
             if (Yes == pi->options.sym_key) {
                 rkey = ID2SYM(rb_intern3(key, klen, oj_utf8_encoding));
             } else {
-		rkey = rb_utf8_str_new(key, klen);
+                rkey = rb_utf8_str_new(key, klen);
             }
         }
         if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
@@ -1008,20 +999,10 @@ static void hash_set_num(struct _parseInfo *pi, Val kval, NumInfo ni) {
                 // match the expected value.
                 parent->val = rb_funcall2(parent->val, oj_utc_id, 0, 0);
             } else if (ni->has_exp) {
-                int64_t          t = (int64_t)(ni->i + ni->exp);
-                struct _timeInfo ti;
-                VALUE            args[8];
-
-                sec_as_time(t, &ti);
-
-                args[0]     = LONG2NUM(ti.year);
-                args[1]     = LONG2NUM(ti.mon);
-                args[2]     = LONG2NUM(ti.day);
-                args[3]     = LONG2NUM(ti.hour);
-                args[4]     = LONG2NUM(ti.min);
-                args[5]     = rb_float_new((double)ti.sec + ((double)nsec + 0.5) / 1000000000.0);
-                args[6]     = LONG2NUM(ni->exp);
-                parent->val = rb_funcall2(rb_cTime, oj_new_id, 7, args);
+                struct timespec ts;
+                ts.tv_sec   = ni->i;
+                ts.tv_nsec  = nsec;
+                parent->val = rb_time_timespec_new(&ts, (int)ni->exp);
             } else {
                 parent->val = rb_time_nano_new(ni->i, (long)nsec);
             }

data/ext/oj/fast.c

@@ -677,21 +677,23 @@ static void free_doc_cb(void *x) {
 }
 
 static void mark_leaf(Leaf leaf) {
-    switch (leaf->value_type) {
-    case COL_VAL:
-        if (NULL != leaf->elements) {
-            Leaf first = leaf->elements->next;
-            Leaf e     = first;
+    if (NULL != leaf) {
+        switch (leaf->value_type) {
+        case COL_VAL:
+            if (NULL != leaf->elements) {
+                Leaf first = leaf->elements->next;
+                Leaf e     = first;
 
-            do {
-                mark_leaf(e);
-                e = e->next;
-            } while (e != first);
-        }
-        break;
-    case RUBY_VAL: mark(leaf->value); break;
+                do {
+                    mark_leaf(e);
+                    e = e->next;
+                } while (e != first);
+            }
+            break;
+        case RUBY_VAL: mark(leaf->value); break;
 
-    default: break;
+        default: break;
+        }
     }
 }
 

data/ext/oj/intern.c

@@ -37,13 +37,10 @@ typedef struct _hash {
 struct _hash class_hash;
 struct _hash attr_hash;
 
-static struct _cache *str_cache = NULL;
 static VALUE          str_cache_obj;
 
-static struct _cache *sym_cache = NULL;
 static VALUE          sym_cache_obj;
 
-static struct _cache *attr_cache = NULL;
 static VALUE          attr_cache_obj;
 
 static VALUE form_str(const char *str, size_t len) {
@@ -93,15 +90,15 @@ void oj_hash_init(void) {
     rb_gc_register_address(&cache_class);
     rb_undef_alloc_func(cache_class);
 
-    str_cache     = cache_create(0, form_str, true, true);
+    struct _cache *str_cache     = cache_create(0, form_str, true, true);
     str_cache_obj = Data_Wrap_Struct(cache_class, cache_mark, cache_free, str_cache);
     rb_gc_register_address(&str_cache_obj);
 
-    sym_cache     = cache_create(0, form_sym, true, true);
+    struct _cache *sym_cache     = cache_create(0, form_sym, true, true);
     sym_cache_obj = Data_Wrap_Struct(cache_class, cache_mark, cache_free, sym_cache);
     rb_gc_register_address(&sym_cache_obj);
 
-    attr_cache     = cache_create(0, form_attr, false, true);
+    struct _cache *attr_cache = cache_create(0, form_attr, false, true);
     attr_cache_obj = Data_Wrap_Struct(cache_class, cache_mark, cache_free, attr_cache);
     rb_gc_register_address(&attr_cache_obj);
 
@@ -122,18 +119,18 @@ oj_str_intern(const char *key, size_t len) {
 #if HAVE_RB_ENC_INTERNED_STR && 0
     return rb_enc_interned_str(key, len, rb_utf8_encoding());
 #else
-    return cache_intern(str_cache, key, len);
+    return cache_intern(DATA_PTR(str_cache_obj), key, len);
 #endif
 }
 
 VALUE
 oj_sym_intern(const char *key, size_t len) {
-    return cache_intern(sym_cache, key, len);
+  return cache_intern(DATA_PTR(sym_cache_obj), key, len);
 }
 
 ID
 oj_attr_intern(const char *key, size_t len) {
-    return cache_intern(attr_cache, key, len);
+  return cache_intern(DATA_PTR(attr_cache_obj), key, len);
 }
 
 static uint64_t hash_calc(const uint8_t *key, size_t len) {

data/ext/oj/introspect.c

@@ -0,0 +1,96 @@
+
+#include "cache.h"
+#include "oj.h"
+#include "parser.h"
+#include "usual.h"
+
+#define BYTE_OFFSETS_STACK_INC_SIZE 256
+
+VALUE mod = Qnil;
+
+typedef struct _introspect {
+    struct _usual usual;
+    void (*start)(struct _ojParser *p);
+    void (*free)(struct _ojParser *p);
+    void (*mark)(struct _ojParser *p);
+    void (*open_object)(struct _ojParser *p);
+    void (*close_object)(struct _ojParser *p);
+
+    int len;
+    int cur;
+    long *stack;
+
+} * Introspect;
+
+static void dfree(ojParser p) {
+    Introspect d = (Introspect)p->ctx;
+
+    xfree(d->stack);
+    // As with the mark() function, this function should still work.
+    d->free(p);
+}
+
+static void start(ojParser p) {
+    Introspect d = (Introspect)p->ctx;
+
+    d->start(p);
+
+    d->stack = ALLOC_N(long, BYTE_OFFSETS_STACK_INC_SIZE);
+    d->len = BYTE_OFFSETS_STACK_INC_SIZE;
+    d->cur = 0;
+}
+
+static void open_object(ojParser p) {
+    Introspect d = (Introspect)p->ctx;
+
+    d->open_object(p);
+
+    // TBD add offset
+}
+
+static void close_object(ojParser p) {
+    Introspect d = (Introspect)p->ctx;
+
+    d->close_object(p);
+
+    // TBD set offset on hash
+}
+
+static VALUE new_parser(VALUE self, VALUE ropts) {
+    volatile VALUE pv = oj_parser_new();
+    ojParser       p  = (ojParser)DATA_PTR(pv);
+    Introspect     d  = ALLOC(struct _introspect);
+
+    oj_init_usual(p, &d->usual);
+
+    // Set the options before switching to the Introspect delegate.
+    p->ctx    = (void *)d;
+
+    d->free = p->free;
+    p->free   = dfree;
+
+    d->start = p->start;
+    p->start  = start;
+
+    // We are cheating with the mark, free, and options functions. Since
+    // struct _usual is the first member of struct _introspect the cast to
+    // Usual in the usual.c mark() function should still work just fine.
+
+    d->open_object = p->funcs[TOP_FUN].open_object;
+    p->funcs[TOP_FUN].open_object = open_object;
+
+    d->close_object = p->funcs[TOP_FUN].close_object;
+    p->funcs[TOP_FUN].close_object = close_object;
+
+    Check_Type(ropts, T_HASH);
+    oj_parser_set_option(p, ropts);
+
+    return pv;
+}
+
+void Init_introspect(void) {
+    mod = rb_define_module("Introspect");
+    rb_gc_register_address(&mod);
+
+    rb_define_module_function(mod, "parser", new_parser, 1);
+}

data/ext/oj/object.c

@@ -67,9 +67,9 @@ static VALUE str_to_value(ParseInfo pi, const char *str, size_t len, const char
 
 // The much faster approach (4x faster)
 static int parse_num(const char *str, const char *end, int cnt) {
-    int n = 0;
+    int  n = 0;
     char c;
-    int i;
+    int  i;
 
     for (i = cnt; 0 < i; i--, str++) {
         c = *str;
@@ -83,9 +83,9 @@ static int parse_num(const char *str, const char *end, int cnt) {
 
 VALUE
 oj_parse_xml_time(const char *str, int len) {
-    VALUE args[8];
+    VALUE       args[8];
     const char *end = str + len;
-    int n;
+    int         n;
 
     // year
     if (0 > (n = parse_num(str, end, 4))) {
@@ -269,19 +269,10 @@ static int hat_num(ParseInfo pi, Val parent, Val kval, NumInfo ni) {
                     // match the expected value.
                     parent->val = rb_funcall2(parent->val, oj_utc_id, 0, 0);
                 } else if (ni->has_exp) {
-                    int64_t          t = (int64_t)(ni->i + ni->exp);
-                    struct _timeInfo ti;
-                    VALUE            args[8];
-
-                    sec_as_time(t, &ti);
-                    args[0]     = LONG2NUM((long)(ti.year));
-                    args[1]     = LONG2NUM(ti.mon);
-                    args[2]     = LONG2NUM(ti.day);
-                    args[3]     = LONG2NUM(ti.hour);
-                    args[4]     = LONG2NUM(ti.min);
-                    args[5]     = rb_float_new((double)ti.sec + ((double)nsec + 0.5) / 1000000000.0);
-                    args[6]     = LONG2NUM(ni->exp);
-                    parent->val = rb_funcall2(rb_cTime, oj_new_id, 7, args);
+                    struct timespec ts;
+                    ts.tv_sec = ni->i;
+                    ts.tv_nsec = nsec;
+                    parent->val = rb_time_timespec_new(&ts, (int)ni->exp);
                 } else {
                     parent->val = rb_time_nano_new(ni->i, (long)nsec);
                 }
@@ -333,26 +324,30 @@ static int hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, vol
                 // If struct is not defined then we let this fail and raise an exception.
                 sc = oj_name2struct(pi, *RARRAY_PTR(value), rb_eArgError);
             }
-            // Create a properly initialized struct instance without calling the initialize method.
-            parent->val = rb_obj_alloc(sc);
-            // If the JSON array has more entries than the struct class allows, we record an error.
+            if (sc == rb_cRange) {
+              parent->val = rb_class_new_instance(len - 1, RARRAY_PTR(value) + 1, rb_cRange);
+            } else {
+                // Create a properly initialized struct instance without calling the initialize method.
+                parent->val = rb_obj_alloc(sc);
+                // If the JSON array has more entries than the struct class allows, we record an error.
 #ifdef RSTRUCT_LEN
 #if RSTRUCT_LEN_RETURNS_INTEGER_OBJECT
             slen = (int)NUM2LONG(RSTRUCT_LEN(parent->val));
 #else   // RSTRUCT_LEN_RETURNS_INTEGER_OBJECT
-            slen = (int)RSTRUCT_LEN(parent->val);
+                slen = (int)RSTRUCT_LEN(parent->val);
 #endif  // RSTRUCT_LEN_RETURNS_INTEGER_OBJECT
 #else
-            slen = FIX2INT(rb_funcall2(parent->val, oj_length_id, 0, 0));
+                slen = FIX2INT(rb_funcall2(parent->val, oj_length_id, 0, 0));
 #endif
-            // MRI >= 1.9
-            if (len - 1 > slen) {
-                oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Invalid struct data");
-            } else {
-                int i;
+                // MRI >= 1.9
+                if (len - 1 > slen) {
+                    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Invalid struct data");
+                } else {
+                    int i;
 
-                for (i = 0; i < len - 1; i++) {
-                    rb_struct_aset(parent->val, INT2FIX(i), RARRAY_PTR(value)[i + 1]);
+                    for (i = 0; i < len - 1; i++) {
+                        rb_struct_aset(parent->val, INT2FIX(i), RARRAY_PTR(value)[i + 1]);
+                    }
                 }
             }
             return 1;
@@ -374,11 +369,17 @@ static int hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, vol
 }
 
 void oj_set_obj_ivar(Val parent, Val kval, VALUE value) {
-    rb_ivar_set(parent->val, oj_attr_intern(kval->key, kval->klen), value);
+    if (kval->klen == 5 && strncmp("~mesg", kval->key, 5) == 0 && rb_obj_is_kind_of(parent->val, rb_eException)) {
+        parent->val = rb_funcall(parent->val, rb_intern("exception"), 1, value);
+    } else if (kval->klen == 3 && strncmp("~bt", kval->key, 3) == 0 && rb_obj_is_kind_of(parent->val, rb_eException)) {
+        rb_funcall(parent->val, rb_intern("set_backtrace"), 1, value);
+    } else {
+        rb_ivar_set(parent->val, oj_attr_intern(kval->key, kval->klen), value);
+    }
 }
 
 static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, const char *orig) {
-    const char *   key    = kval->key;
+    const char    *key    = kval->key;
     int            klen   = kval->klen;
     Val            parent = stack_peek(&pi->stack);
     volatile VALUE rval   = Qnil;
@@ -451,7 +452,7 @@ WHICH_TYPE:
 }
 
 static void hash_set_num(ParseInfo pi, Val kval, NumInfo ni) {
-    const char *   key    = kval->key;
+    const char    *key    = kval->key;
     int            klen   = kval->klen;
     Val            parent = stack_peek(&pi->stack);
     volatile VALUE rval   = Qnil;

data/ext/oj/oj.c

@@ -32,6 +32,7 @@ ID oj_array_append_id;
 ID oj_array_end_id;
 ID oj_array_start_id;
 ID oj_as_json_id;
+ID oj_at_id;
 ID oj_begin_id;
 ID oj_bigdecimal_id;
 ID oj_end_id;
@@ -89,7 +90,9 @@ VALUE oj_array_class_sym;
 VALUE oj_create_additions_sym;
 VALUE oj_decimal_class_sym;
 VALUE oj_hash_class_sym;
+VALUE oj_in_sym;
 VALUE oj_indent_sym;
+VALUE oj_nanosecond_sym;
 VALUE oj_object_class_sym;
 VALUE oj_quirks_mode_sym;
 VALUE oj_safe_sym;
@@ -929,7 +932,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         if (Qnil == v) {
             return ST_CONTINUE;
         }
-        if (TYPE(v) == T_STRUCT && rb_obj_class(v) == rb_cRange) {
+        if (rb_obj_class(v) == rb_cRange) {
             VALUE min = rb_funcall(v, oj_begin_id, 0);
             VALUE max = rb_funcall(v, oj_end_id, 0);
 
@@ -1814,6 +1817,7 @@ void Init_oj(void) {
     oj_array_end_id          = rb_intern("array_end");
     oj_array_start_id        = rb_intern("array_start");
     oj_as_json_id            = rb_intern("as_json");
+    oj_at_id                 = rb_intern("at");
     oj_begin_id              = rb_intern("begin");
     oj_bigdecimal_id         = rb_intern("BigDecimal");
     oj_end_id                = rb_intern("end");
@@ -1961,10 +1965,14 @@ void Init_oj(void) {
     rb_gc_register_address(&oj_decimal_class_sym);
     oj_hash_class_sym = ID2SYM(rb_intern("hash_class"));
     rb_gc_register_address(&oj_hash_class_sym);
+    oj_in_sym = ID2SYM(rb_intern("in"));
+    rb_gc_register_address(&oj_in_sym);
     oj_indent_sym = ID2SYM(rb_intern("indent"));
     rb_gc_register_address(&oj_indent_sym);
     oj_max_nesting_sym = ID2SYM(rb_intern("max_nesting"));
     rb_gc_register_address(&oj_max_nesting_sym);
+    oj_nanosecond_sym = ID2SYM(rb_intern("nanosecond"));
+    rb_gc_register_address(&oj_nanosecond_sym);
     oj_object_class_sym = ID2SYM(rb_intern("object_class"));
     rb_gc_register_address(&oj_object_class_sym);
     oj_object_nl_sym = ID2SYM(rb_intern("object_nl"));

data/ext/oj/oj.h

@@ -317,7 +317,9 @@ extern VALUE oj_ascii_only_sym;
 extern VALUE oj_create_additions_sym;
 extern VALUE oj_decimal_class_sym;
 extern VALUE oj_hash_class_sym;
+extern VALUE oj_in_sym;
 extern VALUE oj_indent_sym;
+extern VALUE oj_nanosecond_sym;
 extern VALUE oj_max_nesting_sym;
 extern VALUE oj_object_class_sym;
 extern VALUE oj_object_nl_sym;
@@ -334,6 +336,7 @@ extern ID oj_array_append_id;
 extern ID oj_array_end_id;
 extern ID oj_array_start_id;
 extern ID oj_as_json_id;
+extern ID oj_at_id;
 extern ID oj_begin_id;
 extern ID oj_bigdecimal_id;
 extern ID oj_end_id;

data/ext/oj/parser.c

@@ -1254,6 +1254,32 @@ static VALUE parser_new(int argc, VALUE *argv, VALUE self) {
     return Data_Wrap_Struct(parser_class, parser_mark, parser_free, p);
 }
 
+// Create a new parser without setting the delegate. The parser is
+// wrapped. The parser is (ojParser)DATA_PTR(value) where value is the return
+// from this function. A delegate must be added before the parser can be
+// used. Optionally oj_parser_set_options can be called if the options are not
+// set directly.
+VALUE oj_parser_new() {
+    ojParser p = ALLOC(struct _ojParser);
+
+#if HAVE_RB_EXT_RACTOR_SAFE
+    // This doesn't seem to do anything.
+    rb_ext_ractor_safe(true);
+#endif
+    memset(p, 0, sizeof(struct _ojParser));
+    buf_init(&p->key);
+    buf_init(&p->buf);
+    p->map = value_map;
+
+    return Data_Wrap_Struct(parser_class, parser_mark, parser_free, p);
+}
+
+// Set set the options from a hash (ropts).
+void oj_parser_set_option(ojParser p, VALUE ropts) {
+    Check_Type(ropts, T_HASH);
+    rb_hash_foreach(ropts, opt_cb, (VALUE)p);
+}
+
 /* Document-method: method_missing(value)
  * call-seq: method_missing(value)
  *

data/ext/oj/parser.h

@@ -88,4 +88,15 @@ typedef struct _ojParser {
     bool     just_one;
 } * ojParser;
 
+// Create a new parser without setting the delegate. The parser is
+// wrapped. The parser is (ojParser)DATA_PTR(value) where value is the return
+// from this function. A delegate must be added before the parser can be
+// used. Optionally oj_parser_set_options can be called if the options are not
+// set directly.
+extern VALUE oj_parser_new();
+
+// Set set the options from a hash (ropts).
+extern void oj_parser_set_option(ojParser p, VALUE ropts);
+
+
 #endif /* OJ_PARSER_H */