oj 2.0.0 → 3.0.0

data/ext/oj/parse.h

@@ -0,0 +1,92 @@
+/* parse.h
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#ifndef __OJ_PARSE_H__
+#define __OJ_PARSE_H__
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "ruby.h"
+#include "oj.h"
+#include "val_stack.h"
+#include "circarray.h"
+#include "reader.h"
+#include "rxclass.h"
+
+struct _RxClass;
+
+typedef struct _NumInfo {
+    int64_t	i;
+    int64_t	num;
+    int64_t	div;
+    int64_t	di;
+    const char	*str;
+    size_t	len;
+    long	exp;
+    int		big;
+    int		infinity;
+    int		nan;
+    int		neg;
+    int		hasExp;
+    int		no_big;
+} *NumInfo;
+
+typedef struct _ParseInfo {
+    // used for the string parser
+    const char		*json;
+    const char		*cur;
+    const char		*end;
+    // used for the stream parser
+    struct _Reader	rd;
+
+    struct _Err		err;
+    struct _Options	options;
+    VALUE		handler;
+    struct _ValStack	stack;
+    CircArray		circ_array;
+    struct _RxClass	str_rx;
+    int			expect_value;
+    int			max_depth; // just for the json gem
+    VALUE		proc;
+    VALUE		(*start_hash)(struct _ParseInfo *pi);
+    void		(*end_hash)(struct _ParseInfo *pi);
+    VALUE		(*hash_key)(struct _ParseInfo *pi, const char *key, size_t klen);
+    void		(*hash_set_cstr)(struct _ParseInfo *pi, Val kval, const char *str, size_t len, const char *orig);
+    void		(*hash_set_num)(struct _ParseInfo *pi, Val kval, NumInfo ni);
+    void		(*hash_set_value)(struct _ParseInfo *pi, Val kval, VALUE value);
+
+    VALUE		(*start_array)(struct _ParseInfo *pi);
+    void		(*end_array)(struct _ParseInfo *pi);
+    void		(*array_append_cstr)(struct _ParseInfo *pi, const char *str, size_t len, const char *orig);
+    void		(*array_append_num)(struct _ParseInfo *pi, NumInfo ni);
+    void		(*array_append_value)(struct _ParseInfo *pi, VALUE value);
+
+    void		(*add_cstr)(struct _ParseInfo *pi, const char *str, size_t len, const char *orig);
+    void		(*add_num)(struct _ParseInfo *pi, NumInfo ni);
+    void		(*add_value)(struct _ParseInfo *pi, VALUE val);
+    VALUE		err_class;
+    bool		has_callbacks;
+} *ParseInfo;
+
+extern void	oj_parse2(ParseInfo pi);
+extern void	oj_set_error_at(ParseInfo pi, VALUE err_clas, const char* file, int line, const char *format, ...);
+extern VALUE	oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json, size_t len, int yieldOk);
+extern VALUE	oj_num_as_value(NumInfo ni);
+
+extern void	oj_set_strict_callbacks(ParseInfo pi);
+extern void	oj_set_object_callbacks(ParseInfo pi);
+extern void	oj_set_compat_callbacks(ParseInfo pi);
+
+extern void	oj_sparse2(ParseInfo pi);
+extern VALUE	oj_pi_sparse(int argc, VALUE *argv, ParseInfo pi, int fd);
+
+static inline void
+parse_info_init(ParseInfo pi) {
+    memset(pi, 0, sizeof(struct _ParseInfo));
+}
+
+#endif /* __OJ_PARSE_H__ */

data/ext/oj/reader.c

