oj 3.10.6 → 3.12.1

data/ext/oj/stream_writer.c

@@ -1,22 +1,18 @@
-/* stream_writer.c
- * Copyright (c) 2012, 2017, Peter Ohler
- * All rights reserved.
- */
+// 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 <errno.h>
-
 #include <ruby.h>
 
 #include "encode.h"
 
-extern VALUE	Oj;
+extern VALUE Oj;
 
-static void
-stream_writer_free(void *ptr) {
-    StreamWriter	sw;
+static void stream_writer_free(void *ptr) {
+    StreamWriter sw;
 
     if (0 == ptr) {
-	return;
+        return;
     }
     sw = (StreamWriter)ptr;
     xfree(sw->sw.out.buf);
@@ -24,41 +20,38 @@ stream_writer_free(void *ptr) {
     xfree(ptr);
 }
 
-static void
-stream_writer_reset_buf(StreamWriter sw) {
-    sw->sw.out.cur = sw->sw.out.buf;
+static void stream_writer_reset_buf(StreamWriter sw) {
+    sw->sw.out.cur  = sw->sw.out.buf;
     *sw->sw.out.cur = '\0';
 }
 
-static void
-stream_writer_write(StreamWriter sw) {
-    ssize_t	size = sw->sw.out.cur - sw->sw.out.buf;
+static void stream_writer_write(StreamWriter sw) {
+    ssize_t size = sw->sw.out.cur - sw->sw.out.buf;
 
     switch (sw->type) {
     case STRING_IO:
     case STREAM_IO: {
-	volatile VALUE	rs = rb_str_new(sw->sw.out.buf, size);
-
-	// Oddly enough, when pushing ASCII characters with UTF-8 encoding or
-	// even ASCII-8BIT does not change the output encoding. Pushing any
-	// non-ASCII no matter what the encoding changes the output encoding
-	// to ASCII-8BIT if it the string is not forced to UTF-8 here.
-	rs = oj_encode(rs);
-	rb_funcall(sw->stream, oj_write_id, 1, rs);
-	break;
+        volatile VALUE rs = rb_str_new(sw->sw.out.buf, size);
+
+        // Oddly enough, when pushing ASCII characters with UTF-8 encoding or
+        // even ASCII-8BIT does not change the output encoding. Pushing any
+        // non-ASCII no matter what the encoding changes the output encoding
+        // to ASCII-8BIT if it the string is not forced to UTF-8 here.
+        rs = oj_encode(rs);
+        rb_funcall(sw->stream, oj_write_id, 1, rs);
+        break;
     }
     case FILE_IO:
-	if (size != write(sw->fd, sw->sw.out.buf, size)) {
-	    rb_raise(rb_eIOError, "Write failed. [_%d_:%s]\n", errno, strerror(errno));
-	}
-	break;
-    default:
-	rb_raise(rb_eArgError, "expected an IO Object.");
+        if (size != write(sw->fd, sw->sw.out.buf, size)) {
+            rb_raise(rb_eIOError, "Write failed. [_%d_:%s]\n", errno, strerror(errno));
+        }
+        break;
+    default: rb_raise(rb_eArgError, "expected an IO Object.");
     }
     stream_writer_reset_buf(sw);
 }
 
-static VALUE	buffer_size_sym = Qundef;
+static VALUE buffer_size_sym = Qundef;
 
 /* Document-method: new
  * call-seq: new(io, options)
@@ -76,62 +69,60 @@ static VALUE	buffer_size_sym = Qundef;
  * - *io* [_IO_] stream to write to
  * - *options* [_Hash_] formating options
  */
-static VALUE
-stream_writer_new(int argc, VALUE *argv, VALUE self) {
-    StreamWriterType	type = STREAM_IO;
-    int			fd = 0;
-    VALUE		stream = argv[0];
-    VALUE		clas = rb_obj_class(stream);
-    StreamWriter	sw;
+static VALUE stream_writer_new(int argc, VALUE *argv, VALUE self) {
+    StreamWriterType type   = STREAM_IO;
+    int              fd     = 0;
+    VALUE            stream = argv[0];
+    VALUE            clas   = rb_obj_class(stream);
+    StreamWriter     sw;
 #if !IS_WINDOWS
-    VALUE		s;
+    VALUE s;
 #endif
-    
+
     if (oj_stringio_class == clas) {
-	type = STRING_IO;
+        type = STRING_IO;
 #if !IS_WINDOWS
     } else if (rb_respond_to(stream, oj_fileno_id) &&
-	       Qnil != (s = rb_funcall(stream, oj_fileno_id, 0)) &&
-	       0 != (fd = FIX2INT(s))) {
-	type = FILE_IO;
+               Qnil != (s = rb_funcall(stream, oj_fileno_id, 0)) && 0 != (fd = FIX2INT(s))) {
+        type = FILE_IO;
 #endif
     } else if (rb_respond_to(stream, oj_write_id)) {
-	type = STREAM_IO;
+        type = STREAM_IO;
     } else {
-	rb_raise(rb_eArgError, "expected an IO Object.");
+        rb_raise(rb_eArgError, "expected an IO Object.");
     }
     sw = ALLOC(struct _streamWriter);
     if (2 == argc && T_HASH == rb_type(argv[1])) {
-	volatile VALUE	v;
-	int		buf_size = 0;
-
-	if (Qundef == buffer_size_sym) {
-	    buffer_size_sym = ID2SYM(rb_intern("buffer_size"));	rb_gc_register_address(&buffer_size_sym);
-	    
-	}
-	if (Qnil != (v = rb_hash_lookup(argv[1], buffer_size_sym))) {
+        volatile VALUE v;
+        int            buf_size = 0;
+
+        if (Qundef == buffer_size_sym) {
+            buffer_size_sym = ID2SYM(rb_intern("buffer_size"));
+            rb_gc_register_address(&buffer_size_sym);
+        }
+        if (Qnil != (v = rb_hash_lookup(argv[1], buffer_size_sym))) {
 #ifdef RUBY_INTEGER_UNIFICATION
-	    if (rb_cInteger != rb_obj_class(v)) {
-		rb_raise(rb_eArgError, ":buffer size must be a Integer.");
-	    }
+            if (rb_cInteger != rb_obj_class(v)) {
+                rb_raise(rb_eArgError, ":buffer size must be a Integer.");
+            }
 #else
-	    if (T_FIXNUM != rb_type(v)) {
-		rb_raise(rb_eArgError, ":buffer size must be a Integer.");
-	    }
+            if (T_FIXNUM != rb_type(v)) {
+                rb_raise(rb_eArgError, ":buffer size must be a Integer.");
+            }
 #endif
-	    buf_size = FIX2INT(v);
-	}
-	oj_str_writer_init(&sw->sw, buf_size);
-	oj_parse_options(argv[1], &sw->sw.opts);
-	sw->flush_limit = buf_size;
+            buf_size = FIX2INT(v);
+        }
+        oj_str_writer_init(&sw->sw, buf_size);
+        oj_parse_options(argv[1], &sw->sw.opts);
+        sw->flush_limit = buf_size;
     } else {
-	oj_str_writer_init(&sw->sw, 4096);
-	sw->flush_limit = 0;
+        oj_str_writer_init(&sw->sw, 4096);
+        sw->flush_limit = 0;
     }
     sw->sw.out.indent = sw->sw.opts.indent;
-    sw->stream = stream;
-    sw->type = type;
-    sw->fd = fd;
+    sw->stream        = stream;
+    sw->type          = type;
+    sw->fd            = fd;
 
     return Data_Wrap_Struct(oj_stream_writer_class, 0, stream_writer_free, sw);
 }
@@ -145,14 +136,13 @@ stream_writer_new(int argc, VALUE *argv, VALUE self) {
  *
  * - *key* [_String_] the key pending for the next push
  */
-static VALUE
-stream_writer_push_key(VALUE self, VALUE key) {
-    StreamWriter	sw = (StreamWriter)DATA_PTR(self);
+static VALUE stream_writer_push_key(VALUE self, VALUE key) {
+    StreamWriter sw = (StreamWriter)DATA_PTR(self);
 
     rb_check_type(key, T_STRING);
     oj_str_writer_push_key(&sw->sw, StringValuePtr(key));
     if (sw->flush_limit < sw->sw.out.cur - sw->sw.out.buf) {
-	stream_writer_write(sw);
+        stream_writer_write(sw);
     }
     return Qnil;
 }
@@ -165,28 +155,23 @@ stream_writer_push_key(VALUE self, VALUE key) {
  *
  * - *key* [_String_] the key if adding to an object in the JSON document
  */
-static VALUE
-stream_writer_push_object(int argc, VALUE *argv, VALUE self) {
-    StreamWriter	sw = (StreamWriter)DATA_PTR(self);
+static VALUE stream_writer_push_object(int argc, VALUE *argv, VALUE self) {
+    StreamWriter sw = (StreamWriter)DATA_PTR(self);
 
     switch (argc) {
-    case 0:
-	oj_str_writer_push_object(&sw->sw, 0);
-	break;
+    case 0: oj_str_writer_push_object(&sw->sw, 0); break;
     case 1:
-	if (Qnil == argv[0]) {
-	    oj_str_writer_push_object(&sw->sw, 0);
-	} else {
-	    rb_check_type(argv[0], T_STRING);
-	    oj_str_writer_push_object(&sw->sw, StringValuePtr(argv[0]));
-	}
-	break;
-    default:
-	rb_raise(rb_eArgError, "Wrong number of argument to 'push_object'.");
-	break;
+        if (Qnil == argv[0]) {
+            oj_str_writer_push_object(&sw->sw, 0);
+        } else {
+            rb_check_type(argv[0], T_STRING);
+            oj_str_writer_push_object(&sw->sw, StringValuePtr(argv[0]));
+        }
+        break;
+    default: rb_raise(rb_eArgError, "Wrong number of argument to 'push_object'."); break;
     }
     if (sw->flush_limit < sw->sw.out.cur - sw->sw.out.buf) {
-	stream_writer_write(sw);
+        stream_writer_write(sw);
     }
     return Qnil;
 }
@@ -199,28 +184,23 @@ stream_writer_push_object(int argc, VALUE *argv, VALUE self) {
  *
  * - *key* [_String_] the key if adding to an object in the JSON document
  */
-static VALUE
-stream_writer_push_array(int argc, VALUE *argv, VALUE self) {
-    StreamWriter	sw = (StreamWriter)DATA_PTR(self);
+static VALUE stream_writer_push_array(int argc, VALUE *argv, VALUE self) {
+    StreamWriter sw = (StreamWriter)DATA_PTR(self);
 
     switch (argc) {
-    case 0:
-	oj_str_writer_push_array(&sw->sw, 0);
-	break;
+    case 0: oj_str_writer_push_array(&sw->sw, 0); break;
     case 1:
-	if (Qnil == argv[0]) {
-	    oj_str_writer_push_array(&sw->sw, 0);
-	} else {
-	    rb_check_type(argv[0], T_STRING);
-	    oj_str_writer_push_array(&sw->sw, StringValuePtr(argv[0]));
-	}
-	break;
-    default:
-	rb_raise(rb_eArgError, "Wrong number of argument to 'push_object'.");
-	break;
+        if (Qnil == argv[0]) {
+            oj_str_writer_push_array(&sw->sw, 0);
+        } else {
+            rb_check_type(argv[0], T_STRING);
+            oj_str_writer_push_array(&sw->sw, StringValuePtr(argv[0]));
+        }
+        break;
+    default: rb_raise(rb_eArgError, "Wrong number of argument to 'push_object'."); break;
     }
     if (sw->flush_limit < sw->sw.out.cur - sw->sw.out.buf) {
-	stream_writer_write(sw);
+        stream_writer_write(sw);
     }
     return Qnil;
 }
@@ -232,28 +212,23 @@ stream_writer_push_array(int argc, VALUE *argv, VALUE self) {
  * - *value* [_Object_] value to add to the JSON document
  * - *key* [_String_] the key if adding to an object in the JSON document
  */
-static VALUE
-stream_writer_push_value(int argc, VALUE *argv, VALUE self) {
-    StreamWriter	sw = (StreamWriter)DATA_PTR(self);
+static VALUE stream_writer_push_value(int argc, VALUE *argv, VALUE self) {
+    StreamWriter sw = (StreamWriter)DATA_PTR(self);
 
     switch (argc) {
-    case 1:
-	oj_str_writer_push_value((StrWriter)DATA_PTR(self), *argv, 0);
-	break;
+    case 1: oj_str_writer_push_value((StrWriter)DATA_PTR(self), *argv, 0); break;
     case 2:
-	if (Qnil == argv[1]) {
-	    oj_str_writer_push_value((StrWriter)DATA_PTR(self), *argv, 0);
-	} else {
-	    rb_check_type(argv[1], T_STRING);
-	    oj_str_writer_push_value((StrWriter)DATA_PTR(self), *argv, StringValuePtr(argv[1]));
-	}
-	break;
-    default:
-	rb_raise(rb_eArgError, "Wrong number of argument to 'push_value'.");
-	break;
+        if (Qnil == argv[1]) {
+            oj_str_writer_push_value((StrWriter)DATA_PTR(self), *argv, 0);
+        } else {
+            rb_check_type(argv[1], T_STRING);
+            oj_str_writer_push_value((StrWriter)DATA_PTR(self), *argv, StringValuePtr(argv[1]));
+        }
+        break;
+    default: rb_raise(rb_eArgError, "Wrong number of argument to 'push_value'."); break;
     }
     if (sw->flush_limit < sw->sw.out.cur - sw->sw.out.buf) {
-	stream_writer_write(sw);
+        stream_writer_write(sw);
     }
     return Qnil;
 }
@@ -267,29 +242,26 @@ stream_writer_push_value(int argc, VALUE *argv, VALUE self) {
  * - *value* [_Object_] value to add to the JSON document
  * - *key* [_String_] the key if adding to an object in the JSON document
  */
-static VALUE
-stream_writer_push_json(int argc, VALUE *argv, VALUE self) {
-    StreamWriter	sw = (StreamWriter)DATA_PTR(self);
+static VALUE stream_writer_push_json(int argc, VALUE *argv, VALUE self) {
+    StreamWriter sw = (StreamWriter)DATA_PTR(self);
 
     rb_check_type(argv[0], T_STRING);
     switch (argc) {
-    case 1:
-	oj_str_writer_push_json((StrWriter)DATA_PTR(self), StringValuePtr(*argv), 0);
-	break;
+    case 1: oj_str_writer_push_json((StrWriter)DATA_PTR(self), StringValuePtr(*argv), 0); break;
     case 2:
-	if (Qnil == argv[1]) {
-	    oj_str_writer_push_json((StrWriter)DATA_PTR(self), StringValuePtr(*argv), 0);
-	} else {
-	    rb_check_type(argv[1], T_STRING);
-	    oj_str_writer_push_json((StrWriter)DATA_PTR(self), StringValuePtr(*argv), StringValuePtr(argv[1]));
-	}
-	break;
-    default:
-	rb_raise(rb_eArgError, "Wrong number of argument to 'push_json'.");
-	break;
+        if (Qnil == argv[1]) {
+            oj_str_writer_push_json((StrWriter)DATA_PTR(self), StringValuePtr(*argv), 0);
+        } else {
+            rb_check_type(argv[1], T_STRING);
+            oj_str_writer_push_json((StrWriter)DATA_PTR(self),
+                                    StringValuePtr(*argv),
+                                    StringValuePtr(argv[1]));
+        }
+        break;
+    default: rb_raise(rb_eArgError, "Wrong number of argument to 'push_json'."); break;
     }
     if (sw->flush_limit < sw->sw.out.cur - sw->sw.out.buf) {
-	stream_writer_write(sw);
+        stream_writer_write(sw);
     }
     return Qnil;
 }
@@ -300,13 +272,12 @@ stream_writer_push_json(int argc, VALUE *argv, VALUE self) {
  * Pops up a level in the JSON document closing the array or object that is
  * currently open.
  */
-static VALUE
-stream_writer_pop(VALUE self) {
-    StreamWriter	sw = (StreamWriter)DATA_PTR(self);
+static VALUE stream_writer_pop(VALUE self) {
+    StreamWriter sw = (StreamWriter)DATA_PTR(self);
 
     oj_str_writer_pop(&sw->sw);
     if (sw->flush_limit < sw->sw.out.cur - sw->sw.out.buf) {
-	stream_writer_write(sw);
+        stream_writer_write(sw);
     }
     return Qnil;
 }
@@ -317,9 +288,8 @@ stream_writer_pop(VALUE self) {
  * Pops all level in the JSON document closing all the array or object that is
  * currently open.
  */
-static VALUE
-stream_writer_pop_all(VALUE self) {
-    StreamWriter	sw = (StreamWriter)DATA_PTR(self);
+static VALUE stream_writer_pop_all(VALUE self) {
+    StreamWriter sw = (StreamWriter)DATA_PTR(self);
 
     oj_str_writer_pop_all(&sw->sw);
     stream_writer_write(sw);
@@ -332,22 +302,20 @@ stream_writer_pop_all(VALUE self) {
  *
  * Flush any remaining characters in the buffer.
  */
-static VALUE
-stream_writer_flush(VALUE self) {
+static VALUE stream_writer_flush(VALUE self) {
     stream_writer_write((StreamWriter)DATA_PTR(self));
 
     return Qnil;
 }
 
 /* Document-class: Oj::StreamWriter
- * 
+ *
  * Supports building a JSON document one element at a time. Build the IO stream
  * document by pushing values into the document. Pushing an array or an object
  * will create that element in the JSON document and subsequent pushes will add
  * the elements to that array or object until a pop() is called.
  */
-void
-oj_stream_writer_init() {
+void oj_stream_writer_init() {
     oj_stream_writer_class = rb_define_class_under(Oj, "StreamWriter", rb_cObject);
     rb_define_module_function(oj_stream_writer_class, "new", stream_writer_new, -1);
     rb_define_method(oj_stream_writer_class, "push_key", stream_writer_push_key, 1);
@@ -359,5 +327,3 @@ oj_stream_writer_init() {
     rb_define_method(oj_stream_writer_class, "pop_all", stream_writer_pop_all, 0);
     rb_define_method(oj_stream_writer_class, "flush", stream_writer_flush, 0);
 }
-
-

data/ext/oj/strict.c

@@ -1,210 +1,237 @@
-/* strict.c
- * Copyright (c) 2012, Peter Ohler
- * All rights reserved.
- */
+// Copyright (c) 2012 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
 
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
-#include "oj.h"
+#include "encode.h"
 #include "err.h"
+#include "hash.h"
+#include "oj.h"
 #include "parse.h"
-#include "encode.h"
 #include "trace.h"
 
-static void
-hash_end(ParseInfo pi) {
+VALUE oj_cstr_to_value(const char *str, size_t len, size_t cache_str) {
+    volatile VALUE rstr = Qnil;
+
+    if (len <= cache_str) {
+        VALUE *slot;
+
+        if (Qnil == (rstr = oj_str_hash_get(str, len, &slot))) {
+            rstr  = rb_str_new(str, len);
+            rstr  = oj_encode(rstr);
+            *slot = rstr;
+            rb_gc_register_address(slot);
+        }
+    } else {
+        rstr = rb_str_new(str, len);
+        rstr = oj_encode(rstr);
+    }
+    return rstr;
+}
+
+VALUE oj_calc_hash_key(ParseInfo pi, Val parent) {
+    volatile VALUE rkey = parent->key_val;
+
+    if (Qundef != rkey) {
+        return rkey;
+    }
+    if (Yes != pi->options.cache_keys) {
+        rkey = rb_str_new(parent->key, parent->klen);
+        rkey = oj_encode(rkey);
+        if (Yes == pi->options.sym_key) {
+            rkey = rb_str_intern(rkey);
+        }
+        return rkey;
+    }
+    VALUE *slot;
+
+    if (Yes == pi->options.sym_key) {
+        if (Qnil == (rkey = oj_sym_hash_get(parent->key, parent->klen, &slot))) {
+            rkey  = rb_str_new(parent->key, parent->klen);
+            rkey  = oj_encode(rkey);
+            rkey  = rb_str_intern(rkey);
+            *slot = rkey;
+            rb_gc_register_address(slot);
+        }
+    } else {
+        if (Qnil == (rkey = oj_str_hash_get(parent->key, parent->klen, &slot))) {
+            rkey  = rb_str_new(parent->key, parent->klen);
+            rkey  = oj_encode(rkey);
+            *slot = rkey;
+            rb_gc_register_address(slot);
+        }
+    }
+    return rkey;
+}
+
+static void hash_end(ParseInfo pi) {
     if (Yes == pi->options.trace) {
-	oj_trace_parse_hash_end(pi, __FILE__, __LINE__);
+        oj_trace_parse_hash_end(pi, __FILE__, __LINE__);
     }
 }
 
-static void
-array_end(ParseInfo pi) {
+static void array_end(ParseInfo pi) {
     if (Yes == pi->options.trace) {
-	oj_trace_parse_array_end(pi, __FILE__, __LINE__);
+        oj_trace_parse_array_end(pi, __FILE__, __LINE__);
     }
 }
 
-static VALUE
-noop_hash_key(ParseInfo pi, const char *key, size_t klen) {
+static VALUE noop_hash_key(ParseInfo pi, const char *key, size_t klen) {
     return Qundef;
 }
 
-static void
-add_value(ParseInfo pi, VALUE val) {
+static void add_value(ParseInfo pi, VALUE val) {
     if (Yes == pi->options.trace) {
-	oj_trace_parse_call("add_value", pi, __FILE__, __LINE__, val);
+        oj_trace_parse_call("add_value", pi, __FILE__, __LINE__, val);
     }
     pi->stack.head->val = val;
 }
 
-static void
-add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
-    volatile VALUE	rstr = rb_str_new(str, len);
+static void add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
+    volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
 
-    rstr = oj_encode(rstr);
     pi->stack.head->val = rstr;
     if (Yes == pi->options.trace) {
-	oj_trace_parse_call("add_string", pi, __FILE__, __LINE__, rstr);
+        oj_trace_parse_call("add_string", pi, __FILE__, __LINE__, rstr);
     }
 }
 
-static void
-add_num(ParseInfo pi, NumInfo ni) {
+static void add_num(ParseInfo pi, NumInfo ni) {
     if (ni->infinity || ni->nan) {
-	oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
+        oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
     }
     pi->stack.head->val = oj_num_as_value(ni);
     if (Yes == pi->options.trace) {
-	oj_trace_parse_call("add_number", pi, __FILE__, __LINE__, pi->stack.head->val);
+        oj_trace_parse_call("add_number", pi, __FILE__, __LINE__, pi->stack.head->val);
     }
 }
 
-static VALUE
-start_hash(ParseInfo pi) {
+static VALUE start_hash(ParseInfo pi) {
     if (Qnil != pi->options.hash_class) {
-	return rb_class_new_instance(0, NULL, pi->options.hash_class);
+        return rb_class_new_instance(0, NULL, pi->options.hash_class);
     }
     if (Yes == pi->options.trace) {
-	oj_trace_parse_in("start_hash", pi, __FILE__, __LINE__);
+        oj_trace_parse_in("start_hash", pi, __FILE__, __LINE__);
     }
     return rb_hash_new();
 }
 
-static VALUE
-calc_hash_key(ParseInfo pi, Val parent) {
-    volatile VALUE	rkey = parent->key_val;
+static void hash_set_cstr(ParseInfo pi, Val parent, const char *str, size_t len, const char *orig) {
+    volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
 
-    if (Qundef == rkey) {
-	rkey = rb_str_new(parent->key, parent->klen);
-    }
-    rkey = oj_encode(rkey);
-    if (Yes == pi->options.sym_key) {
-	rkey = rb_str_intern(rkey);
-    }
-    return rkey;
-}
-
-static void
-hash_set_cstr(ParseInfo pi, Val parent, const char *str, size_t len, const char *orig) {
-    volatile VALUE	rstr = rb_str_new(str, len);
-
-    rstr = oj_encode(rstr);
-    rb_hash_aset(stack_peek(&pi->stack)->val, calc_hash_key(pi, parent), rstr);
+    rb_hash_aset(stack_peek(&pi->stack)->val,
+                 oj_calc_hash_key(pi, parent),
+                 rstr);
     if (Yes == pi->options.trace) {
-	oj_trace_parse_call("set_string", pi, __FILE__, __LINE__, rstr);
+        oj_trace_parse_call("set_string", pi, __FILE__, __LINE__, rstr);
     }
 }
 
-static void
-hash_set_num(ParseInfo pi, Val parent, NumInfo ni) {
-    volatile VALUE	v;
-    
+static void hash_set_num(ParseInfo pi, Val parent, NumInfo ni) {
+    volatile VALUE v;
+
     if (ni->infinity || ni->nan) {
-	oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
+        oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
     }
     v = oj_num_as_value(ni);
-    rb_hash_aset(stack_peek(&pi->stack)->val, calc_hash_key(pi, parent), v);
+    rb_hash_aset(stack_peek(&pi->stack)->val,
+                 oj_calc_hash_key(pi, parent),
+                 v);
     if (Yes == pi->options.trace) {
-	oj_trace_parse_call("set_number", pi, __FILE__, __LINE__, v);
+        oj_trace_parse_call("set_number", pi, __FILE__, __LINE__, v);
     }
 }
 
-static void
-hash_set_value(ParseInfo pi, Val parent, VALUE value) {
-    rb_hash_aset(stack_peek(&pi->stack)->val, calc_hash_key(pi, parent), value);
+static void hash_set_value(ParseInfo pi, Val parent, VALUE value) {
+    rb_hash_aset(stack_peek(&pi->stack)->val,
+                 oj_calc_hash_key(pi, parent),
+                 value);
     if (Yes == pi->options.trace) {
-	oj_trace_parse_call("set_value", pi, __FILE__, __LINE__, value);
+        oj_trace_parse_call("set_value", pi, __FILE__, __LINE__, value);
     }
 }
 
-static VALUE
-start_array(ParseInfo pi) {
+static VALUE start_array(ParseInfo pi) {
     if (Yes == pi->options.trace) {
-	oj_trace_parse_in("start_array", pi, __FILE__, __LINE__);
+        oj_trace_parse_in("start_array", pi, __FILE__, __LINE__);
     }
     return rb_ary_new();
 }
 
-static void
-array_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
-    volatile VALUE	rstr = rb_str_new(str, len);
+static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
+    volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
 
-    rstr = oj_encode(rstr);
     rb_ary_push(stack_peek(&pi->stack)->val, rstr);
     if (Yes == pi->options.trace) {
-	oj_trace_parse_call("append_string", pi, __FILE__, __LINE__, rstr);
+        oj_trace_parse_call("append_string", pi, __FILE__, __LINE__, rstr);
     }
 }
 
-static void
-array_append_num(ParseInfo pi, NumInfo ni) {
-    volatile VALUE	v;
-    
+static void array_append_num(ParseInfo pi, NumInfo ni) {
+    volatile VALUE v;
+
     if (ni->infinity || ni->nan) {
-	oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
+        oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
     }
     v = oj_num_as_value(ni);
     rb_ary_push(stack_peek(&pi->stack)->val, v);
     if (Yes == pi->options.trace) {
-	oj_trace_parse_call("append_number", pi, __FILE__, __LINE__, v);
+        oj_trace_parse_call("append_number", pi, __FILE__, __LINE__, v);
     }
 }
 
-static void
-array_append_value(ParseInfo pi, VALUE value) {
+static void array_append_value(ParseInfo pi, VALUE value) {
     rb_ary_push(stack_peek(&pi->stack)->val, value);
     if (Yes == pi->options.trace) {
-	oj_trace_parse_call("append_value", pi, __FILE__, __LINE__, value);
-    }
-}
-
-void
-oj_set_strict_callbacks(ParseInfo pi) {
-    pi->start_hash = start_hash;
-    pi->end_hash = hash_end;
-    pi->hash_key = noop_hash_key;
-    pi->hash_set_cstr = hash_set_cstr;
-    pi->hash_set_num = hash_set_num;
-    pi->hash_set_value = hash_set_value;
-    pi->start_array = start_array;
-    pi->end_array = array_end;
-    pi->array_append_cstr = array_append_cstr;
-    pi->array_append_num = array_append_num;
+        oj_trace_parse_call("append_value", pi, __FILE__, __LINE__, value);
+    }
+}
+
+void oj_set_strict_callbacks(ParseInfo pi) {
+    pi->start_hash         = start_hash;
+    pi->end_hash           = hash_end;
+    pi->hash_key           = noop_hash_key;
+    pi->hash_set_cstr      = hash_set_cstr;
+    pi->hash_set_num       = hash_set_num;
+    pi->hash_set_value     = hash_set_value;
+    pi->start_array        = start_array;
+    pi->end_array          = array_end;
+    pi->array_append_cstr  = array_append_cstr;
+    pi->array_append_num   = array_append_num;
     pi->array_append_value = array_append_value;
-    pi->add_cstr = add_cstr;
-    pi->add_num = add_num;
-    pi->add_value = add_value;
-    pi->expect_value = 1;
+    pi->add_cstr           = add_cstr;
+    pi->add_num            = add_num;
+    pi->add_value          = add_value;
+    pi->expect_value       = 1;
 }
 
 VALUE
 oj_strict_parse(int argc, VALUE *argv, VALUE self) {
-    struct _parseInfo	pi;
+    struct _parseInfo pi;
 
     parse_info_init(&pi);
-    pi.options = oj_default_options;
-    pi.handler = Qnil;
+    pi.options   = oj_default_options;
+    pi.handler   = Qnil;
     pi.err_class = Qnil;
     oj_set_strict_callbacks(&pi);
 
     if (T_STRING == rb_type(*argv)) {
-	return oj_pi_parse(argc, argv, &pi, 0, 0, true);
+        return oj_pi_parse(argc, argv, &pi, 0, 0, true);
     } else {
-	return oj_pi_sparse(argc, argv, &pi, 0);
+        return oj_pi_sparse(argc, argv, &pi, 0);
     }
 }
 
 VALUE
 oj_strict_parse_cstr(int argc, VALUE *argv, char *json, size_t len) {
-    struct _parseInfo	pi;
+    struct _parseInfo pi;
 
     parse_info_init(&pi);
-    pi.options = oj_default_options;
-    pi.handler = Qnil;
+    pi.options   = oj_default_options;
+    pi.handler   = Qnil;
     pi.err_class = Qnil;
     oj_set_strict_callbacks(&pi);