oj 3.14.2 → 3.14.3

data/ext/oj/dump_leaf.c

@@ -17,9 +17,7 @@ inline static void dump_chars(const char *s, size_t size, Out out) {
 static void dump_leaf_str(Leaf leaf, Out out) {
     switch (leaf->value_type) {
     case STR_VAL: oj_dump_cstr(leaf->str, strlen(leaf->str), 0, 0, out); break;
-    case RUBY_VAL:
-        oj_dump_cstr(rb_string_value_cstr(&leaf->value), (int)RSTRING_LEN(leaf->value), 0, 0, out);
-        break;
+    case RUBY_VAL: oj_dump_cstr(StringValueCStr(leaf->value), (int)RSTRING_LEN(leaf->value), 0, 0, out); break;
     case COL_VAL:
     default: rb_raise(rb_eTypeError, "Unexpected value type %02x.\n", leaf->value_type); break;
     }
@@ -142,11 +140,11 @@ void oj_dump_leaf_to_json(Leaf leaf, Options copts, Out out) {
 void oj_write_leaf_to_file(Leaf leaf, const char *path, Options copts) {
     struct _out out;
     size_t      size;
-    FILE *      f;
+    FILE       *f;
 
     oj_out_init(&out);
 
-    out.omit_nil  = copts->dump_opts.omit_nil;
+    out.omit_nil = copts->dump_opts.omit_nil;
     oj_dump_leaf_to_json(leaf, copts, &out);
     size = out.cur - out.buf;
     if (0 == (f = fopen(path, "w"))) {

data/ext/oj/dump_object.c

@@ -1,8 +1,8 @@
 // Copyright (c) 2012, 2017 Peter Ohler. All rights reserved.
 // Licensed under the MIT License. See LICENSE file in the project root for license details.
 
-#include "mem.h"
 #include "dump.h"
+#include "mem.h"
 #include "odd.h"
 #include "trace.h"
 
@@ -32,7 +32,7 @@ static void dump_data(VALUE obj, int depth, Out out, bool as_ok) {
     } else {
         if (oj_bigdecimal_class == clas) {
             volatile VALUE rstr = oj_safe_string_convert(obj);
-            const char *   str  = RSTRING_PTR(rstr);
+            const char    *str  = RSTRING_PTR(rstr);
             int            len  = (int)RSTRING_LEN(rstr);
 
             if (No != out->opts->bigdec_as_num) {
@@ -61,7 +61,7 @@ static void dump_obj(VALUE obj, int depth, Out out, bool as_ok) {
 
     if (oj_bigdecimal_class == clas) {
         volatile VALUE rstr = oj_safe_string_convert(obj);
-        const char *   str  = RSTRING_PTR(rstr);
+        const char    *str  = RSTRING_PTR(rstr);
         int            len  = (int)RSTRING_LEN(rstr);
 
         if (0 == strcasecmp("Infinity", str)) {
@@ -224,37 +224,36 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
         oj_dump_obj_val(value, depth, out);
         break;
 
-    default:
-        {
-            int     d2 = depth + 1;
-            long    s2 = size + out->indent + 1;
-            int     i;
-            int     started = 0;
-            uint8_t b;
-
-            assure_size(out, s2 + 15);
-            APPEND_CHARS(out->cur, "\"^#", 3);
-            out->hash_cnt++;
-            for (i = 28; 0 <= i; i -= 4) {
-                b = (uint8_t)((out->hash_cnt >> i) & 0x0000000F);
-                if ('\0' != b) {
-                    started = 1;
-                }
-                if (started) {
-                    *out->cur++ = hex_chars[b];
-                }
+    default: {
+        int     d2 = depth + 1;
+        long    s2 = size + out->indent + 1;
+        int     i;
+        int     started = 0;
+        uint8_t b;
+
+        assure_size(out, s2 + 15);
+        APPEND_CHARS(out->cur, "\"^#", 3);
+        out->hash_cnt++;
+        for (i = 28; 0 <= i; i -= 4) {
+            b = (uint8_t)((out->hash_cnt >> i) & 0x0000000F);
+            if ('\0' != b) {
+                started = 1;
+            }
+            if (started) {
+                *out->cur++ = hex_chars[b];
             }
-            APPEND_CHARS(out->cur, "\":[", 3);
-            fill_indent(out, d2);
-            oj_dump_obj_val(key, d2, out);
-            assure_size(out, s2);
-            *out->cur++ = ',';
-            fill_indent(out, d2);
-            oj_dump_obj_val(value, d2, out);
-            assure_size(out, size);
-            fill_indent(out, depth);
-            *out->cur++ = ']';
         }
+        APPEND_CHARS(out->cur, "\":[", 3);
+        fill_indent(out, d2);
+        oj_dump_obj_val(key, d2, out);
+        assure_size(out, s2);
+        *out->cur++ = ',';
+        fill_indent(out, d2);
+        oj_dump_obj_val(value, d2, out);
+        assure_size(out, size);
+        fill_indent(out, depth);
+        *out->cur++ = ']';
+    }
     }
     out->depth  = depth;
     *out->cur++ = ',';
@@ -364,10 +363,10 @@ static void dump_hash(VALUE obj, int depth, Out out, bool as_ok) {
 }
 
 static void dump_odd(VALUE obj, Odd odd, VALUE clas, int depth, Out out) {
-    ID *           idp;
-    AttrGetFunc *  fp;
+    ID            *idp;
+    AttrGetFunc   *fp;
     volatile VALUE v;
-    const char *   name;
+    const char    *name;
     size_t         size;
     int            d2 = depth + 1;
 
@@ -644,7 +643,7 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
 #endif
     out->cur--;
     APPEND_CHARS(out->cur, "]}", 2);
-    *out->cur   = '\0';
+    *out->cur = '\0';
 }
 
 static void dump_complex(VALUE obj, int depth, Out out, bool as_ok) {

data/ext/oj/dump_strict.c

@@ -22,15 +22,13 @@ static const char ninf_val[] = NINF_VAL;
 static const char nan_val[]  = NAN_VAL;
 
 static void raise_strict(VALUE obj) {
-    rb_raise(rb_eTypeError,
-             "Failed to dump %s Object to JSON in strict mode.\n",
-             rb_class2name(rb_obj_class(obj)));
+    rb_raise(rb_eTypeError, "Failed to dump %s Object to JSON in strict mode.\n", rb_class2name(rb_obj_class(obj)));
 }
 
 // Removed dependencies on math due to problems with CentOS 5.4.
 static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
     char   buf[64];
-    char * b;
+    char*  b;
     double d   = rb_num2dbl(obj);
     int    cnt = 0;
 

data/ext/oj/encoder.c

@@ -27,7 +27,7 @@ typedef struct _encoder {
     struct _dumpOpts dump_opts;
     struct _rxClass  str_rx;
     VALUE*           ignore;  // Qnil terminated array of classes or NULL
-} * Encoder;
+}* Encoder;
 
 /*
     rb_define_module_function(Oj, "encode", encode, -1);

data/ext/oj/err.c

@@ -39,11 +39,7 @@ void _oj_err_set_with_location(Err         err,
     oj_err_set(err, eclas, "%s at line %d, column %d [%s:%d]", msg, n, col, file, line);
 }
 
-void _oj_raise_error(const char *msg,
-                     const char *json,
-                     const char *current,
-                     const char *file,
-                     int         line) {
+void _oj_raise_error(const char *msg, const char *json, const char *current, const char *file, int line) {
     struct _err err;
     int         n   = 1;
     int         col = 1;
@@ -56,13 +52,6 @@ void _oj_raise_error(const char *msg,
             n++;
         }
     }
-    oj_err_set(&err,
-               oj_parse_error_class,
-               "%s at line %d, column %d [%s:%d]",
-               msg,
-               n,
-               col,
-               file,
-               line);
+    oj_err_set(&err, oj_parse_error_class, "%s at line %d, column %d [%s:%d]", msg, n, col, file, line);
     rb_raise(err.clas, "%s", err.msg);
 }

data/ext/oj/err.h

@@ -5,6 +5,7 @@
 #define OJ_ERR_H
 
 #include <errno.h>
+
 #include "ruby.h"
 
 // Needed to silence 2.4.0 warnings.
@@ -12,12 +13,12 @@
 #define NORETURN(x) x
 #endif
 
-#define OJ_ERR_START		300
+#define OJ_ERR_START 300
 
 typedef enum {
-    OJ_OK		= 0,
-    OJ_ERR_MEMORY	= ENOMEM,
-    OJ_ERR_PARSE	= OJ_ERR_START,
+    OJ_OK         = 0,
+    OJ_ERR_MEMORY = ENOMEM,
+    OJ_ERR_PARSE  = OJ_ERR_START,
     OJ_ERR_READ,
     OJ_ERR_WRITE,
     OJ_ERR_OVERFLOW,
@@ -29,13 +30,12 @@ typedef enum {
     OJ_ERR_LAST,
 } ojStatus;
 
-#define set_error(err, eclas, msg, json, current) \
-    _oj_err_set_with_location(err, eclas, msg, json, current, FILE, LINE)
+#define set_error(err, eclas, msg, json, current) _oj_err_set_with_location(err, eclas, msg, json, current, FILE, LINE)
 
 typedef struct _err {
     VALUE clas;
     char  msg[128];
-} * Err;
+} *Err;
 
 extern VALUE oj_parse_error_class;
 
@@ -52,11 +52,8 @@ NORETURN(extern void oj_err_raise(Err e));
 
 #define raise_error(msg, json, current) _oj_raise_error(msg, json, current, __FILE__, __LINE__)
 
-NORETURN(extern void _oj_raise_error(const char *msg,
-                                     const char *json,
-                                     const char *current,
-                                     const char *file,
-                                     int         line));
+NORETURN(
+    extern void _oj_raise_error(const char *msg, const char *json, const char *current, const char *file, int line));
 
 inline static void err_init(Err e) {
     e->clas = Qnil;

data/ext/oj/extconf.rb

@@ -47,7 +47,7 @@ if enable_config('trace-log', false)
   dflags['OJ_ENABLE_TRACE_LOG'] = 1
 end
 
-dflags.each do |k,v|
+dflags.each do |k, v|
   if v.nil?
     $CPPFLAGS += " -D#{k}"
   else

data/ext/oj/fast.c

@@ -11,15 +11,15 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "mem.h"
+#include "dump.h"
 #include "encode.h"
+#include "mem.h"
 #include "oj.h"
-#include "dump.h"
 
 // maximum to allocate on the stack, arbitrary limit
 #define SMALL_JSON 65536
 #define MAX_STACK 100
-//#define BATCH_SIZE	(4096 / sizeof(struct _leaf) - 1)
+// #define BATCH_SIZE	(4096 / sizeof(struct _leaf) - 1)
 #define BATCH_SIZE 100
 
 // Support for compaction
@@ -33,25 +33,25 @@ typedef struct _batch {
     struct _batch *next;
     int            next_avail;
     struct _leaf   leaves[BATCH_SIZE];
-} * Batch;
+} *Batch;
 
 typedef struct _doc {
     Leaf          data;
-    Leaf *        where;                  // points to current location
+    Leaf         *where;                  // points to current location
     Leaf          where_path[MAX_STACK];  // points to head of path
-    char *        json;
+    char         *json;
     unsigned long size;  // number of leaves/branches in the doc
     VALUE         self;
     Batch         batches;
     struct _batch batch0;
-} * Doc;
+} *Doc;
 
 typedef struct _parseInfo {
     char *str;  // buffer being read from
     char *s;    // current position in buffer
     Doc   doc;
     void *stack_min;
-} * ParseInfo;
+} *ParseInfo;
 
 static void  leaf_init(Leaf leaf, int type);
 static Leaf  leaf_new(Doc doc, int type);
@@ -251,7 +251,7 @@ static void skip_comment(ParseInfo pi) {
 #endif
 
 static void leaf_fixnum_value(Leaf leaf) {
-    char *  s   = leaf->str;
+    char   *s   = leaf->str;
     int64_t n   = 0;
     int     neg = 0;
     int     big = 0;
@@ -357,7 +357,7 @@ static Leaf read_next(ParseInfo pi) {
 
 static Leaf read_obj(ParseInfo pi) {
     Leaf        h = leaf_new(pi->doc, T_HASH);
-    char *      end;
+    char       *end;
     const char *key = 0;
     Leaf        val = 0;
 
@@ -1086,14 +1086,14 @@ static void each_value(Doc doc, Leaf leaf) {
  *   doc.close()
  */
 static VALUE doc_open(VALUE clas, VALUE str) {
-    char *         json;
+    char          *json;
     size_t         len;
     volatile VALUE obj;
     int            given = rb_block_given_p();
 
     Check_Type(str, T_STRING);
-    len      = (int)RSTRING_LEN(str) + 1;
-    json     = OJ_R_ALLOC_N(char, len);
+    len  = (int)RSTRING_LEN(str) + 1;
+    json = OJ_R_ALLOC_N(char, len);
 
     memcpy(json, StringValuePtr(str), len);
     obj = parse_json(clas, json, given);
@@ -1126,20 +1126,19 @@ static VALUE doc_open(VALUE clas, VALUE str) {
  *   doc.close()
  */
 static VALUE doc_open_file(VALUE clas, VALUE filename) {
-    char *         path;
-    char *         json;
-    FILE *         f;
+    char          *path;
+    char          *json;
+    FILE          *f;
     size_t         len;
     volatile VALUE obj;
     int            given = rb_block_given_p();
 
-    Check_Type(filename, T_STRING);
     path = StringValuePtr(filename);
     if (0 == (f = fopen(path, "r"))) {
         rb_raise(rb_eIOError, "%s", strerror(errno));
     }
     fseek(f, 0, SEEK_END);
-    len      = ftell(f);
+    len  = ftell(f);
     json = OJ_R_ALLOC_N(char, len + 1);
 
     fseek(f, 0, SEEK_SET);
@@ -1152,7 +1151,7 @@ static VALUE doc_open_file(VALUE clas, VALUE filename) {
     }
     fclose(f);
     json[len] = '\0';
-    obj = parse_json(clas, json, given);
+    obj       = parse_json(clas, json, given);
     // TBD is this needed
     /*
     if (given) {
@@ -1198,11 +1197,11 @@ static VALUE doc_where(VALUE self) {
     if (0 == *doc->where_path || doc->where == doc->where_path) {
         return oj_slash_string;
     } else {
-        Leaf * lp;
+        Leaf  *lp;
         Leaf   leaf;
         size_t size = 3;  // leading / and terminating \0
-        char * path;
-        char * p;
+        char  *path;
+        char  *p;
 
         for (lp = doc->where_path; lp <= doc->where; lp++) {
             leaf = *lp;
@@ -1305,7 +1304,6 @@ static VALUE doc_type(int argc, VALUE *argv, VALUE self) {
     VALUE       type = Qnil;
 
     if (1 <= argc) {
-        Check_Type(*argv, T_STRING);
         path = StringValuePtr(*argv);
     }
     if (0 != (leaf = get_doc_leaf(doc, path))) {
@@ -1314,11 +1312,7 @@ static VALUE doc_type(int argc, VALUE *argv, VALUE self) {
         case T_TRUE: type = rb_cTrueClass; break;
         case T_FALSE: type = rb_cFalseClass; break;
         case T_STRING: type = rb_cString; break;
-#ifdef RUBY_INTEGER_UNIFICATION
         case T_FIXNUM: type = rb_cInteger; break;
-#else
-        case T_FIXNUM: type = rb_cFixnum; break;
-#endif
         case T_FLOAT: type = rb_cFloat; break;
         case T_ARRAY: type = rb_cArray; break;
         case T_HASH: type = rb_cHash; break;
@@ -1345,11 +1339,10 @@ static VALUE doc_fetch(int argc, VALUE *argv, VALUE self) {
     Doc            doc;
     Leaf           leaf;
     volatile VALUE val  = Qnil;
-    const char *   path = 0;
+    const char    *path = 0;
 
     doc = self_doc(self);
     if (1 <= argc) {
-        Check_Type(*argv, T_STRING);
         path = StringValuePtr(*argv);
         if (2 == argc) {
             val = argv[1];
@@ -1374,7 +1367,6 @@ static VALUE doc_exists(VALUE self, VALUE str) {
     Leaf leaf;
 
     doc = self_doc(self);
-    Check_Type(str, T_STRING);
     if (0 != (leaf = get_doc_leaf(doc, StringValuePtr(str)))) {
         if (NULL != leaf) {
             return Qtrue;
@@ -1411,7 +1403,6 @@ static VALUE doc_each_leaf(int argc, VALUE *argv, VALUE self) {
             memcpy(save_path, doc->where_path, sizeof(Leaf) * (wlen + 1));
         }
         if (1 <= argc) {
-            Check_Type(*argv, T_STRING);
             path = StringValuePtr(*argv);
             if ('/' == *path) {
                 doc->where = doc->where_path;
@@ -1446,7 +1437,6 @@ static VALUE doc_move(VALUE self, VALUE str) {
     const char *path;
     int         loc;
 
-    Check_Type(str, T_STRING);
     path = StringValuePtr(str);
     if ('/' == *path) {
         doc->where = doc->where_path;
@@ -1481,14 +1471,13 @@ static VALUE doc_each_child(int argc, VALUE *argv, VALUE self) {
         Doc         doc  = self_doc(self);
         const char *path = 0;
         size_t      wlen;
-        Leaf *      where_orig = doc->where;
+        Leaf       *where_orig = doc->where;
 
         wlen = doc->where - doc->where_path;
         if (0 < wlen) {
             memcpy(save_path, doc->where_path, sizeof(Leaf) * (wlen + 1));
         }
         if (1 <= argc) {
-            Check_Type(*argv, T_STRING);
             path = StringValuePtr(*argv);
             if ('/' == *path) {
                 doc->where = doc->where_path;
@@ -1555,7 +1544,6 @@ static VALUE doc_each_value(int argc, VALUE *argv, VALUE self) {
         Leaf        leaf;
 
         if (1 <= argc) {
-            Check_Type(*argv, T_STRING);
             path = StringValuePtr(*argv);
         }
         if (0 != (leaf = get_doc_leaf(doc, path))) {
@@ -1587,11 +1575,9 @@ static VALUE doc_dump(int argc, VALUE *argv, VALUE self) {
 
     if (1 <= argc) {
         if (Qnil != *argv) {
-            Check_Type(*argv, T_STRING);
             path = StringValuePtr(*argv);
         }
         if (2 <= argc) {
-            Check_Type(argv[1], T_STRING);
             filename = StringValuePtr(argv[1]);
         }
     }
@@ -1603,7 +1589,7 @@ static VALUE doc_dump(int argc, VALUE *argv, VALUE self) {
 
             oj_out_init(&out);
 
-            out.omit_nil  = oj_default_options.dump_opts.omit_nil;
+            out.omit_nil = oj_default_options.dump_opts.omit_nil;
             oj_dump_leaf_to_json(leaf, &oj_default_options, &out);
             rjson = rb_str_new2(out.buf);
 

data/ext/oj/intern.c

@@ -9,8 +9,8 @@
 #include <pthread.h>
 #endif
 
-#include "mem.h"
 #include "cache.h"
+#include "mem.h"
 #include "parse.h"
 
 // Only used for the class cache so 256 should be sufficient.
@@ -22,10 +22,10 @@
 
 typedef struct _keyVal {
     struct _keyVal *next;
-    const char *    key;
+    const char     *key;
     size_t          len;
     VALUE           val;
-} * KeyVal;
+} *KeyVal;
 
 typedef struct _hash {
     struct _keyVal slots[HASH_SLOT_CNT];
@@ -34,16 +34,16 @@ typedef struct _hash {
 #else
     VALUE mutex;
 #endif
-} * Hash;
+} *Hash;
 
 struct _hash class_hash;
 struct _hash attr_hash;
 
-static VALUE          str_cache_obj;
+static VALUE str_cache_obj;
 
-static VALUE          sym_cache_obj;
+static VALUE sym_cache_obj;
 
-static VALUE          attr_cache_obj;
+static VALUE attr_cache_obj;
 
 static VALUE form_str(const char *str, size_t len) {
     return rb_str_freeze(rb_utf8_str_new(str, len));
@@ -61,26 +61,26 @@ static VALUE form_attr(const char *str, size_t len) {
         ID    id;
 
         if ('~' == *str) {
-	    memcpy(b, str + 1, len - 1);
-	    b[len - 1] = '\0';
-	    len -= 2;
-	} else {
-	    *b = '@';
-	    memcpy(b + 1, str, len);
-	    b[len + 1] = '\0';
-	}
+            memcpy(b, str + 1, len - 1);
+            b[len - 1] = '\0';
+            len -= 2;
+        } else {
+            *b = '@';
+            memcpy(b + 1, str, len);
+            b[len + 1] = '\0';
+        }
         id = rb_intern3(buf, len + 1, oj_utf8_encoding);
         OJ_R_FREE(b);
         return id;
     }
     if ('~' == *str) {
-	memcpy(buf, str + 1, len - 1);
-	buf[len - 1] = '\0';
-	len -= 2;
+        memcpy(buf, str + 1, len - 1);
+        buf[len - 1] = '\0';
+        len -= 2;
     } else {
-	*buf = '@';
-	memcpy(buf + 1, str, len);
-	buf[len + 1] = '\0';
+        *buf = '@';
+        memcpy(buf + 1, str, len);
+        buf[len + 1] = '\0';
     }
     return (VALUE)rb_intern3(buf, len + 1, oj_utf8_encoding);
 }
@@ -89,19 +89,16 @@ void oj_hash_init(void) {
     VALUE cache_class = rb_define_class_under(Oj, "Cache", rb_cObject);
     rb_undef_alloc_func(cache_class);
 
-    rb_gc_register_address(&cache_class);
-    rb_undef_alloc_func(cache_class);
-
-    struct _cache *str_cache     = cache_create(0, form_str, true, true);
-    str_cache_obj = Data_Wrap_Struct(cache_class, cache_mark, cache_free, str_cache);
+    struct _cache *str_cache = cache_create(0, form_str, true, true);
+    str_cache_obj            = Data_Wrap_Struct(cache_class, cache_mark, cache_free, str_cache);
     rb_gc_register_address(&str_cache_obj);
 
-    struct _cache *sym_cache     = cache_create(0, form_sym, true, true);
-    sym_cache_obj = Data_Wrap_Struct(cache_class, cache_mark, cache_free, sym_cache);
+    struct _cache *sym_cache = cache_create(0, form_sym, true, true);
+    sym_cache_obj            = Data_Wrap_Struct(cache_class, cache_mark, cache_free, sym_cache);
     rb_gc_register_address(&sym_cache_obj);
 
     struct _cache *attr_cache = cache_create(0, form_attr, false, true);
-    attr_cache_obj = Data_Wrap_Struct(cache_class, cache_mark, cache_free, attr_cache);
+    attr_cache_obj            = Data_Wrap_Struct(cache_class, cache_mark, cache_free, attr_cache);
     rb_gc_register_address(&attr_cache_obj);
 
     memset(class_hash.slots, 0, sizeof(class_hash.slots));
@@ -127,12 +124,11 @@ oj_str_intern(const char *key, size_t len) {
 
 VALUE
 oj_sym_intern(const char *key, size_t len) {
-  return cache_intern(DATA_PTR(sym_cache_obj), key, len);
+    return cache_intern(DATA_PTR(sym_cache_obj), key, len);
 }
 
-ID
-oj_attr_intern(const char *key, size_t len) {
-  return cache_intern(DATA_PTR(attr_cache_obj), key, len);
+ID oj_attr_intern(const char *key, size_t len) {
+    return cache_intern(DATA_PTR(attr_cache_obj), key, len);
 }
 
 static uint64_t hash_calc(const uint8_t *key, size_t len) {
@@ -186,10 +182,10 @@ static VALUE resolve_classname(VALUE mod, const char *classname, int auto_define
 static VALUE resolve_classpath(ParseInfo pi, const char *name, size_t len, int auto_define, VALUE error_class) {
     char        class_name[1024];
     VALUE       clas;
-    char *      end = class_name + sizeof(class_name) - 1;
-    char *      s;
-    const char *n = name;
-    size_t	nlen = len;
+    char       *end = class_name + sizeof(class_name) - 1;
+    char       *s;
+    const char *n    = name;
+    size_t      nlen = len;
 
     clas = rb_cObject;
     for (s = class_name; 0 < len; n++, len--) {
@@ -212,11 +208,11 @@ static VALUE resolve_classpath(ParseInfo pi, const char *name, size_t len, int a
     }
     *s = '\0';
     if (Qundef == (clas = resolve_classname(clas, class_name, auto_define))) {
-	if (sizeof(class_name) <= nlen) {
-	    nlen = sizeof(class_name) - 1;
-	}
-	strncpy(class_name, name, nlen);
-	class_name[nlen] = '\0';
+        if (sizeof(class_name) <= nlen) {
+            nlen = sizeof(class_name) - 1;
+        }
+        strncpy(class_name, name, nlen);
+        class_name[nlen] = '\0';
         oj_set_error_at(pi, error_class, __FILE__, __LINE__, "class '%s' is not defined", class_name);
         if (Qnil != error_class) {
             pi->err_class = error_class;

data/ext/oj/intern.h

@@ -4,8 +4,8 @@
 #ifndef OJ_INTERN_H
 #define OJ_INTERN_H
 
-#include <stdbool.h>
 #include <ruby.h>
+#include <stdbool.h>
 
 struct _parseInfo;
 
@@ -14,12 +14,8 @@ extern void oj_hash_init(void);
 extern VALUE oj_str_intern(const char *key, size_t len);
 extern VALUE oj_sym_intern(const char *key, size_t len);
 extern ID    oj_attr_intern(const char *key, size_t len);
-extern VALUE oj_class_intern(const char *       key,
-                             size_t             len,
-                             bool               safe,
-                             struct _parseInfo *pi,
-                             int                auto_define,
-                             VALUE              error_class);
+extern VALUE
+oj_class_intern(const char *key, size_t len, bool safe, struct _parseInfo *pi, int auto_define, VALUE error_class);
 
 extern char *oj_strndup(const char *s, size_t len);