ox 1.9.4 → 2.0.0

data/ext/ox/sax.h

@@ -0,0 +1,116 @@
+/* sax.h
+ * Copyright (c) 2011, 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.
+ */
+
+#ifndef __OX_SAX_H__
+#define __OX_SAX_H__
+
+#include "sax_buf.h"
+#include "sax_has.h"
+#include "sax_stack.h"
+#include "sax_hint.h"
+
+typedef struct _SaxOptions {
+    int			symbolize;
+    int			convert_special;
+    int			smart;
+} *SaxOptions;
+
+typedef struct _SaxDrive {
+    struct _Buf		buf;
+    struct _NStack	stack;	/* element name stack */
+    VALUE		handler;
+    VALUE		value_obj;
+    struct _SaxOptions	options;
+    int			err;
+    struct _Has		has;
+    Hints		hints;
+#if HAS_ENCODING_SUPPORT
+    rb_encoding *encoding;
+#elif HAS_PRIVATE_ENCODING
+    VALUE	encoding;
+#endif
+} *SaxDrive;
+
+extern void	ox_sax_parse(VALUE handler, VALUE io, SaxOptions options);
+extern void	ox_sax_drive_cleanup(SaxDrive dr);
+extern void	ox_sax_drive_error(SaxDrive dr, const char *msg);
+extern int	ox_sax_collapse_special(SaxDrive dr, char *str, int line, int col);
+
+extern VALUE	ox_sax_value_class;
+
+inline static VALUE
+str2sym(SaxDrive dr, const char *str, char **strp) {
+    VALUE       *slot;
+    VALUE       sym;
+
+    if (dr->options.symbolize) {
+	if (Qundef == (sym = ox_cache_get(ox_symbol_cache, str, &slot, strp))) {
+#if HAS_ENCODING_SUPPORT
+	    if (0 != dr->encoding) {
+		VALUE	rstr = rb_str_new2(str);
+
+		rb_enc_associate(rstr, dr->encoding);
+		sym = rb_funcall(rstr, ox_to_sym_id, 0);
+	    } else {
+		sym = ID2SYM(rb_intern(str));
+	    }
+#elif HAS_PRIVATE_ENCODING
+	    if (Qnil != dr->encoding) {
+		VALUE	rstr = rb_str_new2(str);
+
+		rb_funcall(rstr, ox_force_encoding_id, 1, dr->encoding);
+		sym = rb_funcall(rstr, ox_to_sym_id, 0);
+	    } else {
+		sym = ID2SYM(rb_intern(str));
+	    }
+#else
+	    sym = ID2SYM(rb_intern(str));
+#endif
+	    *slot = sym;
+	}
+    } else {
+	sym = rb_str_new2(str);
+#if HAS_ENCODING_SUPPORT
+	if (0 != dr->encoding) {
+	    rb_enc_associate(sym, dr->encoding);
+	}
+#elif HAS_PRIVATE_ENCODING
+	if (Qnil != dr->encoding) {
+	    rb_funcall(sym, ox_force_encoding_id, 1, dr->encoding);
+	}
+#endif
+	if (0 != strp) {
+	    *strp = StringValuePtr(sym);
+	}
+    }
+    return sym;
+}
+
+#endif /* __OX_SAX_H__ */

data/ext/ox/sax_as.c

