oj 3.12.3 → 3.13.1

data/ext/oj/parser.h

@@ -0,0 +1,90 @@
+// Copyright (c) 2021 Peter Ohler, All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#ifndef OJ_PARSER_H
+#define OJ_PARSER_H
+
+#include <stdbool.h>
+#include <ruby.h>
+
+#include "buf.h"
+
+#define TOP_FUN 0
+#define ARRAY_FUN 1
+#define OBJECT_FUN 2
+
+typedef uint8_t byte;
+
+typedef enum {
+    OJ_NONE    = '\0',
+    OJ_NULL    = 'n',
+    OJ_TRUE    = 't',
+    OJ_FALSE   = 'f',
+    OJ_INT     = 'i',
+    OJ_DECIMAL = 'd',
+    OJ_BIG     = 'b',  // indicates parser buf is used
+    OJ_STRING  = 's',
+    OJ_OBJECT  = 'o',
+    OJ_ARRAY   = 'a',
+} ojType;
+
+typedef struct _num {
+    long double dub;
+    int64_t     fixnum;  // holds all digits
+    uint32_t    len;
+    int16_t     div;  // 10^div
+    int16_t     exp;
+    uint8_t     shift;  // shift of fixnum to get decimal
+    bool        neg;
+    bool        exp_neg;
+    // for numbers as strings, reuse buf
+} * Num;
+
+struct _ojParser;
+
+typedef struct _funcs {
+    void (*add_null)(struct _ojParser *p);
+    void (*add_true)(struct _ojParser *p);
+    void (*add_false)(struct _ojParser *p);
+    void (*add_int)(struct _ojParser *p);
+    void (*add_float)(struct _ojParser *p);
+    void (*add_big)(struct _ojParser *p);
+    void (*add_str)(struct _ojParser *p);
+    void (*open_array)(struct _ojParser *p);
+    void (*close_array)(struct _ojParser *p);
+    void (*open_object)(struct _ojParser *p);
+    void (*close_object)(struct _ojParser *p);
+} * Funcs;
+
+typedef struct _ojParser {
+    const char *  map;
+    const char *  next_map;
+    int           depth;
+    unsigned char stack[1024];
+
+    // value data
+    struct _num num;
+    struct _buf key;
+    struct _buf buf;
+
+    struct _funcs funcs[3]; // indexed by XXX_FUN defines
+
+    void (*start)(struct _ojParser *p);
+    VALUE (*option)(struct _ojParser *p, const char *key, VALUE value);
+    VALUE (*result)(struct _ojParser *p);
+    void (*free)(struct _ojParser *p);
+    void (*mark)(struct _ojParser *p);
+
+    void *ctx;
+    VALUE reader;
+
+    char     token[8];
+    long     line;
+    long     col;
+    int      ri;
+    uint32_t ucode;
+    ojType   type;  // valType
+    bool     just_one;
+} * ojParser;
+
+#endif /* OJ_PARSER_H */

data/ext/oj/rails.c

@@ -157,9 +157,9 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
     assure_size(out, 2);
     *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);
         assure_size(out, size + sep_len + 6);
         if (0 < i) {
@@ -202,7 +202,7 @@ static void dump_enumerable(VALUE obj, int depth, Out out, bool as_ok) {
 
 static void dump_bigdecimal(VALUE obj, int depth, Out out, bool as_ok) {
     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);
 
     if ('I' == *str || 'N' == *str || ('-' == *str && 'I' == str[1])) {
         oj_dump_nil(Qnil, depth, out, false);
@@ -355,7 +355,7 @@ 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 = 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);
 }
 
 static ID parameters_id = 0;
@@ -1224,7 +1224,7 @@ static void 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);
         }
     }

data/ext/oj/resolve.c

@@ -9,7 +9,7 @@
 #endif
 
 #include "err.h"
-#include "hash.h"
+#include "intern.h"
 #include "oj.h"
 #include "parse.h"
 
