oj 2.0.0 → 3.0.0

data/ext/oj/rxclass.c

@@ -0,0 +1,133 @@
+/* rxclass.c
+ * Copyright (c) 2017, Peter Ohler
+ * All rights reserved.
+ */
+
+#include <sys/types.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <regex.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "rxclass.h"
+
+typedef struct _RxC {
+    struct _RxC	*next;
+    VALUE	rrx;
+    regex_t	rx;
+    VALUE	clas;
+    char	src[256];
+} *RxC;
+
+void
+oj_rxclass_init(RxClass rc) {
+    *rc->err = '\0';
+    rc->head = NULL;
+    rc->tail = NULL;
+}
+
+void
+oj_rxclass_cleanup(RxClass rc) {
+    RxC	rxc;
+
+    while (NULL != (rxc = rc->head)) {
+	rc->head = rc->head->next;
+	if (Qnil == rxc->rrx) {
+	    regfree(&rxc->rx);
+	}
+	xfree(rxc);
+    }
+}
+
+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->clas = clas;
+    if (NULL == rc->tail) {
+	rc->head = rxc;
+    } else {
+	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) {
+    // Use mallow and not ALLOC_N to avoid pulliing ruby.h which conflicts
+    // with regex_t.
+    RxC	rxc;
+    int	err;
+    int	flags = 0;
+    
+    if (sizeof(rxc->src) <= strlen(expr)) {
+	snprintf(rc->err, sizeof(rc->err), "expressions must be less than %lu chracter", sizeof(rxc->src));
+	return EINVAL;
+    }
+    rxc = ALLOC_N(struct _RxC, 1);
+    rxc->next = 0;
+    rxc->rrx = Qnil;
+    rxc->clas = clas;
+    if (0 != (err = regcomp(&rxc->rx, expr, flags))) {
+	regerror(err, &rxc->rx, rc->err, sizeof(rc->err));
+	free(rxc);
+	return err;
+    }
+    if (NULL == rc->tail) {
+	rc->head = rxc;
+    } else {
+	rc->tail->next = rxc;
+    }
+    rc->tail = rxc;
+
+    return 0;
+}
+
+VALUE
+oj_rxclass_match(RxClass rc, const char *str, int len) {
+    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)) {
+	    // 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;
+	    }
+	} else {
+	    // TBD allocate a larger buffer and attempt
+	}
+    }
+    return Qnil;
+}
+
+void
+oj_rxclass_copy(RxClass src, RxClass dest) {
+    dest->head = NULL;
+    dest->tail = NULL;
+    if (NULL != src->head) {
+	RxC	rxc;
+
+	for (rxc = src->head; NULL != rxc; rxc = rxc->next) {
+	    if (Qnil != rxc->rrx) {
+		oj_rxclass_rappend(dest, rxc->rrx, rxc->clas);
+	    } else {
+		oj_rxclass_append(dest, rxc->src, rxc->clas);
+	    }
+	}
+    }
+}

data/ext/oj/rxclass.h

@@ -0,0 +1,27 @@
+/* rxclass.h
+ * Copyright (c) 2017, Peter Ohler
+ * All rights reserved.
+ */
+
+#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;
+
+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,31 +1,6 @@
 /* saj.c
  * Copyright (c) 2012, Peter Ohler
  * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * 
- *  - Redistributions of source code must retain the above copyright notice, this
- *    list of conditions and the following disclaimer.
- * 
- *  - Redistributions in binary form must reproduce the above copyright notice,
- *    this list of conditions and the following disclaimer in the documentation
- *    and/or other materials provided with the distribution.
- * 
- *  - Neither the name of Peter Ohler nor the names of its contributors may be
- *    used to endorse or promote products derived from this software without
- *    specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #if !IS_WINDOWS
@@ -35,19 +10,14 @@
 #include <stdio.h>
 #include <string.h>
 #include <math.h>
+#include <sys/types.h>
+#include <unistd.h>
 
-/* Workaround: */
-#ifndef INFINITY
-#define INFINITY (1.0/0.0)
-#endif
+// Workaround in case INFINITY is not defined in math.h or if the OS is CentOS
+#define OJ_INFINITY (1.0/0.0)
 
 #include "oj.h"
