oj 3.11.3 → 3.11.8

data/ext/oj/resolve.c

@@ -1,76 +1,76 @@
 // 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>
 #ifdef HAVE_PTHREAD_MUTEX_INIT
 #include <pthread.h>
 #endif
 
-#include "oj.h"
 #include "err.h"
-#include "parse.h"
 #include "hash.h"
+#include "oj.h"
+#include "parse.h"
 
-inline static VALUE
-resolve_classname(VALUE mod, const char *classname, int auto_define) {
-    VALUE	clas;
-    ID		ci = rb_intern(classname);
+inline static VALUE resolve_classname(VALUE mod, const char *classname, int auto_define) {
+    VALUE clas;
+    ID    ci = rb_intern(classname);
 
     if (rb_const_defined_at(mod, ci)) {
-	clas = rb_const_get_at(mod, ci);
+        clas = rb_const_get_at(mod, ci);
     } else if (auto_define) {
-	clas = rb_define_class_under(mod, classname, oj_bag_class);
+        clas = rb_define_class_under(mod, classname, oj_bag_class);
     } else {
-	clas = Qundef;
+        clas = Qundef;
     }
     return clas;
 }
 
 static VALUE
 resolve_classpath(ParseInfo pi, const char *name, size_t len, int auto_define, VALUE error_class) {
-    char	class_name[1024];
-    VALUE	clas;
-    char	*end = class_name + sizeof(class_name) - 1;
-    char	*s;
-    const char	*n = name;
+    char        class_name[1024];
+    VALUE       clas;
+    char *      end = class_name + sizeof(class_name) - 1;
+    char *      s;
+    const char *n = name;
 
     clas = rb_cObject;
     for (s = class_name; 0 < len; n++, len--) {
-	if (':' == *n) {
-	    *s = '\0';
-	    n++;
-	    len--;
-	    if (':' != *n) {
-		return Qundef;
-	    }
-	    if (Qundef == (clas = resolve_classname(clas, class_name, auto_define))) {
-		return Qundef;
-	    }
-	    s = class_name;
-	} else if (end <= s) {
-	    return Qundef;
-	} else {
-	    *s++ = *n;
-	}
+        if (':' == *n) {
+            *s = '\0';
+            n++;
+            len--;
+            if (':' != *n) {
+                return Qundef;
+            }
+            if (Qundef == (clas = resolve_classname(clas, class_name, auto_define))) {
+                return Qundef;
+            }
+            s = class_name;
+        } else if (end <= s) {
+            return Qundef;
+        } else {
+            *s++ = *n;
+        }
     }
     *s = '\0';
     if (Qundef == (clas = resolve_classname(clas, class_name, auto_define))) {
-	oj_set_error_at(pi, error_class, __FILE__, __LINE__, "class %s is not defined", name);
-	if (Qnil != error_class) {
-	    pi->err_class = error_class;
-	}
+        oj_set_error_at(pi, error_class, __FILE__, __LINE__, "class %s is not defined", name);
+        if (Qnil != error_class) {
+            pi->err_class = error_class;
+        }
     }
     return clas;
 }
 
 VALUE
 oj_name2class(ParseInfo pi, const char *name, size_t len, int auto_define, VALUE error_class) {
-    VALUE	clas;
-    VALUE	*slot;
+    VALUE  clas;
+    VALUE *slot;
 
     if (No == pi->options.class_cache) {
-	return resolve_classpath(pi, name, len, auto_define, error_class);
+        return resolve_classpath(pi, name, len, auto_define, error_class);
     }
 #ifdef HAVE_PTHREAD_MUTEX_INIT
     pthread_mutex_lock(&oj_cache_mutex);
@@ -78,9 +78,9 @@ oj_name2class(ParseInfo pi, const char *name, size_t len, int auto_define, VALUE
     rb_mutex_lock(oj_cache_mutex);
 #endif
     if (Qnil == (clas = oj_class_hash_get(name, len, &slot))) {
-	if (Qundef != (clas = resolve_classpath(pi, name, len, auto_define, error_class))) {
-	    *slot = clas;
-	}
+        if (Qundef != (clas = resolve_classpath(pi, name, len, auto_define, error_class))) {
+            *slot = clas;
+        }
     }
 #ifdef HAVE_PTHREAD_MUTEX_INIT
     pthread_mutex_unlock(&oj_cache_mutex);
@@ -92,8 +92,8 @@ oj_name2class(ParseInfo pi, const char *name, size_t len, int auto_define, VALUE
 
 VALUE
 oj_name2struct(ParseInfo pi, VALUE nameVal, VALUE error_class) {
-    size_t	len = RSTRING_LEN(nameVal);
-    const char	*str = StringValuePtr(nameVal);
+    size_t      len = RSTRING_LEN(nameVal);
+    const char *str = StringValuePtr(nameVal);
 
     return resolve_classpath(pi, str, len, 0, error_class);
 }

data/ext/oj/resolve.h

@@ -1,11 +1,12 @@
 // Copyright (c) 2011 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
 
 #ifndef OJ_RESOLVE_H
 #define OJ_RESOLVE_H
 
 #include "ruby.h"
 
-extern VALUE	oj_name2class(ParseInfo pi, const char *name, size_t len, int auto_define, VALUE error_class);
-extern VALUE	oj_name2struct(ParseInfo pi, VALUE nameVal, VALUE error_class);
+extern VALUE oj_name2class(ParseInfo pi, const char *name, size_t len, int auto_define, VALUE error_class);
+extern VALUE oj_name2struct(ParseInfo pi, VALUE nameVal, VALUE error_class);
 
 #endif /* OJ_RESOLVE_H */

data/ext/oj/rxclass.c

@@ -1,10 +1,11 @@
 // Copyright (c) 2017 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
 
-#include <sys/types.h>
-#include <stdlib.h>
 #include <errno.h>
-#include <string.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
 #if !IS_WINDOWS
 #include <regex.h>
 #endif
@@ -12,65 +13,64 @@
 #include "rxclass.h"
 
 typedef struct _rxC {
-    struct _rxC	*next;
-    VALUE	rrx;
+    struct _rxC *next;
+    VALUE        rrx;
 #if !IS_WINDOWS
-    regex_t	rx;
+    regex_t rx;
 #endif
-    VALUE	clas;
-    char	src[256];
-} *RxC;
+    VALUE clas;
+    char  src[256];
+} * RxC;
 
-void
-oj_rxclass_init(RxClass rc) {
+void oj_rxclass_init(RxClass rc) {
     *rc->err = '\0';
     rc->head = NULL;
     rc->tail = NULL;
 }
 
-void
-oj_rxclass_cleanup(RxClass rc) {
-    RxC	rxc;
+void oj_rxclass_cleanup(RxClass rc) {
+    RxC rxc;
 
     while (NULL != (rxc = rc->head)) {
-	rc->head = rc->head->next;
+        rc->head = rc->head->next;
 #if !IS_WINDOWS
-	if (Qnil == rxc->rrx) {
-	    regfree(&rxc->rx);
-	}
-	xfree(rxc);
+        if (Qnil == rxc->rrx) {
+            regfree(&rxc->rx);
+        }
+        xfree(rxc);
 #endif
     }
 }
 
-void
-oj_rxclass_rappend(RxClass rc, VALUE rx, VALUE clas) {
-    RxC	rxc = ALLOC_N(struct _rxC, 1);
+void oj_rxclass_rappend(RxClass rc, VALUE rx, VALUE clas) {
+    RxC rxc = ALLOC_N(struct _rxC, 1);
 
     memset(rxc, 0, sizeof(struct _rxC));
-    rxc->rrx = rx;
+    rxc->rrx  = rx;
     rxc->clas = clas;
     if (NULL == rc->tail) {
-	rc->head = rxc;
+        rc->head = rxc;
     } else {
-	rc->tail->next = rxc;
+        rc->tail->next = rxc;
     }
     rc->tail = rxc;
 }
 
 // Attempt to compile the expression. If it fails populate the error code..
-int
-oj_rxclass_append(RxClass rc, const char *expr, VALUE clas) {
-    RxC	rxc;
+int oj_rxclass_append(RxClass rc, const char *expr, VALUE clas) {
+    RxC rxc;
 #if !IS_WINDOWS
-    int	err;
-    int	flags = 0;
+    int err;
+    int flags = 0;
 #endif
     if (sizeof(rxc->src) <= strlen(expr)) {
-	snprintf(rc->err, sizeof(rc->err), "expressions must be less than %lu characters", (unsigned long)sizeof(rxc->src));
-	return EINVAL;
+        snprintf(rc->err,
+                 sizeof(rc->err),
+                 "expressions must be less than %lu characters",
+                 (unsigned long)sizeof(rxc->src));
+        return EINVAL;
     }
-    rxc = ALLOC_N(struct _rxC, 1);
+    rxc       = ALLOC_N(struct _rxC, 1);
     rxc->next = 0;
     rxc->clas = clas;
 
@@ -79,15 +79,15 @@ oj_rxclass_append(RxClass rc, const char *expr, VALUE clas) {
 #else
     rxc->rrx = Qnil;
     if (0 != (err = regcomp(&rxc->rx, expr, flags))) {
-	regerror(err, &rxc->rx, rc->err, sizeof(rc->err));
-	free(rxc);
-	return err;
+        regerror(err, &rxc->rx, rc->err, sizeof(rc->err));
+        free(rxc);
+        return err;
     }
 #endif
     if (NULL == rc->tail) {
-	rc->head = rxc;
+        rc->head = rxc;
     } else {
-	rc->tail->next = rxc;
+        rc->tail->next = rxc;
     }
     rc->tail = rxc;
 
@@ -96,49 +96,48 @@ oj_rxclass_append(RxClass rc, const char *expr, VALUE clas) {
 
 VALUE
 oj_rxclass_match(RxClass rc, const char *str, int len) {
-    RxC		rxc;
-    char	buf[4096];
+    RxC  rxc;
+    char buf[4096];
 
     for (rxc = rc->head; NULL != rxc; rxc = rxc->next) {
-	if (Qnil != rxc->rrx) {
-	    // Must use a valiabel for this to work.
-	    volatile VALUE	rstr = rb_str_new(str, len);
-
-	    //if (Qtrue == rb_funcall(rxc->rrx, rb_intern("match?"), 1, rstr)) {
-	    if (Qnil != rb_funcall(rxc->rrx, rb_intern("match"), 1, rstr)) {
-		return rxc->clas;
-	    }
-	} else if (len < (int)sizeof(buf)) {
+        if (Qnil != rxc->rrx) {
+            // Must use a valiabel for this to work.
+            volatile VALUE rstr = rb_str_new(str, len);
+
+            // if (Qtrue == rb_funcall(rxc->rrx, rb_intern("match?"), 1, rstr)) {
+            if (Qnil != rb_funcall(rxc->rrx, rb_intern("match"), 1, rstr)) {
+                return rxc->clas;
+            }
+        } else if (len < (int)sizeof(buf)) {
 #if !IS_WINDOWS
-	    // string is not \0 terminated so copy and atempt a match
-	    memcpy(buf, str, len);
-	    buf[len] = '\0';
-	    if (0 == regexec(&rxc->rx, buf, 0, NULL, 0)) { // match
-		return rxc->clas;
-	    }
+            // string is not \0 terminated so copy and atempt a match
+            memcpy(buf, str, len);
+            buf[len] = '\0';
+            if (0 == regexec(&rxc->rx, buf, 0, NULL, 0)) {  // match
+                return rxc->clas;
+            }
 #endif
-	} else {
-	    // TBD allocate a larger buffer and attempt
-	}
+        } else {
+            // TBD allocate a larger buffer and attempt
+        }
     }
     return Qnil;
 }
 
-void
-oj_rxclass_copy(RxClass src, RxClass dest) {
+void oj_rxclass_copy(RxClass src, RxClass dest) {
     dest->head = NULL;
     dest->tail = NULL;
     if (NULL != src->head) {
-	RxC	rxc;
+        RxC rxc;
 
-	for (rxc = src->head; NULL != rxc; rxc = rxc->next) {
-	    if (Qnil != rxc->rrx) {
-		oj_rxclass_rappend(dest, rxc->rrx, rxc->clas);
-	    } else {
+        for (rxc = src->head; NULL != rxc; rxc = rxc->next) {
+            if (Qnil != rxc->rrx) {
+                oj_rxclass_rappend(dest, rxc->rrx, rxc->clas);
+            } else {
 #if !IS_WINDOWS
-		oj_rxclass_append(dest, rxc->src, rxc->clas);
+                oj_rxclass_append(dest, rxc->src, rxc->clas);
 #endif
-	    }
-	}
+            }
+        }
     }
 }

data/ext/oj/rxclass.h

@@ -1,24 +1,26 @@
 // Copyright (c) 2017 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
 
 #ifndef OJ_RXCLASS_H
 #define OJ_RXCLASS_H
 
 #include <stdbool.h>
+
 #include "ruby.h"
 
 struct _rxC;
 
 typedef struct _rxClass {
-    struct _rxC	*head;
-    struct _rxC	*tail;
-    char	err[128];
-} *RxClass;
+    struct _rxC *head;
+    struct _rxC *tail;
+    char         err[128];
+} * RxClass;
 
-extern void	oj_rxclass_init(RxClass rc);
-extern void	oj_rxclass_cleanup(RxClass rc);
-extern int	oj_rxclass_append(RxClass rc, const char *expr, VALUE clas);
-extern VALUE	oj_rxclass_match(RxClass rc, const char *str, int len);
-extern void	oj_rxclass_copy(RxClass src, RxClass dest);
-extern void	oj_rxclass_rappend(RxClass rc, VALUE rx, VALUE clas);
+extern void  oj_rxclass_init(RxClass rc);
+extern void  oj_rxclass_cleanup(RxClass rc);
+extern int   oj_rxclass_append(RxClass rc, const char *expr, VALUE clas);
+extern VALUE oj_rxclass_match(RxClass rc, const char *str, int len);
+extern void  oj_rxclass_copy(RxClass src, RxClass dest);
+extern void  oj_rxclass_rappend(RxClass rc, VALUE rx, VALUE clas);
 
 #endif /* OJ_RXCLASS_H */

data/ext/oj/saj.c

@@ -1,45 +1,46 @@
 // Copyright (c) 2012 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
 
 #if !IS_WINDOWS
-#include <sys/resource.h>  /* for getrlimit() on linux */
+#include <sys/resource.h> /* for getrlimit() on linux */
 #endif
-#include <stdlib.h>
+#include <math.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
-#include <math.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 // Workaround in case INFINITY is not defined in math.h or if the OS is CentOS
-#define OJ_INFINITY (1.0/0.0)
+#define OJ_INFINITY (1.0 / 0.0)
 
-#include "oj.h"
 #include "encode.h"
+#include "oj.h"
 
 typedef struct _parseInfo {
-    char	*str;		/* buffer being read from */
-    char	*s;		/* current position in buffer */
-    void	*stack_min;
-    VALUE	handler;
-    int		has_hash_start;
-    int		has_hash_end;
-    int		has_array_start;
-    int		has_array_end;
-    int		has_add_value;
-    int		has_error;
-} *ParseInfo;
-
-static void	read_next(ParseInfo pi, const char *key);
-static void	read_hash(ParseInfo pi, const char *key);
-static void	read_array(ParseInfo pi, const char *key);
-static void	read_str(ParseInfo pi, const char *key);
-static void	read_num(ParseInfo pi, const char *key);
-static void	read_true(ParseInfo pi, const char *key);
-static void	read_false(ParseInfo pi, const char *key);
-static void	read_nil(ParseInfo pi, const char *key);
-static void	next_non_white(ParseInfo pi);
-static char*	read_quoted_value(ParseInfo pi);
-static void	skip_comment(ParseInfo pi);
+    char *str; /* buffer being read from */
+    char *s;   /* current position in buffer */
+    void *stack_min;
+    VALUE handler;
+    int   has_hash_start;
+    int   has_hash_end;
+    int   has_array_start;
+    int   has_array_end;
+    int   has_add_value;
+    int   has_error;
+} * ParseInfo;
+
+static void  read_next(ParseInfo pi, const char *key);
+static void  read_hash(ParseInfo pi, const char *key);
+static void  read_array(ParseInfo pi, const char *key);
+static void  read_str(ParseInfo pi, const char *key);
+static void  read_num(ParseInfo pi, const char *key);
+static void  read_true(ParseInfo pi, const char *key);
+static void  read_false(ParseInfo pi, const char *key);
+static void  read_nil(ParseInfo pi, const char *key);
+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
@@ -54,126 +55,108 @@ static void	skip_comment(ParseInfo pi);
  * all cases to parse the string.
  */
 
-inline static void
-call_error(const char *msg, ParseInfo pi, const char* file, int line) {
-    char	buf[128];
-    const char	*s = pi->s;
-    int		jline = 1;
-    int		col = 1;
+inline static void call_error(const char *msg, ParseInfo pi, const char *file, int line) {
+    char        buf[128];
+    const char *s     = pi->s;
+    int         jline = 1;
+    int         col   = 1;
 
     for (; pi->str < s && '\n' != *s; s--) {
-	col++;
+        col++;
     }
     for (; pi->str < s; s--) {
-	if ('\n' == *s) {
-	    jline++;
-	}
+        if ('\n' == *s) {
+            jline++;
+        }
     }
     sprintf(buf, "%s at line %d, column %d [%s:%d]", msg, jline, col, file, line);
     rb_funcall(pi->handler, oj_error_id, 3, rb_str_new2(buf), LONG2NUM(jline), LONG2NUM(col));
 }
 
-inline static void
-next_non_white(ParseInfo pi) {
+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;
-	}
+        switch (*pi->s) {
+        case ' ':
+        case '\t':
+        case '\f':
+        case '\n':
+        case '\r': break;
+        case '/': skip_comment(pi); break;
+        default: return;
+        }
     }
 }
 
-inline static void
-call_add_value(VALUE handler, VALUE value, const char *key) {
-    volatile VALUE	k;
+inline static void call_add_value(VALUE handler, VALUE value, const char *key) {
+    volatile VALUE k;
 
     if (0 == key) {
-	k = Qnil;
+        k = Qnil;
     } else {
-	k = rb_str_new2(key);
-	k = oj_encode(k);
+        k = rb_str_new2(key);
+        k = oj_encode(k);
     }
     rb_funcall(handler, oj_add_value_id, 2, value, k);
 }
 
-inline static void
-call_no_value(VALUE handler, ID method, const char *key) {
-    volatile VALUE	k;
+inline static void call_no_value(VALUE handler, ID method, const char *key) {
+    volatile VALUE k;
 
     if (0 == key) {
-	k = Qnil;
+        k = Qnil;
     } else {
-	k = rb_str_new2(key);
-	k = oj_encode(k);
+        k = rb_str_new2(key);
+        k = oj_encode(k);
     }
     rb_funcall(handler, method, 1, k);
 }
 
-static void
-skip_comment(ParseInfo pi) {
+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) {
-		if (pi->has_error) {
-		    call_error("comment not terminated", pi, __FILE__, __LINE__);
-		} else {
-		    raise_error("comment not terminated", pi->str, pi->s);
-		}
-	    }
-	}
+        pi->s++;
+        for (; '\0' != *pi->s; pi->s++) {
+            if ('*' == *pi->s && '/' == *(pi->s + 1)) {
+                pi->s++;
+                return;
+            } else if ('\0' == *pi->s) {
+                if (pi->has_error) {
+                    call_error("comment not terminated", pi, __FILE__, __LINE__);
+                } else {
+                    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;
-	    }
-	}
+        for (; 1; pi->s++) {
+            switch (*pi->s) {
+            case '\n':
+            case '\r':
+            case '\f':
+            case '\0': return;
+            default: break;
+            }
+        }
     } else {
-	if (pi->has_error) {
-	    call_error("invalid comment", pi, __FILE__, __LINE__);
-	} else {
-	    raise_error("invalid comment", pi->str, pi->s);
-	}
+        if (pi->has_error) {
+            call_error("invalid comment", pi, __FILE__, __LINE__);
+        } else {
+            raise_error("invalid comment", pi->str, pi->s);
+        }
     }
 }
 
-static void
-read_next(ParseInfo pi, const char *key) {
-    VALUE	obj;
+static void read_next(ParseInfo pi, const char *key) {
+    VALUE obj;
 
-    if ((void*)&obj < pi->stack_min) {
-	rb_raise(rb_eSysStackError, "JSON is too deeply nested");
+    if ((void *)&obj < pi->stack_min) {
+        rb_raise(rb_eSysStackError, "JSON is too deeply nested");
     }
-    next_non_white(pi);	/* skip white space */
+    next_non_white(pi); /* skip white space */
     switch (*pi->s) {
-    case '{':
-	read_hash(pi, key);
-	break;
-    case '[':
-	read_array(pi, key);
-	break;
-    case '"':
-	read_str(pi, key);
-	break;
+    case '{': read_hash(pi, key); break;
+    case '[': read_array(pi, key); break;
+    case '"': read_str(pi, key); break;
     case '+':
     case '-':
     case '0':
@@ -185,113 +168,104 @@ read_next(ParseInfo pi, const char *key) {
     case '6':
     case '7':
     case '8':
-    case '9':
-	read_num(pi, key);
-	break;
-    case 'I':
-	read_num(pi, key);
-	break;
-    case 't':
-	read_true(pi, key);
-	break;
-    case 'f':
-	read_false(pi, key);
-	break;
-    case 'n':
-	read_nil(pi, key);
-	break;
-    case '\0':
-	return;
-    default:
-	return;
+    case '9': read_num(pi, key); break;
+    case 'I': read_num(pi, key); break;
+    case 't': read_true(pi, key); break;
+    case 'f': read_false(pi, key); break;
+    case 'n': read_nil(pi, key); break;
+    case '\0': return;
+    default: return;
     }
 }
 
-static void
-read_hash(ParseInfo pi, const char *key) {
-    const char	*ks;
+static void read_hash(ParseInfo pi, const char *key) {
+    const char *ks;
 
     if (pi->has_hash_start) {
-	call_no_value(pi->handler, oj_hash_start_id, key);
+        call_no_value(pi->handler, oj_hash_start_id, key);
     }
     pi->s++;
     next_non_white(pi);
     if ('}' == *pi->s) {
-	pi->s++;
+        pi->s++;
     } else {
-	while (1) {
-	    next_non_white(pi);
-	    ks = read_quoted_value(pi);
-	    next_non_white(pi);
-	    if (':' == *pi->s) {
-		pi->s++;
-	    } else {
-		if (pi->has_error) {
-		    call_error("invalid format, expected :", pi, __FILE__, __LINE__);
-		}
-		raise_error("invalid format, expected :", pi->str, pi->s);
-	    }
-	    read_next(pi, ks);
-	    next_non_white(pi);
-	    if ('}' == *pi->s) {
-		pi->s++;
-		break;
-	    } else if (',' == *pi->s) {
-		pi->s++;
-	    } else {
-		if (pi->has_error) {
-		    call_error("invalid format, expected , or } while in an object", pi, __FILE__, __LINE__);
-		}
-		raise_error("invalid format, expected , or } while in an object", pi->str, pi->s);
-	    }
-	}
+        while (1) {
+            next_non_white(pi);
+            ks = read_quoted_value(pi);
+            next_non_white(pi);
+            if (':' == *pi->s) {
+                pi->s++;
+            } else {
+                if (pi->has_error) {
+                    call_error("invalid format, expected :", pi, __FILE__, __LINE__);
+                }
+                raise_error("invalid format, expected :", pi->str, pi->s);
+            }
+            read_next(pi, ks);
+            next_non_white(pi);
+            if ('}' == *pi->s) {
+                pi->s++;
+                break;
+            } else if (',' == *pi->s) {
+                pi->s++;
+            } else {
+                if (pi->has_error) {
+                    call_error("invalid format, expected , or } while in an object",
+                               pi,
+                               __FILE__,
+                               __LINE__);
+                }
+                raise_error("invalid format, expected , or } while in an object", pi->str, pi->s);
+            }
+        }
     }
     if (pi->has_hash_end) {
-	call_no_value(pi->handler, oj_hash_end_id, key);
+        call_no_value(pi->handler, oj_hash_end_id, key);
     }
 }
 
-static void
-read_array(ParseInfo pi, const char *key) {
+static void read_array(ParseInfo pi, const char *key) {
     if (pi->has_array_start) {
-	call_no_value(pi->handler, oj_array_start_id, key);
+        call_no_value(pi->handler, oj_array_start_id, key);
     }
     pi->s++;
     next_non_white(pi);
     if (']' == *pi->s) {
-	pi->s++;
+        pi->s++;
     } else {
-	while (1) {
-	    read_next(pi, 0);
-	    next_non_white(pi);
-	    if (',' == *pi->s) {
-		pi->s++;
-	    } else if (']' == *pi->s) {
-		pi->s++;
-		break;
-	    } else {
-		if (pi->has_error) {
-		    call_error("invalid format, expected , or ] while in an array", pi, __FILE__, __LINE__);
-		}
-		raise_error("invalid format, expected , or ] while in an array", pi->str, pi->s);
-	    }
-	}
+        while (1) {
+            read_next(pi, 0);
+            next_non_white(pi);
+            if (',' == *pi->s) {
+                pi->s++;
+            } else if (']' == *pi->s) {
+                pi->s++;
+                break;
+            } else {
+                if (pi->has_error) {
+                    call_error("invalid format, expected , or ] while in an array",
+                               pi,
+                               __FILE__,
+                               __LINE__);
+                }
+                raise_error("invalid format, expected , or ] while in an array", pi->str, pi->s);
+            }
+        }
     }
     if (pi->has_array_end) {
-	call_no_value(pi->handler, oj_array_end_id, key);
+        call_no_value(pi->handler, oj_array_end_id, key);
     }
 }
 
-static void
-read_str(ParseInfo pi, const char *key) {
-    char	*text;
+static void read_str(ParseInfo pi, const char *key) {
+    char *text;
 
     text = read_quoted_value(pi);
     if (pi->has_add_value) {
-	VALUE	s = rb_str_new2(text);
+        VALUE s = rb_str_new2(text);
 
-	s = oj_encode(s);
-	call_add_value(pi->handler, s, key);
+        s = oj_encode(s);
+        call_add_value(pi->handler, s, key);
     }
 }
 
@@ -301,230 +275,228 @@ read_str(ParseInfo pi, const char *key) {
 #define NUM_MAX (FIXNUM_MAX >> 8)
 #endif
 
-static void
-read_num(ParseInfo pi, const char *key) {
-    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;
+static void read_num(ParseInfo pi, const char *key) {
+    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;
+        pi->s++;
+        neg = 1;
     } else if ('+' == *pi->s) {
-	pi->s++;
+        pi->s++;
     }
     if ('I' == *pi->s) {
-	if (0 != strncmp("Infinity", pi->s, 8)) {
-	    if (pi->has_error) {
-		call_error("number or other value", pi, __FILE__, __LINE__);
-	    }
-	    raise_error("number or other value", pi->str, pi->s);
-	}
-	pi->s += 8;
-	if (neg) {
-	    if (pi->has_add_value) {
-		call_add_value(pi->handler, rb_float_new(-OJ_INFINITY), key);
-	    }
-	} else {
-	    if (pi->has_add_value) {
-		call_add_value(pi->handler, rb_float_new(OJ_INFINITY), key);
-	    }
-	}
-	return;
+        if (0 != strncmp("Infinity", pi->s, 8)) {
+            if (pi->has_error) {
+                call_error("number or other value", pi, __FILE__, __LINE__);
+            }
+            raise_error("number or other value", pi->str, pi->s);
+        }
+        pi->s += 8;
+        if (neg) {
+            if (pi->has_add_value) {
+                call_add_value(pi->handler, rb_float_new(-OJ_INFINITY), key);
+            }
+        } else {
+            if (pi->has_add_value) {
+                call_add_value(pi->handler, rb_float_new(OJ_INFINITY), key);
+            }
+        }
+        return;
     }
     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 (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;
-	    }
-	}
+        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;
-	    }
-	}
+        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;
-
-	    *pi->s = '\0';
-	    if (pi->has_add_value) {
-		call_add_value(pi->handler, rb_funcall(rb_cObject, oj_bigdecimal_id, 1, rb_str_new2(start)), key);
-	    }
-	    *pi->s = c;
-	} else {
-	    if (neg) {
-		n = -n;
-	    }
-	    if (pi->has_add_value) {
-		call_add_value(pi->handler, LONG2NUM(n), key);
-	    }
-	}
-	return;
+        if (big) {
+            char c = *pi->s;
+
+            *pi->s = '\0';
+            if (pi->has_add_value) {
+                call_add_value(pi->handler,
+                               rb_funcall(rb_cObject, oj_bigdecimal_id, 1, rb_str_new2(start)),
+                               key);
+            }
+            *pi->s = c;
+        } else {
+            if (neg) {
+                n = -n;
+            }
+            if (pi->has_add_value) {
+                call_add_value(pi->handler, LONG2NUM(n), key);
+            }
+        }
+        return;
     } else { /* decimal */
-	if (big) {
-	    char	c = *pi->s;
-
-	    *pi->s = '\0';
-	    if (pi->has_add_value) {
-		call_add_value(pi->handler, rb_funcall(rb_cObject, oj_bigdecimal_id, 1, rb_str_new2(start)), key);
-	    }
-	    *pi->s = c;
-	} 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);
-	    }
-	    if (pi->has_add_value) {
-		call_add_value(pi->handler, rb_float_new(d), key);
-	    }
-	}
+        if (big) {
+            char c = *pi->s;
+
+            *pi->s = '\0';
+            if (pi->has_add_value) {
+                call_add_value(pi->handler,
+                               rb_funcall(rb_cObject, oj_bigdecimal_id, 1, rb_str_new2(start)),
+                               key);
+            }
+            *pi->s = c;
+        } 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);
+            }
+            if (pi->has_add_value) {
+                call_add_value(pi->handler, rb_float_new(d), key);
+            }
+        }
     }
 }
 
-static void
-read_true(ParseInfo pi, const char *key) {
+static void read_true(ParseInfo pi, const char *key) {
     pi->s++;
     if ('r' != *pi->s || 'u' != *(pi->s + 1) || 'e' != *(pi->s + 2)) {
-	if (pi->has_error) {
-	    call_error("invalid format, expected 'true'", pi, __FILE__, __LINE__);
-	}
-	raise_error("invalid format, expected 'true'", pi->str, pi->s);
+        if (pi->has_error) {
+            call_error("invalid format, expected 'true'", pi, __FILE__, __LINE__);
+        }
+        raise_error("invalid format, expected 'true'", pi->str, pi->s);
     }
     pi->s += 3;
     if (pi->has_add_value) {
-	call_add_value(pi->handler, Qtrue, key);
+        call_add_value(pi->handler, Qtrue, key);
     }
 }
 
-static void
-read_false(ParseInfo pi, const char *key) {
+static void read_false(ParseInfo pi, const char *key) {
     pi->s++;
     if ('a' != *pi->s || 'l' != *(pi->s + 1) || 's' != *(pi->s + 2) || 'e' != *(pi->s + 3)) {
-	if (pi->has_error) {
-	    call_error("invalid format, expected 'false'", pi, __FILE__, __LINE__);
-	}
-	raise_error("invalid format, expected 'false'", pi->str, pi->s);
+        if (pi->has_error) {
+            call_error("invalid format, expected 'false'", pi, __FILE__, __LINE__);
+        }
+        raise_error("invalid format, expected 'false'", pi->str, pi->s);
     }
     pi->s += 4;
     if (pi->has_add_value) {
-	call_add_value(pi->handler, Qfalse, key);
+        call_add_value(pi->handler, Qfalse, key);
     }
 }
 
-static void
-read_nil(ParseInfo pi, const char *key) {
+static void read_nil(ParseInfo pi, const char *key) {
     pi->s++;
     if ('u' != *pi->s || 'l' != *(pi->s + 1) || 'l' != *(pi->s + 2)) {
-	if (pi->has_error) {
-	    call_error("invalid format, expected 'null'", pi, __FILE__, __LINE__);
-	}
-	raise_error("invalid format, expected 'null'", pi->str, pi->s);
+        if (pi->has_error) {
+            call_error("invalid format, expected 'null'", pi, __FILE__, __LINE__);
+        }
+        raise_error("invalid format, expected 'null'", pi->str, pi->s);
     }
     pi->s += 3;
     if (pi->has_add_value) {
-	call_add_value(pi->handler, Qnil, key);
+        call_add_value(pi->handler, Qnil, key);
     }
 }
 
-static uint32_t
-read_hex(ParseInfo pi, char *h) {
-    uint32_t	b = 0;
-    int		i;
+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;
-	    if (pi->has_error) {
-		call_error("invalid hex character", pi, __FILE__, __LINE__);
-	    }
-	    raise_error("invalid hex character", pi->str, pi->s);
-	}
+        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;
+            if (pi->has_error) {
+                call_error("invalid hex character", pi, __FILE__, __LINE__);
+            }
+            raise_error("invalid hex character", pi->str, pi->s);
+        }
     }
     return b;
 }
 
-static char*
-unicode_to_chars(ParseInfo pi, char *t, uint32_t code) {
+static char *unicode_to_chars(ParseInfo pi, char *t, uint32_t code) {
     if (0x0000007F >= code) {
-	*t = (char)code;
+        *t = (char)code;
     } else if (0x000007FF >= code) {
-	*t++ = 0xC0 | (code >> 6);
-	*t = 0x80 | (0x3F & 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);
+        *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);
+        *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);
+        *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);
+        *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 {
-	if (pi->has_error) {
-	    call_error("invalid Unicode", pi, __FILE__, __LINE__);
-	}
-	raise_error("invalid Unicode", pi->str, pi->s);
+        if (pi->has_error) {
+            call_error("invalid Unicode", pi, __FILE__, __LINE__);
+        }
+        raise_error("invalid Unicode", pi->str, pi->s);
     }
     return t;
 }
@@ -532,119 +504,119 @@ unicode_to_chars(ParseInfo pi, char *t, uint32_t code) {
 /* 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 */
+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;
-			if (pi->has_error) {
-			    call_error("invalid escaped character", pi, __FILE__, __LINE__);
-			}
-			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;
-		if (pi->has_error) {
-		    call_error("invalid escaped character", pi, __FILE__, __LINE__);
-		}
-		raise_error("invalid escaped character", pi->str, pi->s);
-		break;
-	    }
-	} else if (t != h) {
-	    *t = *h;
-	}
-    }
-    *t = '\0'; /* terminate value */
+        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;
+                        if (pi->has_error) {
+                            call_error("invalid escaped character", pi, __FILE__, __LINE__);
+                        }
+                        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;
+                if (pi->has_error) {
+                    call_error("invalid escaped character", pi, __FILE__, __LINE__);
+                }
+                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;
 }
 
