oj 2.1.7 → 2.2.0

data/ext/oj/object.c

@@ -72,7 +72,7 @@ hash_key(ParseInfo pi, const char *key, size_t klen, char k1) {
 
 static VALUE
 str_to_value(ParseInfo pi, const char *str, size_t len, const char *orig) {
-    VALUE	rstr = Qnil;
+    volatile VALUE	rstr = Qnil;
 
     if (':' == *orig && 0 < len) {
 	rstr = rb_str_new(str + 1, len - 1);
@@ -183,11 +183,11 @@ static int
 hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, VALUE value) {
     if (2 == klen && 'u' == key[1] && T_ARRAY == rb_type(value)) {
 #if HAS_RSTRUCT
-	long	len = RARRAY_LEN(value);
-	VALUE	*a = RARRAY_PTR(value);
-	VALUE	sc;
-	VALUE	s;
-	VALUE	*sv;
+	long		len = RARRAY_LEN(value);
+	VALUE		*a = RARRAY_PTR(value);
+	VALUE		sc;
+	volatile VALUE	s;
+	VALUE		*sv;
 
 	if (0 == len) {
 	    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Invalid struct data");
@@ -231,11 +231,11 @@ hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, VALUE value) {
 
 static void
 copy_ivars(VALUE target, VALUE src) {
-    VALUE	vars = rb_funcall(src, oj_instance_variables_id, 0);
-    VALUE	*np = RARRAY_PTR(vars);
-    ID		vid;
-    int		i, cnt = (int)RARRAY_LEN(vars);
-    const char	*attr;
+    volatile VALUE	vars = rb_funcall(src, oj_instance_variables_id, 0);
+    VALUE		*np = RARRAY_PTR(vars);
+    ID			vid;
+    int			i, cnt = (int)RARRAY_LEN(vars);
+    const char		*attr;
 
     for (i = cnt; 0 < i; i--, np++) {
 	vid = rb_to_id(*np);

data/ext/oj/oj.c

@@ -80,6 +80,7 @@ ID	oj_write_id;
 
 VALUE	oj_bag_class;
 VALUE	oj_bigdecimal_class;
+VALUE	oj_cstack_class;
 VALUE	oj_date_class;
 VALUE	oj_datetime_class;
 VALUE	oj_parse_error_class;
@@ -89,6 +90,7 @@ VALUE	oj_time_class;
 
 VALUE	oj_slash_string;
 
+static VALUE	ascii_sym;
 static VALUE	ascii_only_sym;
 static VALUE	auto_define_sym;
 static VALUE	bigdecimal_as_decimal_sym;
@@ -97,10 +99,13 @@ static VALUE	circular_sym;
 static VALUE	class_cache_sym;
 static VALUE	compat_sym;
 static VALUE	create_id_sym;
+static VALUE	escape_mode_sym;
 static VALUE	indent_sym;
+static VALUE	json_sym;
 static VALUE	mode_sym;
 static VALUE	null_sym;
 static VALUE	object_sym;
+static VALUE	xss_safe_sym;
 static VALUE	ruby_sym;
 static VALUE	sec_prec_sym;
 static VALUE	strict_sym;
@@ -134,7 +139,7 @@ struct _Options	oj_default_options = {
     No,			// circular
     No,			// auto_define
     No,			// sym_key
-    No,			// ascii_only
+    JSONEsc,		// escape_mode
     ObjectMode,		// mode
     Yes,		// class_cache
     UnixTime,		// time_format
@@ -155,6 +160,7 @@ static VALUE	define_mimic_json(int argc, VALUE *argv, VALUE self);
  * - circular: [true|false|nil] support circular references while dumping
  * - auto_define: [true|false|nil] automatically define classes if they do not exist
  * - symbol_keys: [true|false|nil] use symbols instead of strings for hash keys
+ * - escape_mode: [:json|:xss_safe|:ascii|nil] use symbols instead of strings for hash keys
  * - class_cache: [true|false|nil] cache classes for faster parsing (if dynamically modifying classes or reloading classes then don't use this)
  * - mode: [:object|:strict|:compat|:null] load and dump modes to use for JSON
  * - time_format: [:unix|:xmlschema|:ruby] time format when dumping in :compat mode
@@ -173,7 +179,6 @@ get_def_opts(VALUE self) {
     rb_hash_aset(opts, circular_sym, (Yes == oj_default_options.circular) ? Qtrue : ((No == oj_default_options.circular) ? Qfalse : Qnil));
     rb_hash_aset(opts, class_cache_sym, (Yes == oj_default_options.class_cache) ? Qtrue : ((No == oj_default_options.class_cache) ? Qfalse : Qnil));
     rb_hash_aset(opts, auto_define_sym, (Yes == oj_default_options.auto_define) ? Qtrue : ((No == oj_default_options.auto_define) ? Qfalse : Qnil));
-    rb_hash_aset(opts, ascii_only_sym, (Yes == oj_default_options.ascii_only) ? Qtrue : ((No == oj_default_options.ascii_only) ? Qfalse : Qnil));
     rb_hash_aset(opts, symbol_keys_sym, (Yes == oj_default_options.sym_key) ? Qtrue : ((No == oj_default_options.sym_key) ? Qfalse : Qnil));
     rb_hash_aset(opts, bigdecimal_as_decimal_sym, (Yes == oj_default_options.bigdec_as_num) ? Qtrue : ((No == oj_default_options.bigdec_as_num) ? Qfalse : Qnil));
     rb_hash_aset(opts, bigdecimal_load_sym, (Yes == oj_default_options.bigdec_load) ? Qtrue : ((No == oj_default_options.bigdec_load) ? Qfalse : Qnil));
@@ -184,6 +189,12 @@ get_def_opts(VALUE self) {
     case ObjectMode:
     default:		rb_hash_aset(opts, mode_sym, object_sym);	break;
     }
+    switch (oj_default_options.escape_mode) {
+    case JSONEsc:	rb_hash_aset(opts, escape_mode_sym, json_sym);		break;
+    case XSSEsc:	rb_hash_aset(opts, escape_mode_sym, xss_safe_sym);	break;
+    case ASCIIEsc:	rb_hash_aset(opts, escape_mode_sym, ascii_sym);		break;
+    default:		rb_hash_aset(opts, escape_mode_sym, json_sym);		break;
+    }
     switch (oj_default_options.time_format) {
     case XmlTime:	rb_hash_aset(opts, time_format_sym, xmlschema_sym);	break;
     case RubyTime:	rb_hash_aset(opts, time_format_sym, ruby_sym);		break;
@@ -204,7 +215,9 @@ get_def_opts(VALUE self) {
  * @param [true|false|nil] :auto_define automatically define classes if they do not exist
  * @param [true|false|nil] :symbol_keys convert hash keys to symbols
  * @param [true|false|nil] :class_cache cache classes for faster parsing
- * @param [true|false|nil] :ascii_only encode all high-bit characters as escaped sequences if true
+ * @param [:json|:xss_safe|:ascii|nil] :escape mode encodes all high-bit characters as
+ *        escaped sequences if :ascii, :json is standand UTF-8 JSON encoding,
+ *        and :xss_safe escapes &, <, and >, and some others.
  * @param [true|false|nil] :bigdecimal_as_decimal dump BigDecimal as a decimal number or as a String
  * @param [true|false|nil] :bigdecimal_load load decimals as a BigDecimal instead of as a Float
  * @param [:object|:strict|:compat|:null] load and dump mode to use for JSON
@@ -230,7 +243,6 @@ set_def_opts(VALUE self, VALUE opts) {
 	{ auto_define_sym, &oj_default_options.auto_define },
 	{ symbol_keys_sym, &oj_default_options.sym_key },
 	{ class_cache_sym, &oj_default_options.class_cache },
-	{ ascii_only_sym, &oj_default_options.ascii_only },
 	{ bigdecimal_as_decimal_sym, &oj_default_options.bigdec_as_num },
 	{ bigdecimal_load_sym, &oj_default_options.bigdec_load },
 	{ Qnil, 0 }
@@ -286,6 +298,19 @@ set_def_opts(VALUE self, VALUE opts) {
 	rb_raise(rb_eArgError, ":time_format must be :unix, :xmlschema, or :ruby.");
     }
 
+    v = rb_hash_lookup(opts, escape_mode_sym);
+    if (Qnil == v) {
+	// ignore
+    } else if (json_sym == v) {
+	oj_default_options.escape_mode = JSONEsc;
+    } else if (xss_safe_sym == v) {
+	oj_default_options.escape_mode = XSSEsc;
+    } else if (ascii_sym == v) {
+	oj_default_options.escape_mode = ASCIIEsc;
+    } else {
+	rb_raise(rb_eArgError, ":encoding must be :json, :rails, or :ascii.");
+    }
+
     if (Qtrue == rb_funcall(opts, rb_intern("has_key?"), 1, create_id_sym)) {
 	if (0 != oj_default_options.create_id) {
 	    if (json_class != oj_default_options.create_id) {
@@ -318,6 +343,13 @@ set_def_opts(VALUE self, VALUE opts) {
 	    }
 	}
     }
+    // This is here only for backwards compatibility with the original Oj.
+    v = rb_hash_lookup(opts, ascii_only_sym);
+    if (Qtrue == v) {
+	oj_default_options.escape_mode = ASCIIEsc;
+    } else if (Qfalse == v) {
+	oj_default_options.escape_mode = JSONEsc;
+    }
     return Qnil;
 }
 
@@ -328,7 +360,6 @@ oj_parse_options(VALUE ropts, Options copts) {
 	{ auto_define_sym, &copts->auto_define },
 	{ symbol_keys_sym, &copts->sym_key },
 	{ class_cache_sym, &copts->class_cache },
-	{ ascii_only_sym, &copts->ascii_only },
 	{ bigdecimal_as_decimal_sym, &copts->bigdec_as_num },
 	{ bigdecimal_load_sym, &copts->bigdec_load },
 	{ Qnil, 0 }
@@ -382,6 +413,19 @@ oj_parse_options(VALUE ropts, Options copts) {
 		rb_raise(rb_eArgError, ":time_format must be :unix, :xmlschema, or :ruby.");
 	    }
 	}
+
+	if (Qnil != (v = rb_hash_lookup(ropts, escape_mode_sym))) {
+	    if (json_sym == v) {
+		copts->escape_mode = JSONEsc;
+	    } else if (xss_safe_sym == v) {
+		copts->escape_mode = XSSEsc;
+	    } else if (ascii_sym == v) {
+		copts->escape_mode = ASCIIEsc;
+	    } else {
+		rb_raise(rb_eArgError, ":encoding must be :json, :rails, or :ascii.");
+	    }
+	}
+
 	if (Qtrue == rb_funcall(ropts, rb_intern("has_key?"), 1, create_id_sym)) {
 	    v = rb_hash_lookup(ropts, create_id_sym);
 	    if (Qnil == v) {
@@ -415,6 +459,13 @@ oj_parse_options(VALUE ropts, Options copts) {
 		}
 	    }
 	}
+	// This is here only for backwards compatibility with the original Oj.
+	v = rb_hash_lookup(ropts, ascii_only_sym);
+	if (Qtrue == v) {
+	    copts->escape_mode = ASCIIEsc;
+	} else if (Qfalse == v) {
+	    copts->escape_mode = JSONEsc;
+	}
     }
  }
 
@@ -1009,7 +1060,7 @@ mimic_create_id(VALUE self, VALUE id) {
  * will be replaced with Oj methods.
  *
  * Note that this also sets the default options of :mode to :compat and
- * :ascii_only to true.
+ * :encoding to :ascii.
  */
 static VALUE
 define_mimic_json(int argc, VALUE *argv, VALUE self) {
@@ -1079,7 +1130,7 @@ define_mimic_json(int argc, VALUE *argv, VALUE self) {
     symbolize_names_sym = ID2SYM(rb_intern("symbolize_names"));		rb_gc_register_address(&symbolize_names_sym);
 
     oj_default_options.mode = CompatMode;
-    oj_default_options.ascii_only = Yes;
+    oj_default_options.escape_mode = ASCIIEsc;
 
     return mimic;
 }
@@ -1114,6 +1165,8 @@ iconv_rescue(VALUE x) {
 void Init_oj() {
     Oj = rb_define_module("Oj");
 
+    oj_cstack_class = rb_define_class_under(Oj, "CStack", rb_cObject);
+
     rb_require("time");
     rb_require("date");
     rb_require("bigdecimal");
@@ -1185,6 +1238,7 @@ void Init_oj() {
     oj_struct_class = rb_const_get(rb_cObject, rb_intern("Struct"));
     oj_time_class = rb_const_get(rb_cObject, rb_intern("Time"));
 
+    ascii_sym = ID2SYM(rb_intern("ascii"));		rb_gc_register_address(&ascii_sym);
     ascii_only_sym = ID2SYM(rb_intern("ascii_only"));	rb_gc_register_address(&ascii_only_sym);
     auto_define_sym = ID2SYM(rb_intern("auto_define"));	rb_gc_register_address(&auto_define_sym);
     bigdecimal_as_decimal_sym = ID2SYM(rb_intern("bigdecimal_as_decimal"));rb_gc_register_address(&bigdecimal_as_decimal_sym);
@@ -1193,10 +1247,13 @@ void Init_oj() {
     class_cache_sym = ID2SYM(rb_intern("class_cache"));	rb_gc_register_address(&class_cache_sym);
     compat_sym = ID2SYM(rb_intern("compat"));		rb_gc_register_address(&compat_sym);
     create_id_sym = ID2SYM(rb_intern("create_id"));	rb_gc_register_address(&create_id_sym);
+    escape_mode_sym = ID2SYM(rb_intern("escape_mode"));	rb_gc_register_address(&escape_mode_sym);
     indent_sym = ID2SYM(rb_intern("indent"));		rb_gc_register_address(&indent_sym);
+    json_sym = ID2SYM(rb_intern("json"));		rb_gc_register_address(&json_sym);
     mode_sym = ID2SYM(rb_intern("mode"));		rb_gc_register_address(&mode_sym);
     null_sym = ID2SYM(rb_intern("null"));		rb_gc_register_address(&null_sym);
     object_sym = ID2SYM(rb_intern("object"));		rb_gc_register_address(&object_sym);
+    xss_safe_sym = ID2SYM(rb_intern("xss_safe"));	rb_gc_register_address(&xss_safe_sym);
     ruby_sym = ID2SYM(rb_intern("ruby"));		rb_gc_register_address(&ruby_sym);
     sec_prec_sym = ID2SYM(rb_intern("second_precision"));rb_gc_register_address(&sec_prec_sym);
     strict_sym = ID2SYM(rb_intern("strict"));		rb_gc_register_address(&strict_sym);

data/ext/oj/oj.h

@@ -85,6 +85,12 @@ typedef enum {
     RubyTime	= 'r'
 } TimeFormat;
 
+typedef enum {
+    JSONEsc	= 'j',
+    XSSEsc	= 'x',
+    ASCIIEsc	= 'a'
+} Encoding;
+
 typedef struct _DumpOpts {
     const char	*indent;
     const char	*before_sep;
@@ -103,7 +109,7 @@ typedef struct _Options {
     char	circular;	// YesNo
     char	auto_define;	// YesNo
     char	sym_key;	// YesNo
-    char	ascii_only;	// YesNo
+    char	escape_mode;	// Escape_Mode
     char	mode;		// Mode
     char	class_cache;	// YesNo
     char	time_format;	// TimeFormat
@@ -181,6 +187,7 @@ extern VALUE		oj_utf8_encoding;
 
 extern VALUE	oj_bag_class;
 extern VALUE	oj_bigdecimal_class;
+extern VALUE	oj_cstack_class;
 extern VALUE	oj_date_class;
 extern VALUE	oj_datetime_class;
 extern VALUE	oj_doc_class;

data/ext/oj/parse.c

@@ -499,9 +499,8 @@ read_num(ParseInfo pi) {
 
 static void
 array_start(ParseInfo pi) {
-    VALUE	v = Qnil;
+    VALUE	v = pi->start_array(pi);
 
-    v = pi->start_array(pi);
     stack_push(&pi->stack, v, NEXT_ARRAY_NEW);
 }
 
@@ -521,9 +520,8 @@ array_end(ParseInfo pi) {
 
 static void
 hash_start(ParseInfo pi) {
-    VALUE	v = Qnil;
+    VALUE	v = pi->start_hash(pi);
 
-    v = pi->start_hash(pi);
     stack_push(&pi->stack, v, NEXT_HASH_NEW);
 }
 
@@ -571,9 +569,11 @@ colon(ParseInfo pi) {
 
 void
 oj_parse2(ParseInfo pi) {
+    volatile VALUE	rstack = Qnil;
+
     pi->cur = pi->json;
     err_init(&pi->err);
-    stack_init(&pi->stack);
+    rstack = oj_stack_init(&pi->stack);
     while (1) {
 	next_non_white(pi);
 	switch (*pi->cur++) {
@@ -656,7 +656,7 @@ oj_num_as_value(NumInfo ni) {
 	    rnum = rb_float_new(OJ_INFINITY);
 	}
     } else if (ni->nan) {
-	rnum = rb_float_new(NAN);
+	rnum = rb_float_new(0.0/0.0);
     } else if (1 == ni->div && 0 == ni->exp) { // fixnum
 	if (ni->big) {
 	    if (256 > ni->len) {
@@ -719,11 +719,11 @@ protect_parse(VALUE pip) {
 
 VALUE
 oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json) {
-    char	*buf = 0;
-    VALUE	input;
-    VALUE	result = Qnil;
-    int		line = 0;
-    int		free_json = 0;
+    char		*buf = 0;
+    VALUE		input;
+    volatile VALUE	result = Qnil;
+    int			line = 0;
+    int			free_json = 0;
 
     if (argc < 1) {
 	rb_raise(rb_eArgError, "Wrong number of arguments to parse.");
@@ -784,15 +784,8 @@ oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json) {
     // GC can run at any time. When it runs any Object created by C will be
     // freed. This usually only happens with large files but it does happen and
     // it happens more frequently on Ruby 1.8.7.
-#if HAS_GC_GUARD
-    rb_gc_disable();
-#endif
     rb_protect(protect_parse, (VALUE)pi, &line);
     result = stack_head_val(&pi->stack);
-#if HAS_GC_GUARD
-    RB_GC_GUARD(result);
-    rb_gc_enable();
-#endif
     // proceed with cleanup
     if (0 != pi->circ_array) {
 	oj_circ_array_free(pi->circ_array);

data/ext/oj/saj.c

@@ -44,12 +44,6 @@
 #include "oj.h"
 #include "encode.h"
 
-typedef struct _CX {
-    VALUE	*cur;
-    VALUE	*end;
-    VALUE	stack[1024];
-} *CX;
-
 typedef struct _ParseInfo {
     char	*str;		/* buffer being read from */
     char	*s;		/* current position in buffer */
@@ -145,7 +139,7 @@ next_white(ParseInfo pi) {
 
 inline static void
 call_add_value(VALUE handler, VALUE value, const char *key) {
-    VALUE	k;
+    volatile VALUE	k;
 
     if (0 == key) {
 	k = Qnil;
@@ -158,7 +152,7 @@ call_add_value(VALUE handler, VALUE value, const char *key) {
 
 inline static void
 call_no_value(VALUE handler, ID method, const char *key) {
-    VALUE	k;
+    volatile VALUE	k;
 
     if (0 == key) {
 	k = Qnil;
@@ -668,7 +662,7 @@ respond_to(VALUE obj, ID method) {
 
 static void
 sajkey_parse(VALUE handler, char *json) {
-    VALUE		obj = Qnil;
+    volatile VALUE	obj = Qnil;
     struct _ParseInfo	pi;
 
     if (0 == json) {
@@ -737,14 +731,14 @@ oj_saj_parse(int argc, VALUE *argv, VALUE self) {
 	json = ALLOC_N(char, len);
 	strcpy(json, StringValuePtr(input));
     } else {
-	VALUE	clas = rb_obj_class(input);
-	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, StringValuePtr(s));
+	    strcpy(json, rb_string_value_cstr((VALUE*)&s));
 #ifndef JRUBY_RUBY
 #if !IS_WINDOWS
 	    // JRuby gets confused with what is the real fileno.
@@ -765,7 +759,7 @@ oj_saj_parse(int argc, VALUE *argv, VALUE self) {
 	    s = rb_funcall2(input, oj_read_id, 0, 0);
 	    len = RSTRING_LEN(s) + 1;
 	    json = ALLOC_N(char, len);
-	    strcpy(json, StringValuePtr(s));
+	    strcpy(json, rb_string_value_cstr((VALUE*)&s));
 	} else {
 	    rb_raise(rb_eArgError, "saj_parse() expected a String or IO Object.");
 	}

data/ext/oj/scp.c

@@ -107,7 +107,7 @@ add_value(ParseInfo pi, VALUE val) {
 
 static void
 add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
-    VALUE	rstr = rb_str_new(str, len);
+    volatile VALUE	rstr = rb_str_new(str, len);
 
     rstr = oj_encode(rstr);
      rb_funcall((VALUE)pi->cbc, oj_add_value_id, 1, rstr);
@@ -140,7 +140,7 @@ end_array(ParseInfo pi) {
 
 static VALUE
 hash_key(ParseInfo pi, const char *key, size_t klen) {
-    VALUE	rkey = rb_str_new(key, klen);
+    volatile VALUE	rkey = rb_str_new(key, klen);
 
     rkey = oj_encode(rkey);
     if (Yes == pi->options.sym_key) {
@@ -151,7 +151,7 @@ hash_key(ParseInfo pi, const char *key, size_t klen) {
 
 static void
 hash_set_cstr(ParseInfo pi, const char *key, size_t klen, const char *str, size_t len, const char *orig) {
-    VALUE	rstr = rb_str_new(str, len);
+    volatile VALUE	rstr = rb_str_new(str, len);
 
     rstr = oj_encode(rstr);
     rb_funcall((VALUE)pi->cbc, oj_hash_set_id, 3, stack_peek(&pi->stack)->val, hash_key(pi, key, klen), rstr);
@@ -169,7 +169,7 @@ hash_set_value(ParseInfo pi, const char *key, size_t klen, VALUE value) {
 
 static void
 array_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
-    VALUE	rstr = rb_str_new(str, len);
+    volatile VALUE	rstr = rb_str_new(str, len);
 
     rstr = oj_encode(rstr);
     rb_funcall((VALUE)pi->cbc, oj_array_append_id, 2, stack_peek(&pi->stack)->val, rstr);