oj 3.13.7 → 3.13.23

data/ext/oj/object.c

@@ -35,7 +35,7 @@ static VALUE calc_hash_key(ParseInfo pi, Val kval, char k1) {
         return ID2SYM(rb_intern3(kval->key + 1, kval->klen - 1, oj_utf8_encoding));
     }
     if (Yes == pi->options.sym_key) {
-	return ID2SYM(rb_intern3(kval->key, kval->klen, oj_utf8_encoding));
+        return ID2SYM(rb_intern3(kval->key, kval->klen, oj_utf8_encoding));
     }
 #if HAVE_RB_ENC_INTERNED_STR
     rkey = rb_enc_interned_str(kval->key, kval->klen, oj_utf8_encoding);
@@ -60,16 +60,11 @@ static VALUE str_to_value(ParseInfo pi, const char *str, size_t len, const char
         }
         rstr = oj_circ_array_get(pi->circ_array, i);
     } else {
-	rstr = rb_utf8_str_new(str, len);
+        rstr = rb_utf8_str_new(str, len);
     }
     return rstr;
 }
 
-#if (RUBY_VERSION_MAJOR == 1 && RUBY_VERSION_MINOR == 8)
-static VALUE oj_parse_xml_time(const char *str, int len) {
-    return rb_funcall(rb_cTime, oj_parse_id, 1, rb_str_new(str, len));
-}
-#else
 // The much faster approach (4x faster)
 static int parse_num(const char *str, const char *end, int cnt) {
     int  n = 0;
@@ -201,7 +196,6 @@ oj_parse_xml_time(const char *str, int len) {
     }
     return rb_funcall2(rb_cTime, oj_new_id, 7, args);
 }
-#endif
 
 static int hat_cstr(ParseInfo pi, Val parent, Val kval, const char *str, size_t len) {
     const char *key  = kval->key;
@@ -226,13 +220,10 @@ static int hat_cstr(ParseInfo pi, Val parent, Val kval, const char *str, size_t
             }
             parent->val      = odd->clas;
             parent->odd_args = oj_odd_alloc_args(odd);
-        } break;
-        case 'm':
-            parent->val = ID2SYM(rb_intern3(str + 1, len - 1, oj_utf8_encoding));
-            break;
-        case 's':
-	    parent->val = rb_utf8_str_new(str, len);
             break;
+        }
+        case 'm': parent->val = ID2SYM(rb_intern3(str + 1, len - 1, oj_utf8_encoding)); break;
+        case 's': parent->val = rb_utf8_str_new(str, len); break;
         case 'c':  // class
         {
             VALUE clas = oj_name2class(pi, str, len, Yes == pi->options.auto_define, rb_eArgError);
@@ -242,7 +233,8 @@ static int hat_cstr(ParseInfo pi, Val parent, Val kval, const char *str, size_t
             } else {
                 parent->val = clas;
             }
-        } break;
+            break;
+        }
         case 't':  // time
             parent->val = oj_parse_xml_time(str, (int)len);
             break;
@@ -277,27 +269,17 @@ 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);
                 }
             }
             break;
-        case 'i':  // circular index
-            if (!ni->infinity && !ni->neg && 1 == ni->div && 0 == ni->exp &&
-                0 != pi->circ_array) {  // fixnum
+        case 'i':                                                                                    // circular index
+            if (!ni->infinity && !ni->neg && 1 == ni->div && 0 == ni->exp && 0 != pi->circ_array) {  // fixnum
                 if (Qnil == parent->val) {
                     parent->val = rb_hash_new();
                 }
@@ -334,7 +316,7 @@ static int hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, vol
                 int            i, cnt = (int)RARRAY_LEN(e1);
 
                 for (i = 0; i < cnt; i++) {
-                    rstr    = rb_ary_entry(e1, 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);
@@ -342,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;
@@ -383,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;
@@ -402,9 +394,7 @@ WHICH_TYPE:
         }
         break;
     case T_HASH:
-        rb_hash_aset(parent->val,
-                     calc_hash_key(pi, kval, parent->k1),
-                     str_to_value(pi, str, len, orig));
+        rb_hash_aset(parent->val, calc_hash_key(pi, kval, parent->k1), str_to_value(pi, str, len, orig));
         break;
     case T_STRING:
         rval = str_to_value(pi, str, len, orig);
@@ -456,13 +446,13 @@ WHICH_TYPE:
                         rb_class2name(rb_obj_class(parent->val)));
         return;
     }
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_call("set_string", pi, __FILE__, __LINE__, rval);
     }
 }
 
 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;
