oj 3.16.3 → 3.17.4

data/ext/oj/rails.c

@@ -140,7 +140,7 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
     volatile VALUE v;
     int            cnt;
     int            i;
-    int            len;
+    size_t         len;
     const char    *name;
 
 #ifdef RSTRUCT_LEN
@@ -161,7 +161,7 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
         volatile VALUE s = rb_sym2str(RARRAY_AREF(ma, i));
 
         name = RSTRING_PTR(s);
-        len  = (int)RSTRING_LEN(s);
+        len  = RSTRING_LEN(s);
         assure_size(out, size + sep_len + 6);
         if (0 < i) {
             *out->cur++ = ',';
@@ -205,11 +205,11 @@ static void dump_bigdecimal(VALUE obj, int depth, Out out, bool as_ok) {
     if ('I' == *str || 'N' == *str || ('-' == *str && 'I' == str[1])) {
         oj_dump_nil(Qnil, depth, out, false);
     } else if (out->opts->int_range_max != 0 || out->opts->int_range_min != 0) {
-        oj_dump_cstr(str, (int)RSTRING_LEN(rstr), 0, 0, out);
+        oj_dump_cstr(str, RSTRING_LEN(rstr), 0, 0, out);
     } else if (Yes == out->opts->bigdec_as_num) {
-        oj_dump_raw(str, (int)RSTRING_LEN(rstr), out);
+        oj_dump_raw(str, RSTRING_LEN(rstr), out);
     } else {
-        oj_dump_cstr(str, (int)RSTRING_LEN(rstr), 0, 0, out);
+        oj_dump_cstr(str, RSTRING_LEN(rstr), 0, 0, out);
     }
 }
 
@@ -330,14 +330,14 @@ static void dump_timewithzone(VALUE obj, int depth, Out out, bool as_ok) {
 static void dump_to_s(VALUE obj, int depth, Out out, bool as_ok) {
     volatile VALUE rstr = oj_safe_string_convert(obj);
 
-    oj_dump_cstr(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), 0, 0, out);
+    oj_dump_cstr(RSTRING_PTR(rstr), RSTRING_LEN(rstr), 0, 0, out);
 }
 
 static ID parameters_id = 0;
 
 typedef struct _strLen {
     const char *str;
-    int         len;
+    size_t      len;
 } *StrLen;
 
 static void dump_actioncontroller_parameters(VALUE obj, int depth, Out out, bool as_ok) {
@@ -352,10 +352,10 @@ static StrLen columns_array(VALUE rcols, int *ccnt) {
     volatile VALUE v;
     StrLen         cp;
     StrLen         cols;
-    int            i;
-    int            cnt = (int)RARRAY_LEN(rcols);
+    size_t         i;
+    size_t         cnt = RARRAY_LEN(rcols);
 
-    *ccnt = cnt;
+    *ccnt = (int)cnt;
     cols  = OJ_R_ALLOC_N(struct _strLen, cnt);
     for (i = 0, cp = cols; i < cnt; i++, cp++) {
         v = RARRAY_AREF(rcols, i);
@@ -363,7 +363,7 @@ static StrLen columns_array(VALUE rcols, int *ccnt) {
             v = oj_safe_string_convert(v);
         }
         cp->str = StringValuePtr(v);
-        cp->len = (int)RSTRING_LEN(v);
+        cp->len = RSTRING_LEN(v);
     }
     return cols;
 }
@@ -424,7 +424,8 @@ static void dump_activerecord_result(VALUE obj, int depth, Out out, bool as_ok)
     volatile VALUE rows;
     StrLen         cols;
     int            ccnt = 0;
-    int            i, rcnt;
+    size_t         i;
+    size_t         rcnt;
     size_t         size;
     int            d2 = depth + 1;
 
@@ -435,7 +436,7 @@ static void dump_activerecord_result(VALUE obj, int depth, Out out, bool as_ok)
     out->argc = 0;
     cols      = columns_array(rb_ivar_get(obj, columns_id), &ccnt);
     rows      = rb_ivar_get(obj, rows_id);
-    rcnt      = (int)RARRAY_LEN(rows);
+    rcnt      = RARRAY_LEN(rows);
     assure_size(out, 2);
     *out->cur++ = '[';
     if (out->opts->dump_opts.use) {
@@ -622,6 +623,7 @@ static void encoder_free(void *ptr) {
     if (NULL != ptr) {
         Encoder e = (Encoder)ptr;
 
+        oj_options_release(&e->opts);
         if (NULL != e->ropts.table) {
             OJ_R_FREE(e->ropts.table);
         }
@@ -632,10 +634,19 @@ static void encoder_free(void *ptr) {
 static void encoder_mark(void *ptr) {
     if (NULL != ptr) {
         Encoder e = (Encoder)ptr;
+        int     i;
 
+        oj_options_mark(&e->opts);
         if (Qnil != e->arg) {
             rb_gc_mark(e->arg);
         }
+        // The optimized classes in the encoder table are not reachable from
+        // anywhere else once optimize() is called on the encoder itself.
+        for (i = 0; i < e->ropts.len; i++) {
+            if (Qnil != e->ropts.table[i].clas) {
+                rb_gc_mark(e->ropts.table[i].clas);
+            }
+        }
     }
 }
 
@@ -660,13 +671,21 @@ static VALUE encoder_new(int argc, VALUE *argv, VALUE self) {
     Encoder e = OJ_R_ALLOC(struct _encoder);
 
     e->opts = oj_default_options;
-    e->arg  = Qnil;
+    // Detach from the match_string regexps owned by the defaults before the
+    // options are parsed so that a :match_string option builds a chain of its
+    // own that is freed with the encoder.
+    e->opts.str_rx.head = NULL;
+    e->opts.str_rx.tail = NULL;
     copy_opts(&ropts, &e->ropts);
 
     if (1 <= argc && Qnil != *argv) {
-        oj_parse_options(*argv, &e->opts);
         e->arg = *argv;
+    } else {
+        e->arg = rb_hash_new();
     }
+    oj_parse_options(e->arg, &e->opts);
+    oj_options_take_ownership(&e->opts);
+
     return TypedData_Wrap_Struct(encoder_class, &oj_encoder_type, e);
 }
 
@@ -917,7 +936,7 @@ static VALUE encode(VALUE obj, ROptTable ropts, Options opts, int argc, VALUE *a
     if (Yes == copts.circular) {
         oj_cache8_new(&out.circ_cache);
     }
-    // dump_rails_val(*argv, 0, &out, true);
+
     rb_protect(protect_dump, (VALUE)&oo, &line);
 
     if (0 == line) {
@@ -933,8 +952,7 @@ static VALUE encode(VALUE obj, ROptTable ropts, Options opts, int argc, VALUE *a
         if (0 == out.buf) {
             rb_raise(rb_eNoMemError, "Not enough memory.");
         }
-        rstr = rb_str_new2(out.buf);
-        rstr = oj_encode(rstr);
+        rstr = rb_utf8_str_new_cstr(out.buf);
     }
     if (Yes == copts.circular) {
         oj_cache8_delete(out.circ_cache);
@@ -1101,6 +1119,8 @@ static VALUE rails_set_decoder(VALUE self) {
     } else {
         json_error = rb_define_class_under(json, "JSONError", rb_eStandardError);
     }
+
+    rb_global_variable(&oj_json_parser_error_class);
     if (rb_const_defined_at(json, rb_intern("ParserError"))) {
         oj_json_parser_error_class = rb_const_get(json, rb_intern("ParserError"));
     } else {
@@ -1172,7 +1192,7 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
     char   buf[64];
     char  *b;
     double d   = rb_num2dbl(obj);
-    int    cnt = 0;
+    size_t cnt = 0;
 
     if (0.0 == d) {
         b    = buf;
@@ -1193,7 +1213,7 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
             volatile VALUE rstr = oj_safe_string_convert(obj);
 
             strcpy(buf, RSTRING_PTR(rstr));
-            cnt = (int)RSTRING_LEN(rstr);
+            cnt = RSTRING_LEN(rstr);
         }
     }
     assure_size(out, cnt);
@@ -1205,7 +1225,8 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
 
 static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
     size_t size;
-    int    i, cnt;
+    size_t i;
+    size_t cnt;
     int    d2 = depth + 1;
 
     if (Yes == out->opts->circular) {
@@ -1214,12 +1235,11 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
             return;
         }
     }
-    // if (!oj_rails_array_opt && as_ok && 0 < out->argc && rb_respond_to(a, oj_as_json_id)) {
-    if (as_ok && 0 < out->argc && rb_respond_to(a, oj_as_json_id)) {
+    if (!oj_rails_array_opt && as_ok && rb_respond_to(a, oj_as_json_id)) {
         dump_as_json(a, depth, out, false);
         return;
     }
-    cnt         = (int)RARRAY_LEN(a);
+    cnt         = RARRAY_LEN(a);
     *out->cur++ = '[';
     size        = 2;
     assure_size(out, size);
@@ -1282,18 +1302,19 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
     if (out->omit_nil && Qnil == value) {
         return ST_CONTINUE;
     }
-    if (rtype != T_STRING && rtype != T_SYMBOL) {
-        key   = oj_safe_string_convert(key);
-        rtype = rb_type(key);
+    if (NULL != out->opts->dump_opts.only || NULL != out->opts->dump_opts.except) {
+        if (oj_key_skip(key, out->opts->dump_opts.only, out->opts->dump_opts.except)) {
+            return ST_CONTINUE;
+        }
     }
     if (!out->opts->dump_opts.use) {
         size = depth * out->indent + 1;
         assure_size(out, size);
         fill_indent(out, depth);
-        if (rtype == T_STRING) {
-            oj_dump_str(key, 0, out, false);
-        } else {
-            oj_dump_sym(key, 0, out, false);
+        switch (rtype) {
+        case T_STRING: oj_dump_str(key, 0, out, false); break;
+        case T_SYMBOL: oj_dump_sym(key, 0, out, false); break;
+        default: oj_dump_str(oj_safe_string_convert(key), 0, out, false); break;
         }
         *out->cur++ = ':';
     } else {
@@ -1308,10 +1329,10 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
                 APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, out->opts->dump_opts.indent_size);
             }
         }
-        if (rtype == T_STRING) {
-            oj_dump_str(key, 0, out, false);
-        } else {
-            oj_dump_sym(key, 0, out, false);
+        switch (rtype) {
+        case T_STRING: oj_dump_str(key, 0, out, false); break;
+        case T_SYMBOL: oj_dump_sym(key, 0, out, false); break;
+        default: oj_dump_str(oj_safe_string_convert(key), 0, out, false); break;
         }
         size = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
         assure_size(out, size);
@@ -1340,7 +1361,7 @@ static void dump_hash(VALUE obj, int depth, Out out, bool as_ok) {
             return;
         }
     }
-    if ((!oj_rails_hash_opt || 0 < out->argc) && as_ok && rb_respond_to(obj, oj_as_json_id)) {
+    if (!oj_rails_hash_opt && as_ok && rb_respond_to(obj, oj_as_json_id)) {
         dump_as_json(obj, depth, out, false);
         return;
     }

data/ext/oj/reader.c

@@ -101,7 +101,7 @@ int oj_reader_read(Reader reader) {
         } else {
             shift = reader->pro - reader->head - 1;  // leave one character so we can backup one
         }
-        if (0 >= shift) {                            /* no space left so allocate more */
+        if (0 >= shift) { /* no space left so allocate more */
             const char *old  = reader->head;
             size_t      size = reader->end - reader->head + BUF_PAD;
 
@@ -164,8 +164,14 @@ static VALUE partial_io_cb(VALUE rbuf) {
     }
     str = StringValuePtr(rstr);
     cnt = RSTRING_LEN(rstr);
-    strcpy(reader->tail, str);
-    reader->read_end = reader->tail + cnt;
+    if (cnt > (size_t)(reader->end - reader->tail)) {
+        // A misbehaving IO returned more than the requested number of bytes.
+        // Copying it in with strcpy() would overflow the reader buffer.
+        rb_raise(rb_eIOError, "read returned more than the requested number of bytes");
+    }
+    memcpy(reader->tail, str, cnt);
+    reader->tail[cnt] = '\0';
+    reader->read_end  = reader->tail + cnt;
 
     return Qtrue;
 }
@@ -184,8 +190,14 @@ static VALUE io_cb(VALUE rbuf) {
     }
     str = StringValuePtr(rstr);
     cnt = RSTRING_LEN(rstr);
-    strcpy(reader->tail, str);
-    reader->read_end = reader->tail + cnt;
+    if (cnt > (size_t)(reader->end - reader->tail)) {
+        // A misbehaving IO returned more than the requested number of bytes.
+        // Copying it in with strcpy() would overflow the reader buffer.
+        rb_raise(rb_eIOError, "read returned more than the requested number of bytes");
+    }
+    memcpy(reader->tail, str, cnt);
+    reader->tail[cnt] = '\0';
+    reader->read_end  = reader->tail + cnt;
 
     return Qtrue;
 }

data/ext/oj/rxclass.c

@@ -96,7 +96,7 @@ int oj_rxclass_append(RxClass rc, const char *expr, VALUE clas) {
 }
 
 VALUE
-oj_rxclass_match(RxClass rc, const char *str, int len) {
+oj_rxclass_match(RxClass rc, const char *str, size_t len) {
     RxC  rxc;
     char buf[4096];
 
@@ -142,3 +142,19 @@ void oj_rxclass_copy(RxClass src, RxClass dest) {
         }
     }
 }
+
+// Add the Ruby objects in the chain to an array. The regexps and the classes
+// can be referenced from nowhere else, as with a default match_string option,
+// and are collected unless something holds onto them.
+void oj_rxclass_keep(RxClass rc, VALUE keep) {
+    RxC rxc;
+
+    for (rxc = rc->head; NULL != rxc; rxc = rxc->next) {
+        if (Qnil != rxc->rrx) {
+            rb_ary_push(keep, rxc->rrx);
+        }
+        if (Qnil != rxc->clas) {
+            rb_ary_push(keep, rxc->clas);
+        }
+    }
+}

data/ext/oj/rxclass.h

@@ -19,8 +19,9 @@ typedef struct _rxClass {
 extern void  oj_rxclass_init(RxClass rc);
 extern void  oj_rxclass_cleanup(RxClass rc);
 extern int   oj_rxclass_append(RxClass rc, const char *expr, VALUE clas);
-extern VALUE oj_rxclass_match(RxClass rc, const char *str, int len);
+extern VALUE oj_rxclass_match(RxClass rc, const char *str, size_t len);
 extern void  oj_rxclass_copy(RxClass src, RxClass dest);
 extern void  oj_rxclass_rappend(RxClass rc, VALUE rx, VALUE clas);
+extern void  oj_rxclass_keep(RxClass rc, VALUE keep);
 
 #endif /* OJ_RXCLASS_H */

data/ext/oj/safe.c

@@ -0,0 +1,230 @@
+
+#include "safe.h"
+
+static VALUE max_hash_size_sym, max_array_size_sym, max_depth_sym, max_total_elements_sym, max_hash_size_error_class,
+    max_array_size_error_class, max_depth_error_class, max_total_elements_error_class;
+
+static void check_object_size(safe_T safe) {
+    if (NIL_P(safe->max_hash_size)) {
+        return;
+    }
+
+    struct _usual usual                   = safe->usual;
+    Col           current_object_location = usual.ctail - 1;
+
+    long int number_of_items_in_stack = usual.vtail - usual.vhead;
+    long int number_of_items_in_hash  = (number_of_items_in_stack - current_object_location->vi - 1) / 2;
+
+    if (safe->max_hash_size > number_of_items_in_hash) {
+        return;
+    }
+
+    rb_raise(max_hash_size_error_class, "Too many object items!");
+}
+
+static void check_array_size(safe_T safe) {
+    if (NIL_P(safe->max_array_size)) {
+        return;
+    }
+
+    struct _usual usual                   = safe->usual;
+    Col           current_object_location = usual.ctail - 1;
+
+    long int number_of_items_in_stack = usual.vtail - usual.vhead;
+    long int number_of_items_in_array = number_of_items_in_stack - current_object_location->vi - 1;
+
+    if (safe->max_array_size > number_of_items_in_array) {
+        return;
+    }
+
+    rb_raise(max_array_size_error_class, "Too many array items!");
+}
+
+static void check_max_depth(safe_T safe, ojParser p) {
+    if (NIL_P(safe->max_depth) || safe->max_depth >= (p->depth + 1)) {
+        return;
+    }
+
+    rb_raise(max_depth_error_class, "JSON is too deep!");
+}
+
+static void check_max_total_elements(safe_T safe) {
+    /*
+    * We check if `max_total_elements` is greater than `current_elements_count`
+    * (instead of greater than or equal) because top-level elements (e.g., [],
+    * null, true) are not counted. As a result, `current_elements_count`
+    * always holds one less than the actual total.
+    */
+    if (NIL_P(safe->max_total_elements) || safe->max_total_elements > safe->current_elements_count) {
+        return;
+    }
+
+    rb_raise(max_total_elements_error_class, "Too many elements!");
+}
+
+static void safe_start(ojParser p) {
+    safe_T safe = (safe_T)p->ctx;
+
+    safe->current_hash_size      = 0;
+    safe->current_array_size     = 0;
+    safe->current_elements_count = 0;
+
+    safe->delegated_start_func(p);
+}
+
+static void safe_open_object(ojParser p) {
+    safe_T safe = (safe_T)p->ctx;
+
+    safe->current_hash_size++;
+    safe->current_elements_count++;
+
+    check_array_size(safe);
+    check_max_depth(safe, p);
+    check_max_total_elements(safe);
+
+    safe->delegated_open_object_func(p);
+}
+
+static void safe_open_array(ojParser p) {
+    safe_T safe = (safe_T)p->ctx;
+
+    safe->current_array_size++;
+    safe->current_elements_count++;
+
+    check_array_size(safe);
+    check_max_depth(safe, p);
+    check_max_total_elements(safe);
+
+    safe->delegated_open_array_func(p);
+}
+
+DEFINE_DELEGATED_FUNCTION(add_null);
+DEFINE_DELEGATED_FUNCTION(add_true);
+DEFINE_DELEGATED_FUNCTION(add_false);
+DEFINE_DELEGATED_FUNCTION(add_int);
+DEFINE_DELEGATED_FUNCTION(add_float);
+DEFINE_DELEGATED_FUNCTION(add_big);
+DEFINE_DELEGATED_FUNCTION(add_str);
+
+static void safe_open_object_key(ojParser p) {
+    safe_T safe = (safe_T)p->ctx;
+
+    safe->current_hash_size++;
+    safe->current_elements_count += 2;
+
+    check_object_size(safe);
+    check_max_depth(safe, p);
+    check_max_total_elements(safe);
+
+    safe->delegated_open_object_key_func(p);
+}
+
+static void safe_open_array_key(ojParser p) {
+    safe_T safe = (safe_T)p->ctx;
+
+    safe->current_array_size++;
+    safe->current_elements_count += 2;
+
+    check_object_size(safe);
+    check_max_depth(safe, p);
+    check_max_total_elements(safe);
+
+    safe->delegated_open_array_key_func(p);
+}
+
+DEFINE_DELEGATED_OBJECT_FUNCTION(add_null);
+DEFINE_DELEGATED_OBJECT_FUNCTION(add_true);
+DEFINE_DELEGATED_OBJECT_FUNCTION(add_false);
+DEFINE_DELEGATED_OBJECT_FUNCTION(add_int);
+DEFINE_DELEGATED_OBJECT_FUNCTION(add_float);
+DEFINE_DELEGATED_OBJECT_FUNCTION(add_big);
+DEFINE_DELEGATED_OBJECT_FUNCTION(add_str);
+
+void oj_init_safe_parser(ojParser p, safe_T safe, VALUE options) {
+    // Safe parser inherits all members of usual parser
+    oj_init_usual(p, &safe->usual);
+
+    safe->delegated_start_func = p->start;
+    p->start                   = safe_start;
+
+    Funcs f;
+
+    // Array parser functions
+    f                                = &p->funcs[ARRAY_FUN];
+    safe->delegated_open_object_func = f->open_object;
+    f->open_object                   = safe_open_object;
+    safe->delegated_open_array_func  = f->open_array;
+    f->open_array                    = safe_open_array;
+    // The following overrides are done for counting objects
+    safe->delegated_add_null_func  = f->add_null;
+    f->add_null                    = safe_add_null;
+    safe->delegated_add_true_func  = f->add_true;
+    f->add_true                    = safe_add_true;
+    safe->delegated_add_false_func = f->add_false;
+    f->add_false                   = safe_add_false;
+    safe->delegated_add_int_func   = f->add_int;
+    f->add_int                     = safe_add_int;
+    safe->delegated_add_float_func = f->add_float;
+    f->add_float                   = safe_add_float;
+    safe->delegated_add_big_func   = f->add_big;
+    f->add_big                     = safe_add_big;
+    safe->delegated_add_str_func   = f->add_str;
+    f->add_str                     = safe_add_str;
+
+    // Object parser functions
+    f                                    = &p->funcs[OBJECT_FUN];
+    safe->delegated_open_object_key_func = f->open_object;
+    f->open_object                       = safe_open_object_key;
+    safe->delegated_open_array_key_func  = f->open_array;
+    f->open_array                        = safe_open_array_key;
+    // The following overrides are done for counting objects
+    safe->delegated_add_null_key_func  = f->add_null;
+    f->add_null                        = safe_add_null_key;
+    safe->delegated_add_true_key_func  = f->add_true;
+    f->add_true                        = safe_add_true_key;
+    safe->delegated_add_false_key_func = f->add_false;
+    f->add_false                       = safe_add_false_key;
+    safe->delegated_add_int_key_func   = f->add_int;
+    f->add_int                         = safe_add_int_key;
+    safe->delegated_add_float_key_func = f->add_float;
+    f->add_float                       = safe_add_float_key;
+    safe->delegated_add_big_key_func   = f->add_big;
+    f->add_big                         = safe_add_big_key;
+    safe->delegated_add_str_key_func   = f->add_str;
+    f->add_str                         = safe_add_str_key;
+
+    SET_CONFIG(max_hash_size);
+    SET_CONFIG(max_array_size);
+    SET_CONFIG(max_depth);
+    SET_CONFIG(max_total_elements);
+}
+
+void oj_set_parser_safe(ojParser p, VALUE options) {
+    safe_T s = OJ_R_ALLOC(struct _safe_S);
+
+    oj_init_safe_parser(p, s, options);
+}
+
+void oj_safe_init(VALUE parser_class) {
+    VALUE validation_error_class = rb_define_class_under(parser_class, "ValidationError", rb_eRuntimeError);
+
+    max_hash_size_error_class      = rb_define_class_under(parser_class, "HashSizeError", validation_error_class);
+    max_array_size_error_class     = rb_define_class_under(parser_class, "ArraySizeError", validation_error_class);
+    max_depth_error_class          = rb_define_class_under(parser_class, "DepthError", validation_error_class);
+    max_total_elements_error_class = rb_define_class_under(parser_class, "TotalElementsError", validation_error_class);
+
+    rb_gc_register_address(&max_hash_size_error_class);
+    rb_gc_register_address(&max_array_size_error_class);
+    rb_gc_register_address(&max_depth_error_class);
+    rb_gc_register_address(&max_total_elements_error_class);
+
+    max_hash_size_sym      = ID2SYM(rb_intern("max_hash_size"));
+    max_array_size_sym     = ID2SYM(rb_intern("max_array_size"));
+    max_depth_sym          = ID2SYM(rb_intern("max_depth"));
+    max_total_elements_sym = ID2SYM(rb_intern("max_total_elements"));
+
+    rb_gc_register_address(&max_hash_size_sym);
+    rb_gc_register_address(&max_array_size_sym);
+    rb_gc_register_address(&max_depth_sym);
+    rb_gc_register_address(&max_total_elements_sym);
+}

data/ext/oj/safe.h

@@ -0,0 +1,79 @@
+#include <ruby.h>
+
+#include "parser.h"
+#include "usual.h"
+
+#define SET_CONFIG(config_name)                                                        \
+    do {                                                                               \
+        VALUE rb_##config_name = rb_hash_aref(options, config_name##_sym);             \
+                                                                                       \
+        if (RB_INTEGER_TYPE_P(rb_##config_name)) {                                     \
+            safe->config_name = NUM2LONG(rb_##config_name);                            \
+        } else if (!NIL_P(rb_##config_name)) {                                         \
+            rb_raise(rb_eArgError, "Incorrect value provided for `" #config_name "`"); \
+        } else {                                                                       \
+            safe->config_name = Qnil;                                                  \
+        }                                                                              \
+    } while (0);
+
+#define DEFINE_DELEGATED_FUNCTION(function_name)   \
+    static void safe_##function_name(ojParser p) { \
+        safe_T safe = (safe_T)p->ctx;              \
+                                                   \
+        safe->current_elements_count++;            \
+                                                   \
+        check_array_size(safe);                    \
+        check_max_total_elements(safe);            \
+                                                   \
+        safe->delegated_##function_name##_func(p); \
+    }
+
+#define DEFINE_DELEGATED_OBJECT_FUNCTION(function_name)  \
+    static void safe_##function_name##_key(ojParser p) { \
+        safe_T safe = (safe_T)p->ctx;                    \
+                                                         \
+        safe->current_elements_count += 2;               \
+                                                         \
+        check_object_size(safe);                         \
+        check_max_total_elements(safe);                  \
+                                                         \
+        safe->delegated_##function_name##_key_func(p);   \
+    }
+
+typedef struct _safe_S {
+    struct _usual usual;
+
+    long int max_hash_size;
+    long int max_array_size;
+    long int max_depth;
+    long int max_total_elements;
+    long int max_json_size_bytes;
+
+    long int current_hash_size;
+    long int current_array_size;
+    long int current_elements_count;
+
+    void (*delegated_start_func)(struct _ojParser *p);
+
+    // Array functions
+    void (*delegated_open_object_func)(struct _ojParser *p);
+    void (*delegated_open_array_func)(struct _ojParser *p);
+    void (*delegated_add_null_func)(struct _ojParser *p);
+    void (*delegated_add_true_func)(struct _ojParser *p);
+    void (*delegated_add_false_func)(struct _ojParser *p);
+    void (*delegated_add_int_func)(struct _ojParser *p);
+    void (*delegated_add_float_func)(struct _ojParser *p);
+    void (*delegated_add_big_func)(struct _ojParser *p);
+    void (*delegated_add_str_func)(struct _ojParser *p);
+
+    // Object functions
+    void (*delegated_open_object_key_func)(struct _ojParser *p);
+    void (*delegated_open_array_key_func)(struct _ojParser *p);
+    void (*delegated_add_null_key_func)(struct _ojParser *p);
+    void (*delegated_add_true_key_func)(struct _ojParser *p);
+    void (*delegated_add_false_key_func)(struct _ojParser *p);
+    void (*delegated_add_int_key_func)(struct _ojParser *p);
+    void (*delegated_add_float_key_func)(struct _ojParser *p);
+    void (*delegated_add_big_key_func)(struct _ojParser *p);
+    void (*delegated_add_str_key_func)(struct _ojParser *p);
+} *safe_T;