-
-typedef struct _CX {
-    VALUE	*cur;
-    VALUE	*end;
-    VALUE	stack[1024];
-} *CX;
+#include "encode.h"
 
 typedef struct _ParseInfo {
     char	*str;		/* buffer being read from */
@@ -74,9 +44,9 @@ static void	next_non_white(ParseInfo pi);
 static char*	read_quoted_value(ParseInfo pi);
 static void	skip_comment(ParseInfo pi);
 
-/* This XML parser is a single pass, destructive, callback parser. It is a
+/* 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
- * XML document string. It is destructive because it re-uses the content of
+ * JSON document string. It is destructive because it re-uses the content of
  * the string for values in the callback and places \0 characters at various
  * places to mark the end of tokens and strings. It is a callback parser like
  * a SAX parser because it uses callback when document elements are
@@ -125,49 +95,28 @@ next_non_white(ParseInfo pi) {
     }
 }
 
-inline static void
-next_white(ParseInfo pi) {
-    for (; 1; pi->s++) {
-	switch(*pi->s) {
-	case ' ':
-	case '\t':
-	case '\f':
-	case '\n':
-	case '\r':
-	case '\0':
-	    return;
-	default:
-	    break;
-	}
-    }
-}
-
 inline static void
 call_add_value(VALUE handler, VALUE value, const char *key) {
-    VALUE	k;
+    volatile VALUE	k;
 
     if (0 == key) {
 	k = Qnil;
     } else {
 	k = rb_str_new2(key);
-#if HAS_ENCODING_SUPPORT
-	rb_enc_associate(k, oj_utf8_encoding);
-#endif
+	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) {
-    VALUE	k;
+    volatile VALUE	k;
 
     if (0 == key) {
 	k = Qnil;
     } else {
 	k = rb_str_new2(key);
-#if HAS_ENCODING_SUPPORT
-	rb_enc_associate(k, oj_utf8_encoding);
-#endif
+	k = oj_encode(k);
     }
     rb_funcall(handler, method, 1, k);
 }
@@ -344,9 +293,7 @@ read_str(ParseInfo pi, const char *key) {
     if (pi->has_add_value) {
 	VALUE	s = rb_str_new2(text);
 
-#if HAS_ENCODING_SUPPORT
-	rb_enc_associate(s, oj_utf8_encoding);
-#endif
+	s = oj_encode(s);
 	call_add_value(pi->handler, s, key);
     }
 }
@@ -384,11 +331,11 @@ read_num(ParseInfo pi, const char *key) {
 	pi->s += 8;
 	if (neg) {
 	    if (pi->has_add_value) {
-		call_add_value(pi->handler, rb_float_new(-INFINITY), key);
+		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(INFINITY), key);
+		call_add_value(pi->handler, rb_float_new(OJ_INFINITY), key);
 	    }
 	}
 	return;
@@ -655,25 +602,9 @@ read_quoted_value(ParseInfo pi) {
     return value;
 }
 
-inline static int
-respond_to(VALUE obj, ID method) {
-#ifdef JRUBY_RUBY
-    /* There is a bug in JRuby where rb_respond_to() returns true (1) even if
-     * a method is private. */
-    {
-	VALUE	args[1];
-
-	*args = ID2SYM(method);
-	return (Qtrue == rb_funcall2(obj, rb_intern("respond_to?"), 1, args));
-    }
-#else
-    return rb_respond_to(obj, method);
-#endif
-}
-
-void
-oj_saj_parse(VALUE handler, char *json) {
-    VALUE		obj = Qnil;
+static void
+saj_parse(VALUE handler, char *json) {
+    volatile VALUE	obj = Qnil;
     struct _ParseInfo	pi;
 
     if (0 == json) {
@@ -703,12 +634,12 @@ oj_saj_parse(VALUE handler, char *json) {
     }
 #endif
     pi.handler = handler;
-    pi.has_hash_start = respond_to(handler, oj_hash_start_id);
-    pi.has_hash_end = respond_to(handler, oj_hash_end_id);
-    pi.has_array_start = respond_to(handler, oj_array_start_id);
-    pi.has_array_end = respond_to(handler, oj_array_end_id);
-    pi.has_add_value = respond_to(handler, oj_add_value_id);
-    pi.has_error = respond_to(handler, oj_error_id);
+    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);
     read_next(&pi, 0);
     next_non_white(&pi);
     if ('\0' != *pi.s) {
@@ -720,93 +651,64 @@ oj_saj_parse(VALUE handler, char *json) {
     }
 }
 
-
-#if 0
-static void
-cx_add(CX cx, VALUE obj, const char *key) {
-    if (0 == cx->cur) {
-	cx->cur = cx->stack;
-	*cx->cur = obj;
+/* call-seq: saj_parse(handler, io)
+ *
+ * Parses an IO stream or file containing an JSON document. Raises an exception
+ * if the JSON is malformed.
+ * @param [Oj::Saj] handler Saj (responds to Oj::Saj methods) like handler
+ * @param [IO|String] io IO Object to read from
+ * @deprecated The sc_parse() method along with the ScHandler is the preferred
+ * callback parser. It is slightly faster and handles streams while the
+ * saj_parse() methos requires a complete read before parsing.
+ * @see sc_parse
+ */
+VALUE
+oj_saj_parse(int argc, VALUE *argv, VALUE self) {
+    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");
+    }
+    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));
     } else {
-	if (0 != key) {
-	    VALUE	ks = rb_str_new2(key);
-#if HAS_ENCODING_SUPPORT
-	    rb_enc_associate(ks, oj_utf8_encoding);
+	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';
 #endif
-	    rb_hash_aset(*cx->cur, ks, obj);
+	} 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_ary_push(*cx->cur, obj);
+	    rb_raise(rb_eArgError, "saj_parse() expected a String or IO Object.");
 	}
     }