@@ -481,8 +471,8 @@ WHICH_TYPE:
         rb_hash_aset(parent->val, calc_hash_key(pi, kval, parent->k1), rval);
         break;
     case T_OBJECT:
-        if (2 == klen && '^' == *key && 'i' == key[1] && !ni->infinity && !ni->neg &&
-            1 == ni->div && 0 == ni->exp && 0 != pi->circ_array) {  // fixnum
+        if (2 == klen && '^' == *key && 'i' == key[1] && !ni->infinity && !ni->neg && 1 == ni->div && 0 == ni->exp &&
+            0 != pi->circ_array) {  // fixnum
             oj_circ_array_set(pi->circ_array, parent->val, ni->i);
         } else {
             rval = oj_num_as_value(ni);
@@ -527,7 +517,7 @@ WHICH_TYPE:
                         rb_class2name(rb_obj_class(parent->val)));
         return;
     }
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_call("add_number", pi, __FILE__, __LINE__, rval);
     }
 }
@@ -559,11 +549,7 @@ WHICH_TYPE:
                 volatile VALUE *a   = RARRAY_PTR(value);
 
                 if (2 != len) {
-                    oj_set_error_at(pi,
-                                    oj_parse_error_class,
-                                    __FILE__,
-                                    __LINE__,
-                                    "invalid hash pair");
+                    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid hash pair");
                     return;
                 }
                 rb_hash_aset(parent->val, *a, a[1]);
@@ -617,13 +603,13 @@ WHICH_TYPE:
                         rb_class2name(rb_obj_class(parent->val)));
         return;
     }
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_call("add_value", pi, __FILE__, __LINE__, value);
     }
 }
 
 static VALUE start_hash(ParseInfo pi) {
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_in("start_hash", pi, __FILE__, __LINE__);
     }
     return Qnil;
@@ -637,14 +623,11 @@ static void end_hash(ParseInfo pi) {
     } else if (NULL != parent->odd_args) {
         OddArgs oa = parent->odd_args;
 
-        parent->val = rb_funcall2(oa->odd->create_obj,
-                                  oa->odd->create_op,
-                                  oa->odd->attr_cnt,
-                                  oa->args);
+        parent->val = rb_funcall2(oa->odd->create_obj, oa->odd->create_op, oa->odd->attr_cnt, oa->args);
         oj_odd_free(oa);
         parent->odd_args = NULL;
     }
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_hash_end(pi, __FILE__, __LINE__);
     }
 }
@@ -653,8 +636,7 @@ static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const c
     volatile VALUE rval = Qnil;
 
     // orig lets us know whether the string was ^r1 or \u005er1
-    if (3 <= len && 0 != pi->circ_array && '^' == orig[0] &&
-        0 == rb_array_len(stack_peek(&pi->stack)->val)) {
+    if (3 <= len && 0 != pi->circ_array && '^' == orig[0] && 0 == rb_array_len(stack_peek(&pi->stack)->val)) {
         if ('i' == str[1]) {
             long i = read_long(str + 2, len - 2);
 
@@ -673,7 +655,7 @@ static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const c
     }
     rval = str_to_value(pi, str, len, orig);
     rb_ary_push(stack_peek(&pi->stack)->val, rval);
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_call("append_string", pi, __FILE__, __LINE__, rval);
     }
 }