-static void
-saj_parse(VALUE handler, char *json) {
-    volatile VALUE	obj = Qnil;
-    struct _parseInfo	pi;
+static void saj_parse(VALUE handler, char *json) {
+    volatile VALUE    obj = Qnil;
+    struct _parseInfo pi;
 
     if (0 == json) {
-	if (pi.has_error) {
-	    call_error("Invalid arg, xml string can not be null", &pi, __FILE__, __LINE__);
-	}
-	raise_error("Invalid arg, xml string can not be null", json, 0);
+        if (pi.has_error) {
+            call_error("Invalid arg, xml string can not be null", &pi, __FILE__, __LINE__);
+        }
+        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;
+        json += 3;
     }
     /* initialize parse info */
     pi.str = json;
-    pi.s = json;
+    pi.s   = json;
 #if IS_WINDOWS
-    pi.stack_min = (void*)((char*)&obj - (512 * 1024)); /* assume a 1M stack and give half to ruby */
+    pi.stack_min = (void *)((char *)&obj -
+                            (512 * 1024)); /* assume a 1M stack and give half to ruby */
 #else
     {
-	struct rlimit	lim;
+        struct rlimit lim;
 
-	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 */
-	}
+        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
-    pi.handler = handler;
-    pi.has_hash_start = rb_respond_to(handler, oj_hash_start_id);
-    pi.has_hash_end = rb_respond_to(handler, oj_hash_end_id);
+    pi.handler         = handler;
+    pi.has_hash_start  = rb_respond_to(handler, oj_hash_start_id);
+    pi.has_hash_end    = rb_respond_to(handler, oj_hash_end_id);
     pi.has_array_start = rb_respond_to(handler, oj_array_start_id);
-    pi.has_array_end = rb_respond_to(handler, oj_array_end_id);
-    pi.has_add_value = rb_respond_to(handler, oj_add_value_id);
-    pi.has_error = rb_respond_to(handler, oj_error_id);
+    pi.has_array_end   = rb_respond_to(handler, oj_array_end_id);
+    pi.has_add_value   = rb_respond_to(handler, oj_add_value_id);
+    pi.has_error       = rb_respond_to(handler, oj_error_id);
     read_next(&pi, 0);
     next_non_white(&pi);
     if ('\0' != *pi.s) {
-	if (pi.has_error) {
-	    call_error("invalid format, extra characters", &pi, __FILE__, __LINE__);
-	} else {
-	    raise_error("invalid format, extra characters", pi.str, pi.s);
-	}
+        if (pi.has_error) {
+            call_error("invalid format, extra characters", &pi, __FILE__, __LINE__);
+        } else {
+            raise_error("invalid format, extra characters", pi.str, pi.s);
+        }
     }
 }
 
@@ -661,48 +633,48 @@ saj_parse(VALUE handler, char *json) {
  */
 VALUE
 oj_saj_parse(int argc, VALUE *argv, VALUE self) {
-    char	*json = 0;
-    size_t	len = 0;
-    VALUE	input = argv[1];
+    char * json  = 0;
+    size_t len   = 0;
+    VALUE  input = argv[1];
 
     if (argc < 2) {
-	rb_raise(rb_eArgError, "Wrong number of arguments to saj_parse.\n");
+        rb_raise(rb_eArgError, "Wrong number of arguments to saj_parse.\n");
     }
     if (rb_type(input) == T_STRING) {
-	// the json string gets modified so make a copy of it
-	len = RSTRING_LEN(input) + 1;
-	json = ALLOC_N(char, len);
-	strcpy(json, StringValuePtr(input));
+        // the json string gets modified so make a copy of it
+        len  = RSTRING_LEN(input) + 1;
+        json = ALLOC_N(char, len);
+        strcpy(json, StringValuePtr(input));
     } else {
-	VALUE		clas = rb_obj_class(input);
-	volatile VALUE	s;
-
-	if (oj_stringio_class == clas) {
-	    s = rb_funcall2(input, oj_string_id, 0, 0);
-	    len = RSTRING_LEN(s) + 1;
-	    json = ALLOC_N(char, len);
-	    strcpy(json, rb_string_value_cstr((VALUE*)&s));
+        VALUE          clas = rb_obj_class(input);
+        volatile VALUE s;
+
+        if (oj_stringio_class == clas) {
+            s    = rb_funcall2(input, oj_string_id, 0, 0);
+            len  = RSTRING_LEN(s) + 1;
+            json = ALLOC_N(char, len);
+            strcpy(json, rb_string_value_cstr((VALUE *)&s));
 #if !IS_WINDOWS
-	} else if (rb_cFile == clas && 0 == FIX2INT(rb_funcall(input, oj_pos_id, 0))) {
-	    int		fd = FIX2INT(rb_funcall(input, oj_fileno_id, 0));
-	    ssize_t	cnt;
-
-	    len = lseek(fd, 0, SEEK_END);
-	    lseek(fd, 0, SEEK_SET);
-	    json = ALLOC_N(char, len + 1);
-	    if (0 >= (cnt = read(fd, json, len)) || cnt != (ssize_t)len) {
-		rb_raise(rb_eIOError, "failed to read from IO Object.");
-	    }
-	    json[len] = '\0';
+        } else if (rb_cFile == clas && 0 == FIX2INT(rb_funcall(input, oj_pos_id, 0))) {
+            int     fd = FIX2INT(rb_funcall(input, oj_fileno_id, 0));
+            ssize_t cnt;
+
+            len = lseek(fd, 0, SEEK_END);
+            lseek(fd, 0, SEEK_SET);
+            json = ALLOC_N(char, len + 1);
+            if (0 >= (cnt = read(fd, json, len)) || cnt != (ssize_t)len) {
+                rb_raise(rb_eIOError, "failed to read from IO Object.");
+            }
+            json[len] = '\0';
 #endif
-	} else if (rb_respond_to(input, oj_read_id)) {
-	    s = rb_funcall2(input, oj_read_id, 0, 0);
-	    len = RSTRING_LEN(s) + 1;
-	    json = ALLOC_N(char, len);
-	    strcpy(json, rb_string_value_cstr((VALUE*)&s));
-	} else {
-	    rb_raise(rb_eArgError, "saj_parse() expected a String or IO Object.");
-	}
+        } else if (rb_respond_to(input, oj_read_id)) {
+            s    = rb_funcall2(input, oj_read_id, 0, 0);
+            len  = RSTRING_LEN(s) + 1;
+            json = ALLOC_N(char, len);
+            strcpy(json, rb_string_value_cstr((VALUE *)&s));
+        } else {
+            rb_raise(rb_eArgError, "saj_parse() expected a String or IO Object.");
+        }
     }
     saj_parse(*argv, json);
     xfree(json);