@@ -0,0 +1,254 @@
+/* sax_as.c
+ * Copyright (c) 2011, 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 <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 "ox.h"
+#include "sax.h"
+
+static VALUE
+parse_double_time(const char *text) {
+    long        v = 0;
+    long        v2 = 0;
+    const char  *dot = 0;
+    char        c;
+    
+    for (; '.' != *text; text++) {
+        c = *text;
+        if (c < '0' || '9' < c) {
+            return Qnil;
+        }
+        v = 10 * v + (long)(c - '0');
+    }
+    dot = text++;
+    for (; '\0' != *text && text - dot <= 6; text++) {
+        c = *text;
+        if (c < '0' || '9' < c) {
+            return Qnil;
+        }
+        v2 = 10 * v2 + (long)(c - '0');
+    }
+    for (; text - dot <= 9; text++) {
+        v2 *= 10;
+    }
+#if HAS_NANO_TIME
+    return rb_time_nano_new(v, v2);
+#else
+    return rb_time_new(v, v2 / 1000);
+#endif
+}
+
+typedef struct _Tp {
+    int         cnt;
+    char        end;
+    char        alt;
+} *Tp;
+
+static VALUE
+parse_xsd_time(const char *text) {
+    long        cargs[10];
+    long        *cp = cargs;
+    long        v;
+    int         i;
+    char        c = '\0';
+    struct _Tp  tpa[10] = { { 4, '-', '-' },
+                           { 2, '-', '-' },
+                           { 2, 'T', ' ' },
+                           { 2, ':', ':' },
+                           { 2, ':', ':' },
+                           { 2, '.', '.' },
+                           { 9, '+', '-' },
+                           { 2, ':', ':' },
+                           { 2, '\0', '\0' },
+                           { 0, '\0', '\0' } };
+    Tp          tp = tpa;
+    struct tm   tm;
+
+    memset(cargs, 0, sizeof(cargs));
+    for (; 0 != tp->cnt; tp++) {
+        for (i = tp->cnt, v = 0; 0 < i ; text++, i--) {
+            c = *text;
+            if (c < '0' || '9' < c) {
+                if ('\0' == c || tp->end == c || tp->alt == c) {
+                    break;
+                }
+		return Qnil;
+            }
+            v = 10 * v + (long)(c - '0');
+        }
+	if ('\0' == c) {
+	    break;
+	}
+        c = *text++;
+        if (tp->end != c && tp->alt != c) {
+	    return Qnil;
+        }
+        *cp++ = v;
+    }
+    tm.tm_year = (int)cargs[0] - 1900;
+    tm.tm_mon = (int)cargs[1] - 1;
+    tm.tm_mday = (int)cargs[2];
+    tm.tm_hour = (int)cargs[3];
+    tm.tm_min = (int)cargs[4];
+    tm.tm_sec = (int)cargs[5];
+#if HAS_NANO_TIME
+    return rb_time_nano_new(mktime(&tm), cargs[6]);
+#else
+    return rb_time_new(mktime(&tm), cargs[6] / 1000);
+#endif
+}
+
+static VALUE
+sax_value_as_s(VALUE self) {
+    SaxDrive	dr = DATA_PTR(self);
+    VALUE	rs;
+
+    if ('\0' == *dr->buf.str) {
+	return Qnil;
+    }
+    if (dr->options.convert_special) {
+	ox_sax_collapse_special(dr, dr->buf.str, dr->buf.line, dr->buf.col);
+    }
+    rs = rb_str_new2(dr->buf.str);
+#if HAS_ENCODING_SUPPORT
+    if (0 != dr->encoding) {
+	rb_enc_associate(rs, dr->encoding);
+    }
+#elif HAS_PRIVATE_ENCODING
+    if (Qnil != dr->encoding) {
+	rb_funcall(rs, ox_force_encoding_id, 1, dr->encoding);
+    }
+#endif
+    return rs;
+}
+
+static VALUE
+sax_value_as_sym(VALUE self) {
+    SaxDrive	dr = DATA_PTR(self);
+
+    if ('\0' == *dr->buf.str) {
+	return Qnil;
+    }
+    return str2sym(dr, dr->buf.str, 0);
+}
+
+static VALUE
+sax_value_as_f(VALUE self) {
+    SaxDrive	dr = DATA_PTR(self);
+
+    if ('\0' == *dr->buf.str) {
+	return Qnil;
+    }
+    return rb_float_new(strtod(dr->buf.str, 0));
+}
+
+static VALUE
+sax_value_as_i(VALUE self) {
+    SaxDrive	dr = DATA_PTR(self);
+    const char	*s = dr->buf.str;
+    long	n = 0;
+    int		neg = 0;
+
+    if ('\0' == *s) {
+	return Qnil;
+    }
+    if ('-' == *s) {
+	neg = 1;
+	s++;
+    } else if ('+' == *s) {
+	s++;
+    }
+    for (; '\0' != *s; s++) {
+	if ('0' <= *s && *s <= '9') {
+	    n = n * 10 + (*s - '0');
+	} else {
+	    rb_raise(ox_arg_error_class, "Not a valid Fixnum.\n");
+	}
+    }
+    if (neg) {
+	n = -n;
+    }
+    return LONG2NUM(n);
+}
+
+static VALUE
+sax_value_as_time(VALUE self) {
+    SaxDrive	dr = DATA_PTR(self);
+    const char	*str = dr->buf.str;
+    VALUE       t;
+
+    if ('\0' == *str) {
+	return Qnil;
+    }
+    if (Qnil == (t = parse_double_time(str)) &&
+	Qnil == (t = parse_xsd_time(str))) {
+        VALUE       args[1];
+
+        /*printf("**** time parse\n"); */
+        *args = rb_str_new2(str);
+        t = rb_funcall2(ox_time_class, ox_parse_id, 1, args);
+    }
+    return t;
+}
+
+static VALUE
+sax_value_as_bool(VALUE self) {
+    return (0 == strcasecmp("true", ((SaxDrive)DATA_PTR(self))->buf.str)) ? Qtrue : Qfalse;
+}
+
+static VALUE
+sax_value_empty(VALUE self) {
+    return ('\0' == *((SaxDrive)DATA_PTR(self))->buf.str) ? Qtrue : Qfalse;
+}
+
+void
+ox_sax_define() {
+    VALUE	sax_module = rb_const_get_at(Ox, rb_intern("Sax"));
+
+    ox_sax_value_class = rb_define_class_under(sax_module, "Value", rb_cObject);
+
+    rb_define_method(ox_sax_value_class, "as_s", sax_value_as_s, 0);
+    rb_define_method(ox_sax_value_class, "as_sym", sax_value_as_sym, 0);
+    rb_define_method(ox_sax_value_class, "as_i", sax_value_as_i, 0);
+    rb_define_method(ox_sax_value_class, "as_f", sax_value_as_f, 0);
+    rb_define_method(ox_sax_value_class, "as_time", sax_value_as_time, 0);
+    rb_define_method(ox_sax_value_class, "as_bool", sax_value_as_bool, 0);
+    rb_define_method(ox_sax_value_class, "empty?", sax_value_empty, 0);
+}

