oj 2.0.14 → 2.1.0

data/test/tests.rb

@@ -120,7 +120,6 @@ class Juice < ::Test::Unit::TestCase
                    :time_format=>:unix,
                    :bigdecimal_as_decimal=>true,
                    :bigdecimal_load=>false,
-                   :max_stack=>65536,
                    :create_id=>'json_class'}, opts)
   end
 
@@ -137,7 +136,6 @@ class Juice < ::Test::Unit::TestCase
       :time_format=>:unix,
       :bigdecimal_as_decimal=>true,
       :bigdecimal_load=>false,
-      :max_stack=>65536,
       :create_id=>'json_class'}
     o2 = {
       :indent=>4,
@@ -151,7 +149,6 @@ class Juice < ::Test::Unit::TestCase
       :time_format=>:ruby,
       :bigdecimal_as_decimal=>false,
       :bigdecimal_load=>true,
-      :max_stack=>4000,
       :create_id=>nil}
     o3 = { :indent => 4 }
     Oj.default_options = o2
@@ -237,10 +234,11 @@ class Juice < ::Test::Unit::TestCase
   def test_symbol_strict
     begin
       Oj.dump(:abc, :mode => :strict)
-      assert(false)
     rescue Exception
       assert(true)
+      return
     end
+    assert(false, "*** expected an exception")
   end
   def test_symbol_null
     json = Oj.dump(:abc, :mode => :null)
@@ -578,12 +576,6 @@ class Juice < ::Test::Unit::TestCase
     obj = Orange.new(true, 58)
     json = Oj.dump(obj, :indent => 2)
     assert(!json.nil?)
-=begin
-    assert_equal(%{{
-  "json_class":"Orange",
-  "x":true,
-  "y":58}}, json)
-=end
     dump_and_load(obj, false)
   end
 
@@ -930,14 +922,12 @@ class Juice < ::Test::Unit::TestCase
 
 # Stream Deeply Nested
   def test_deep_nest
-    unless 'jruby' == RUBY_DESCRIPTION.split(' ')[0]
-      begin
-        n = 100000
-        Oj.load('[' * n + ']' * n)
-        assert(false)
-      rescue Exception => e
-        assert(e.class == SystemStackError)
-      end
+    #unless 'jruby' == RUBY_DESCRIPTION.split(' ')[0]
+    begin
+      n = 10000
+      Oj.strict_load('[' * n + ']' * n)
+    rescue Exception => e
+      assert(false, e.message)
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oj
 version: !ruby/object:Gem::Version
-  version: 2.0.14
+  version: 2.1.0
 platform: ruby
 authors:
 - Peter Ohler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-26 00:00:00.000000000 Z
+date: 2013-06-16 00:00:00.000000000 Z
 dependencies: []
 description: 'The fastest JSON parser and object serializer. '
 email: peter@ohler.com
@@ -22,31 +22,48 @@ files:
 - lib/oj/error.rb
 - lib/oj/mimic.rb
 - lib/oj/saj.rb
+- lib/oj/schandler.rb
 - lib/oj/version.rb
 - lib/oj.rb
 - ext/oj/extconf.rb
-- ext/oj/cache.h
+- ext/oj/buf.h
 - ext/oj/cache8.h
+- ext/oj/circarray.h
+- ext/oj/err.h
+- ext/oj/hash.h
+- ext/oj/odd.h
 - ext/oj/oj.h
-- ext/oj/cache.c
+- ext/oj/parse.h
+- ext/oj/resolve.h
+- ext/oj/val_stack.h
 - ext/oj/cache8.c
+- ext/oj/circarray.c
+- ext/oj/compat.c
 - ext/oj/dump.c
+- ext/oj/err.c
 - ext/oj/fast.c
-- ext/oj/load.c
+- ext/oj/hash.c
+- ext/oj/hash_test.c
+- ext/oj/object.c
+- ext/oj/odd.c
 - ext/oj/oj.c
+- ext/oj/parse.c
+- ext/oj/resolve.c
 - ext/oj/saj.c
+- ext/oj/scp.c
+- ext/oj/strict.c
+- ext/oj/val_stack.c
 - test/a.rb
 - test/bug.rb
 - test/files.rb
 - test/foo.rb
 - test/mj.rb
 - test/perf.rb
-- test/perf1.rb
-- test/perf2.rb
+- test/perf_compat.rb
 - test/perf_fast.rb
-- test/perf_obj.rb
-- test/perf_obj_old.rb
+- test/perf_object.rb
 - test/perf_saj.rb
+- test/perf_scp.rb
 - test/perf_simple.rb
 - test/perf_strict.rb
 - test/sample/change.rb
@@ -63,10 +80,14 @@ files:
 - test/sample/text.rb
 - test/sample.rb
 - test/sample_json.rb
+- test/test_compat.rb
 - test/test_fast.rb
 - test/test_mimic.rb
 - test/test_mimic_after.rb
+- test/test_object.rb
 - test/test_saj.rb
+- test/test_scp.rb
+- test/test_strict.rb
 - test/tests.rb
 - LICENSE
 - README.md
@@ -92,7 +113,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: oj
-rubygems_version: 2.0.0
+rubygems_version: 2.0.2
 signing_key: 
 specification_version: 4
 summary: A fast JSON parser and serializer.

data/ext/oj/cache.c