@@ -0,0 +1,223 @@
+/* reader.c
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#include <stdlib.h>
+#include <errno.h>
+#include <stdio.h>
+#include <strings.h>
+#include <sys/types.h>
+#if NEEDS_UIO
+#include <sys/uio.h>	
+#endif
+#include <unistd.h>
+#include <time.h>
+
+#include "ruby.h"
+#include "oj.h"
+#include "reader.h"
+
+#define BUF_PAD	4
+
+static VALUE		rescue_cb(VALUE rdr, VALUE err);
+static VALUE		io_cb(VALUE rdr);
+static VALUE		partial_io_cb(VALUE rdr);
+static int		read_from_io(Reader reader);
+static int		read_from_fd(Reader reader);
+static int		read_from_io_partial(Reader reader);
+//static int		read_from_str(Reader reader);
+
+void
+oj_reader_init(Reader reader, VALUE io, int fd) {
+    VALUE	io_class = rb_obj_class(io);
+    VALUE	stat;
+    VALUE	ftype;
+
+    reader->head = reader->base;
+    *((char*)reader->head) = '\0';
+    reader->end = reader->head + sizeof(reader->base) - BUF_PAD;
+    reader->tail = reader->head;
+    reader->read_end = reader->head;
+    reader->pro = 0;
+    reader->str = 0;
+    reader->pos = 0;
+    reader->line = 1;
+    reader->col = 0;
+    reader->free_head = 0;
+
+    if (0 != fd) {
+	reader->read_func = read_from_fd;
+	reader->fd = fd;
+    } else if (rb_cString == io_class) {
+	reader->read_func = 0;
+	reader->in_str = StringValuePtr(io);
+	reader->head = (char*)reader->in_str;
+	reader->tail = reader->head;
+	reader->read_end = reader->head + RSTRING_LEN(io);
+    } else if (oj_stringio_class == io_class) {
+	VALUE	s = rb_funcall2(io, oj_string_id, 0, 0);
+
+	reader->read_func = 0;
+	reader->in_str = StringValuePtr(s);
+	reader->head = (char*)reader->in_str;
+	reader->tail = reader->head;
+	reader->read_end = reader->head + RSTRING_LEN(s);
+    } else if (rb_cFile == io_class &&
+	       Qnil != (stat = rb_funcall(io, oj_stat_id, 0)) &&
+	       Qnil != (ftype = rb_funcall(stat, oj_ftype_id, 0)) &&
+	       0 == strcmp("file", StringValuePtr(ftype)) &&
+	       0 == FIX2INT(rb_funcall(io, oj_pos_id, 0))) {
+	reader->read_func = read_from_fd;
+	reader->fd = FIX2INT(rb_funcall(io, oj_fileno_id, 0));
+    } else if (rb_respond_to(io, oj_readpartial_id)) {
+	reader->read_func = read_from_io_partial;
+	reader->io = io;
+    } else if (rb_respond_to(io, oj_read_id)) {
+	reader->read_func = read_from_io;
+	reader->io = io;
+    } else {
+	rb_raise(rb_eArgError, "parser io argument must be a String or respond to readpartial() or read().\n");
+    }
+}
+
+int
+oj_reader_read(Reader reader) {
+    int		err;
+    size_t	shift = 0;
+
+    if (0 == reader->read_func) {
+	return -1;
+    }
+    // if there is not much room to read into, shift or realloc a larger buffer.
+    if (reader->head < reader->tail && 4096 > reader->end - reader->tail) {
+	if (0 == reader->pro) {
+	    shift = reader->tail - reader->head;
+	} else {
+	    shift = reader->pro - reader->head - 1; // leave one character so we can backup one
+	}
+	if (0 >= shift) { /* no space left so allocate more */
+	    const char	*old = reader->head;
+	    size_t	size = reader->end - reader->head + BUF_PAD;
+	
+	    if (reader->head == reader->base) {
+		reader->head = ALLOC_N(char, size * 2);
+		memcpy((char*)reader->head, old, size);
+	    } else {
+		REALLOC_N(reader->head, char, size * 2);
+	    }
+	    reader->free_head = 1;
+	    reader->end = reader->head + size * 2 - BUF_PAD;
+	    reader->tail = reader->head + (reader->tail - old);
+	    reader->read_end = reader->head + (reader->read_end - old);
+	    if (0 != reader->pro) {
+		reader->pro = reader->head + (reader->pro - old);
+	    }
+	    if (0 != reader->str) {
+		reader->str = reader->head + (reader->str - old);
+	    }
+	} else {
+	    memmove((char*)reader->head, reader->head + shift, reader->read_end - (reader->head + shift));
+	    reader->tail -= shift;
+	    reader->read_end -= shift;
+	    if (0 != reader->pro) {
+		reader->pro -= shift;
+	    }
+	    if (0 != reader->str) {
+		reader->str -= shift;
+	    }
+	}
+    }
+    err = reader->read_func(reader);
+    *(char*)reader->read_end = '\0';
+
+    return err;
+}
+
+static VALUE
+rescue_cb(VALUE rbuf, VALUE err) {
+    VALUE	clas = rb_obj_class(err);
+
+    if (rb_eTypeError != clas && rb_eEOFError != clas) {
+	Reader	reader = (Reader)rbuf;
+
+	rb_raise(clas, "at line %d, column %d\n", reader->line, reader->col);
+    }
+    return Qfalse;
+}
+
+static VALUE
+partial_io_cb(VALUE rbuf) {
+    Reader	reader = (Reader)rbuf;
+    VALUE	args[1];
+    VALUE	rstr;
+    char	*str;
+    size_t	cnt;
+
+    args[0] = ULONG2NUM(reader->end - reader->tail);
+    rstr = rb_funcall2(reader->io, oj_readpartial_id, 1, args);
+    if (Qnil == rstr) {
+	return Qfalse;
+    }
+    str = StringValuePtr(rstr);
+    cnt = RSTRING_LEN(rstr);
+    //printf("*** partial read %lu bytes, str: '%s'\n", cnt, str);
+    strcpy(reader->tail, str);
+    reader->read_end = reader->tail + cnt;
+
+    return Qtrue;
+}
+
+static VALUE
+io_cb(VALUE rbuf) {
+    Reader	reader = (Reader)rbuf;
+    VALUE	args[1];
+    VALUE	rstr;
+    char	*str;
+    size_t	cnt;
+
+    args[0] = ULONG2NUM(reader->end - reader->tail);
+    rstr = rb_funcall2(reader->io, oj_read_id, 1, args);
+    if (Qnil == rstr) {
+	return Qfalse;
+    }
+    str = StringValuePtr(rstr);
+    cnt = RSTRING_LEN(rstr);
+    //printf("*** read %lu bytes, str: '%s'\n", cnt, str);
+    strcpy(reader->tail, str);
+    reader->read_end = reader->tail + cnt;
+
+    return Qtrue;
+}
+
+static int
+read_from_io_partial(Reader reader) {
+    return (Qfalse == rb_rescue(partial_io_cb, (VALUE)reader, rescue_cb, (VALUE)reader));
+}
+
+static int
+read_from_io(Reader reader) {
+    return (Qfalse == rb_rescue(io_cb, (VALUE)reader, rescue_cb, (VALUE)reader));
+}
+
+static int
+read_from_fd(Reader reader) {
+    ssize_t	cnt;
+    size_t	max = reader->end - reader->tail;
+
+    cnt = read(reader->fd, reader->tail, max);
+    if (cnt <= 0) {
+	return -1;
+    } else if (0 != cnt) {
+	reader->read_end = reader->tail + cnt;
+    }
+    return 0;
+}
+
+// This is only called when the end of the string is reached so just return -1.
+/*
+static int
+read_from_str(Reader reader) {
+    return -1;
+}
+*/

