oj 0.5

data/LICENSE

@@ -0,0 +1,27 @@
+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.

data/README.md

@@ -0,0 +1,58 @@
+# Oj gem
+A fast JSON parser and Object marshaller as a Ruby gem.
+
+## <a name="installation">Installation</a>
+    gem install oj
+
+## <a name="source">Source</a>
+
+*GitHub* *repo*: https://github.com/ohler55/oj
+
+*RubyGems* *repo*: https://rubygems.org/gems/oj
+
+## <a name="build_status">Build Status</a>
+
+[![Build Status](http://travis-ci.org/ohler55/oj.png)](http://travis-ci.org/ohler55/oj)
+
+## <a name="links">Links of Interest</a>
+
+## <a name="release">Release Notes</a>
+
+### Release 0.5
+
+This is the first release sith a version of 0.5 indicating it is only half
+done. Basic load() and dump() is supported for Hash, Array, NilClass,
+TrueClass, FalseClass, Fixnum, Float, Symbol, and String Objects.
+
+## <a name="description">Description</a>
+
+Optimized JSON (Oj), as the name implies was written to provide speed
+optimized JSON handling. It was designed as a faster alternative to Yajl and
+other the common Ruby JSON parsers. So far is has achieved that at about 2
+time faster than Yajl for parsing and 3 or more times faster writing JSON.
+
+Coming soon: As an Object marshaller with support for circular references.
+
+Coming soon: A SAX like JSON stream parser.
+
+Oj is compatible with Ruby 1.8.7, 1.9.2, 1.9.3, JRuby, and RBX.
+
+### Simple JSON Writing and Parsing:
+
+    require 'oj'
+    
+    h = { 'one' => 1, 'array' => [ true, false ] }
+    json = Oj.dump(h)
+    
+    # json =
+    # {
+    #   "one":1,
+    #   "array":[
+    #     true,
+    #     false
+    #   ]
+    # }
+
+    h2 = Oj.parse(json)
+    puts "Same? #{h == h2}"
+    # true

data/ext/oj/dump.c

@@ -0,0 +1,484 @@
+/* dump.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.
+ */
+
+#include <stdlib.h>
+#include <errno.h>
+#include <time.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "ruby.h"
+#include "oj.h"
+
+typedef unsigned long   ulong;
+
+typedef struct _Str {
+    const char  *str;
+    size_t      len;
+} *Str;
+
+typedef struct _Element {
+    struct _Str         clas;
+    struct _Str         attr;
+    unsigned long       id;
+    int                 indent; // < 0 indicates no \n
+    int                 closed;
+    char                type;
+} *Element;
+
+typedef struct _Out {
+    void                (*w_start)(struct _Out *out, Element e);
+    void                (*w_end)(struct _Out *out, Element e);
+    void                (*w_time)(struct _Out *out, VALUE obj);
+    char                *buf;
+    char                *end;
+    char                *cur;
+//    Cache8              circ_cache;
+//    unsigned long       circ_cnt;
+    int                 indent;
+    int                 depth; // used by dumpHash
+    Options             opts;
+    VALUE		obj;
+} *Out;
+
+static void     dump_obj_to_json(VALUE obj, Options copts, Out out);
+static void	dump_val(VALUE obj, int depth, Out out);
+static void	dump_nil(Out out);
+static void	dump_true(Out out);
+static void	dump_false(Out out);
+static void	dump_fixnum(VALUE obj, Out out);
+static void	dump_float(VALUE obj, Out out);
+static void	dump_cstr(const char *str, int cnt, Out out);
+static void	dump_hex(u_char c, Out out);
+static void	dump_str(VALUE obj, Out out);
+static void	dump_sym(VALUE obj, Out out);
+static void	dump_array(VALUE obj, int depth, Out out);
+static void	dump_hash(VALUE obj, int depth, Out out);
+
+static void     grow(Out out, size_t len);
+static int      is_json_friendly(const u_char *str, int len);
+static int	json_friendly_size(const u_char *str, int len);
+
+
+static char     json_friendly_chars[256] = "\
+uuuuuuuuxxxuxxuuuuuuuuuuuuuuuuuu\
+ooxooooooooooooxoooooooooooooooo\
+ooooooooooooooooooooooooooooxooo\
+ooooooooooooooooooooooooooooooou\
+uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu\
+uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu\
+uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu\
+uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu";
+
+inline static int
+is_json_friendly(const u_char *str, int len) {
+    for (; 0 < len; str++, len--) {
+        if ('o' != json_friendly_chars[*str]) {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+inline static int
+json_friendly_size(const u_char *str, int len) {
+    int		cnt = 0;
+    
+    for (; 0 < len; str++, len--) {
+	switch (json_friendly_chars[*str]) {
+	case 'o':	cnt++;		break;
+	case 'x':	cnt += 2;	break;
+	case 'u':	cnt += 6;	break;
+	default:			break;
+	}
+    }
+    return cnt;
+}
+
+inline static void
+fill_indent(Out out, int cnt) {
+    cnt *= out->indent;
+    if (0 <= cnt) {
+        *out->cur++ = '\n';
+        for (; 0 < cnt; cnt--) {
+            *out->cur++ = ' ';
+        }
+    }
+}
+
+static void
+grow(Out out, size_t len) {
+    size_t  size = out->end - out->buf;
+    long    pos = out->cur - out->buf;
+    char    *buf;
+        
+    size *= 2;
+    if (size <= len * 2 + pos) {
+        size += len;
+    }
+    if (0 == (buf = (char*)realloc(out->buf, size + 10))) { // 1 extra for terminator character plus extra (paranoid)
+        rb_raise(rb_eNoMemError, "Failed to create string. [%d:%s]\n", ENOSPC, strerror(ENOSPC));
+    }
+    out->buf = buf;
+    out->end = buf + size;
+    out->cur = out->buf + pos;
+}
+
+inline static void
+dump_hex(u_char c, Out out) {
+    u_char	d = c & 0xF0;
+
+    if (9 < d) {
+	*out->cur++ = (d - 10) + 'a';
+    } else {
+	*out->cur++ = d + '0';
+    }
+    d = c & 0x0F;
+    if (9 < d) {
+	*out->cur++ = (d - 10) + 'a';
+    } else {
+	*out->cur++ = d + '0';
+    }
+}
+
+static void
+dump_nil(Out out) {
+    size_t      size = 4;
+
+    if (out->end - out->cur <= (long)size) {
+        grow(out, size);
+    }
+    *out->cur++ = 'n';
+    *out->cur++ = 'u';
+    *out->cur++ = 'l';
+    *out->cur++ = 'l';
+    *out->cur = '\0';
+}
+
+static void
+dump_true(Out out) {
+    size_t      size = 4;
+
+    if (out->end - out->cur <= (long)size) {
+        grow(out, size);
+    }
+    *out->cur++ = 't';
+    *out->cur++ = 'r';
+    *out->cur++ = 'u';
+    *out->cur++ = 'e';
+    *out->cur = '\0';
+}
+
+static void
+dump_false(Out out) {
+    size_t      size = 5;
+
+    if (out->end - out->cur <= (long)size) {
+        grow(out, size);
+    }
+    *out->cur++ = 'f';
+    *out->cur++ = 'a';
+    *out->cur++ = 'l';
+    *out->cur++ = 's';
+    *out->cur++ = 'e';
+    *out->cur = '\0';
+}
+
+static void
+dump_fixnum(VALUE obj, Out out) {
+    char        buf[32];
+    char        *b = buf + sizeof(buf) - 1;
+    long        num = NUM2LONG(obj);
+    int         neg = 0;
+
+    if (0 > num) {
+        neg = 1;
+        num = -num;
+    }
+    *b-- = '\0';
+    if (0 < num) {
+        for (; 0 < num; num /= 10, b--) {
+            *b = (num % 10) + '0';
+        }
+        if (neg) {
+            *b = '-';
+        } else {
+            b++;
+        }
+    } else {
+        *b = '0';
+    }
+    if (out->end - out->cur <= (long)(sizeof(buf) - (b - buf))) {
+        grow(out, sizeof(buf) - (b - buf));
+    }
+    for (; '\0' != *b; b++) {
+        *out->cur++ = *b;
+    }
+    *out->cur = '\0';
+}
+
+static void
+dump_float(VALUE obj, Out out) {
+    char	buf[64];
+    char	*b;
+    int		cnt = sprintf(buf, "%0.16g", RFLOAT_VALUE(obj)); // used sprintf due to bug in snprintf
+
+    if (out->end - out->cur <= (long)cnt) {
+        grow(out, cnt);
+    }
+    for (b = buf; '\0' != *b; b++) {
+        *out->cur++ = *b;
+    }
+    *out->cur = '\0';
+}
+
+static void
+dump_cstr(const char *str, int cnt, Out out) {
+    int	size = json_friendly_size((u_char*)str, cnt);
+    
+    if (cnt == size) {
+	cnt += 2;
+	if (out->end - out->cur <= (long)cnt) {
+	    grow(out, cnt);
+	}
+	*out->cur++ = '"';
+	for (; '\0' != *str; str++) {
+	    *out->cur++ = *str;
+	}
+	*out->cur++ = '"';
+    } else {
+	size += 2;
+	if (out->end - out->cur <= (long)size) {
+	    grow(out, size);
+	}
+	*out->cur++ = '"';
+	for (; 0 < cnt; cnt--, str++) {
+	    switch (json_friendly_chars[(u_char)*str]) {
+	    case 'o':
+		*out->cur++ = *str;
+		break;
+	    case 'x':
+		*out->cur++ = '\\';
+		switch (*str) {
+		case '\b':	*out->cur++ = 'b';	break;
+		case '\t':	*out->cur++ = 't';	break;
+		case '\n':	*out->cur++ = 'n';	break;
+		case '\f':	*out->cur++ = 'f';	break;
+		case '\r':	*out->cur++ = 'r';	break;
+		default:	*out->cur++ = *str;	break;
+		}
+		break;
+	    case 'u':
+		*out->cur++ = '\\';
+		*out->cur++ = 'u';
+		if ((u_char)*str <= 0x7F) {
+		    *out->cur++ = '0';
+		    *out->cur++ = '0';
+		    dump_hex((u_char)*str, out);
+		} else { // continuation?
+		    // TBD lead with \u00 . grab next char?
+		    *out->cur++ = '0';
+		    *out->cur++ = '0';
+		    dump_hex((u_char)*str, out);
+		}
+		break;
+	    default:
+		break; // ignore, should never happen if the table is correct
+	    }
+	}
+	*out->cur++ = '"';
+    }
+    *out->cur = '\0';
+}
+
+static void
+dump_str(VALUE obj, Out out) {
+    dump_cstr(StringValuePtr(obj), (int)RSTRING_LEN(obj), out);
+}
+
+static void
+dump_sym(VALUE obj, Out out) {
+    const char	*sym = rb_id2name(SYM2ID(obj));
+    
+    dump_cstr(sym, (int)strlen(sym), out);
+}
+
+static void
+dump_array(VALUE a, int depth, Out out) {
+    VALUE       *np = RARRAY_PTR(a);
+    size_t      size = 2;
+    int		cnt = (int)RARRAY_LEN(a);
+    int		d2 = depth + 1;
+    
+    if (out->end - out->cur <= (long)size) {
+        grow(out, size);
+    }
+    *out->cur++ = '[';
+    if (0 == cnt) {
+	*out->cur++ = ']';
+    } else {
+	size = d2 * out->indent + 2;
+	for (; 0 < cnt; cnt--, np++) {
+	    if (out->end - out->cur <= (long)size) {
+		grow(out, size);
+	    }
+	    fill_indent(out, d2);
+	    dump_val(*np, d2, out);
+	    if (1 < cnt) {
+		// TBD check size?
+		*out->cur++ = ',';
+	    }
+	}
+	size = depth * out->indent + 1;
+	if (out->end - out->cur <= (long)size) {
+	    grow(out, size);
+	}
+	fill_indent(out, depth);
+	*out->cur++ = ']';
+    }
+    *out->cur = '\0';
+}
+
+static int
+hash_cb(VALUE key, VALUE value, Out out) {
+    int		depth = out->depth;
+    size_t	size = depth * out->indent + 1;
+
+    if (out->end - out->cur <= (long)size) {
+	grow(out, size);
+    }
+    fill_indent(out, depth);
+    dump_str(key, out);
+    *out->cur++ = ':';
+    dump_val(value, depth, out);
+    out->depth = depth;
+    *out->cur++ = ',';
+    
+    return ST_CONTINUE;
+}
+
+static void
+dump_hash(VALUE obj, int depth, Out out) {
+    int	cnt = (int)RHASH_SIZE(obj);
+
+    *out->cur++ = '{';
+    if (0 == cnt) {
+	*out->cur++ = '}';
+    } else {
+	size_t	size = depth * out->indent + 2;
+
+	out->depth = depth + 1;
+	rb_hash_foreach(obj, hash_cb, (VALUE)out);
+	out->cur--; // backup to overwrite last comma
+	if (out->end - out->cur <= (long)size) {
+	    grow(out, size);
+	}
+	fill_indent(out, depth);
+	*out->cur++ = '}';
+    }
+    *out->cur = '\0';
+}
+
+static void
+dump_val(VALUE obj, int depth, Out out) {
+    switch (rb_type(obj)) {
+    case T_NIL:		dump_nil(out);			break;
+    case T_TRUE:	dump_true(out);			break;
+    case T_FALSE:	dump_false(out);		break;
+    case T_FIXNUM:	dump_fixnum(obj, out);		break;
+    case T_FLOAT:	dump_float(obj, out);		break;
+    case T_BIGNUM:	break; // TBD
+    case T_STRING:	dump_str(obj, out);		break;
+    case T_SYMBOL:	dump_sym(obj, out);		break;
+    case T_ARRAY:	dump_array(obj, depth, out);	break;
+    case T_HASH:	dump_hash(obj, depth, out);	break;
+    case T_OBJECT:
+    case T_REGEXP:
+    case T_CLASS:
+    case T_DATA: // for Time
+	// TBD
+	rb_raise(rb_eNotImpError, "Failed to dump '%s' Object (%02x)\n",
+		 rb_class2name(rb_obj_class(obj)), rb_type(obj));
+	break;
+    default:
+	rb_raise(rb_eNotImpError, "Failed to dump '%s' Object (%02x)\n",
+		 rb_class2name(rb_obj_class(obj)), rb_type(obj));
+	break;
+    }
+}
+
+static void
+dump_obj_to_json(VALUE obj, Options copts, Out out) {
+    out->buf = (char*)malloc(65336);
+    out->end = out->buf + 65325; // 1 less than end plus extra for possible errors
+    out->cur = out->buf;
+//    out->circ_cache = 0;
+//    out->circ_cnt = 0;
+    out->opts = copts;
+    out->obj = obj;
+/*    if (Yes == copts->circular) {
+        ox_cache8_new(&out->circ_cache);
+	}*/
+    out->indent = copts->indent;
+    out->indent = 2; // TBD
+    dump_val(obj, 0, out);
+    
+/*    if (Yes == copts->circular) {
+        ox_cache8_delete(out->circ_cache);
+	}*/
+}
+
+char*
+write_obj_to_str(VALUE obj, Options copts) {
+    struct _Out out;
+
+    dump_obj_to_json(obj, copts, &out);
+
+    return out.buf;
+}
+
+void
+write_obj_to_file(VALUE obj, const char *path, Options copts) {
+    struct _Out out;
+    size_t      size;
+    FILE        *f;    
+
+    dump_obj_to_json(obj, copts, &out);
+    size = out.cur - out.buf;
+    if (0 == (f = fopen(path, "w"))) {
+        rb_raise(rb_eIOError, "%s\n", strerror(errno));
+    }
+    if (size != fwrite(out.buf, 1, size, f)) {
+        int err = ferror(f);
+        rb_raise(rb_eIOError, "Write failed. [%d:%s]\n", err, strerror(err));
+    }
+    free(out.buf);
+    fclose(f);
+}

data/ext/oj/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+
+$CPPFLAGS += ' -Wall'
+#puts "*** $CPPFLAGS: #{$CPPFLAGS}"
+extension_name = 'oj'
+dir_config(extension_name)
+create_makefile(extension_name)

data/ext/oj/load.c

@@ -0,0 +1,426 @@
+/* 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.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+#include "ruby.h"
+#include "oj.h"
+
+typedef struct _ParseInfo {
+    char	*str;		/* buffer being read from */
+    char	*s;		/* current position in buffer */
+#ifdef HAVE_RUBY_ENCODING_H
+    rb_encoding	*encoding;
+#else
+    void	*encoding;
+#endif
+    int		trace;
+} *ParseInfo;
+
+static VALUE	read_next(ParseInfo pi);
+static VALUE	read_obj(ParseInfo pi);
+static VALUE	read_array(ParseInfo pi);
+static VALUE	read_str(ParseInfo pi);
+static VALUE	read_num(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);
+
+
+/* This XML 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
+ * XML 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;
+	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;
+	}
+    }
+}
+
+VALUE
+parse(char *json, int trace) {
+    VALUE		obj;
+    struct _ParseInfo	pi;
+
+    if (0 == json) {
+	raise_error("Invalid arg, xml string can not be null", json, 0);
+    }
+    if (trace) {
+	printf("Parsing JSON:\n%s\n", json);
+    }
+    /* initialize parse info */
+    pi.str = json;
+    pi.s = json;
+    pi.encoding = 0;
+    pi.trace = trace;
+    if (Qundef == (obj = read_next(&pi))) {
+	raise_error("no object read", pi.str, pi.s);
+    }
+    next_non_white(&pi);	// skip white space
+    if ('\0' != *pi.s) {
+	raise_error("invalid format, extra characters", pi.str, pi.s);
+    }
+    return obj;
+}
+
+static VALUE
+read_next(ParseInfo pi) {
+    VALUE	obj;
+
+    next_non_white(pi);	// skip white space
+    switch (*pi->s) {
+    case '{':
+	obj = read_obj(pi);
+	break;
+    case '[':
+	obj = read_array(pi);
+	break;
+    case '"':
+	obj = read_str(pi);
+	break;
+    case '+':
+    case '-':
+    case '0':
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+    case '8':
+    case '9':
+	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;
+    
+    pi->s++;
+    while (1) {
+	next_non_white(pi);
+	if ('"' != *pi->s || Qundef == (key = read_str(pi))) {
+	    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 (Qundef == (val = read_next(pi))) {
+	    raise_error("unexpected character", pi->str, pi->s);
+	}
+	if (Qundef == obj) {
+	    obj = rb_hash_new();
+	}
+	rb_hash_aset(obj, key, val);
+	next_non_white(pi);
+	if ('}' == *pi->s) {
+	    pi->s++;
+	    break;
+	} else if (',' == *pi->s) {
+	    pi->s++;
+	} else {
+	    raise_error("invalid format, expected , or } while in an object", pi->str, pi->s);
+	}
+    }
+    return obj;
+}
+
+static VALUE
+read_array(ParseInfo pi) {
+    VALUE	a = rb_ary_new();
+    VALUE	e;
+
+    pi->s++;
+    while (1) {
+	if (Qundef == (e = read_next(pi))) {
+	    raise_error("unexpected character", pi->str, pi->s);
+	}
+        rb_ary_push(a, e);
+	next_non_white(pi);	// skip white space
+	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) {
+    char	*text = read_quoted_value(pi);
+    VALUE	s = rb_str_new2(text);
+
+#ifdef HAVE_RUBY_ENCODING_H
+    if (0 != pi->encoding) {
+        rb_enc_associate(s, pi->encoding);
+    }
+#endif
+    return s;
+}
+
+static VALUE
+read_num(ParseInfo pi) {
+    int64_t	n = 0;
+    long	a = 0;
+    long	div = 1;
+    long	e = 0;
+    int		neg = 0;
+    int		eneg = 0;
+
+    if ('-' == *pi->s) {
+	pi->s++;
+	neg = 1;
+    } else if ('+' == *pi->s) {
+	pi->s++;
+    }
+    for (; '0' <= *pi->s && *pi->s <= '9'; pi->s++) {
+	n = n * 10 + (*pi->s - '0');
+    }
+    if ('.' == *pi->s) {
+	pi->s++;
+	for (; '0' <= *pi->s && *pi->s <= '9'; pi->s++) {
+	    a = a * 10 + (*pi->s - '0');
+	    div *= 10;
+	}
+    }
+    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 (neg) {
+	n = -n;
+    }
+    if (0 == e && 0 == a && 1 == div) {
+	return LONG2NUM(n);
+    } else {
+	double	d = (double)n + (double)a / (double)div;
+
+	if (0 != e) {
+	    if (eneg) {
+		e = -e;
+	    }
+	    d *= pow(10.0, e);
+	}
+	return DBL2NUM(d);
+    }
+}
+
+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 char
+read_hex(ParseInfo pi, char *h) {
+    uint8_t	b = 0;
+
+    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);
+    }
+    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 (char)b;
+}
+
+/* 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
+    
+    h++;	// skip quote character
+    t++;
+    value = h;
+    // TBD can whole string be read in and then eval-ed by ruby of there is a special character
+    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':
+		// TBD if first character is 00 then skip it
+		h++;
+		*t = read_hex(pi, h);
+		h += 2;
+		if ('\0' != *t) {
+		    t++;
+		}
+		*t = read_hex(pi, h);
+		h++;
+		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;
+}

data/ext/oj/oj.c

@@ -0,0 +1,157 @@
+/* oj.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 "ruby.h"
+#include "oj.h"
+
+struct _Options  default_options = {
+    { '\0' },           // encoding
+    2,                  // indent
+    0,                  // trace
+    No,                 // circular
+    NoMode,             // mode
+//    StrictEffort,       // effort
+};
+
+void Init_oj();
+
+VALUE    Oj = Qnil;
+
+static VALUE
+load(char *json, int argc, VALUE *argv, VALUE self) {
+    VALUE	obj;
+
+    // TBD other options like obj mode
+    obj = parse(json, 0);
+    free(json);
+
+    return obj;
+}
+
+/* call-seq: load(xml, options) => Hash, Array, String, Fixnum, Float, true, false, or nil
+ *
+ * Parses a JSON document String into a Hash, Array, String, Fixnum, Float,
+ * true, false, or nil Raises an exception if the JSON is * malformed or the
+ * classes specified are not valid.
+ * @param [String] json JSON String
+ * @param [Hash] options load options
+ */
+static VALUE
+load_str(int argc, VALUE *argv, VALUE self) {
+    char        *json;
+    
+    Check_Type(*argv, T_STRING);
+    // the xml string gets modified so make a copy of it
+    json = strdup(StringValuePtr(*argv));
+
+    return load(json, argc - 1, argv + 1, self);
+}
+
+static VALUE
+load_file(int argc, VALUE *argv, VALUE self) {
+    char                *path;
+    char                *json;
+    FILE                *f;
+    unsigned long       len;
+    
+    Check_Type(*argv, T_STRING);
+    path = StringValuePtr(*argv);
+    if (0 == (f = fopen(path, "r"))) {
+        rb_raise(rb_eIOError, "%s\n", strerror(errno));
+    }
+    fseek(f, 0, SEEK_END);
+    len = ftell(f);
+    if (0 == (json = malloc(len + 1))) {
+        fclose(f);
+        rb_raise(rb_eNoMemError, "Could not allocate memory for %ld byte file.\n", len);
+    }
+    fseek(f, 0, SEEK_SET);
+    if (len != fread(json, 1, len, f)) {
+        fclose(f);
+        rb_raise(rb_eLoadError, "Failed to read %ld bytes from %s.\n", len, path);
+    }
+    fclose(f);
+    json[len] = '\0';
+
+    return load(json, argc - 1, argv + 1, self);
+}
+
+static VALUE
+dump(int argc, VALUE *argv, VALUE self) {
+    char                *json;
+    struct _Options     copts = default_options;
+    VALUE               rstr;
+    
+    if (2 == argc) {
+        //parse_dump_options(argv[1], &copts);
+    }
+    if (0 == (json = write_obj_to_str(*argv, &copts))) {
+        rb_raise(rb_eNoMemError, "Not enough memory.\n");
+    }
+    rstr = rb_str_new2(json);
+#ifdef ENCODING_INLINE_MAX
+    if ('\0' != *copts.encoding) {
+        rb_enc_associate(rstr, rb_enc_find(copts.encoding));
+    }
+#endif
+    free(json);
+
+    return rstr;
+}
+
+void Init_oj() {
+
+    Oj = rb_define_module("Oj");
+
+    rb_define_module_function(Oj, "load", load_str, -1);
+    rb_define_module_function(Oj, "load_file", load_file, -1);
+    rb_define_module_function(Oj, "dump", dump, -1);
+}
+
+void
+_raise_error(const char *msg, const char *xml, const char *current, const char* file, int line) {
+    int         xline = 1;
+    int         col = 1;
+
+    for (; xml < current && '\n' != *current; current--) {
+        col++;
+    }
+    for (; xml < current; current--) {
+        if ('\n' == *current) {
+            xline++;
+        }
+    }
+    rb_raise(rb_eSyntaxError, "%s at line %d, column %d [%s:%d]\n", msg, xline, col, file, line);
+}

data/ext/oj/oj.h

@@ -0,0 +1,98 @@
+/* oj.h
+ * 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.
+ */
+
+#ifndef __OJ_H__
+#define __OJ_H__
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+#include "ruby.h"
+#ifdef HAVE_RUBY_ENCODING_H
+// HAVE_RUBY_ENCODING_H defined for Ruby 1.9
+#include "ruby/encoding.h"
+#endif
+
+#ifdef JRUBY
+#define NO_RSTRUCT 1
+#endif
+
+#if (defined RBX_Qnil && !defined RUBINIUS)
+#define RUBINIUS
+#endif
+
+#ifdef RUBINIUS
+#undef T_RATIONAL
+#undef T_COMPLEX
+#define NO_RSTRUCT 1
+#endif
+
+#define raise_error(msg, xml, current) _raise_error(msg, xml, current, __FILE__, __LINE__)
+
+typedef enum {
+    Yes    = 'y',
+    No     = 'n',
+    NotSet = 0
+} YesNo;
+
+typedef enum {
+    ObjMode  = 'o',
+    GenMode  = 'g',
+    NoMode   = 0
+} LoadMode;
+
+typedef struct _Options {
+    char        encoding[64];   // encoding, stored in the option to avoid GC invalidation in default values
+    int         indent;         // indention for dump, default 2
+    int         trace;          // trace level
+    char        circular;       // YesNo
+    char        mode;           // LoadMode
+    char        effort;         // Effort
+} *Options;
+
+extern VALUE    parse(char *json, int trace);
+extern char*	write_obj_to_str(VALUE obj, Options copts);
+
+extern void     _raise_error(const char *msg, const char *xml, const char *current, const char* file, int line);
+
+
+extern VALUE    Oj;
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+#endif /* __OJ_H__ */

data/lib/oj.rb

@@ -0,0 +1,36 @@
+# Copyright (c) 2011, Peter Ohler<br>
+# 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.
+
+module Oj
+  private
+  @@keep = []
+end
+
+#require 'ox/version'
+
+require 'oj/oj' # C extension

data/lib/oj/version.rb

@@ -0,0 +1,5 @@
+
+module Oj
+  # Current version of the module. 
+  VERSION = '0.5'
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: oj
+version: !ruby/object:Gem::Version
+  version: '0.5'
+  prerelease: 
+platform: ruby
+authors:
+- Peter Ohler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-19 00:00:00.000000000 Z
+dependencies: []
+description: ! "A fast JSON parser and object serializer that uses only standard C
+  lib.\n            \nOptimized JSON (Oj), as the name implies was written to provide
+  speed optimized\nJSON handling. It was designed to be an alternative to Yajl and
+  other Ruby\nJSON parsers and as an alternative to Marshal for Object serialization. "
+email: peter@ohler.com
+executables: []
+extensions:
+- ext/oj/extconf.rb
+extra_rdoc_files:
+- README.md
+files:
+- lib/oj/version.rb
+- lib/oj.rb
+- ext/oj/extconf.rb
+- ext/oj/oj.h
+- ext/oj/dump.c
+- ext/oj/load.c
+- ext/oj/oj.c
+- LICENSE
+- README.md
+homepage: https://github.com/ohler55/oj
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+- README.md
+require_paths:
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: oj
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: A fast JSON parser and serializer.
+test_files: []