@@ -1,148 +0,0 @@
-/* cache.c
- * Copyright (c) 2011, Peter Ohler
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * 
- *  - Redistributions of source code must retain the above copyright notice, this
- *    list of conditions and the following disclaimer.
- * 
- *  - Redistributions in binary form must reproduce the above copyright notice,
- *    this list of conditions and the following disclaimer in the documentation
- *    and/or other materials provided with the distribution.
- * 
- *  - Neither the name of Peter Ohler nor the names of its contributors may be
- *    used to endorse or promote products derived from this software without
- *    specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <stdlib.h>
-#include <errno.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdarg.h>
-
-#include "cache.h"
-
-struct _Cache {
-    char                *key; // only set if the node has a value, and it is not an exact match
-    VALUE               value;
-    struct _Cache       *slots[16];
-};
-
-static void     slot_print(Cache cache, unsigned int depth);
-
-void
-oj_cache_new(Cache *cache) {
-    if (0 == (*cache = ALLOC(struct _Cache))) {
-        rb_raise(rb_eNoMemError, "not enough memory\n");
-    }
-    (*cache)->key = 0;
-    (*cache)->value = Qundef;
-    memset((*cache)->slots, 0, sizeof((*cache)->slots));
-}
-
-VALUE
-oj_cache_get(Cache cache, const char *key, VALUE **slot) {
-    unsigned char       *k = (unsigned char*)key;
-    Cache               *cp;
-
-    for (; '\0' != *k; k++) {
-        cp = cache->slots + (unsigned int)(*k >> 4); // upper 4 bits
-        if (0 == *cp) {
-            oj_cache_new(cp);
-        }
-        cache = *cp;
-        cp = cache->slots + (unsigned int)(*k & 0x0F); // lower 4 bits
-        if (0 == *cp) {
-            oj_cache_new(cp);
-            cache = *cp;
-            cache->key = ('\0' == *(k + 1)) ? 0 : strdup(key);
-            break;
-        } else {
-            cache = *cp;
-            if (Qundef != cache->value && 0 != cache->key) {
-                unsigned char   *ck = (unsigned char*)(cache->key + (unsigned int)(k - (unsigned char*)key + 1));
-
-                if (0 == strcmp((char*)ck, (char*)(k + 1))) {
-                    break;
-                } else {
-                    Cache     *cp2 = cp;
-
-                    // if value was set along with the key then there are no slots filled yet
-                    cp2 = (*cp2)->slots + (*ck >> 4);
-                    oj_cache_new(cp2);
-                    cp2 = (*cp2)->slots + (*ck & 0x0F);
-                    oj_cache_new(cp2);
-                    if ('\0' == *(ck + 1)) {
-                        xfree(cache->key);
-                    } else {
-                        (*cp2)->key = cache->key;
-                    }
-                    (*cp2)->value = cache->value;
-                    cache->key = 0;
-                    cache->value = Qundef;
-                }
-            }
-        }
-    }
-    *slot = &cache->value;
-
-    return cache->value;
-}
-
-void
-oj_cache_print(Cache cache) {
-    //printf("-------------------------------------------\n");
-    slot_print(cache, 0);
-}
-
-static void
-slot_print(Cache c, unsigned int depth) {
-    char                indent[256];
-    Cache               *cp;
-    unsigned int        i;
-
-    if (sizeof(indent) - 1 < depth) {
-        depth = ((int)sizeof(indent) - 1);
-    }
-    memset(indent, ' ', depth);
-    indent[depth] = '\0';
-    for (i = 0, cp = c->slots; i < 16; i++, cp++) {
-        if (0 == *cp) {
-            //printf("%s%02u:\n", indent, i);
-        } else {
-            if (0 == (*cp)->key && Qundef == (*cp)->value) {
-                printf("%s%02u:\n", indent, i);
-            } else {
-                const char      *key = (0 == (*cp)->key) ? "*" : (*cp)->key;
-                const char      *vs;
-                const char      *clas;
-
-                if (Qundef == (*cp)->value) {
-                    vs = "undefined";
-                    clas = "";
-                } else {
-                    VALUE       rs = rb_funcall2((*cp)->value, rb_intern("to_s"), 0, 0);
-
-                    vs = StringValuePtr(rs);
-                    clas = rb_class2name(rb_obj_class((*cp)->value));
-                }
-                printf("%s%02u: %s = %s (%s)\n", indent, i, key, vs, clas);
-            }
-            slot_print(*cp, depth + 2);
-        }
-    }
-}

data/ext/oj/load.c

@@ -1,1089 +0,0 @@
-/* load.c
- * Copyright (c) 2012, Peter Ohler
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * 
- *  - Redistributions of source code must retain the above copyright notice, this
- *    list of conditions and the following disclaimer.
- * 
- *  - Redistributions in binary form must reproduce the above copyright notice,
- *    this list of conditions and the following disclaimer in the documentation
- *    and/or other materials provided with the distribution.
- * 
- *  - Neither the name of Peter Ohler nor the names of its contributors may be
- *    used to endorse or promote products derived from this software without
- *    specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#if SAFE_CACHE
-#include <pthread.h>
-#endif
-#if !IS_WINDOWS
-#include <sys/resource.h>  // for getrlimit() on linux
-#endif
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <math.h>
-
-// Workaround in case INFINITY is not defined in math.h or if the OS is CentOS
-#define OJ_INFINITY (1.0/0.0)
-
-#include "oj.h"
-
-enum {
-    TIME_HINT = 0x0100,
-};
-
-typedef struct _CircArray {
-    VALUE		obj_array[1024];
-    VALUE		*objs;
-    unsigned long	size; // allocated size or initial array size
-    unsigned long	cnt;
-} *CircArray;
-
-typedef struct _ParseInfo {
-    char	*str;		/* buffer being read from */
-    char	*s;		/* current position in buffer */
-    CircArray	circ_array;
-    Options	options;
-    char	*stack_min;
-} *ParseInfo;
-
-static CircArray	circ_array_new(void);
-static void		circ_array_free(CircArray ca);
-static void		circ_array_set(CircArray ca, VALUE obj, unsigned long id);
-static VALUE		circ_array_get(CircArray ca, unsigned long id);
-
-static VALUE	classname2class(const char *name, ParseInfo pi);
-static VALUE	read_next(ParseInfo pi, int hint);
-static VALUE	read_obj(ParseInfo pi);
-static VALUE	read_array(ParseInfo pi, int hint);
-static VALUE	read_str(ParseInfo pi, int hint);
-static VALUE	read_num(ParseInfo pi);
-static VALUE	read_time(ParseInfo pi);
-static VALUE	read_true(ParseInfo pi);
-static VALUE	read_false(ParseInfo pi);
-static VALUE	read_nil(ParseInfo pi);
-static void	next_non_white(ParseInfo pi);
-static char*	read_quoted_value(ParseInfo pi);
-static void	skip_comment(ParseInfo pi);
-
-
-/* This JSON parser is a single pass, destructive, callback parser. It is a
- * single pass parse since it only make one pass over the characters in the
- * JSON document string. It is destructive because it re-uses the content of
- * the string for values in the callback and places \0 characters at various
- * places to mark the end of tokens and strings. It is a callback parser like
- * a SAX parser because it uses callback when document elements are
- * encountered.
- *
- * Parsing is very tolerant. Lack of headers and even mispelled element
- * endings are passed over without raising an error. A best attempt is made in
- * all cases to parse the string.
- */
-
-inline static void
-next_non_white(ParseInfo pi) {
-    for (; 1; pi->s++) {
-	switch(*pi->s) {
-	case ' ':
-	case '\t':
-	case '\f':
-	case '\n':
-	case '\r':
-	    break;
-	case '/':
-	    skip_comment(pi);
-	    break;
-	default:
-	    return;
-	}
-    }
-}
-
-inline static void
-next_white(ParseInfo pi) {
-    for (; 1; pi->s++) {
-	switch(*pi->s) {
-	case ' ':
-	case '\t':
-	case '\f':
-	case '\n':
-	case '\r':
-	case '\0':
-	    return;
-	default:
-	    break;
-	}
-    }
-}
-
-inline static VALUE
-resolve_classname(VALUE mod, const char *class_name, int auto_define) {
-    VALUE	clas;
-    ID		ci = rb_intern(class_name);
-
-    if (rb_const_defined_at(mod, ci)) {
-	clas = rb_const_get_at(mod, ci);
-    } else if (auto_define) {
-	clas = rb_define_class_under(mod, class_name, oj_bag_class);
-    } else {
-	clas = Qundef;
-    }
-    return clas;
-}
-
-inline static VALUE
-classname2obj(const char *name, ParseInfo pi) {
-    VALUE   clas = classname2class(name, pi);
-    
-    if (Qundef == clas) {
-	return Qnil;
-    } else {
-	return rb_obj_alloc(clas);
-    }
-}
-
-static VALUE
-resolve_classpath(const char *name, ParseInfo pi) {
-    char	class_name[1024];
-    VALUE	clas;
-    int		auto_define = (Yes == pi->options->auto_define);
-    char	*end = class_name + sizeof(class_name) - 1;
-    char	*s;
-    const char	*n = name;
-
-    clas = rb_cObject;
-    for (s = class_name; '\0' != *n; n++) {
-	if (':' == *n) {
-	    *s = '\0';
-	    n++;
-	    if (':' != *n) {
-		raise_error("Invalid classname, expected another ':'", pi->str, pi->s);
-	    }
-	    if (Qundef == (clas = resolve_classname(clas, class_name, auto_define))) {
-		char	buf[1024];
-
-		snprintf(buf, sizeof(buf) - 1, "Class %s not defined", class_name);
-		raise_error(buf, pi->str, pi->s);
-	    }
-	    s = class_name;
-	} else if (end <= s) {
-	    raise_error("Invalid classname, limit is 1024 characters", pi->str, pi->s);
-	} else {
-	    *s++ = *n;
-	}
-    }
-    *s = '\0';
-    return resolve_classname(clas, class_name, auto_define);
-}
-
-static VALUE
-classname2class(const char *name, ParseInfo pi) {
-    VALUE	clas;
-    VALUE	*slot;
-
-    if (No == pi->options->class_cache) {
-	return resolve_classpath(name, pi);
-    }
-#if SAFE_CACHE
-    pthread_mutex_lock(&oj_cache_mutex);
-#endif
-    if (Qundef == (clas = oj_cache_get(oj_class_cache, name, &slot))) {
-	if (Qundef != (clas = resolve_classpath(name, pi))) {
-	    *slot = clas;
-	}
-    }
-#if SAFE_CACHE
-    pthread_mutex_unlock(&oj_cache_mutex);
-#endif
-    return clas;
-}
-
-#if HAS_RSTRUCT
-inline static VALUE
-structname2obj(const char *name) {
-    VALUE	ost;
-
-    ost = rb_const_get(oj_struct_class, rb_intern(name));
-// use encoding as the indicator for Ruby 1.8.7 or 1.9.x
-#if HAS_ENCODING_SUPPORT
-    return rb_struct_alloc_noinit(ost);
-#else
-    return rb_struct_new(ost);
-#endif
-}
-#endif
-
-inline static unsigned long
-read_ulong(const char *s, ParseInfo pi) {
-    unsigned long	n = 0;
-
-    for (; '\0' != *s; s++) {
-	if ('0' <= *s && *s <= '9') {
-	    n = n * 10 + (*s - '0');
-	} else {
-	    raise_error("Not a valid ID number", pi->str, pi->s);
-	}
-    }
-    return n;
-}
-
-static CircArray
-circ_array_new() {
-    CircArray	ca;
-    
-    if (0 == (ca = ALLOC(struct _CircArray))) {
-	rb_raise(rb_eNoMemError, "not enough memory\n");
-    }
-    ca->objs = ca->obj_array;
-    ca->size = sizeof(ca->obj_array) / sizeof(VALUE);
-    ca->cnt = 0;
-    
-    return ca;
-}
-
-static void
-circ_array_free(CircArray ca) {
-    if (ca->objs != ca->obj_array) {
-	xfree(ca->objs);
-    }
-    xfree(ca);
-}
-
-static void
-circ_array_set(CircArray ca, VALUE obj, unsigned long id) {
-    if (0 < id && 0 != ca) {
-	unsigned long	i;
-
-	if (ca->size < id) {
-	    unsigned long	cnt = id + 512;
-
-	    if (ca->objs == ca->obj_array) {
-		if (0 == (ca->objs = ALLOC_N(VALUE, cnt))) {
-		    rb_raise(rb_eNoMemError, "not enough memory\n");
-		}
-		memcpy(ca->objs, ca->obj_array, sizeof(VALUE) * ca->cnt);
-	    } else { 
-		REALLOC_N(ca->objs, VALUE, cnt);
-	    }
-	    ca->size = cnt;
-	}
-	id--;
-	for (i = ca->cnt; i < id; i++) {
-	    ca->objs[i] = Qnil;
-	}
-	ca->objs[id] = obj;
-	if (ca->cnt <= id) {
-	    ca->cnt = id + 1;
-	}
-    }
-}
-
-static VALUE
-circ_array_get(CircArray ca, unsigned long id) {
-    VALUE	obj = Qnil;
-
-    if (id <= ca->cnt && 0 != ca) {
-	obj = ca->objs[id - 1];
-    }
-    return obj;
-}
-
-static void
-skip_comment(ParseInfo pi) {
-    pi->s++; // skip first /
-    if ('*' == *pi->s) {
-	pi->s++;
-	for (; '\0' != *pi->s; pi->s++) {
-	    if ('*' == *pi->s && '/' == *(pi->s + 1)) {
-		pi->s++;
-		return;
-	    } else if ('\0' == *pi->s) {
-		raise_error("comment not terminated", pi->str, pi->s);
-	    }
-	}
-    } else if ('/' == *pi->s) {
-	for (; 1; pi->s++) {
-	    switch (*pi->s) {
-	    case '\n':
-	    case '\r':
-	    case '\f':
-	    case '\0':
-		return;
-	    default:
-		break;
-	    }
-	}
-    } else {
-	raise_error("invalid comment", pi->str, pi->s);
-    }
-}
-
-static VALUE
-read_next(ParseInfo pi, int hint) {
-    VALUE	obj;
-
-    if ((char*)&obj < pi->stack_min) {
-	rb_raise(rb_eSysStackError, "JSON is too deeply nested");
-    }
-    next_non_white(pi);	// skip white space
-    switch (*pi->s) {
-    case '{':
-	obj = read_obj(pi);
-	break;
-    case '[':
-	obj = read_array(pi, hint);
-	break;
-    case '"':
-	obj = read_str(pi, hint);
-	break;
-    case '+':
-    case '-':
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9':
-	if (TIME_HINT == hint) {
-	    obj = read_time(pi);
-	} else {
-	    obj = read_num(pi);
-	}
-	break;
-    case 'I':
-	obj = read_num(pi);
-	break;
-    case 't':
-	obj = read_true(pi);
-	break;
-    case 'f':
-	obj = read_false(pi);
-	break;
-    case 'n':
-	obj = read_nil(pi);
-	break;
-    case '\0':
-	obj = Qundef;
-	break;
-    default:
-	obj = Qundef;
-	break;
-    }
-    return obj;
-}
-
-static VALUE
-read_obj(ParseInfo pi) {
-    VALUE	obj = Qundef;
-    VALUE	key = Qundef;
-    VALUE	val = Qundef;
-    const char	*ks;
-    int		obj_type = T_NONE;
-    const char	*json_class_name = 0;
-    Mode	mode = pi->options->mode;
-    Odd		odd = 0;
-    VALUE	odd_args[MAX_ODD_ARGS];
-    VALUE	*vp;
-    
-    pi->s++;
-    next_non_white(pi);
-    if ('}' == *pi->s) {
-	pi->s++;
-	return rb_hash_new();
-    }
-    while (1) {
-	next_non_white(pi);
-	ks = 0;
-	key = Qundef;
-	val = Qundef;
-	if ('"' != *pi->s || Qundef == (key = read_str(pi, 0))) {
-	    raise_error("unexpected character", pi->str, pi->s);
-	}
-	next_non_white(pi);
-	if (':' == *pi->s) {
-	    pi->s++;
-	} else {
-	    raise_error("invalid format, expected :", pi->str, pi->s);
-	}
-	if (T_STRING == rb_type(key)) {
-	    ks = StringValuePtr(key);
-	} else {
-	    ks = 0;
-	}
-	if (0 != ks && Qundef == obj && ObjectMode == mode) {
-	    if ('^' == *ks && '\0' == ks[2]) { // special directions
-		switch (ks[1]) {
-		case 't': // Time
-		    obj = read_next(pi, TIME_HINT); // raises if can not convert to Time
-		    key = Qundef;
-		    break;
-		case 'c': // Class
-		    obj = read_next(pi, T_CLASS);
-		    key = Qundef;
-		    break;
-		case 's': // String
-		    obj = read_next(pi, T_STRING);
-		    key = Qundef;
-		    break;
-		case 'm': // Symbol
-		    obj = read_next(pi, T_SYMBOL);
-		    key = Qundef;
-		    break;
-		case 'o': // Object
-		    obj = read_next(pi, T_OBJECT);
-		    obj_type = T_OBJECT;
-		    key = Qundef;
-		    break;
-		case 'O': // Odd class
-		    if (0 == (odd = oj_get_odd(read_next(pi, T_CLASS)))) {
-			raise_error("Not a valid build in class.", pi->str, pi->s);
-		    }
-		    obj = Qundef;
-		    key = Qundef;
-		    for (vp = odd_args + MAX_ODD_ARGS - 1; odd_args <=vp; vp--) {
-			*vp = Qnil;
-		    }
-		    break;
-		case 'u': // Struct
-		    obj = read_next(pi, T_STRUCT);
-		    obj_type = T_STRUCT;
-		    key = Qundef;
-		    break;
-		default:
-		    // handle later
-		    break;
-		}
-	    }
-	}
-	if (Qundef != key) {
-	    if (Qundef == val && Qundef == (val = read_next(pi, 0))) {
-		raise_error("unexpected character", pi->str, pi->s);
-	    }
-	    if (Qundef == obj && 0 == odd) {
-		obj = rb_hash_new();
-		obj_type = T_HASH;
-	    }
-	    if (ObjectMode == mode && 0 != ks && '^' == *ks) {
-		int	val_type = rb_type(val);
-
-		if ('i' == ks[1] && '\0' == ks[2] && T_FIXNUM == val_type) {
-		    circ_array_set(pi->circ_array, obj, NUM2ULONG(val));
-		    key = Qundef;
-		} else if ('#' == ks[1] &&
-		    (T_NONE == obj_type || T_HASH == obj_type) &&
-		    T_ARRAY == val_type && 2 == RARRAY_LEN(val)) {  // Hash entry
-		    VALUE	*np = RARRAY_PTR(val);
-
-		    key = *np;
-		    val = *(np + 1);
-		}
-	    }
-	    if (Qundef != key) {
-		if (0 != odd) {
-		    ID	*idp;
-
-		    for (idp = odd->attrs, vp = odd_args; 0 != *idp; idp++, vp++) {
-			if (0 == strcmp(rb_id2name(*idp), ks)) {
-			    *vp = val;
-			    break;
-			}
-		    }
-		    if (odd_args + MAX_ODD_ARGS <= vp) {
-			raise_error("invalid attribute", pi->str, pi->s);
-		    }
-		} else if (T_OBJECT == obj_type) {
-		    VALUE	*slot;
-		    ID		var_id;
-
-#if SAFE_CACHE
-		    pthread_mutex_lock(&oj_cache_mutex);
-#endif
-		    if (Qundef == (var_id = oj_cache_get(oj_attr_cache, ks, &slot))) {
-			char	attr[1024];
-
-			if ('~' == *ks) {
-			    strncpy(attr, ks + 1, sizeof(attr) - 1);
-			} else {
-			    *attr = '@';
-			    strncpy(attr + 1, ks, sizeof(attr) - 2);
-			}
-			attr[sizeof(attr) - 1] = '\0';
-			var_id = rb_intern(attr);
-			*slot = var_id;
-		    }
-#if SAFE_CACHE
-		    pthread_mutex_unlock(&oj_cache_mutex);
-#endif
-#if HAS_EXCEPTION_MAGIC
-		    if ('~' == *ks && Qtrue == rb_obj_is_kind_of(obj, rb_eException)) {
-			if (0 == strcmp("~mesg", ks)) {
-			    VALUE	args[1];
-
-			    args[0] = val;
-			    obj = rb_class_new_instance(1, args, rb_class_of(obj));
-			} else if (0 == strcmp("~bt", ks)) {
-			    rb_funcall(obj, rb_intern("set_backtrace"), 1, val);
-			}
-		    } else {
-			rb_ivar_set(obj, var_id, val);
-		    }
-#else
-		    rb_ivar_set(obj, var_id, val);
-#endif
-		} else if (T_HASH == obj_type) {
-		    if (Yes == pi->options->sym_key && T_STRING == rb_type(key)) {
-			rb_hash_aset(obj, rb_str_intern(key), val);
-		    } else {
-			rb_hash_aset(obj, key, val);
-		    }
-		    if ((CompatMode == mode || ObjectMode == mode) &&
-			0 == json_class_name && 0 != ks && 
-			0 != pi->options->create_id && *pi->options->create_id == *ks && 0 == strcmp(pi->options->create_id, ks) &&
-			T_STRING == rb_type(val)) {
-			json_class_name = StringValuePtr(val);
-		    }
-		} else {
-		    raise_error("invalid Object format, too many Hash entries.", pi->str, pi->s);
-		}
-	    }
-	}
-	next_non_white(pi);
-	if ('}' == *pi->s) {
-	    pi->s++;
-	    break;
-	} else if (',' == *pi->s) {
-	    pi->s++;
-	} else {
-	    //printf("*** '%s'\n", pi->s);
-	    raise_error("invalid format, expected , or } while in an object", pi->str, pi->s);
-	}
-    }
-    if (0 != odd) {
-	obj = rb_funcall2(odd->create_obj, odd->create_op, odd->attr_cnt, odd_args);
-    } else if (0 != json_class_name) {
-	VALUE	clas = classname2class(json_class_name, pi);
-	VALUE	args[1];
-
-	*args = obj;
-	obj = rb_funcall2(clas, oj_json_create_id, 1, args);
-    }
-    return obj;
-}
-
-static VALUE
-read_array(ParseInfo pi, int hint) {
-    VALUE	a = Qundef;
-    VALUE	e;
-    int		type = T_NONE;
-    int		cnt = 0;
-    int		a_str;
-#if HAS_RSTRUCT
-    long	slen = 0;
-#endif
-
-    pi->s++;
-    next_non_white(pi);
-    if (']' == *pi->s) {
-	pi->s++;
-	return rb_ary_new();
-    }
-    while (1) {
-	next_non_white(pi);
-	a_str = ('"' == *pi->s);
-	if (Qundef == (e = read_next(pi, 0))) {
-	    raise_error("unexpected character", pi->str, pi->s);
-	}
-#if HAS_RSTRUCT
-	if (Qundef == a && T_STRUCT == hint && T_STRING == rb_type(e)) {
-	    a = structname2obj(StringValuePtr(e));
-	    type = T_STRUCT;
-	    slen = RSTRUCT_LEN(a);
-	    e = Qundef;
-	}
-#endif
-	if (Qundef == a) {
-	    a = rb_ary_new();
-	    type = T_ARRAY;
-	}
-	if (a_str && T_FIXNUM == rb_type(e)) {
-	    circ_array_set(pi->circ_array, a, NUM2ULONG(e));
-	    e = Qundef;
-	}
-	if (Qundef != e) {
-	    if (T_STRUCT == type) {
-#if HAS_RSTRUCT
-		if (slen <= cnt) {
-		    raise_error("Too many elements for Struct", pi->str, pi->s);
-		}
-		RSTRUCT_PTR(a)[cnt] = e;
-#else
-		raise_error("Ruby structs not supported with this version of Ruby", pi->str, pi->s);
-#endif
-	    } else {
-		rb_ary_push(a, e);
-	    }
-	    cnt++;
-	}
-	next_non_white(pi);
-	if (',' == *pi->s) {
-	    pi->s++;
-	} else if (']' == *pi->s) {
-	    pi->s++;
-	    break;
-	} else {
-	    raise_error("invalid format, expected , or ] while in an array", pi->str, pi->s);
-	}
-    }
-    return a;
-}
-
-static VALUE
-read_str(ParseInfo pi, int hint) {
-    char	*text;
-    VALUE	obj;
-    int		escaped;
-
-    escaped = ('\\' == pi->s[1]);
-    text = read_quoted_value(pi);
-    if (ObjectMode != pi->options->mode) {
-	hint = T_STRING;
-    }
-    switch (hint) {
-    case T_CLASS:
-	obj = classname2class(text, pi);
-	break;
-    case T_OBJECT:
-	obj = classname2obj(text, pi);
-	break;
-    case T_STRING:
-	obj = rb_str_new2(text);
-#if HAS_ENCODING_SUPPORT
-	rb_enc_associate(obj, oj_utf8_encoding);
-#endif
-	break;
-    case T_SYMBOL:
-#if HAS_ENCODING_SUPPORT
-	obj = rb_str_new2(text);
-	rb_enc_associate(obj, oj_utf8_encoding);
-	obj = rb_funcall(obj, oj_to_sym_id, 0);
-#else
-	obj = ID2SYM(rb_intern(text));
-#endif
-	break;
-    case 0:
-    default:
-	obj = Qundef;
-	if (':' == *text && !escaped) { // Symbol
-#if HAS_ENCODING_SUPPORT
-	    obj = rb_str_new2(text + 1);
-	    rb_enc_associate(obj, oj_utf8_encoding);
-	    obj = rb_funcall(obj, oj_to_sym_id, 0);
-#else
-	    obj = ID2SYM(rb_intern(text + 1));
-#endif
-	} else if (ObjectMode == pi->options->mode && '^' == *text && '\0' != text[2]) {
-	    char	c1 = text[1];
-
-	    if ('r' == c1 && 0 != pi->circ_array) {
-		obj = circ_array_get(pi->circ_array, read_ulong(text + 2, pi));
-	    } else if ('i' == c1) {
-		obj = ULONG2NUM(read_ulong(text + 2, pi));
-	    }
-	}
-	if (Qundef == obj) {
-	    obj = rb_str_new2(text);
-#if HAS_ENCODING_SUPPORT
-	    rb_enc_associate(obj, oj_utf8_encoding);
-#endif
-	}
-	break;
-    }
-    return obj;
-}
-
-#ifdef RUBINIUS_RUBY
-#define NUM_MAX 0x07FFFFFF
-#else
-#define NUM_MAX (FIXNUM_MAX >> 8)
-#endif
-
-static VALUE
-read_num(ParseInfo pi) {
-    char	*start = pi->s;
-    int64_t	n = 0;
-    long	a = 0;
-    long	div = 1;
-    long	e = 0;
-    int		neg = 0;
-    int		eneg = 0;
-    int		big = 0;
-
-    if ('-' == *pi->s) {
-	pi->s++;
-	neg = 1;
-    } else if ('+' == *pi->s) {
-	pi->s++;
-    }
-    if ('I' == *pi->s) {
-	if (0 != strncmp("Infinity", pi->s, 8)) {
-	    raise_error("number or other value", pi->str, pi->s);
-	}
-	pi->s += 8;
-	if (Yes == pi->options->bigdec_load) {
-	    char	c = *pi->s;
-	    VALUE	num;
-
-	    *pi->s = '\0';
-	    num = rb_funcall(oj_bigdecimal_class, oj_new_id, 1, rb_str_new2(start));
-	    *pi->s = c;
-
-	    return num;
-	} else {
-	    if (neg) {
-		return rb_float_new(-OJ_INFINITY);
-	    } else {
-		return rb_float_new(OJ_INFINITY);
-	    }
-	}
-    }
-    for (; '0' <= *pi->s && *pi->s <= '9'; pi->s++) {
-	if (big) {
-	    big++;
-	} else {
-	    n = n * 10 + (*pi->s - '0');
-	    if (NUM_MAX <= n) {
-		big = 1;
-	    }
-	}
-    }
-    if ('.' == *pi->s) {
-	pi->s++;
-	for (; '0' <= *pi->s && *pi->s <= '9'; pi->s++) {
-	    a = a * 10 + (*pi->s - '0');
-	    div *= 10;
-	    if (NUM_MAX <= div) {
-		big = 1;
-	    }
-	}
-    }
-    if ('e' == *pi->s || 'E' == *pi->s) {
-	pi->s++;
-	if ('-' == *pi->s) {
-	    pi->s++;
-	    eneg = 1;
-	} else if ('+' == *pi->s) {
-	    pi->s++;
-	}
-	for (; '0' <= *pi->s && *pi->s <= '9'; pi->s++) {
-	    e = e * 10 + (*pi->s - '0');
-	    if (NUM_MAX <= e) {
-		big = 1;
-	    }
-	}
-    }
-    if (0 == e && 0 == a && 1 == div) {
-	if (big) {
-	    char	c = *pi->s;
-	    VALUE	num;
-	
-	    *pi->s = '\0';
-	    num = rb_cstr_to_inum(start, 10, 0);
-	    *pi->s = c;
-
-	    return num;
-	} else {
-	    if (neg) {
-		n = -n;
-	    }
-	    return LONG2NUM(n);
-	}
-    } else { // decimal
-	if (big || Yes == pi->options->bigdec_load) {
-	    char	c = *pi->s;
-	    VALUE	num;
-	
-	    *pi->s = '\0';
-	    num = rb_funcall(oj_bigdecimal_class, oj_new_id, 1, rb_str_new2(start));
-	    *pi->s = c;
-
-	    return num;
-	} else {
-	    double	d = (double)n + (double)a / (double)div;
-
-	    if (neg) {
-		d = -d;
-	    }
-	    if (1 < big) {
-		e += big - 1;
-	    }
-	    if (0 != e) {
-		if (eneg) {
-		    e = -e;
-		}
-		d *= pow(10.0, e);
-	    }
-	    return rb_float_new(d);
-	}
-    }
-}
-
-static VALUE
-read_time(ParseInfo pi) {
-    time_t	v = 0;
-    long	v2 = 0;
-    int		neg = 0;
-
-    if ('-' == *pi->s) {
-	pi->s++;
-	neg = 1;
-    }
-    for (; '0' <= *pi->s && *pi->s <= '9'; pi->s++) {
-	v = v * 10 + (*pi->s - '0');
-    }
-    if ('.' == *pi->s) {
-	int	cnt;
-
-	pi->s++;
-	for (cnt = 9; 0 < cnt && '0' <= *pi->s && *pi->s <= '9'; pi->s++, cnt--) {
-	    v2 = v2 * 10 + (*pi->s - '0');
-	}
-	for (; 0 < cnt; cnt--) {
-	    v2 *= 10;
-	}
-    }
-    if (neg) {
-	v = -v;
-	if (0 < v2) {
-	    v--;
-	    v2 = 1000000000 - v2;
-	}
-    }
-#if HAS_NANO_TIME
-    return rb_time_nano_new(v, v2);
-#else
-    return rb_time_new(v, v2 / 1000);
-#endif
-}
-
-static VALUE
-read_true(ParseInfo pi) {
-    pi->s++;
-    if ('r' != *pi->s || 'u' != *(pi->s + 1) || 'e' != *(pi->s + 2)) {
-	raise_error("invalid format, expected 'true'", pi->str, pi->s);
-    }
-    pi->s += 3;
-
-    return Qtrue;
-}
-
-static VALUE
-read_false(ParseInfo pi) {
-    pi->s++;
-    if ('a' != *pi->s || 'l' != *(pi->s + 1) || 's' != *(pi->s + 2) || 'e' != *(pi->s + 3)) {
-	raise_error("invalid format, expected 'false'", pi->str, pi->s);
-    }
-    pi->s += 4;
-
-    return Qfalse;
-}
-
-static VALUE
-read_nil(ParseInfo pi) {
-    pi->s++;
-    if ('u' != *pi->s || 'l' != *(pi->s + 1) || 'l' != *(pi->s + 2)) {
-	raise_error("invalid format, expected 'nil'", pi->str, pi->s);
-    }
-    pi->s += 3;
-
-    return Qnil;
-}
-
-static uint32_t
-read_hex(ParseInfo pi, char *h) {
-    uint32_t	b = 0;
-    int		i;
-
-    // TBD this can be made faster with a table
-    for (i = 0; i < 4; i++, h++) {
-	b = b << 4;
-	if ('0' <= *h && *h <= '9') {
-	    b += *h - '0';
-	} else if ('A' <= *h && *h <= 'F') {
-	    b += *h - 'A' + 10;
-	} else if ('a' <= *h && *h <= 'f') {
-	    b += *h - 'a' + 10;
-	} else {
-	    pi->s = h;
-	    raise_error("invalid hex character", pi->str, pi->s);
-	}
-    }
-    return b;
-}
-
-static char*
-unicode_to_chars(ParseInfo pi, char *t, uint32_t code) {
-    if (0x0000007F >= code) {
-	*t = (char)code;
-    } else if (0x000007FF >= code) {
-	*t++ = 0xC0 | (code >> 6);
-	*t = 0x80 | (0x3F & code);
-    } else if (0x0000FFFF >= code) {
-	*t++ = 0xE0 | (code >> 12);
-	*t++ = 0x80 | ((code >> 6) & 0x3F);
-	*t = 0x80 | (0x3F & code);
-    } else if (0x001FFFFF >= code) {
-	*t++ = 0xF0 | (code >> 18);
-	*t++ = 0x80 | ((code >> 12) & 0x3F);
-	*t++ = 0x80 | ((code >> 6) & 0x3F);
-	*t = 0x80 | (0x3F & code);
-    } else if (0x03FFFFFF >= code) {
-	*t++ = 0xF8 | (code >> 24);
-	*t++ = 0x80 | ((code >> 18) & 0x3F);
-	*t++ = 0x80 | ((code >> 12) & 0x3F);
-	*t++ = 0x80 | ((code >> 6) & 0x3F);
-	*t = 0x80 | (0x3F & code);
-    } else if (0x7FFFFFFF >= code) {
-	*t++ = 0xFC | (code >> 30);
-	*t++ = 0x80 | ((code >> 24) & 0x3F);
-	*t++ = 0x80 | ((code >> 18) & 0x3F);
-	*t++ = 0x80 | ((code >> 12) & 0x3F);
-	*t++ = 0x80 | ((code >> 6) & 0x3F);
-	*t = 0x80 | (0x3F & code);
-    } else {
-	raise_error("invalid Unicode", pi->str, pi->s);
-    }
-    return t;
-}
-
-/* Assume the value starts immediately and goes until the quote character is
- * reached again. Do not read the character after the terminating quote.
- */
-static char*
-read_quoted_value(ParseInfo pi) {
-    char	*value = 0;
-    char	*h = pi->s; // head
-    char	*t = h;	    // tail
-    uint32_t	code;
-    
-    h++;	// skip quote character
-    t++;
-    value = h;
-    for (; '"' != *h; h++, t++) {
-	if ('\0' == *h) {
-	    pi->s = h;
-	    raise_error("quoted string not terminated", pi->str, pi->s);
-	} else if ('\\' == *h) {
-	    h++;
-	    switch (*h) {
-	    case 'n':	*t = '\n';	break;
-	    case 'r':	*t = '\r';	break;
-	    case 't':	*t = '\t';	break;
-	    case 'f':	*t = '\f';	break;
-	    case 'b':	*t = '\b';	break;
-	    case '"':	*t = '"';	break;
-	    case '/':	*t = '/';	break;
-	    case '\\':	*t = '\\';	break;
-	    case 'u':
-		h++;
-		code = read_hex(pi, h);
-		h += 3;
-		if (0x0000D800 <= code && code <= 0x0000DFFF) {
-		    uint32_t	c1 = (code - 0x0000D800) & 0x000003FF;
-		    uint32_t	c2;
-
-		    h++;
-		    if ('\\' != *h || 'u' != *(h + 1)) {
-			pi->s = h;
-			raise_error("invalid escaped character", pi->str, pi->s);
-		    }
-		    h += 2;
-		    c2 = read_hex(pi, h);
-		    h += 3;
-		    c2 = (c2 - 0x0000DC00) & 0x000003FF;
-		    code = ((c1 << 10) | c2) + 0x00010000;
-		}
-		t = unicode_to_chars(pi, t, code);
-		break;
-	    default:
-		pi->s = h;
-		raise_error("invalid escaped character", pi->str, pi->s);
-		break;
-	    }
-	} else if (t != h) {
-	    *t = *h;
-	}
-    }
-    *t = '\0'; // terminate value
-    pi->s = h + 1;
-
-    return value;
-}
-
-VALUE
-oj_parse(char *json, Options options) {
-    VALUE		obj;
-    struct _ParseInfo	pi;
-
-    if (0 == json) {
-	raise_error("Invalid arg, xml string can not be null", json, 0);
-    }
-    /* skip UTF-8 BOM if present */
-    if (0xEF == (uint8_t)*json && 0xBB == (uint8_t)json[1] && 0xBF == (uint8_t)json[2]) {
-	json += 3;
-    }
-    /* initialize parse info */
-    pi.str = json;
-    pi.s = json;
-    pi.circ_array = 0;
-    if (Yes == options->circular) {
-	pi.circ_array = circ_array_new();
-    }
-    pi.options = options;
-#if IS_WINDOWS
-    pi.stack_min = (char*)&obj - (512 * 1024); // assume a 1M stack and give half to ruby
-#else
-    {
-	struct rlimit	lim;
-
-	// When run under make on linux the limit is not reported corrected and is infinity even though
-	// the return code indicates no error. That forces the rlim_cur value as well as the return code.
-	if (0 == getrlimit(RLIMIT_STACK, &lim) && RLIM_INFINITY != lim.rlim_cur) {
-	    pi.stack_min = (void*)((char*)&obj - (lim.rlim_cur / 4 * 3)); // let 3/4ths of the stack be used only
-	} else {
-	    pi.stack_min = 0; // indicates not to check stack limit
-	}
-    }
-#endif
-    obj = read_next(&pi, 0);
-    if (Yes == options->circular) {
-	circ_array_free(pi.circ_array);
-    }
-    if (Qundef == obj) {
-	raise_error("no object read", pi.str, pi.s);
-    }
-    next_non_white(&pi);
-    if ('\0' != *pi.s) {
-	raise_error("invalid format, extra characters", pi.str, pi.s);
-    }
-    return obj;
-}