data/ext/oj/reader.h

@@ -0,0 +1,151 @@
+/* reader.h
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#ifndef __OJ_READER_H__
+#define __OJ_READER_H__
+
+typedef struct _Reader {
+    char	base[0x00001000];
+    char	*head;
+    char	*end;
+    char	*tail;
+    char	*read_end;	/* one past last character read */
+    char	*pro;		/* protection start, buffer can not slide past this point */
+    char	*str;		/* start of current string being read */
+    long	pos;
+    int		line;
+    int		col;
+    int		free_head;
+    int		(*read_func)(struct _Reader *reader);
+    union {
+	int		fd;
+	VALUE		io;
+	const char	*in_str;
+    };
+} *Reader;
+
+extern void	oj_reader_init(Reader reader, VALUE io, int fd);
+extern int	oj_reader_read(Reader reader);
+
+static inline char
+reader_get(Reader reader) {
+    //printf("*** drive get from '%s'  from start: %ld	buf: %p	 from read_end: %ld\n", reader->tail, reader->tail - reader->head, reader->head, reader->read_end - reader->tail);
+    if (reader->read_end <= reader->tail) {
+	if (0 != oj_reader_read(reader)) {
+	    return '\0';
+	}
+    }
+    if ('\n' == *reader->tail) {
+	reader->line++;
+	reader->col = 0;
+    }
+    reader->col++;
+    reader->pos++;
+    
+    return *reader->tail++;
+}
+
+static inline void
+reader_backup(Reader reader) {
+    reader->tail--;
+    reader->col--;
+    reader->pos--;
+    if (0 >= reader->col) {
+	reader->line--;
+	// allow col to be negative since we never backup twice in a row
+    }
+}
+
+static inline void
+reader_protect(Reader reader) {
+    reader->pro = reader->tail;
+    reader->str = reader->tail; // can't have str before pro
+}
+
+static inline void
+reader_release(Reader reader) {
+    reader->pro = 0;
+}
+
+/* Starts by reading a character so it is safe to use with an empty or
+ * compacted buffer.
+ */
+static inline char
+reader_next_non_white(Reader reader) {
+    char	c;
+
+    while ('\0' != (c = reader_get(reader))) {
+	switch(c) {
+	case ' ':
+	case '\t':
+	case '\f':
+	case '\n':
+	case '\r':
+	    break;
+	default:
+	    return c;
+	}
+    }
+    return '\0';
+}
+
+/* Starts by reading a character so it is safe to use with an empty or
+ * compacted buffer.
+ */
+static inline char
+reader_next_white(Reader reader) {
+    char	c;
+
+    while ('\0' != (c = reader_get(reader))) {
+	switch(c) {
+	case ' ':
+	case '\t':
+	case '\f':
+	case '\n':
+	case '\r':
+	case '\0':
+	    return c;
+	default:
+	    break;
+	}
+    }
+    return '\0';
+}
+
+static inline int
+reader_expect(Reader reader, const char *s) {
+    for (; '\0' != *s; s++) {
+	if (reader_get(reader) != *s) {
+	    return -1;
+	}
+    }
+    return 0;
+}
+
+static inline void
+reader_cleanup(Reader reader) {
+    if (reader->free_head && 0 != reader->head) {
+	xfree((char*)reader->head);
+	reader->head = 0;
+	reader->free_head = 0;
+    }
+}
+
+static inline int
+is_white(char c) {
+    switch(c) {
+    case ' ':
+    case '\t':
+    case '\f':
+    case '\n':
+    case '\r':
+	return 1;
+    default:
+	break;
+    }
+    return 0;
+}
+
+#endif /* __OJ_READER_H__ */

