xaiml 0.1.0

data/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/ext/ox/sax.h

@@ -0,0 +1,55 @@
+/* sax.h
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#ifndef __OX_SAX_H__
+#define __OX_SAX_H__
+
+#include <stdbool.h>
+
+#include "sax_buf.h"
+#include "sax_has.h"
+#include "sax_stack.h"
+#include "sax_hint.h"
+#include "ox.h"
+
+typedef struct _SaxOptions {
+    int			symbolize;
+    int			convert_special;
+    int			smart;
+    SkipMode		skip;
+    char		strip_ns[64];
+    Hints		hints;
+} *SaxOptions;
+
+typedef struct _SaxDrive {
+    struct _Buf		buf;
+    struct _NStack	stack;	/* element name stack */
+    VALUE		handler;
+    VALUE		value_obj;
+    struct _SaxOptions	options;
+    int			err;
+    int			blocked;
+    bool		abort;
+    struct _Has		has;
+#if HAS_ENCODING_SUPPORT
+    rb_encoding *encoding;
+#elif HAS_PRIVATE_ENCODING
+    VALUE	encoding;
+#else
+    const char	*encoding;
+#endif
+} *SaxDrive;
+
+extern void	ox_collapse_return(char *str);
+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 pos, int line, int col);
+
+extern VALUE	ox_sax_value_class;
+
+extern VALUE	str2sym(SaxDrive dr, const char *str, const char **strp);
+
+#endif /* __OX_SAX_H__ */

data/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/ext/ox/sax_as.c

@@ -0,0 +1,276 @@
+/* sax_as.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 "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
+}
+
+/* call-seq: as_s()
+ *
+ * *return* value as an String.
+ */
+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.pos, dr->buf.line, dr->buf.col);
+    }
+    switch (dr->options.skip) {
+    case CrSkip:
+	buf_collapse_return(dr->buf.str);
+	break;
+    case SpcSkip:
+	buf_collapse_white(dr->buf.str);
+	break;
+    default:
+	break;
+    }
+    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;
+}
+
+/* call-seq: as_sym()
+ *
+ * *return* value as an Symbol.
+ */
+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);
+}
+
+/* call-seq: as_f()
+ *
+ * *return* value as an Float.
+ */
+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));
+}
+
+/* call-seq: as_i()
+ *
+ * *return* value as an Fixnum.
+ */
+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);
+}
+
+/* call-seq: as_time()
+ *
+ * *return* value as an Time.
+ */
+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;
+}
+
+/* call-seq: as_bool()
+ *
+ * *return* value as an boolean.
+ */
+static VALUE
+sax_value_as_bool(VALUE self) {
+    return (0 == strcasecmp("true", ((SaxDrive)DATA_PTR(self))->buf.str)) ? Qtrue : Qfalse;
+}
+
+/* call-seq: empty()
+ *
+ * *return* true if the value is empty.
+ */
+static VALUE
+sax_value_empty(VALUE self) {
+    return ('\0' == *((SaxDrive)DATA_PTR(self))->buf.str) ? Qtrue : Qfalse;
+}
+
+/* Document-class: Ox::Sax::Value
+ *
+ * Values in the SAX callbacks. They can be converted to various different
+ * types. with the _as_x()_ methods.
+ */
+void
+ox_sax_define() {
+#if 0
+    ox = rb_define_module("Ox");
+    sax_module = rb_define_class_under(ox, "Sax", rb_cObject);
+#endif
+    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/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/ext/ox/sax_buf.c

@@ -0,0 +1,228 @@
+/* sax_buf.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 "ox.h"
+#include "sax.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(Buf buf);
+static int		read_from_fd(Buf buf);
+static int		read_from_io_partial(Buf buf);
+static int		read_from_str(Buf buf);
+
+void
+ox_sax_buf_init(Buf buf, VALUE io) {
+    volatile VALUE	io_class = rb_obj_class(io);
+    VALUE		rfd;
+
+    if (rb_cString == io_class) {
+	buf->read_func = read_from_str;
+	buf->in.str = StringValuePtr(io);
+    } else if (ox_stringio_class == io_class && 0 == FIX2INT(rb_funcall2(io, ox_pos_id, 0, 0))) {
+	volatile VALUE	s = rb_funcall2(io, ox_string_id, 0, 0);
+
+	buf->read_func = read_from_str;
+	buf->in.str = StringValuePtr(s);
+    } else if (rb_cFile == io_class && Qnil != (rfd = rb_funcall(io, ox_fileno_id, 0))) {
+	buf->read_func = read_from_fd;
+	buf->in.fd = FIX2INT(rfd);
+    } else if (rb_respond_to(io, ox_readpartial_id)) {
+	buf->read_func = read_from_io_partial;
+	buf->in.io = io;
+    } else if (rb_respond_to(io, ox_read_id)) {
+	buf->read_func = read_from_io;
+	buf->in.io = io;
+    } 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) - BUF_PAD;
+    buf->tail = buf->head;
+    buf->read_end = buf->head;
+    buf->pro = 0;
+    buf->str = 0;
+    buf->pos = 0;
+    buf->line = 1;
+    buf->col = 0;
+    buf->pro_pos = 1;
+    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 there is not much room to read into, shift or realloc a larger buffer.
+    if (buf->head < buf->tail && 4096 > buf->end - buf->tail) {
+        if (0 == buf->pro) {
+            shift = buf->tail - buf->head;
+        } else {
+            shift = buf->pro - buf->head - 1; // leave one character so we cab backup one
+        }
+        if (0 >= shift) { /* no space left so allocate more */
+            char        *old = buf->head;
+            size_t      size = buf->end - buf->head + BUF_PAD;
+        
+            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_PAD;
+            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) {
+    VALUE	err_class = rb_obj_class(err);
+
+    if (err_class != rb_eTypeError && err_class != rb_eEOFError) {
+	Buf	buf = (Buf)rbuf;
+
+        //ox_sax_drive_cleanup(buf->dr); called after exiting protect
+        rb_raise(err, "at line %d, column %d\n", buf->line, buf->col);
+    }
+    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->in.io, ox_readpartial_id, 1, args);
+    str = StringValuePtr(rstr);
+    cnt = strlen(str);
+    //printf("*** read partial %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->in.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));
+}
+
+static int
+read_from_fd(Buf buf) {
+    ssize_t     cnt;
+    size_t      max = buf->end - buf->tail;
+
+    cnt = read(buf->in.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;
+}
+
+static char*
+ox_stpncpy(char *dest, const char *src, size_t n) {
+    size_t	cnt = strlen(src) + 1;
+
+    if (n < cnt) {
+	cnt = n;
+    }
+    strncpy(dest, src, cnt);
+
+    return dest + cnt - 1;
+}
+
+
+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 = ox_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;
+}
+