oj 3.16.6 → 3.17.3

data/ext/oj/object.c

@@ -305,7 +305,7 @@ static int hat_num(ParseInfo pi, Val parent, Val kval, NumInfo ni) {
 
 static int hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, volatile VALUE value) {
     if (T_ARRAY == rb_type(value)) {
-        int len = (int)RARRAY_LEN(value);
+        size_t len = RARRAY_LEN(value);
 
         if (2 == klen && 'u' == key[1]) {
             volatile VALUE sc;
@@ -321,19 +321,20 @@ static int hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, vol
             if (T_ARRAY == rb_type(e1)) {
                 VALUE          args[1024];
                 volatile VALUE rstr;
-                int            i, cnt = (int)RARRAY_LEN(e1);
+                size_t         i;
+                size_t         cnt = RARRAY_LEN(e1);
 
                 for (i = 0; i < cnt; i++) {
                     rstr    = RARRAY_AREF(e1, i);
                     args[i] = rb_funcall(rstr, oj_to_sym_id, 0);
                 }
-                sc = rb_funcall2(rb_cStruct, oj_new_id, cnt, args);
+                sc = rb_funcall2(rb_cStruct, oj_new_id, (int)cnt, args);
             } else {
                 // If struct is not defined then we let this fail and raise an exception.
                 sc = oj_name2struct(pi, *RARRAY_CONST_PTR(value), rb_eArgError);
             }
             if (sc == rb_cRange) {
-                parent->val = rb_class_new_instance(len - 1, RARRAY_CONST_PTR(value) + 1, rb_cRange);
+                parent->val = rb_class_new_instance((int)(len - 1), RARRAY_CONST_PTR(value) + 1, rb_cRange);
             } else {
                 // Create a properly initialized struct instance without calling the initialize method.
                 parent->val = rb_obj_alloc(sc);
@@ -348,10 +349,10 @@ static int hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, vol
                 slen = FIX2INT(rb_funcall2(parent->val, oj_length_id, 0, 0));
 #endif
                 // MRI >= 1.9
-                if (len - 1 > slen) {
+                if (len - 1 > (size_t)slen) {
                     oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Invalid struct data");
                 } else {
-                    int i;
+                    size_t i;
 
                     for (i = 0; i < len - 1; i++) {
                         rb_struct_aset(parent->val, INT2FIX(i), RARRAY_CONST_PTR(value)[i + 1]);
@@ -698,9 +699,8 @@ oj_object_parse(int argc, VALUE *argv, VALUE self) {
 
     if (T_STRING == rb_type(*argv)) {
         return oj_pi_parse(argc, argv, &pi, 0, 0, 1);
-    } else {
-        return oj_pi_sparse(argc, argv, &pi, 0);
     }
+    return oj_pi_sparse(argc, argv, &pi, 0);
 }
 
 VALUE

data/ext/oj/oj.c

@@ -18,6 +18,9 @@
 #include "odd.h"
 #include "parse.h"
 #include "rails.h"
+#include "simd.h"
+
+#define MAX_INDENT 16
 
 typedef struct _yesNoOpt {
     VALUE sym;
@@ -119,7 +122,9 @@ static VALUE create_id_sym;
 static VALUE custom_sym;
 static VALUE empty_string_sym;
 static VALUE escape_mode_sym;
+static VALUE except_sym;
 static VALUE integer_range_sym;
+static VALUE max_integer_digits_sym;
 static VALUE fast_sym;
 static VALUE float_prec_sym;
 static VALUE float_format_sym;
@@ -137,6 +142,7 @@ static VALUE null_sym;
 static VALUE object_sym;
 static VALUE omit_null_byte_sym;
 static VALUE omit_nil_sym;
+static VALUE only_sym;
 static VALUE rails_sym;
 static VALUE raise_sym;
 static VALUE ruby_sym;
@@ -166,6 +172,8 @@ pthread_mutex_t oj_cache_mutex;
 VALUE oj_cache_mutex = Qnil;
 #endif
 
+SIMD_Implementation SIMD_Impl = SIMD_NONE;
+
 extern void oj_parser_init();
 
 const char oj_json_class[] = "json_class";
@@ -201,6 +209,7 @@ struct _options oj_default_options = {
     0,              // cache_str
     0,              // int_range_min
     0,              // int_range_max
+    0,              // max_integer_digits
     oj_json_class,  // create_id
     10,             // create_id_len
     9,              // sec_prec
@@ -225,6 +234,8 @@ struct _options oj_default_options = {
         false,      // omit_nil
         false,      // omit_null_byte
         MAX_DEPTH,  // max_depth
+        NULL,       // only
+        NULL,       // except
     },
     {
         // str_rx
@@ -235,6 +246,22 @@ struct _options oj_default_options = {
     NULL,
 };
 
+static VALUE only_array_from_string(const char *str) {
+    volatile VALUE a = Qnil;
+
+    if (NULL != str && 2 < strlen(str)) {
+        str++;
+        char *cp;
+
+        a = rb_ary_new();
+        while (NULL != (cp = strchr(str, ':'))) {
+            rb_ary_push(a, rb_id2sym(rb_intern2(str, cp - str)));
+            str = cp + 1;
+        }
+    }
+    return a;
+}
+
 /* Document-method: default_options()
  *	call-seq: default_options()
  *
@@ -311,10 +338,17 @@ struct _options oj_default_options = {
  * - *:cache_str* [_Fixnum_] maximum string value length to cache (strings less
  *   than this are cached)
  * - *:integer_range* [_Range_] Dump integers outside range as strings.
+ * - *:max_integer_digits* [_Fixnum_] Maximum number of decimal digits allowed in a
+ *   parsed integer. When the limit is exceeded a parse error is raised. 0 (the
+ *   default) disables the limit. Setting a reasonable limit is recommended when
+ *   parsing untrusted input to mitigate CPU-DoS attacks. Only applies to the
+ *   legacy parsers (Oj.load, Oj::Doc, JSON.parse mimic); Oj::Parser is unaffected.
  * - *:trace* [_true,_|_false_] Trace all load and dump calls, default is false
  *   (trace is off)
  * - *:safe* [_true,_|_false_] Safe mimic breaks JSON mimic to be safer, default
  *   is false (safe is off)
+ * - *:only* [_nil,_|_Array_] A list of the fields to encode. All others are skipped.
+ * - *:except* [_nil,_|_Array_] A list of the fields to not encode. All others are encoded.
  *
  * Return [_Hash_] all current option settings.
  */
@@ -423,6 +457,7 @@ static VALUE get_def_opts(VALUE self) {
     } else {
         rb_hash_aset(opts, integer_range_sym, Qnil);
     }
+    rb_hash_aset(opts, max_integer_digits_sym, LONG2NUM((long)oj_default_options.max_integer_digits));
     switch (oj_default_options.escape_mode) {
     case NLEsc: rb_hash_aset(opts, escape_mode_sym, newline_sym); break;
     case JSONEsc: rb_hash_aset(opts, escape_mode_sym, json_sym); break;
@@ -480,6 +515,9 @@ static VALUE get_def_opts(VALUE self) {
     rb_hash_aset(opts, oj_hash_class_sym, oj_default_options.hash_class);
     rb_hash_aset(opts, oj_array_class_sym, oj_default_options.array_class);
 
+    rb_hash_aset(opts, only_sym, only_array_from_string(oj_default_options.dump_opts.only));
+    rb_hash_aset(opts, except_sym, only_array_from_string(oj_default_options.dump_opts.except));
+
     if (NULL == oj_default_options.ignore) {
         rb_hash_aset(opts, ignore_sym, Qnil);
     } else {
@@ -563,6 +601,8 @@ static VALUE get_def_opts(VALUE self) {
  *   - *:cache_keys* [_Boolean_] if true then hash keys are cached
  *   - *:cache_str* [_Fixnum_] maximum string value length to cache (strings less than this are cached)
  *   - *:integer_range* [_Range_] Dump integers outside range as strings.
+ *   - *:max_integer_digits* [_Fixnum_] Maximum decimal digits in a parsed integer
+ *     (0 = unlimited). Use to mitigate CPU-DoS via huge integer values in JSON.
  *   - *:trace* [_Boolean_] turn trace on or off.
  *   - *:safe* [_Boolean_] turn safe mimic on or off.
  */
@@ -622,6 +662,95 @@ bool set_yesno_options(VALUE key, VALUE value, Options copts) {
     return false;
 }
 
+static const char *make_only_value(VALUE v) {
+    switch (rb_type(v)) {
+    case RUBY_T_NIL:
+    case RUBY_T_NONE: return NULL;
+    case RUBY_T_ARRAY: {
+        long  len = rb_array_len(v);
+        long  i;
+        long  size = 0;
+        char *buf;
+        char *bp;
+
+        for (i = 0; i < len; i++) {
+            VALUE x = rb_ary_entry(v, i);
+
+            switch (rb_type(x)) {
+            case RUBY_T_SYMBOL:
+                size += strlen(rb_id2name(rb_sym2id(x)));
+                size++;
+                break;
+            case RUBY_T_STRING:
+                size += strlen(StringValueCStr(x));
+                size++;
+                break;
+            default: rb_raise(rb_eArgError, ":only and :except must be nil, symbol, string, or array."); break;
+            }
+        }
+        if (0 == size) {
+            return NULL;
+        }
+        buf   = OJ_R_ALLOC_N(char, size + 2);
+        bp    = buf;
+        *bp++ = ':';
+        for (i = 0; i < len; i++) {
+            VALUE       x = rb_ary_entry(v, i);
+            const char *str;
+
+            switch (rb_type(x)) {
+            case RUBY_T_SYMBOL:
+                str  = rb_id2name(rb_sym2id(x));
+                size = strlen(str);
+                memcpy(bp, str, size);
+                bp += size;
+                *bp++ = ':';
+                break;
+            case RUBY_T_STRING:
+                str  = StringValueCStr(x);
+                size = strlen(str);
+                memcpy(bp, str, size);
+                bp += size;
+                *bp++ = ':';
+                break;
+            default:
+                // ignore
+                break;
+            }
+        }
+        *bp = '\0';
+
+        return buf;
+    }
+    case RUBY_T_STRING: {
+        const char *str  = StringValueCStr(v);
+        size_t      size = strlen(str);
+        char       *buf  = OJ_R_ALLOC_N(char, size + 3);
+
+        buf[0] = ':';
+        strcpy(buf + 1, str);
+        buf[size + 1] = ':';
+        buf[size + 2] = '\0';
+
+        return buf;
+    }
+    case RUBY_T_SYMBOL: {
+        const char *str  = rb_id2name(rb_sym2id(v));
+        size_t      size = strlen(str);
+        char       *buf  = OJ_R_ALLOC_N(char, size + 3);
+
+        buf[0] = ':';
+        strcpy(buf + 1, str);
+        buf[size + 1] = ':';
+        buf[size + 2] = '\0';
+
+        return buf;
+    }
+    default: rb_raise(rb_eArgError, ":only and zzz :except must be nil, symbol, string, or array."); break;
+    }
+    return NULL;
+}
+
 static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
     Options copts = (Options)opts;
     size_t  len;
@@ -639,7 +768,10 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         case T_FIXNUM:
             copts->dump_opts.indent_size = 0;
             *copts->dump_opts.indent_str = '\0';
-            copts->indent                = FIX2INT(v);
+            if (MAX_INDENT < FIX2INT(v)) {
+                rb_raise(rb_eArgError, "indent is limited to %d characters.", MAX_INDENT);
+            }
+            copts->indent = FIX2INT(v);
             break;
         case T_STRING:
             if (sizeof(copts->dump_opts.indent_str) <= (len = RSTRING_LEN(v))) {
@@ -923,12 +1055,12 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         OJ_R_FREE(copts->ignore);
         copts->ignore = NULL;
         if (Qnil != v) {
-            int cnt;
+            size_t cnt;
 
             rb_check_type(v, T_ARRAY);
-            cnt = (int)RARRAY_LEN(v);
+            cnt = RARRAY_LEN(v);
             if (0 < cnt) {
-                int i;
+                size_t i;
 
                 copts->ignore = OJ_R_ALLOC_N(VALUE, cnt + 1);
                 for (i = 0; i < cnt; i++) {
@@ -954,6 +1086,20 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         } else if (Qfalse != v) {
             rb_raise(rb_eArgError, ":integer_range must be a range of Fixnum.");
         }
+    } else if (max_integer_digits_sym == k) {
+        if (Qnil == v || Qfalse == v) {
+            copts->max_integer_digits = 0;
+        } else if (T_FIXNUM == rb_type(v)) {
+            long n = FIX2LONG(v);
+
+            if (n < 0) {
+                rb_raise(rb_eArgError, ":max_integer_digits must be >= 0.");
+            }
+
+            copts->max_integer_digits = (size_t)n;
+        } else {
+            rb_raise(rb_eArgError, ":max_integer_digits must be a non-negative Integer.");
+        }
     } else if (symbol_keys_sym == k || oj_symbolize_names_sym == k) {
         if (Qnil == v) {
             return ST_CONTINUE;
@@ -973,11 +1119,23 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
     } else if (float_format_sym == k) {
         rb_check_type(v, T_STRING);
-        if (6 < (int)RSTRING_LEN(v)) {
+        if (6 < RSTRING_LEN(v)) {
             rb_raise(rb_eArgError, ":float_format must be 6 bytes or less.");
         }
         strncpy(copts->float_fmt, RSTRING_PTR(v), (size_t)RSTRING_LEN(v));
         copts->float_fmt[RSTRING_LEN(v)] = '\0';
+    } else if (only_sym == k) {
+        if (NULL != copts->dump_opts.only) {
+            OJ_R_FREE((void *)copts->dump_opts.only);
+            copts->dump_opts.only = NULL;
+        }
+        copts->dump_opts.only = make_only_value(v);
+    } else if (except_sym == k) {
+        if (NULL != copts->dump_opts.except) {
+            OJ_R_FREE((void *)copts->dump_opts.except);
+            copts->dump_opts.except = NULL;
+        }
+        copts->dump_opts.except = make_only_value(v);
     }
     return ST_CONTINUE;
 }
@@ -1188,7 +1346,7 @@ static VALUE load_file(int argc, VALUE *argv, VALUE self) {
         OJ_FREE(wide_path);
     }
 #else
-    fd             = open(path, O_RDONLY);
+    fd = open(path, O_RDONLY);
 #endif
     if (0 == fd) {
         rb_raise(rb_eIOError, "%s", strerror(errno));
@@ -1277,8 +1435,7 @@ static VALUE dump_body(VALUE a) {
     if (0 == arg->out->buf) {
         rb_raise(rb_eNoMemError, "Not enough memory.");
     }
-    rstr = rb_str_new2(arg->out->buf);
-    rstr = oj_encode(rstr);
+    rstr = rb_utf8_str_new_cstr(arg->out->buf);
 
     return rstr;
 }
@@ -1378,8 +1535,7 @@ static VALUE to_json(int argc, VALUE *argv, VALUE self) {
     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);
 
     oj_out_free(&out);
 
@@ -1781,6 +1937,78 @@ static VALUE mem_report(VALUE self) {
  *
  * - *:wab* specifically for WAB data exchange.
  */
+
+// =============================================================================
+// Runtime SIMD CPU detection
+// Cross-platform support for Windows (MSVC), Linux, and macOS (GCC/Clang)
+// =============================================================================
+SIMD_Implementation oj_get_simd_implementation(void) {
+#ifdef HAVE_SIMD_X86
+    // x86/x86_64 runtime detection
+
+#if defined(_MSC_VER)
+    // MSVC: Use __cpuid intrinsic
+    int cpu_info[4];
+    __cpuid(cpu_info, 1);
+
+    // Check for SSE4.2 (bit 20 of ECX)
+    if (cpu_info[2] & (1 << 20)) {
+        return SIMD_SSE42;
+    }
+    // Check for SSE2 (bit 26 of EDX)
+    if (cpu_info[3] & (1 << 26)) {
+        return SIMD_SSE2;
+    }
+
+#elif defined(__GNUC__) || defined(__clang__)
+    // GCC/Clang: Use __builtin_cpu_supports if available
+#if defined(__has_builtin)
+#if __has_builtin(__builtin_cpu_supports)
+#define OJ_HAS_BUILTIN_CPU_SUPPORTS 1
+#endif
+#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))
+    // GCC 4.8+ has __builtin_cpu_supports
+#define OJ_HAS_BUILTIN_CPU_SUPPORTS 1
+#endif
+
+#ifdef OJ_HAS_BUILTIN_CPU_SUPPORTS
+#ifdef HAVE_SIMD_SSE4_2
+    if (__builtin_cpu_supports("sse4.2")) {
+        return SIMD_SSE42;
+    }
+#endif
+#ifdef HAVE_SIMD_SSE2
+    if (__builtin_cpu_supports("sse2")) {
+        return SIMD_SSE2;
+    }
+#endif
+#else
+    // Fallback: Use CPUID instruction directly
+    unsigned int eax, ebx, ecx, edx;
+    if (__get_cpuid(1, &eax, &ebx, &ecx, &edx)) {
+        // Check for SSE4.2 (bit 20 of ECX)
+        if (ecx & (1 << 20)) {
+            return SIMD_SSE42;
+        }
+        // Check for SSE2 (bit 26 of EDX)
+        if (edx & (1 << 26)) {
+            return SIMD_SSE2;
+        }
+    }
+#endif  // OJ_HAS_BUILTIN_CPU_SUPPORTS
+
+#endif  // _MSC_VER vs GCC/Clang
+
+#endif  // HAVE_SIMD_X86
+
+#ifdef HAVE_SIMD_NEON
+    // ARM NEON is always available on ARM64 and detected at compile time
+    return SIMD_NEON;
+#endif
+
+    return SIMD_NONE;
+}
+
 void Init_oj(void) {
     int err = 0;
 
@@ -1954,6 +2182,8 @@ void Init_oj(void) {
     rb_gc_register_address(&escape_mode_sym);
     integer_range_sym = ID2SYM(rb_intern("integer_range"));
     rb_gc_register_address(&integer_range_sym);
+    max_integer_digits_sym = ID2SYM(rb_intern("max_integer_digits"));
+    rb_gc_register_address(&max_integer_digits_sym);
     fast_sym = ID2SYM(rb_intern("fast"));
     rb_gc_register_address(&fast_sym);
     float_format_sym = ID2SYM(rb_intern("float_format"));
@@ -2060,6 +2290,10 @@ void Init_oj(void) {
     rb_gc_register_address(&xmlschema_sym);
     xss_safe_sym = ID2SYM(rb_intern("xss_safe"));
     rb_gc_register_address(&xss_safe_sym);
+    only_sym = ID2SYM(rb_intern("only"));
+    rb_gc_register_address(&only_sym);
+    except_sym = ID2SYM(rb_intern("except"));
+    rb_gc_register_address(&except_sym);
 
     oj_slash_string = rb_str_new2("/");
     rb_gc_register_address(&oj_slash_string);
@@ -2081,6 +2315,18 @@ void Init_oj(void) {
 #endif
     oj_init_doc();
 
+    SIMD_Impl = oj_get_simd_implementation();
+
     oj_parser_init();
     oj_scanner_init();
+
+#ifdef HAVE_SIMD_NEON
+    initialize_neon();
+#endif /* HAVE_SIMD_NEON */
+
+#ifdef HAVE_SIMD_SSE4_2
+    if (SIMD_Impl == SIMD_SSE42) {
+        initialize_sse42();
+    }
+#endif /* HAVE_SIMD_SSE4_2 */
 }

data/ext/oj/oj.h

@@ -104,61 +104,64 @@ typedef enum {
 } StreamWriterType;
 
 typedef struct _dumpOpts {
-    bool    use;
-    char    indent_str[16];
-    char    before_sep[16];
-    char    after_sep[16];
-    char    hash_nl[16];
-    char    array_nl[16];
-    uint8_t indent_size;
-    uint8_t before_size;
-    uint8_t after_size;
-    uint8_t hash_size;
-    uint8_t array_size;
-    char    nan_dump;  // NanDump
-    bool    omit_nil;
-    bool    omit_null_byte;
-    int     max_depth;
+    bool        use;
+    char        indent_str[16];
+    char        before_sep[16];
+    char        after_sep[16];
+    char        hash_nl[16];
+    char        array_nl[16];
+    uint8_t     indent_size;
+    uint8_t     before_size;
+    uint8_t     after_size;
+    uint8_t     hash_size;
+    uint8_t     array_size;
+    char        nan_dump;  // NanDump
+    bool        omit_nil;
+    bool        omit_null_byte;
+    int         max_depth;
+    const char *only;
+    const char *except;
 } *DumpOpts;
 
 typedef struct _options {
-    int              indent;         // indention for dump, default 2
-    char             circular;       // YesNo
-    char             auto_define;    // YesNo
-    char             sym_key;        // YesNo
-    char             escape_mode;    // Escape_Mode
-    char             mode;           // Mode
-    char             class_cache;    // YesNo
-    char             time_format;    // TimeFormat
-    char             bigdec_as_num;  // YesNo
-    char             bigdec_load;    // BigLoad
-    char             compat_bigdec;  // boolean (0 or 1)
-    char             to_hash;        // YesNo
-    char             to_json;        // YesNo
-    char             as_json;        // YesNo
-    char             raw_json;       // YesNo
-    char             nilnil;         // YesNo
-    char             empty_string;   // YesNo
-    char             allow_gc;       // allow GC during parse
-    char             quirks_mode;    // allow single JSON values instead of documents
-    char             allow_invalid;  // YesNo - allow invalid unicode
-    char             create_ok;      // YesNo allow create_id
-    char             allow_nan;      // YEsyNo for parsing only
-    char             trace;          // YesNo
-    char             safe;           // YesNo
-    char             sec_prec_set;   // boolean (0 or 1)
-    char             ignore_under;   // YesNo - ignore attrs starting with _ if true in object and custom modes
-    char             cache_keys;     // YesNo
-    char             cache_str;      // string short than or equal to this are cache
-    int64_t          int_range_min;  // dump numbers below as string
-    int64_t          int_range_max;  // dump numbers above as string
-    const char      *create_id;      // 0 or string
-    size_t           create_id_len;  // length of create_id
-    int              sec_prec;       // second precision when dumping time
-    char             float_prec;     // float precision, linked to float_fmt
-    char             float_fmt[7];   // float format for dumping, if empty use Ruby
-    VALUE            hash_class;     // class to use in place of Hash on load
-    VALUE            array_class;    // class to use in place of Array on load
+    int              indent;              // indention for dump, default 2
+    char             circular;            // YesNo
+    char             auto_define;         // YesNo
+    char             sym_key;             // YesNo
+    char             escape_mode;         // Escape_Mode
+    char             mode;                // Mode
+    char             class_cache;         // YesNo
+    char             time_format;         // TimeFormat
+    char             bigdec_as_num;       // YesNo
+    char             bigdec_load;         // BigLoad
+    char             compat_bigdec;       // boolean (0 or 1)
+    char             to_hash;             // YesNo
+    char             to_json;             // YesNo
+    char             as_json;             // YesNo
+    char             raw_json;            // YesNo
+    char             nilnil;              // YesNo
+    char             empty_string;        // YesNo
+    char             allow_gc;            // allow GC during parse
+    char             quirks_mode;         // allow single JSON values instead of documents
+    char             allow_invalid;       // YesNo - allow invalid unicode
+    char             create_ok;           // YesNo allow create_id
+    char             allow_nan;           // YesNo for parsing only
+    char             trace;               // YesNo
+    char             safe;                // YesNo
+    char             sec_prec_set;        // boolean (0 or 1)
+    char             ignore_under;        // YesNo - ignore attrs starting with _ if true in object and custom modes
+    char             cache_keys;          // YesNo
+    char             cache_str;           // string short than or equal to this are cache
+    int64_t          int_range_min;       // dump numbers below as string
+    int64_t          int_range_max;       // dump numbers above as string
+    size_t           max_integer_digits;  // 0 = unlimited; max decimal digits for parsed integers
+    const char      *create_id;           // 0 or string
+    size_t           create_id_len;       // length of create_id
+    int              sec_prec;            // second precision when dumping time
+    char             float_prec;          // float precision, linked to float_fmt
+    char             float_fmt[7];        // float format for dumping, if empty use Ruby
+    VALUE            hash_class;          // class to use in place of Hash on load
+    VALUE            array_class;         // class to use in place of Array on load
     struct _dumpOpts dump_opts;
     struct _rxClass  str_rx;
     VALUE           *ignore;  // Qnil terminated array of classes or NULL