data/ext/oj/resolve.c

@@ -0,0 +1,127 @@
+/* resolve.c
+ * Copyright (c) 2012, Peter Ohler
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ *  - Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ *  - Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ *  - Neither the name of Peter Ohler nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#if USE_PTHREAD_MUTEX
+#include <pthread.h>
+#endif
+
+#include "oj.h"
+#include "err.h"
+#include "parse.h"
+#include "hash.h"
+
+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);
+    } else if (auto_define) {
+	clas = rb_define_class_under(mod, classname, oj_bag_class);
+    } else {
+	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;
+
+    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;
+	}
+    }
+    *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;
+	}
+    }
+    return clas;
+}
+
+VALUE
+oj_name2class(ParseInfo pi, const char *name, size_t len, int auto_define, VALUE error_class) {
+    VALUE	clas;
+    VALUE	*slot;
+
+    if (No == pi->options.class_cache) {
+	return resolve_classpath(pi, name, len, auto_define, error_class);
+    }
+#if USE_PTHREAD_MUTEX
+    pthread_mutex_lock(&oj_cache_mutex);
+#elif USE_RB_MUTEX
+    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 USE_PTHREAD_MUTEX
+    pthread_mutex_unlock(&oj_cache_mutex);
+#elif USE_RB_MUTEX
+    rb_mutex_unlock(oj_cache_mutex);
+#endif
+    return clas;
+}
+
+VALUE
+oj_name2struct(ParseInfo pi, VALUE nameVal, VALUE error_class) {
+    size_t	len = RSTRING_LEN(nameVal);
+    const char	*str = StringValuePtr(nameVal);
+
+    return resolve_classpath(pi, str, len, 0, error_class);
+}

data/ext/oj/{cache.h → resolve.h}

@@ -1,4 +1,4 @@
-/* cache.h
+/* resolve.h
  * Copyright (c) 2011, Peter Ohler
  * All rights reserved.
  * 
@@ -28,19 +28,12 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef __OJ_CACHE_H__
-#define __OJ_CACHE_H__
-
-#define RSTRING_NOT_MODIFIED
+#ifndef __OJ_RESOLVE_H__
+#define __OJ_RESOLVE_H__
 
 #include "ruby.h"
 
-typedef struct _Cache   *Cache;
-
-extern void     oj_cache_new(Cache *cache);
-
-extern VALUE    oj_cache_get(Cache cache, const char *key, VALUE **slot);
-
-extern void     oj_cache_print(Cache cache);
+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_CACHE_H__ */
+#endif /* __OJ_RESOLVE_H__ */