-}
+    saj_parse(*argv, json);
+    xfree(json);
 
-static void
-cx_push(CX cx, VALUE obj, const char *key) {
-    if (0 == cx->cur) {
-	cx->cur = cx->stack;
-    } else {
-	if (cx->end <= cx->cur) {
-	    rb_raise(oj_parse_error_class, "too deeply nested");
-	}
-	cx_add(cx, obj, key);
-	cx->cur++;
-    }
-    *cx->cur = obj;
-}
-
-static void
-hash_start(void *context, const char *key) {
-    cx_push((CX)context, rb_hash_new(), key);
-}
-
-static void
-col_end(void *context, const char *key) {
-    ((CX)context)->cur--;
-}
-
-static void
-array_start(void *context, const char *key) {
-    cx_push((CX)context, rb_ary_new(), key);
-}
-
-static void
-add_str(void *context, const char *str, const char *key) {
-    VALUE	s;
-
-    s = rb_str_new2(str);
-#if HAS_ENCODING_SUPPORT
-    rb_enc_associate(s, oj_utf8_encoding);
-#endif
-    cx_add((CX)context, s, key);
-}
-
-static void
-add_big(void *context, const char *str, const char *key) {
-    cx_add((CX)context, rb_funcall(oj_bigdecimal_class, oj_new_id, 1, rb_str_new2(str)), key);
-}
-
-static void
-add_float(void *context, double num, const char *key) {
-    cx_add((CX)context, rb_float_new(num), key);
-}
-
-static void
-add_fixnum(void *context, int64_t num, const char *key) {
-    cx_add((CX)context, LONG2NUM(num), key);
-}
-
-static void
-add_true(void *context, const char *key) {
-    cx_add((CX)context, Qtrue, key);
-}
-
-static void
-add_false(void *context, const char *key) {
-    cx_add((CX)context, Qfalse, key);
+    return Qnil;
 }
-
-static void
-add_nil(void *context, const char *key) {
-    cx_add((CX)context, Qnil, key);
-}
-#endif