@@ -66,28 +66,10 @@ resolve_classpath(ParseInfo pi, const char *name, size_t len, int auto_define, V
 
 VALUE
 oj_name2class(ParseInfo pi, const char *name, size_t len, int auto_define, VALUE error_class) {
-    VALUE  clas;
-    VALUE *slot;
-
     if (No == pi->options.class_cache) {
         return resolve_classpath(pi, name, len, auto_define, error_class);
     }
-#ifdef HAVE_PTHREAD_MUTEX_INIT
-    pthread_mutex_lock(&oj_cache_mutex);
-#else
-    rb_mutex_lock(oj_cache_mutex);
-#endif
-    if (Qnil == (clas = oj_class_hash_get(name, len, &slot))) {
-        if (Qundef != (clas = resolve_classpath(pi, name, len, auto_define, error_class))) {
-            *slot = clas;
-        }
-    }
-#ifdef HAVE_PTHREAD_MUTEX_INIT
-    pthread_mutex_unlock(&oj_cache_mutex);
-#else
-    rb_mutex_unlock(oj_cache_mutex);
-#endif
-    return clas;
+    return oj_class_intern(name, len, true, pi, auto_define, error_class);
 }
 
 VALUE

data/ext/oj/saj2.c

@@ -0,0 +1,346 @@
+// Copyright (c) 2021, Peter Ohler, All rights reserved.
+
+#include "cache.h"
+#include "oj.h"
+#include "parser.h"
+
+typedef struct _delegate {
+    VALUE          handler;
+    VALUE *        keys;
+    VALUE *        tail;
+    size_t         klen;
+    struct _cache *str_cache;
+    uint8_t        cache_str;
+    bool           cache_keys;
+    bool           thread_safe;
+} * Delegate;
+
+static VALUE get_key(ojParser p) {
+    Delegate       d   = (Delegate)p->ctx;
+    const char *   key = buf_str(&p->key);
+    size_t         len = buf_len(&p->key);
+    volatile VALUE rkey;
+
+    if (d->cache_keys) {
+        rkey = cache_intern(d->str_cache, key, len);
+    } else {
+        rkey = rb_utf8_str_new(key, len);
+    }
+    return rkey;
+}
+
+static void push_key(Delegate d, VALUE key) {
+    if (d->klen <= (size_t)(d->tail - d->keys)) {
+        size_t off = d->tail - d->keys;
+
+        d->klen += d->klen / 2;
+        REALLOC_N(d->keys, VALUE, d->klen);
+        d->tail = d->keys + off;
+    }
+    *d->tail = key;
+    d->tail++;
+}
+
+static void noop(ojParser p) {
+}
+
+static void open_object(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_hash_start_id, 1, Qnil);
+}
+
+static void open_object_key(ojParser p) {
+    Delegate       d   = (Delegate)p->ctx;
+    volatile VALUE key = get_key(p);
+
+    push_key(d, key);
+    rb_funcall(d->handler, oj_hash_start_id, 1, key);
+}
+
+static void open_array(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_array_start_id, 1, Qnil);
+}
+
+static void open_array_key(ojParser p) {
+    Delegate       d   = (Delegate)p->ctx;
+    volatile VALUE key = get_key(p);
+
+    push_key(d, key);
+    rb_funcall(d->handler, oj_array_start_id, 1, key);
+}
+
+static void close_object(ojParser p) {
+    Delegate d   = (Delegate)p->ctx;
+    VALUE    key = Qnil;
+
+    if (OBJECT_FUN == p->stack[p->depth]) {
+        d->tail--;
+        if (d->tail < d->keys) {
+            rb_raise(rb_eIndexError, "accessing key stack");
+        }
+        key = *d->tail;
+    }
+    rb_funcall(d->handler, oj_hash_end_id, 1, key);
+}
+
+static void close_array(ojParser p) {
+    Delegate d   = (Delegate)p->ctx;
+    VALUE    key = Qnil;
+
+    if (OBJECT_FUN == p->stack[p->depth]) {
+        d->tail--;
+        if (d->tail < d->keys) {
+            rb_raise(rb_eIndexError, "accessing key stack");
+        }
+        key = *d->tail;
+    }
+    rb_funcall(d->handler, oj_array_end_id, 1, key);
+}
+
+static void add_null(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, Qnil, Qnil);
+}
+
+static void add_null_key(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, Qnil, get_key(p));
+}
+
+static void add_true(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, Qtrue, Qnil);
+}
+
+static void add_true_key(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, Qtrue, get_key(p));
+}
+
+static void add_false(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, Qfalse, Qnil);
+}
+
+static void add_false_key(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, Qfalse, get_key(p));
+}
+
+static void add_int(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, LONG2NUM(p->num.fixnum), Qnil);
+}
+
+static void add_int_key(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, LONG2NUM(p->num.fixnum), get_key(p));
+}
+
+static void add_float(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, rb_float_new(p->num.dub), Qnil);
+}
+
+static void add_float_key(ojParser p) {
+    rb_funcall(((Delegate)p->ctx)->handler, oj_add_value_id, 2, rb_float_new(p->num.dub), get_key(p));
+}
+
+static void add_big(ojParser p) {
+    rb_funcall((VALUE)p->ctx,
+               oj_add_value_id,
+               2,
+               rb_funcall(rb_cObject, oj_bigdecimal_id, 1, rb_str_new(buf_str(&p->buf), buf_len(&p->buf))),
+               Qnil);
+}
+
+static void add_big_key(ojParser p) {
+    rb_funcall((VALUE)p->ctx,
+               oj_add_value_id,
+               2,
+               rb_funcall(rb_cObject, oj_bigdecimal_id, 1, rb_str_new(buf_str(&p->buf), buf_len(&p->buf))),
+               get_key(p));
+}
+
+static void add_str(ojParser p) {
+    Delegate       d = (Delegate)p->ctx;
+    volatile VALUE rstr;
+    const char *   str = buf_str(&p->buf);
+    size_t         len = buf_len(&p->buf);
+
+    if (d->cache_str <= len) {
+        rstr = cache_intern(d->str_cache, str, len);
+    } else {
+        rstr = rb_utf8_str_new(str, len);
+    }
+    rb_funcall(d->handler, oj_add_value_id, 2, rstr, Qnil);
+}
+
+static void add_str_key(ojParser p) {
+    Delegate       d = (Delegate)p->ctx;
+    volatile VALUE rstr;
+    const char *   str = buf_str(&p->buf);
+    size_t         len = buf_len(&p->buf);
+
+    if (d->cache_str <= len) {
+        rstr = cache_intern(d->str_cache, str, len);
+    } else {
+        rstr = rb_utf8_str_new(str, len);
+    }
+    rb_funcall(d->handler, oj_add_value_id, 2, rstr, get_key(p));
+}
+
+static void reset(ojParser p) {
+    Funcs end = p->funcs + 3;
+
+    for (Funcs f = p->funcs; f < end; f++) {
+        f->add_null     = noop;
+        f->add_true     = noop;
+        f->add_false    = noop;
+        f->add_int      = noop;
+        f->add_float    = noop;
+        f->add_big      = noop;
+        f->add_str      = noop;
+        f->open_array   = noop;
+        f->close_array  = noop;
+        f->open_object  = noop;
+        f->close_object = noop;
+    }
+}
+
+static VALUE option(ojParser p, const char *key, VALUE value) {
+    Delegate d = (Delegate)p->ctx;
+
+    if (0 == strcmp(key, "handler")) {
+        return d->handler;
+    }
+    if (0 == strcmp(key, "handler=")) {
+        d->tail    = d->keys;
+        d->handler = value;
+        reset(p);
+        if (rb_respond_to(value, oj_hash_start_id)) {
+            p->funcs[TOP_FUN].open_object    = open_object;
+            p->funcs[ARRAY_FUN].open_object  = open_object;
+            p->funcs[OBJECT_FUN].open_object = open_object_key;
+        }
+        if (rb_respond_to(value, oj_array_start_id)) {
+            p->funcs[TOP_FUN].open_array    = open_array;
+            p->funcs[ARRAY_FUN].open_array  = open_array;
+            p->funcs[OBJECT_FUN].open_array = open_array_key;
+        }
+        if (rb_respond_to(value, oj_hash_end_id)) {
+            p->funcs[TOP_FUN].close_object    = close_object;
+            p->funcs[ARRAY_FUN].close_object  = close_object;
+            p->funcs[OBJECT_FUN].close_object = close_object;
+        }
+        if (rb_respond_to(value, oj_array_end_id)) {
+            p->funcs[TOP_FUN].close_array    = close_array;
+            p->funcs[ARRAY_FUN].close_array  = close_array;
+            p->funcs[OBJECT_FUN].close_array = close_array;
+        }
+        if (rb_respond_to(value, oj_add_value_id)) {
+            p->funcs[TOP_FUN].add_null    = add_null;
+            p->funcs[ARRAY_FUN].add_null  = add_null;
+            p->funcs[OBJECT_FUN].add_null = add_null_key;
+
+            p->funcs[TOP_FUN].add_true    = add_true;
+            p->funcs[ARRAY_FUN].add_true  = add_true;
+            p->funcs[OBJECT_FUN].add_true = add_true_key;
+
+            p->funcs[TOP_FUN].add_false    = add_false;
+            p->funcs[ARRAY_FUN].add_false  = add_false;
+            p->funcs[OBJECT_FUN].add_false = add_false_key;
+
+            p->funcs[TOP_FUN].add_int    = add_int;
+            p->funcs[ARRAY_FUN].add_int  = add_int;
+            p->funcs[OBJECT_FUN].add_int = add_int_key;
+
+            p->funcs[TOP_FUN].add_float    = add_float;
+            p->funcs[ARRAY_FUN].add_float  = add_float;
+            p->funcs[OBJECT_FUN].add_float = add_float_key;
+
+            p->funcs[TOP_FUN].add_big    = add_big;
+            p->funcs[ARRAY_FUN].add_big  = add_big;
+            p->funcs[OBJECT_FUN].add_big = add_big_key;
+
+            p->funcs[TOP_FUN].add_str    = add_str;
+            p->funcs[ARRAY_FUN].add_str  = add_str;
+            p->funcs[OBJECT_FUN].add_str = add_str_key;
+        }
+        return Qnil;
+    }
+    if (0 == strcmp(key, "cache_keys")) {
+        return d->cache_keys ? Qtrue : Qfalse;
+    }
+    if (0 == strcmp(key, "cache_keys=")) {
+        d->cache_keys = (Qtrue == value);
+
+        return d->cache_keys ? Qtrue : Qfalse;
+    }
+    if (0 == strcmp(key, "cache_strings")) {
+        return INT2NUM((int)d->cache_str);
+    }
+    if (0 == strcmp(key, "cache_strings=")) {
+        int limit = NUM2INT(value);
+
+        if (CACHE_MAX_KEY < limit) {
+            limit = CACHE_MAX_KEY;
+        } else if (limit < 0) {
+            limit = 0;
+        }
+        d->cache_str = limit;
+
+        return INT2NUM((int)d->cache_str);
+    }
+    rb_raise(rb_eArgError, "%s is not an option for the SAJ (Simple API for JSON) delegate", key);
+
+    return Qnil;  // Never reached due to the raise but required by the compiler.
+}
+
+static VALUE result(ojParser p) {
+    return Qnil;
+}
+
+static void start(ojParser p) {
+    Delegate d = (Delegate)p->ctx;
+
+    d->tail = d->keys;
+}
+
+static void dfree(ojParser p) {
+    Delegate d = (Delegate)p->ctx;
+
+    if (NULL != d->keys) {
+        xfree(d->keys);
+    }
+    cache_free(d->str_cache);
+    xfree(p->ctx);
+}
+
+static void mark(ojParser p) {
+    if (NULL == p->ctx) {
+        return;
+    }
+    Delegate d = (Delegate)p->ctx;
+
+    cache_mark(d->str_cache);
+    if (Qnil != d->handler) {
+        rb_gc_mark(d->handler);
+    }
+    if (!d->cache_keys) {
+        for (VALUE *kp = d->keys; kp < d->tail; kp++) {
+            rb_gc_mark(*kp);
+        }
+    }
+}
+
+static VALUE form_str(const char *str, size_t len) {
+    return rb_str_freeze(rb_utf8_str_new(str, len));
+}
+
+void oj_set_parser_saj(ojParser p) {
+    Delegate d = ALLOC(struct _delegate);
+
+    d->klen      = 256;
+    d->keys      = ALLOC_N(VALUE, d->klen);
+    d->tail      = d->keys;
+    d->str_cache = cache_create(0, form_str, true);
+
+    p->ctx = (void *)d;
+    reset(p);
+    p->option = option;
+    p->result = result;
+    p->free   = dfree;
+    p->mark   = mark;
+    p->start  = start;
+}