data/ext/ox/sax_buf.c

@@ -0,0 +1,262 @@
+/* sax_buf.c
+ * Copyright (c) 2011, 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 <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 "ox.h"
+#include "sax.h"
+
+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(Buf buf);
+#ifndef JRUBY_RUBY
+static int		read_from_fd(Buf buf);
+#endif
+static int		read_from_io_partial(Buf buf);
+static int		read_from_str(Buf buf);
+
+void
+ox_sax_buf_init(Buf buf, VALUE io) {
+    if (ox_stringio_class == rb_obj_class(io)) {
+	VALUE	s = rb_funcall2(io, ox_string_id, 0, 0);
+
+	buf->read_func = read_from_str;
+	buf->in_str = StringValuePtr(s);
+    } else if (rb_respond_to(io, ox_readpartial_id)) {
+#ifdef JRUBY_RUBY
+	buf->read_func = read_from_io_partial;
+	buf->io = io;
+#else
+        VALUE   rfd;
+
+        if (rb_respond_to(io, ox_fileno_id) && Qnil != (rfd = rb_funcall(io, ox_fileno_id, 0))) {
+            buf->read_func = read_from_fd;
+            buf->fd = FIX2INT(rfd);
+        } else {
+            buf->read_func = read_from_io_partial;
+            buf->io = io;
+        }
+#endif
+    } else if (rb_respond_to(io, ox_read_id)) {
+#ifdef JRUBY_RUBY
+	buf->read_func = read_from_io;
+	buf->io = io;
+#else
+        VALUE   rfd;
+
+        if (rb_respond_to(io, ox_fileno_id) && Qnil != (rfd = rb_funcall(io, ox_fileno_id, 0))) {
+            buf->read_func = read_from_fd;
+            buf->fd = FIX2INT(rfd);
+        } else {
+            buf->read_func = read_from_io;
+            buf->io = io;
+        }
+#endif
+    } else {
+        rb_raise(ox_arg_error_class, "sax_parser io argument must respond to readpartial() or read().\n");
+    }
+    buf->head = buf->base;
+    *buf->head = '\0';
+    buf->end = buf->head + sizeof(buf->base) - 1; /* 1 less to make debugging easier */
+    buf->tail = buf->head;
+    buf->read_end = buf->head;
+    buf->pro = 0;
+    buf->str = 0;
+    buf->line = 1;
+    buf->col = 0;
+    buf->pro_line = 1;
+    buf->pro_col = 0;
+    buf->dr = 0;
+}
+
+int
+ox_sax_buf_read(Buf buf) {
+    int         err;
+    size_t      shift = 0;
+    
+    if (buf->head < buf->tail) {
+        if (0 == buf->pro) {
+            shift = buf->tail - buf->head;
+        } else {
+            shift = buf->pro - buf->head;
+        }
+        /*printf("\n*** shift: %lu\n", shift); */
+        if (0 == shift) { /* no space left so allocate more */
+            char        *old = buf->head;
+            size_t      size = buf->end - buf->head;
+        
+            if (buf->head == buf->base) {
+                buf->head = ALLOC_N(char, size * 2);
+                memcpy(buf->head, old, size);
+            } else {
+		REALLOC_N(buf->head, char, size * 2);
+            }
+            buf->end = buf->head + size * 2;
+            buf->tail = buf->head + (buf->tail - old);
+            buf->read_end = buf->head + (buf->read_end - old);
+            if (0 != buf->pro) {
+                buf->pro = buf->head + (buf->pro - old);
+            }
+            if (0 != buf->str) {
+                buf->str = buf->head + (buf->str - old);
+            }
+        } else {
+            memmove(buf->head, buf->head + shift, buf->read_end - (buf->head + shift));
+            buf->tail -= shift;
+            buf->read_end -= shift;
+            if (0 != buf->pro) {
+                buf->pro -= shift;
+            }
+            if (0 != buf->str) {
+                buf->str -= shift;
+            }
+        }
+    }
+    err = buf->read_func(buf);
+    *buf->read_end = '\0';
+
+    return err;
+}
+
+static VALUE
+rescue_cb(VALUE rbuf, VALUE err) {
+#ifndef JRUBY_RUBY
+    /* JRuby seems to play by a different set if rules. It passes in an Fixnum
+     * instead of an error like other Rubies. For now assume all errors are
+     * EOF and deal with the results further down the line. */
+#if (defined(RUBINIUS_RUBY) || (1 == RUBY_VERSION_MAJOR && 8 == RUBY_VERSION_MINOR))
+    if (rb_obj_class(err) != rb_eTypeError) {
+#else
+    if (rb_obj_class(err) != rb_eEOFError) {
+#endif
+	Buf	buf = (Buf)rbuf;
+
+        ox_sax_drive_cleanup(buf->dr);
+        rb_raise(err, "at line %d, column %d\n", buf->line, buf->col);
+    }
+#endif
+    return Qfalse;
+}
+
+static VALUE
+partial_io_cb(VALUE rbuf) {
+    Buf		buf = (Buf)rbuf;
+    VALUE	args[1];
+    VALUE	rstr;
+    char	*str;
+    size_t	cnt;
+
+    args[0] = ULONG2NUM(buf->end - buf->tail);
+    rstr = rb_funcall2(buf->io, ox_readpartial_id, 1, args);
+    str = StringValuePtr(rstr);
+    cnt = strlen(str);
+    /*printf("*** read %lu bytes, str: '%s'\n", cnt, str); */
+    strcpy(buf->tail, str);
+    buf->read_end = buf->tail + cnt;
+
+    return Qtrue;
+}
+
+static VALUE
+io_cb(VALUE rbuf) {
+    Buf		buf = (Buf)rbuf;
+    VALUE	args[1];
+    VALUE	rstr;
+    char	*str;
+    size_t	cnt;
+
+    args[0] = ULONG2NUM(buf->end - buf->tail);
+    rstr = rb_funcall2(buf->io, ox_read_id, 1, args);
+    str = StringValuePtr(rstr);
+    cnt = strlen(str);
+    /*printf("*** read %lu bytes, str: '%s'\n", cnt, str); */
+    strcpy(buf->tail, str);
+    buf->read_end = buf->tail + cnt;
+
+    return Qtrue;
+}
+
+static int
+read_from_io_partial(Buf buf) {
+    return (Qfalse == rb_rescue(partial_io_cb, (VALUE)buf, rescue_cb, (VALUE)buf));
+}
+
+static int
+read_from_io(Buf buf) {
+    return (Qfalse == rb_rescue(io_cb, (VALUE)buf, rescue_cb, (VALUE)buf));
+}
+
+#ifndef JRUBY_RUBY
+static int
+read_from_fd(Buf buf) {
+    ssize_t     cnt;
+    size_t      max = buf->end - buf->tail;
+
+    cnt = read(buf->fd, buf->tail, max);
+    if (cnt < 0) {
+        ox_sax_drive_error(buf->dr, "failed to read from file");
+        return -1;
+    } else if (0 != cnt) {
+        buf->read_end = buf->tail + cnt;
+    }
+    return 0;
+}
+#endif
+
+static int
+read_from_str(Buf buf) {
+    size_t      max = buf->end - buf->tail - 1;
+    char	*s;
+    long	cnt;
+
+    if ('\0' == *buf->in_str) {
+	/* done */
+	return -1;
+    }
+    s = stpncpy(buf->tail, buf->in_str, max);
+    *s = '\0';
+    cnt = s - buf->tail;
+    buf->in_str += cnt;
+    buf->read_end = buf->tail + cnt;
+
+    return 0;
+}
+