@@ -682,21 +664,21 @@ static void array_append_num(ParseInfo pi, NumInfo ni) {
     volatile VALUE rval = oj_num_as_value(ni);
 
     rb_ary_push(stack_peek(&pi->stack)->val, rval);
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_call("append_number", pi, __FILE__, __LINE__, rval);
     }
 }
 
 static void add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
     pi->stack.head->val = str_to_value(pi, str, len, orig);
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_call("add_string", pi, __FILE__, __LINE__, pi->stack.head->val);
     }
 }
 
 static void add_num(ParseInfo pi, NumInfo ni) {
     pi->stack.head->val = oj_num_as_value(ni);
-    if (Yes == pi->options.trace) {
+    if (RB_UNLIKELY(Yes == pi->options.trace)) {
         oj_trace_parse_call("add_num", pi, __FILE__, __LINE__, pi->stack.head->val);
     }
 }

data/ext/oj/odd.c

@@ -5,28 +5,27 @@
 
 #include <string.h>
 
-static struct _odd  _odds[4];  // bump up if new initial Odd classes are added
-static struct _odd *odds    = _odds;
-static long         odd_cnt = 0;
-static ID           sec_id;
-static ID           sec_fraction_id;
-static ID           to_f_id;
-static ID           numerator_id;
-static ID           denominator_id;
-static ID           rational_id;
-static VALUE        rational_class;
+static Odd odds = NULL;
+static ID  sec_id;
+static ID  sec_fraction_id;
+static ID  to_f_id;
+static ID  numerator_id;
+static ID  denominator_id;
+static ID  rational_id;
 
 static void set_class(Odd odd, const char *classname) {
     const char **np;
-    ID *         idp;
+    ID          *idp;
 
-    odd->classname  = classname;
-    odd->clen       = strlen(classname);
-    odd->clas       = rb_const_get(rb_cObject, rb_intern(classname));
+    odd->classname = classname;
+    odd->clen      = strlen(classname);
+    odd->clas      = rb_const_get(rb_cObject, rb_intern(classname));
+    rb_gc_register_mark_object(odd->clas);
     odd->create_obj = odd->clas;
-    odd->create_op  = rb_intern("new");
-    odd->is_module  = (T_MODULE == rb_type(odd->clas));
-    odd->raw        = 0;
+    rb_gc_register_mark_object(odd->create_obj);
+    odd->create_op = rb_intern("new");
+    odd->is_module = (T_MODULE == rb_type(odd->clas));
+    odd->raw       = 0;
     for (np = odd->attr_names, idp = odd->attrs; 0 != *np; np++, idp++) {
         *idp = rb_intern(*np);
     }
@@ -37,15 +36,48 @@ static VALUE get_datetime_secs(VALUE obj) {
     volatile VALUE rsecs = rb_funcall(obj, sec_id, 0);
     volatile VALUE rfrac = rb_funcall(obj, sec_fraction_id, 0);
     long           sec   = NUM2LONG(rsecs);
-    long long      num   = rb_num2ll(rb_funcall(rfrac, numerator_id, 0));
-    long long      den   = rb_num2ll(rb_funcall(rfrac, denominator_id, 0));
+    long long      num   = NUM2LL(rb_funcall(rfrac, numerator_id, 0));
+    long long      den   = NUM2LL(rb_funcall(rfrac, denominator_id, 0));
 
     num += sec * den;
 
     return rb_funcall(rb_cObject, rational_id, 2, rb_ll2inum(num), rb_ll2inum(den));
 }
 
-void oj_odd_init() {
+static void print_odd(Odd odd) {
+    const char **np;
+    int          i;
+
+    printf("  %s {\n", odd->classname);
+    printf("    attr_cnt: %d %p\n", odd->attr_cnt, (void *)odd->attr_names);
+    printf("    attr_names: %p\n", (void *)*odd->attr_names);
+    printf("    attr_names: %c\n", **odd->attr_names);
+    for (i = odd->attr_cnt, np = odd->attr_names; 0 < i; i--, np++) {
+        printf("    %d %s\n", i, *np);
+    }
+    printf("  }\n");
+}
+
+void print_all_odds(const char *label) {
+    Odd odd;
+    printf("@ %s {\n", label);
+    for (odd = odds; NULL != odd; odd = odd->next) {
+        print_odd(odd);
+    }
+    printf("}\n");
+}
+
+static Odd odd_create(void) {
+    Odd odd = ALLOC(struct _odd);
+
+    memset(odd, 0, sizeof(struct _odd));
+    odd->next = odds;
+    odds      = odd;
+
+    return odd;
+}
+
+void oj_odd_init(void) {
     Odd          odd;
     const char **np;
 
@@ -55,11 +87,9 @@ void oj_odd_init() {
     numerator_id    = rb_intern("numerator");
     denominator_id  = rb_intern("denominator");
     rational_id     = rb_intern("Rational");
-    rational_class  = rb_const_get(rb_cObject, rational_id);
 
-    memset(_odds, 0, sizeof(_odds));
-    odd = odds;
     // Rational
+    odd   = odd_create();
     np    = odd->attr_names;
     *np++ = "numerator";
     *np++ = "denominator";
@@ -68,8 +98,9 @@ void oj_odd_init() {
     odd->create_obj = rb_cObject;
     odd->create_op  = rational_id;
     odd->attr_cnt   = 2;
+
     // Date
-    odd++;
+    odd   = odd_create();
     np    = odd->attr_names;
     *np++ = "year";
     *np++ = "month";
@@ -78,8 +109,9 @@ void oj_odd_init() {
     *np++ = 0;
     set_class(odd, "Date");
     odd->attr_cnt = 4;
+
     // DateTime
-    odd++;
+    odd   = odd_create();
     np    = odd->attr_names;
     *np++ = "year";
     *np++ = "month";
@@ -93,8 +125,9 @@ void oj_odd_init() {
     set_class(odd, "DateTime");
     odd->attr_cnt     = 8;
     odd->attrFuncs[5] = get_datetime_secs;
+
     // Range
-    odd++;
+    odd   = odd_create();
     np    = odd->attr_names;
     *np++ = "begin";
     *np++ = "end";
@@ -102,15 +135,13 @@ void oj_odd_init() {
     *np++ = 0;
     set_class(odd, "Range");
     odd->attr_cnt = 3;
-
-    odd_cnt = odd - odds + 1;
 }
 
 Odd oj_get_odd(VALUE clas) {
     Odd         odd;
     const char *classname = NULL;
 
-    for (odd = odds + odd_cnt - 1; odds <= odd; odd--) {
+    for (odd = odds; NULL != odd; odd = odd->next) {
         if (clas == odd->clas) {
             return odd;
         }
@@ -129,21 +160,20 @@ Odd oj_get_odd(VALUE clas) {
 Odd oj_get_oddc(const char *classname, size_t len) {
     Odd odd;
 
-    for (odd = odds + odd_cnt - 1; odds <= odd; odd--) {
+    for (odd = odds; NULL != odd; odd = odd->next) {
         if (len == odd->clen && 0 == strncmp(classname, odd->classname, len)) {
             return odd;
         }
-        if (odd->is_module && 0 == strncmp(odd->classname, classname, odd->clen) &&
-            ':' == classname[odd->clen]) {
+        if (odd->is_module && 0 == strncmp(odd->classname, classname, odd->clen) && ':' == classname[odd->clen]) {
             return odd;
         }
     }
-    return 0;
+    return NULL;
 }
 
 OddArgs oj_odd_alloc_args(Odd odd) {
     OddArgs oa = ALLOC_N(struct _oddArgs, 1);
-    VALUE * a;
+    VALUE  *a;
     int     i;
 
     oa->odd = odd;
@@ -159,11 +189,10 @@ void oj_odd_free(OddArgs args) {
 
 int oj_odd_set_arg(OddArgs args, const char *key, size_t klen, VALUE value) {
     const char **np;
-    VALUE *      vp;
+    VALUE       *vp;
     int          i;
 
-    for (i = args->odd->attr_cnt, np = args->odd->attr_names, vp = args->args; 0 < i;
-         i--, np++, vp++) {
+    for (i = args->odd->attr_cnt, np = args->odd->attr_names, vp = args->args; 0 < i; i--, np++, vp++) {
         if (0 == strncmp(key, *np, klen) && '\0' == *((*np) + klen)) {
             *vp = value;
             return 0;
@@ -172,37 +201,26 @@ int oj_odd_set_arg(OddArgs args, const char *key, size_t klen, VALUE value) {
     return -1;
 }
 
-void oj_reg_odd(VALUE  clas,
-                VALUE  create_object,
-                VALUE  create_method,
-                int    mcnt,
-                VALUE *members,
-                bool   raw) {
+void oj_reg_odd(VALUE clas, VALUE create_object, VALUE create_method, int mcnt, VALUE *members, bool raw) {
     Odd          odd;
     const char **np;
-    ID *         ap;
+    ID          *ap;
     AttrGetFunc *fp;
 
-    if (_odds == odds) {
-        odds = ALLOC_N(struct _odd, odd_cnt + 1);
-
-        memcpy(odds, _odds, sizeof(struct _odd) * odd_cnt);
-    } else {
-        REALLOC_N(odds, struct _odd, odd_cnt + 1);
-    }
-    odd       = odds + odd_cnt;
+    odd       = odd_create();
     odd->clas = clas;
+    rb_gc_register_mark_object(odd->clas);
     if (NULL == (odd->classname = strdup(rb_class2name(clas)))) {
-        rb_raise(rb_eNoMemError, "for attribute name.");
+        rb_raise(rb_eNoMemError, "for class name.");
     }
     odd->clen       = strlen(odd->classname);
     odd->create_obj = create_object;
-    odd->create_op  = SYM2ID(create_method);
-    odd->attr_cnt   = mcnt;
-    odd->is_module  = (T_MODULE == rb_type(clas));
-    odd->raw        = raw;
-    for (ap = odd->attrs, np = odd->attr_names, fp = odd->attrFuncs; 0 < mcnt;
-         mcnt--, ap++, np++, members++, fp++) {
+    rb_gc_register_mark_object(odd->create_obj);
+    odd->create_op = SYM2ID(create_method);
+    odd->attr_cnt  = mcnt;
+    odd->is_module = (T_MODULE == rb_type(clas));
+    odd->raw       = raw;
+    for (ap = odd->attrs, np = odd->attr_names, fp = odd->attrFuncs; 0 < mcnt; mcnt--, ap++, np++, members++, fp++) {
         *fp = 0;
         switch (rb_type(*members)) {
         case T_STRING:
@@ -210,14 +228,16 @@ void oj_reg_odd(VALUE  clas,
                 rb_raise(rb_eNoMemError, "for attribute name.");
             }
             break;
-        case T_SYMBOL: *np = rb_id2name(SYM2ID(*members)); break;
-        default:
-            rb_raise(rb_eArgError, "registered member identifiers must be Strings or Symbols.");
+        case T_SYMBOL:
+            // The symbol can move and invalidate the name so make a copy.
+            if (NULL == (*np = strdup(rb_id2name(SYM2ID(*members))))) {
+                rb_raise(rb_eNoMemError, "for attribute name.");
+            }
             break;
+        default: rb_raise(rb_eArgError, "registered member identifiers must be Strings or Symbols."); break;
         }
         *ap = rb_intern(*np);
     }
     *np = 0;
     *ap = 0;
-    odd_cnt++;
 }

data/ext/oj/odd.h

@@ -13,17 +13,18 @@
 typedef VALUE (*AttrGetFunc)(VALUE obj);
 
 typedef struct _odd {
-    const char *classname;
-    size_t      clen;
-    VALUE       clas;  // Ruby class or module
-    VALUE       create_obj;
-    ID          create_op;
-    int         attr_cnt;
-    bool        is_module;
-    bool        raw;
-    const char *attr_names[MAX_ODD_ARGS];  // NULL terminated attr names
-    ID          attrs[MAX_ODD_ARGS];       // 0 terminated attr IDs
-    AttrGetFunc attrFuncs[MAX_ODD_ARGS];
+    struct _odd *next;
+    const char * classname;
+    size_t       clen;
+    VALUE        clas;  // Ruby class or module
+    VALUE        create_obj;
+    ID           create_op;
+    int          attr_cnt;
+    bool         is_module;
+    bool         raw;
+    const char * attr_names[MAX_ODD_ARGS];  // NULL terminated attr names
+    ID           attrs[MAX_ODD_ARGS];       // 0 terminated attr IDs
+    AttrGetFunc  attrFuncs[MAX_ODD_ARGS];
 } * Odd;
 
 typedef struct _oddArgs {
@@ -37,7 +38,6 @@ extern Odd     oj_get_oddc(const char *classname, size_t len);
 extern OddArgs oj_odd_alloc_args(Odd odd);
 extern void    oj_odd_free(OddArgs args);
 extern int     oj_odd_set_arg(OddArgs args, const char *key, size_t klen, VALUE value);
-extern void
-oj_reg_odd(VALUE clas, VALUE create_object, VALUE create_method, int mcnt, VALUE *members, bool raw);
+extern void    oj_reg_odd(VALUE clas, VALUE create_object, VALUE create_method, int mcnt, VALUE *members, bool raw);
 
 #endif /* OJ_ODD_H */