oj 3.12.3 → 3.13.3

data/ext/oj/custom.c

@@ -8,7 +8,7 @@
 #include "dump.h"
 #include "encode.h"
 #include "err.h"
-#include "hash.h"
+#include "intern.h"
 #include "odd.h"
 #include "oj.h"
 #include "parse.h"
@@ -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  = rb_string_value_ptr((VALUE *)&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  = rb_string_value_ptr((VALUE *)&rstr);
+    const char *   str  = RSTRING_PTR(rstr);
     int            len  = (int)RSTRING_LEN(rstr);
 
     if (0 == strcasecmp("Infinity", str)) {
@@ -123,7 +123,7 @@ static void date_dump(VALUE obj, int depth, Out out) {
         case RubyTime:
         case XmlTime:
             v = rb_funcall(obj, rb_intern("iso8601"), 0);
-            oj_dump_cstr(rb_string_value_ptr((VALUE *)&v), (int)RSTRING_LEN(v), 0, 0, out);
+            oj_dump_cstr(RSTRING_PTR(v), (int)RSTRING_LEN(v), 0, 0, out);
             break;
         case UnixZTime:
             v = rb_funcall(obj, rb_intern("to_time"), 0);
@@ -420,7 +420,7 @@ static void dump_odd(VALUE obj, Odd odd, VALUE clas, int depth, Out out) {
         if (Qundef == v || T_STRING != rb_type(v)) {
             rb_raise(rb_eEncodingError, "Invalid type for raw JSON.\n");
         } else {
-            const char *s    = rb_string_value_ptr((VALUE *)&v);
+            const char *s    = RSTRING_PTR(v);
             int         len  = (int)RSTRING_LEN(v);
             const char *name = rb_id2name(*odd->attrs);
             size_t      nlen = strlen(name);
@@ -510,7 +510,7 @@ static VALUE dump_common(VALUE obj, int depth, Out out) {
         if (Yes == out->opts->trace) {
             oj_trace("to_json", obj, __FILE__, __LINE__, depth + 1, TraceRubyOut);
         }
-        s   = rb_string_value_ptr((VALUE *)&rs);
+        s   = RSTRING_PTR(rs);
         len = (int)RSTRING_LEN(rs);
 
         assure_size(out, len + 1);
@@ -537,7 +537,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(rb_string_value_ptr((VALUE *)&rstr),
+            oj_dump_cstr(RSTRING_PTR(rstr),
                          (int)RSTRING_LEN(rstr),
                          false,
                          false,
@@ -833,9 +833,9 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
             v = rb_struct_aref(obj, INT2FIX(i));
 #endif
             if (ma != Qnil) {
-                volatile VALUE s = rb_sym_to_s(rb_ary_entry(ma, i));
+                volatile VALUE s = rb_sym2str(rb_ary_entry(ma, i));
 
-                name = rb_string_value_ptr((VALUE *)&s);
+                name = RSTRING_PTR(s);
                 len  = (int)RSTRING_LEN(s);
             } else {
                 len  = snprintf(num_id, sizeof(num_id), "%d", i);
@@ -956,14 +956,13 @@ 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_str_new(str, len);
+        volatile VALUE rstr = rb_utf8_str_new(str, len);
 
         if (Qundef == rkey) {
-            rkey = rb_str_new(key, klen);
-            rstr = oj_encode(rstr);
-            rkey = oj_encode(rkey);
             if (Yes == pi->options.sym_key) {
-                rkey = rb_str_intern(rkey);
+                rkey = ID2SYM(rb_intern3(key, klen, oj_utf8_encoding));
+            } else {
+		rkey = rb_utf8_str_new(key, klen);
             }
         }
         if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
@@ -1031,7 +1030,7 @@ static void hash_set_num(struct _parseInfo *pi, Val kval, NumInfo ni) {
             }
             if (86400 == ni->exp) {  // UTC time
                 parent->val = rb_time_nano_new(ni->i, (long)nsec);
-                // Since the ruby C routines alway create local time, the
+                // Since the ruby C routines always create local time, the
                 // offset and then a conversion to UTC keeps makes the time
                 // match the expected value.
                 parent->val = rb_funcall2(parent->val, oj_utc_id, 0, 0);
@@ -1089,9 +1088,8 @@ static void array_append_num(ParseInfo pi, NumInfo ni) {
 }
 
 static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
-    volatile VALUE rstr = rb_str_new(str, len);
+    volatile VALUE rstr = rb_utf8_str_new(str, len);
 
-    rstr = oj_encode(rstr);
     if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
         VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, (int)len);
 

data/ext/oj/debug.c

@@ -0,0 +1,132 @@
+// Copyright (c) 2021, Peter Ohler, All rights reserved.
+
+#include "parser.h"
+
+static void add_null(struct _ojParser *p) {
+    switch (p->stack[p->depth]) {
+    case TOP_FUN: printf("*** add_null at top\n"); break;
+    case ARRAY_FUN: printf("*** add_null to array\n"); break;
+    case OBJECT_FUN: printf("*** add_null with '%s'\n", buf_str(&p->key)); break;
+    }
+}
+
+static void add_true(struct _ojParser *p) {
+    switch (p->stack[p->depth]) {
+    case TOP_FUN: printf("*** add_true at top\n"); break;
+    case ARRAY_FUN: printf("*** add_true to array\n"); break;
+    case OBJECT_FUN: printf("*** add_true with '%s'\n", buf_str(&p->key)); break;
+    }
+}
+
+static void add_false(struct _ojParser *p) {
+    switch (p->stack[p->depth]) {
+    case TOP_FUN: printf("*** add_false at top\n"); break;
+    case ARRAY_FUN: printf("*** add_false to array\n"); break;
+    case OBJECT_FUN: printf("*** add_false with '%s'\n", buf_str(&p->key)); break;
+    }
+}
+
+static void add_int(struct _ojParser *p) {
+    switch (p->stack[p->depth]) {
+    case TOP_FUN: printf("*** add_int %lld at top\n", (long long)p->num.fixnum); break;
+    case ARRAY_FUN: printf("*** add_int %lld to array\n", (long long)p->num.fixnum); break;
+    case OBJECT_FUN:
+        printf("*** add_int %lld with '%s'\n", (long long)p->num.fixnum, buf_str(&p->key));
+        break;
+    }
+}
+
+static void add_float(struct _ojParser *p) {
+    switch (p->stack[p->depth]) {
+    case TOP_FUN: printf("*** add_float %Lf at top\n", p->num.dub); break;
+    case ARRAY_FUN: printf("*** add_float %Lf to array\n", p->num.dub); break;
+    case OBJECT_FUN: printf("*** add_float %Lf with '%s'\n", p->num.dub, buf_str(&p->key)); break;
+    }
+}
+
+static void add_big(struct _ojParser *p) {
+    switch (p->stack[p->depth]) {
+    case TOP_FUN: printf("*** add_big %s at top\n", buf_str(&p->buf)); break;
+    case ARRAY_FUN: printf("*** add_big %s to array\n", buf_str(&p->buf)); break;
+    case OBJECT_FUN:
+        printf("*** add_big %s with '%s'\n", buf_str(&p->buf), buf_str(&p->key));
+        break;
+    }
+}
+
+static void add_str(struct _ojParser *p) {
+    switch (p->stack[p->depth]) {
+    case TOP_FUN: printf("*** add_str '%s' at top\n", buf_str(&p->buf)); break;
+    case ARRAY_FUN: printf("*** add_str '%s' to array\n", buf_str(&p->buf)); break;
+    case OBJECT_FUN:
+        printf("*** add_str '%s' with '%s'\n", buf_str(&p->buf), buf_str(&p->key));
+        break;
+    }
+}
+
+static void open_array(struct _ojParser *p) {
+    switch (p->stack[p->depth]) {
+    case TOP_FUN: printf("*** open_array at top\n"); break;
+    case ARRAY_FUN: printf("*** open_array to array\n"); break;
+    case OBJECT_FUN: printf("*** open_array with '%s'\n", buf_str(&p->key)); break;
+    }
+}
+
+static void close_array(struct _ojParser *p) {
+    printf("*** close_array\n");
+}
+
+static void open_object(struct _ojParser *p) {
+    switch (p->stack[p->depth]) {
+    case TOP_FUN: printf("*** open_object at top\n"); break;
+    case ARRAY_FUN: printf("*** open_object to array\n"); break;
+    case OBJECT_FUN: printf("*** open_object with '%s'\n", buf_str(&p->key)); break;
+    }
+}
+
+static void close_object(struct _ojParser *p) {
+    printf("*** close_object\n");
+}
+
+static VALUE option(ojParser p, const char *key, VALUE value) {
+    rb_raise(rb_eArgError, "%s is not an option for the debug delegate", key);
+    return Qnil;
+}
+
+static VALUE result(struct _ojParser *p) {
+    return Qnil;
+}
+
+static void start(struct _ojParser *p) {
+    printf("*** start\n");
+}
+
+static void dfree(struct _ojParser *p) {
+}
+
+static void mark(struct _ojParser *p) {
+}
+
+void oj_set_parser_debug(ojParser p) {
+    Funcs end = p->funcs + 3;
+    Funcs f;
+
+    for (f = p->funcs; f < end; f++) {
+        f->add_null     = add_null;
+        f->add_true     = add_true;
+        f->add_false    = add_false;
+        f->add_int      = add_int;
+        f->add_float    = add_float;
+        f->add_big      = add_big;
+        f->add_str      = add_str;
+        f->open_array   = open_array;
+        f->close_array  = close_array;
+        f->open_object  = open_object;
+        f->close_object = close_object;
+    }
+    p->option = option;
+    p->result = result;
+    p->free   = dfree;
+    p->mark   = mark;
+    p->start  = start;
+}

data/ext/oj/dump.c

@@ -472,7 +472,7 @@ void oj_dump_time(VALUE obj, Out out, int withZone) {
 void oj_dump_ruby_time(VALUE obj, Out out) {
     volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
 
-    oj_dump_cstr(rb_string_value_ptr((VALUE *)&rstr), (int)RSTRING_LEN(rstr), 0, 0, out);
+    oj_dump_cstr(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), 0, 0, out);
 }
 
 void oj_dump_xml_time(VALUE obj, Out out) {
@@ -708,21 +708,18 @@ void oj_write_obj_to_stream(VALUE obj, VALUE stream, Options copts) {
 }
 
 void oj_dump_str(VALUE obj, int depth, Out out, bool as_ok) {
-    rb_encoding *enc = rb_to_encoding(rb_obj_encoding(obj));
+    rb_encoding *enc = rb_enc_get(obj);
 
-    if (rb_utf8_encoding() != enc) {
-        obj = rb_str_conv_enc(obj, enc, rb_utf8_encoding());
+    if (oj_utf8_encoding != enc) {
+        obj = rb_str_conv_enc(obj, enc, oj_utf8_encoding);
     }
-    oj_dump_cstr(rb_string_value_ptr((VALUE *)&obj), (int)RSTRING_LEN(obj), 0, 0, out);
+    oj_dump_cstr(RSTRING_PTR(obj), (int)RSTRING_LEN(obj), 0, 0, out);
 }
 
 void oj_dump_sym(VALUE obj, int depth, Out out, bool as_ok) {
-    // This causes a memory leak in 2.5.1. Maybe in other versions as well.
-    // const char	*sym = rb_id2name(SYM2ID(obj));
+    volatile VALUE s = rb_sym2str(obj);
 
-    volatile VALUE s = rb_sym_to_s(obj);
-
-    oj_dump_cstr(rb_string_value_ptr((VALUE *)&s), (int)RSTRING_LEN(s), 0, 0, out);
+    oj_dump_cstr(RSTRING_PTR(s), (int)RSTRING_LEN(s), 0, 0, out);
 }
 
 static void debug_raise(const char *orig, size_t cnt, int line) {
@@ -760,7 +757,7 @@ void oj_dump_raw_json(VALUE obj, int depth, Out out) {
         if (Yes == out->opts->trace) {
             oj_trace("raw_json", obj, __FILE__, __LINE__, depth + 1, TraceRubyOut);
         }
-        oj_dump_raw(rb_string_value_ptr((VALUE *)&jv), (size_t)RSTRING_LEN(jv), out);
+        oj_dump_raw(RSTRING_PTR(jv), (size_t)RSTRING_LEN(jv), out);
     }
 }
 
@@ -958,7 +955,7 @@ void oj_dump_class(VALUE obj, int depth, Out out, bool as_ok) {
 void oj_dump_obj_to_s(VALUE obj, Out out) {
     volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
 
-    oj_dump_cstr(rb_string_value_ptr((VALUE *)&rstr), (int)RSTRING_LEN(rstr), 0, 0, out);
+    oj_dump_cstr(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), 0, 0, out);
 }
 
 void oj_dump_raw(const char *str, size_t cnt, Out out) {
@@ -1075,7 +1072,7 @@ void oj_dump_bignum(VALUE obj, int depth, Out out, bool as_ok) {
     } else {
         assure_size(out, cnt);
     }
-    memcpy(out->cur, rb_string_value_ptr((VALUE *)&rs), cnt);
+    memcpy(out->cur, RSTRING_PTR(rs), cnt);
     out->cur += cnt;
     if (dump_as_string) {
         *out->cur++ = '"';
@@ -1203,7 +1200,7 @@ void oj_dump_float(VALUE obj, int depth, Out out, bool as_ok) {
         if ((int)sizeof(buf) <= cnt) {
             cnt = sizeof(buf) - 1;
         }
-        memcpy(buf, rb_string_value_ptr((VALUE *)&rstr), cnt);
+        memcpy(buf, RSTRING_PTR(rstr), cnt);
         buf[cnt] = '\0';
     } else {
         cnt = oj_dump_float_printf(buf, sizeof(buf), obj, d, out->opts->float_fmt);
@@ -1223,7 +1220,7 @@ int oj_dump_float_printf(char *buf, size_t blen, VALUE obj, double d, const char
     if (17 <= cnt && (0 == strcmp("0001", buf + cnt - 4) || 0 == strcmp("9999", buf + cnt - 4))) {
         volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
 
-        strcpy(buf, rb_string_value_ptr((VALUE *)&rstr));
+        strcpy(buf, RSTRING_PTR(rstr));
         cnt = (int)RSTRING_LEN(rstr);
     }
     return cnt;

data/ext/oj/dump_compat.c

@@ -129,7 +129,7 @@ dump_to_json(VALUE obj, Out out) {
 	oj_trace("to_json", obj, __FILE__, __LINE__, 0, TraceRubyOut);
     }
 
-    s = rb_string_value_ptr((VALUE*)&rs);
+    s = RSTRING_PTR(rs);
     len = (int)RSTRING_LEN(rs);
 
     assure_size(out, len + 1);
@@ -635,7 +635,7 @@ dump_float(VALUE obj, int depth, Out out, bool as_ok) {
     } else {
 	volatile VALUE	rstr = rb_funcall(obj, oj_to_s_id, 0);
 
-	strcpy(buf, rb_string_value_ptr((VALUE*)&rstr));
+	strcpy(buf, RSTRING_PTR(rstr));
 	cnt = (int)RSTRING_LEN(rstr);
     }
     assure_size(out, cnt);
@@ -886,7 +886,7 @@ dump_bignum(VALUE obj, int depth, Out out, bool as_ok) {
     } else {
 	assure_size(out, cnt);
     }
-    memcpy(out->cur, rb_string_value_ptr((VALUE*)&rs), cnt);
+    memcpy(out->cur, RSTRING_PTR(rs), cnt);
     out->cur += cnt;
     if (dump_as_string) {
 	*out->cur++ = '"';

data/ext/oj/dump_object.c

@@ -36,7 +36,7 @@ static void dump_data(VALUE obj, int depth, Out out, bool as_ok) {
     } else {
         if (oj_bigdecimal_class == clas) {
             volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
-            const char *   str  = rb_string_value_ptr((VALUE *)&rstr);
+            const char *   str  = RSTRING_PTR(rstr);
             int            len  = (int)RSTRING_LEN(rstr);
 
             if (No != out->opts->bigdec_as_num) {
@@ -65,7 +65,7 @@ static void dump_obj(VALUE obj, int depth, Out out, bool as_ok) {
 
     if (oj_bigdecimal_class == clas) {
         volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
-        const char *   str  = rb_string_value_ptr((VALUE *)&rstr);
+        const char *   str  = RSTRING_PTR(rstr);
         int            len  = (int)RSTRING_LEN(rstr);
 
         if (0 == strcasecmp("Infinity", str)) {
@@ -195,7 +195,7 @@ static void dump_str_class(VALUE obj, VALUE clas, int depth, Out out) {
     if (Qundef != clas && rb_cString != clas) {
         dump_obj_attrs(obj, clas, 0, depth, out);
     } else {
-        const char *s   = rb_string_value_ptr((VALUE *)&obj);
+        const char *s   = RSTRING_PTR(obj);
         size_t      len = (int)RSTRING_LEN(obj);
         char        s1  = s[1];
 
@@ -208,9 +208,9 @@ static void dump_str(VALUE obj, int depth, Out out, bool as_ok) {
 }
 
 static void dump_sym(VALUE obj, int depth, Out out, bool as_ok) {
-    volatile VALUE s = rb_sym_to_s(obj);
+    volatile VALUE s = rb_sym2str(obj);
 
-    oj_dump_cstr(rb_string_value_ptr((VALUE *)&s), (int)RSTRING_LEN(s), 1, 0, out);
+    oj_dump_cstr(RSTRING_PTR(s), (int)RSTRING_LEN(s), 1, 0, out);
 }
 
 static int hash_cb(VALUE key, VALUE value, VALUE ov) {
@@ -414,7 +414,7 @@ static void dump_odd(VALUE obj, Odd odd, VALUE clas, int depth, Out out) {
         if (Qundef == v || T_STRING != rb_type(v)) {
             rb_raise(rb_eEncodingError, "Invalid type for raw JSON.");
         } else {
-            const char *s    = rb_string_value_ptr((VALUE *)&v);
+            const char *s    = RSTRING_PTR(v);
             int         len  = (int)RSTRING_LEN(v);
             const char *name = rb_id2name(*odd->attrs);
             size_t      nlen = strlen(name);
@@ -532,7 +532,7 @@ static void dump_obj_attrs(VALUE obj, VALUE clas, slot_t id, int depth, Out out)
         *out->cur++ = 'f';
         *out->cur++ = '"';
         *out->cur++ = ':';
-        oj_dump_cstr(rb_string_value_ptr((VALUE *)&obj), (int)RSTRING_LEN(obj), 0, 0, out);
+        oj_dump_cstr(RSTRING_PTR(obj), (int)RSTRING_LEN(obj), 0, 0, out);
         break;
     case T_ARRAY:
         assure_size(out, d2 * out->indent + 14);
@@ -694,9 +694,9 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
 
         *out->cur++ = '[';
         for (i = 0; i < cnt; i++) {
-            volatile VALUE s = rb_sym_to_s(rb_ary_entry(ma, i));
+            volatile VALUE s = rb_sym2str(rb_ary_entry(ma, i));
 
-            name = rb_string_value_ptr((VALUE *)&s);
+            name = RSTRING_PTR(s);
             len  = (int)RSTRING_LEN(s);
             size = len + 3;
             assure_size(out, size);

data/ext/oj/dump_strict.c

@@ -98,7 +98,7 @@ static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
             if ((int)sizeof(buf) <= cnt) {
                 cnt = sizeof(buf) - 1;
             }
-            memcpy(buf, rb_string_value_ptr((VALUE *)&rstr), cnt);
+            memcpy(buf, RSTRING_PTR(rstr), cnt);
             buf[cnt] = '\0';
         } else {
             cnt = oj_dump_float_printf(buf, sizeof(buf), obj, d, out->opts->float_fmt);
@@ -304,7 +304,7 @@ static void dump_data_strict(VALUE obj, int depth, Out out, bool as_ok) {
     if (oj_bigdecimal_class == clas) {
         volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
 
-        oj_dump_raw(rb_string_value_ptr((VALUE *)&rstr), (int)RSTRING_LEN(rstr), out);
+        oj_dump_raw(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), out);
     } else {
         raise_strict(obj);
     }
@@ -316,7 +316,7 @@ static void dump_data_null(VALUE obj, int depth, Out out, bool as_ok) {
     if (oj_bigdecimal_class == clas) {
         volatile VALUE rstr = rb_funcall(obj, oj_to_s_id, 0);
 
-        oj_dump_raw(rb_string_value_ptr((VALUE *)&rstr), (int)RSTRING_LEN(rstr), out);
+        oj_dump_raw(RSTRING_PTR(rstr), (int)RSTRING_LEN(rstr), out);
     } else {
         oj_dump_nil(Qnil, depth, out, false);
     }

data/ext/oj/err.h

@@ -4,12 +4,31 @@
 #ifndef OJ_ERR_H
 #define OJ_ERR_H
 
+#include <errno.h>
 #include "ruby.h"
+
 // Needed to silence 2.4.0 warnings.
 #ifndef NORETURN
 #define NORETURN(x) x
 #endif
 
+#define OJ_ERR_START		300
+
+typedef enum {
+    OJ_OK		= 0,
+    OJ_ERR_MEMORY	= ENOMEM,
+    OJ_ERR_PARSE	= OJ_ERR_START,
+    OJ_ERR_READ,
+    OJ_ERR_WRITE,
+    OJ_ERR_OVERFLOW,
+    OJ_ERR_ARG,
+    OJ_ERR_TOO_MANY,
+    OJ_ERR_TYPE,
+    OJ_ERR_KEY,
+    OJ_ABORT,
+    OJ_ERR_LAST,
+} ojStatus;
+
 #define set_error(err, eclas, msg, json, current) \
     _oj_err_set_with_location(err, eclas, msg, json, current, FILE, LINE)