oj 3.7.4 → 3.11.2

data/ext/oj/oj.h

@@ -1,12 +1,9 @@
-/* oj.h
- * Copyright (c) 2011, Peter Ohler
- * All rights reserved.
- */
+// Copyright (c) 2011 Peter Ohler. All rights reserved.
 
-#ifndef __OJ_H__
-#define __OJ_H__
+#ifndef OJ_H
+#define OJ_H
 
-#if defined(__cplusplus)
+#if defined(cplusplus)
 extern "C" {
 #if 0
 } /* satisfy cc-mode */
@@ -21,7 +18,7 @@ extern "C" {
 #include <stdint.h>
 #include <stdbool.h>
 
-#if HAVE_LIBPTHREAD
+#ifdef HAVE_PTHREAD_MUTEX_INIT
 #include <pthread.h>
 #endif
 #include "cache8.h"
@@ -69,14 +66,17 @@ typedef enum {
     JSONEsc	= 'j',
     XSSEsc	= 'x',
     ASCIIEsc	= 'a',
-    JXEsc	= 'r', // json
+    JXEsc	= 'g', // json gem
+    RailsXEsc	= 'r', // rails xss mode
     RailsEsc	= 'R', // rails non escape
 } Encoding;
 
 typedef enum {
     BigDec	= 'b',
     FloatDec	= 'f',
-    AutoDec	= 'a'
+    AutoDec	= 'a',
+    FastDec	= 'F',
+    RubyDec	= 'r',
 } BigLoad;
 
 typedef enum {
@@ -107,7 +107,7 @@ typedef enum {
     // Add the fast versions if necessary. Maybe unparse as well if needed.
 } DumpCaller;
 
-typedef struct _DumpOpts {
+typedef struct _dumpOpts {
     bool	use;
     char	indent_str[16];
     char	before_sep[16];
@@ -124,7 +124,7 @@ typedef struct _DumpOpts {
     int		max_depth;
 } *DumpOpts;
 
-typedef struct _Options {
+typedef struct _options {
     int			indent;		// indention for dump, default 2
     char		circular;	// YesNo
     char		auto_define;	// YesNo
@@ -135,9 +135,11 @@ typedef struct _Options {
     char		time_format;	// TimeFormat
     char		bigdec_as_num;	// YesNo
     char		bigdec_load;	// BigLoad
+    char		compat_bigdec;	// boolean (0 or 1)
     char		to_hash;	// YesNo
     char		to_json;	// YesNo
     char		as_json;	// YesNo
+    char		raw_json;	// YesNo
     char		nilnil;		// YesNo
     char		empty_string;	// YesNo
     char		allow_gc;	// allow GC during parse
@@ -146,8 +148,11 @@ typedef struct _Options {
     char		create_ok;	// YesNo allow create_id
     char		allow_nan;	// YEsyNo for parsing only
     char		trace;		// YesNo
-    int64_t		integer_range_min; // dump numbers outside range as string
-    int64_t		integer_range_max;
+    char		safe;		// YesNo
+    char		sec_prec_set;	// boolean (0 or 1)
+    char		ignore_under;	// YesNo - ignore attrs starting with _ if true in object and custom modes
+    int64_t		int_range_min;	// dump numbers below as string
+    int64_t		int_range_max;	// dump numbers above as string
     const char		*create_id;	// 0 or string
     size_t		create_id_len;	// length of create_id
     int			sec_prec;	// second precision when dumping time
@@ -155,28 +160,28 @@ typedef struct _Options {
     char		float_fmt[7];	// float format for dumping, if empty use Ruby
     VALUE		hash_class;	// class to use in place of Hash on load
     VALUE		array_class;	// class to use in place of Array on load
-    struct _DumpOpts	dump_opts;
-    struct _RxClass	str_rx;
+    struct _dumpOpts	dump_opts;
+    struct _rxClass	str_rx;
     VALUE		*ignore;	// Qnil terminated array of classes or NULL
 } *Options;
 
-struct _Out;
-typedef void	(*DumpFunc)(VALUE obj, int depth, struct _Out *out, bool as_ok);
+struct _out;
+typedef void	(*DumpFunc)(VALUE obj, int depth, struct _out *out, bool as_ok);
 
 // rails optimize
-typedef struct _ROpt {
+typedef struct _rOpt {
     VALUE	clas;
     bool	on;
     DumpFunc	dump;
 } *ROpt;
 
-typedef struct _ROptTable {
+typedef struct _rOptTable {
     int			len;
     int			alen;
     ROpt		table;
 } *ROptTable;
 
-typedef struct _Out {
+typedef struct _out {
     char		*buf;
     char		*end;
     char		*cur;
@@ -194,18 +199,18 @@ typedef struct _Out {
     ROptTable		ropts;
 } *Out;
 
-typedef struct _StrWriter {
-    struct _Out		out;
-    struct _Options	opts;
+typedef struct _strWriter {
+    struct _out		out;
+    struct _options	opts;
     int			depth;
     char		*types;	// DumpType
     char		*types_end;
     int			keyWritten;
-    
+
 } *StrWriter;
 
-typedef struct _StreamWriter {
-    struct _StrWriter	sw;
+typedef struct _streamWriter {
+    struct _strWriter	sw;
     StreamWriterType	type;
     VALUE		stream;
     int			fd;
@@ -218,16 +223,16 @@ enum {
     COL_VAL  = 0x02,
     RUBY_VAL = 0x03
 };
-    
-typedef struct _Leaf {
-    struct _Leaf	*next;
+
+typedef struct _leaf {
+    struct _leaf	*next;
     union {
 	const char	*key;	   // hash key
 	size_t		index;	   // array index, 0 is not set
     };
     union {
 	char		*str;	   // pointer to location in json string or allocated
-	struct _Leaf	*elements; // array and hash elements
+	struct _leaf	*elements; // array and hash elements
 	VALUE		value;
     };
     uint8_t		rtype;
@@ -284,7 +289,7 @@ extern void	oj_parse_opt_match_string(RxClass rc, VALUE ropts);
 extern VALUE	oj_rails_encode(int argc, VALUE *argv, VALUE self);
 
 extern VALUE	Oj;
-extern struct _Options	oj_default_options;
+extern struct _options	oj_default_options;
 extern rb_encoding	*oj_utf8_encoding;
 
 extern VALUE	oj_bag_class;
@@ -306,6 +311,7 @@ extern VALUE	oj_array_class_sym;
 extern VALUE	oj_array_nl_sym;
 extern VALUE	oj_ascii_only_sym;
 extern VALUE	oj_create_additions_sym;
+extern VALUE	oj_decimal_class_sym;
 extern VALUE	oj_hash_class_sym;
 extern VALUE	oj_indent_sym;
 extern VALUE	oj_max_nesting_sym;
@@ -348,6 +354,7 @@ extern ID	oj_readpartial_id;
 extern ID	oj_replace_id;
 extern ID	oj_stat_id;
 extern ID	oj_string_id;
+extern ID	oj_raw_json_id;
 extern ID	oj_to_h_id;
 extern ID	oj_to_hash_id;
 extern ID	oj_to_json_id;
@@ -364,17 +371,18 @@ extern ID	oj_write_id;
 
 extern bool	oj_use_hash_alt;
 extern bool	oj_use_array_alt;
+extern bool	string_writer_optimized;
 
-#if HAVE_LIBPTHREAD
+#ifdef HAVE_PTHREAD_MUTEX_INIT
 extern pthread_mutex_t	oj_cache_mutex;
 #else
 extern VALUE	oj_cache_mutex;
 #endif
 
-#if defined(__cplusplus)
+#if defined(cplusplus)
 #if 0
 { /* satisfy cc-mode */
 #endif
 }  /* extern "C" { */
 #endif
-#endif /* __OJ_H__ */
+#endif /* OJ_H */

data/ext/oj/parse.c

@@ -1,13 +1,11 @@
-/* parse.c
- * Copyright (c) 2013, Peter Ohler
- * All rights reserved.
- */
+// Copyright (c) 2013 Peter Ohler. All rights reserved.
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
 #include <math.h>
+#include <ruby/util.h>
 
 #include "oj.h"
 #include "encode.h"
@@ -188,7 +186,7 @@ unicode_to_chars(ParseInfo pi, Buf buf, uint32_t code) {
 // entered at /
 static void
 read_escaped_str(ParseInfo pi, const char *start) {
-    struct _Buf	buf;
+    struct _buf	buf;
     const char	*s;
     int		cnt = (int)(pi->cur - start);
     uint32_t	code;
@@ -214,18 +212,6 @@ read_escaped_str(ParseInfo pi, const char *start) {
 	    case '"':	buf_append(&buf, '"');	break;
 	    case '/':	buf_append(&buf, '/');	break;
 	    case '\\':	buf_append(&buf, '\\');	break;
-	    case '\'':
-		// The json gem claims this is not an error despite the
-		// ECMA-404 indicating it is not valid.
-		if (CompatMode == pi->options.mode) {
-		    buf_append(&buf, '\'');
-		} else {
-		    pi->cur = s;
-		    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid escaped character");
-		    buf_cleanup(&buf);
-		    return;
-		}
-		break;
 	    case 'u':
 		s++;
 		if (0 == (code = read_hex(pi, s)) && err_has(&pi->err)) {
@@ -265,6 +251,12 @@ read_escaped_str(ParseInfo pi, const char *start) {
 		}
 		break;
 	    default:
+		// The json gem claims this is not an error despite the
+		// ECMA-404 indicating it is not valid.
+		if (CompatMode == pi->options.mode) {
+		    buf_append(&buf, *s);
+		    break;
+		}
 		pi->cur = s;
 		oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid escaped character");
 		buf_cleanup(&buf);
@@ -378,7 +370,7 @@ read_str(ParseInfo pi) {
 
 static void
 read_num(ParseInfo pi) {
-    struct _NumInfo	ni;
+    struct _numInfo	ni;
     Val			parent = stack_peek(&pi->stack);
 
     ni.str = pi->cur;
@@ -392,13 +384,23 @@ read_num(ParseInfo pi) {
     ni.infinity = 0;
     ni.nan = 0;
     ni.neg = 0;
-    ni.hasExp = 0;
-    ni.no_big = (FloatDec == pi->options.bigdec_load);
+    ni.has_exp = 0;
+    if (CompatMode == pi->options.mode) {
+	ni.no_big = !pi->options.compat_bigdec;
+	ni.bigdec_load = pi->options.compat_bigdec;
+    } else {
+	ni.no_big = (FloatDec == pi->options.bigdec_load || FastDec == pi->options.bigdec_load || RubyDec == pi->options.bigdec_load);
+	ni.bigdec_load = pi->options.bigdec_load;
+    }
 
     if ('-' == *pi->cur) {
 	pi->cur++;
 	ni.neg = 1;
     } else if ('+' == *pi->cur) {
+	if (StrictMode == pi->options.mode) {
+	    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
+	    return;
+	}
 	pi->cur++;
     }
     if ('I' == *pi->cur) {
@@ -418,7 +420,7 @@ read_num(ParseInfo pi) {
     } else {
 	int	dec_cnt = 0;
 	bool	zero1 = false;
-	
+
 	for (; '0' <= *pi->cur && *pi->cur <= '9'; pi->cur++) {
 	    if (0 == ni.i && '0' == *pi->cur) {
 		zero1 = true;
@@ -445,8 +447,14 @@ read_num(ParseInfo pi) {
 	if ('.' == *pi->cur) {
 	    pi->cur++;
 	    // A trailing . is not a valid decimal but if encountered allow it
-	    // except when mimicing the JSON gem.
-	    if (CompatMode == pi->options.mode) {
+	    // except when mimicing the JSON gem or in strict mode.
+	    if (StrictMode == pi->options.mode || CompatMode == pi->options.mode) {
+		int	pos = (int)(pi->cur - ni.str);
+
+		if (1 == pos || (2 == pos && ni.neg)) {
+		    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number");
+		    return;
+		}
 		if (*pi->cur < '0' || '9' < *pi->cur) {
 		    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number");
 		    return;
@@ -458,18 +466,26 @@ read_num(ParseInfo pi) {
 		if (0 < ni.num || 0 < ni.i) {
 		    dec_cnt++;
 		}
-		ni.num = ni.num * 10 + d;
-		ni.div *= 10;
-		ni.di++;
-		if (INT64_MAX <= ni.div || DEC_MAX < dec_cnt) {
-		    ni.big = 1;
+		if (INT64_MAX <= ni.div) {
+		    if (!ni.no_big) {
+			ni.big = true;
+		    }
+		} else {
+		    ni.num = ni.num * 10 + d;
+		    ni.div *= 10;
+		    ni.di++;
+		    if (INT64_MAX <= ni.div || DEC_MAX < dec_cnt) {
+			if (!ni.no_big) {
+			    ni.big = true;
+			}
+		    }
 		}
 	    }
 	}
 	if ('e' == *pi->cur || 'E' == *pi->cur) {
 	    int	eneg = 0;
 
-	    ni.hasExp = 1;
+	    ni.has_exp = 1;
 	    pi->cur++;
 	    if ('-' == *pi->cur) {
 		pi->cur++;
@@ -480,7 +496,7 @@ read_num(ParseInfo pi) {
 	    for (; '0' <= *pi->cur && *pi->cur <= '9'; pi->cur++) {
 		ni.exp = ni.exp * 10 + (*pi->cur - '0');
 		if (EXP_MAX <= ni.exp) {
-		    ni.big = 1;
+		    ni.big = true;
 		}
 	    }
 	    if (eneg) {
@@ -500,7 +516,11 @@ read_num(ParseInfo pi) {
 	    ni.nan = 1;
 	}
     }
-    if (BigDec == pi->options.bigdec_load) {
+    if (CompatMode == pi->options.mode) {
+	if (pi->options.compat_bigdec) {
+	    ni.big = 1;
+	}
+    } else if (BigDec == pi->options.bigdec_load) {
 	ni.big = 1;
     }
     if (0 == parent) {
@@ -607,7 +627,7 @@ oj_parse2(ParseInfo pi) {
     while (1) {
 	if (0 < pi->max_depth && pi->max_depth <= pi->stack.tail - pi->stack.head - 1) {
 	    VALUE	err_clas = oj_get_json_err_class("NestingError");
-	    
+
 	    oj_set_error_at(pi, err_clas, __FILE__, __LINE__, "Too deeply nested.");
 	    pi->err_class = err_clas;
 	    return;
@@ -729,6 +749,70 @@ oj_parse2(ParseInfo pi) {
     }
 }
 
+static VALUE
+rescue_big_decimal(VALUE str, VALUE ignore) {
+    rb_raise(oj_parse_error_class, "Invalid value for BigDecimal()");
+    return Qnil;
+}
+
+static VALUE
+parse_big_decimal(VALUE str) {
+    return rb_funcall(rb_cObject, oj_bigdecimal_id, 1, str);
+}
+
+static long double	exp_plus[] = {
+    1.0,
+    1.0e1,
+    1.0e2,
+    1.0e3,
+    1.0e4,
+    1.0e5,
+    1.0e6,
+    1.0e7,
+    1.0e8,
+    1.0e9,
+    1.0e10,
+    1.0e11,
+    1.0e12,
+    1.0e13,
+    1.0e14,
+    1.0e15,
+    1.0e16,
+    1.0e17,
+    1.0e18,
+    1.0e19,
+    1.0e20,
+    1.0e21,
+    1.0e22,
+    1.0e23,
+    1.0e24,
+    1.0e25,
+    1.0e26,
+    1.0e27,
+    1.0e28,
+    1.0e29,
+    1.0e30,
+    1.0e31,
+    1.0e32,
+    1.0e33,
+    1.0e34,
+    1.0e35,
+    1.0e36,
+    1.0e37,
+    1.0e38,
+    1.0e39,
+    1.0e40,
+    1.0e41,
+    1.0e42,
+    1.0e43,
+    1.0e44,
+    1.0e45,
+    1.0e46,
+    1.0e47,
+    1.0e48,
+    1.0e49,
+};
+
 VALUE
 oj_num_as_value(NumInfo ni) {
     volatile VALUE	rnum = Qnil;
@@ -741,7 +825,7 @@ oj_num_as_value(NumInfo ni) {
 	}
     } else if (ni->nan) {
 	rnum = rb_float_new(0.0/0.0);
-    } else if (1 == ni->div && 0 == ni->exp) { // fixnum
+    } else if (1 == ni->div && 0 == ni->exp && !ni->has_exp) { // fixnum
 	if (ni->big) {
 	    if (256 > ni->len) {
 		char	buf[256];
@@ -766,35 +850,45 @@ oj_num_as_value(NumInfo ni) {
 	}
     } else { // decimal
 	if (ni->big) {
-	    rnum = rb_funcall(rb_cObject, oj_bigdecimal_id, 1, rb_str_new(ni->str, ni->len));
+	    volatile VALUE	bd = rb_str_new(ni->str, ni->len);
+
+	    rnum = rb_rescue2(parse_big_decimal, bd, rescue_big_decimal, bd, rb_eException, 0);
 	    if (ni->no_big) {
 		rnum = rb_funcall(rnum, rb_intern("to_f"), 0);
 	    }
-	} else {
-	    // All these machinations are to get rounding to work better.
-	    long double	d = (long double)ni->i * (long double)ni->div + (long double)ni->num;
+	} else if (FastDec == ni->bigdec_load) {
+	    long double	ld = (long double)ni->i * (long double)ni->div + (long double)ni->num;
 	    int		x = (int)((int64_t)ni->exp - ni->di);
 
-	    // Rounding sometimes cuts off the last digit even if there are only
-	    // 15 digits. This attempts to fix those few cases where this
-	    // occurs.
-	    if ((long double)INT64_MAX > d && (int64_t)d != (ni->i * ni->div + ni->num)) {
-		rnum = rb_funcall(rb_cObject, oj_bigdecimal_id, 1, rb_str_new(ni->str, ni->len));
-		if (ni->no_big) {
-		    rnum = rb_funcall(rnum, rb_intern("to_f"), 0);
-		}
-	    } else {
-		d = roundl(d);
-		if (0 < x) {
-		    d *= powl(10.0L, x);
-		} else if (0 > x) {
-		    d /= powl(10.0L, -x);
+	    if (0 < x) {
+		if (x < (int)(sizeof(exp_plus) / sizeof(*exp_plus))) {
+		    ld *= exp_plus[x];
+		} else {
+		    ld *= powl(10.0, x);
 		}
-		if (ni->neg) {
-		    d = -d;
+	    } else if (x < 0) {
+		if (-x < (int)(sizeof(exp_plus) / sizeof(*exp_plus))) {
+		    ld /= exp_plus[-x];
+		} else {
+		    ld /= powl(10.0, -x);
 		}
-		rnum = rb_float_new((double)d);
 	    }
+	    if (ni->neg) {
+		ld = -ld;
+	    }
+	    rnum = rb_float_new((double)ld);
+	} else if (RubyDec == ni->bigdec_load) {
+	    volatile VALUE	sv = rb_str_new(ni->str, ni->len);
+
+	    rnum = rb_funcall(sv, rb_intern("to_f"), 0);
+	} else {
+	    char	*end;
+	    double	d = strtod(ni->str, &end);
+
+	    if ((long)ni->len != (long)(end - ni->str)) {
+		rb_raise(oj_parse_error_class, "Invalid float");
+	    }
+	    rnum = rb_float_new(d);
 	}
     }
     return rnum;
@@ -816,6 +910,12 @@ oj_set_error_at(ParseInfo pi, VALUE err_clas, const char* file, int line, const
     if (p + 3 < end) {
 	*p++ = ' ';
 	*p++ = '(';
+	*p++ = 'a';
+	*p++ = 'f';
+	*p++ = 't';
+	*p++ = 'e';
+	*p++ = 'r';
+	*p++ = ' ';
 	start = p;
 	for (vp = pi->stack.head; vp < pi->stack.tail; vp++) {
 	    if (end <= p + 1 + vp->klen) {
@@ -833,7 +933,7 @@ oj_set_error_at(ParseInfo pi, VALUE err_clas, const char* file, int line, const
 			break;
 		    }
 		    p += snprintf(p, end - p, "[%ld]", RARRAY_LEN(vp->val));
-		}		    
+		}
 	    }
 	}
 	*p++ = ')';
@@ -976,12 +1076,12 @@ oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json, size_t len, int yie
 	if (0 != line) {
 	    VALUE	ec = rb_obj_class(rb_errinfo());
 
-	    if (rb_eIOError != ec) {
-		goto CLEANUP;
-	    }
 	    if (rb_eArgError != ec && 0 != ec) {
 		err_class = ec;
 	    }
+	    if (rb_eIOError != ec) {
+		goto CLEANUP;
+	    }
 	}
 	if (NULL != (v = stack_peek(&pi->stack))) {
 	    switch (v->next) {
@@ -1021,7 +1121,7 @@ CLEANUP:
 	if (Qnil != pi->err_class) {
 	    pi->err.clas = pi->err_class;
 	}
-	if (CompatMode == pi->options.mode) {
+	if (CompatMode == pi->options.mode && Yes != pi->options.safe) {
 	    // The json gem requires the error message be UTF-8 encoded. In
 	    // additional the complete JSON source must be returned. There
 	    // does not seem to be a size limit.
@@ -1033,6 +1133,10 @@ CLEANUP:
 		msg = rb_str_append(msg, oj_encode(rb_str_new2(pi->json)));
 	    }
 	    args[0] = msg;
+	    if (pi->err.clas == oj_parse_error_class) {
+		// The error was an Oj::ParseError so change to a JSON::ParserError.
+		pi->err.clas = oj_json_parser_error_class;
+	    }
 	    rb_exc_raise(rb_class_new_instance(1, args, pi->err.clas));
 	} else {
 	    oj_err_raise(&pi->err);
@@ -1050,7 +1154,7 @@ CLEANUP:
 	case T_CLASS:
 	case T_STRING:
 	case T_SYMBOL: {
-	    struct _Err	err;
+	    struct _err	err;
 
 	    if (Qnil == pi->err_class) {
 		err.clas = oj_parse_error_class;