ox-bundlecachetest 2.14.23

data/ext/ox/sax.h

@@ -0,0 +1,69 @@
+/* sax.h
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#ifndef OX_SAX_H
+#define OX_SAX_H
+
+#include <stdbool.h>
+
+#include "ox.h"
+#include "sax_buf.h"
+#include "sax_hint.h"
+#include "sax_stack.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;
+    VALUE (*get_name)(const char *name, size_t len, rb_encoding *encoding, const char **namep);
+    void (*set_pos)(VALUE handler, long pos);
+    void (*set_line)(VALUE handler, long line);
+    void (*set_col)(VALUE handler, long col);
+    void (*attr_cb)(struct _saxDrive *dr, VALUE name, char *value, long pos, long line, long col);
+    void (*attrs_done)(VALUE handler);
+    VALUE (*instruct)(struct _saxDrive *dr, const char *target, long pos, long line, long col);
+    void (*end_instruct)(struct _saxDrive *dr, VALUE target, long pos, long line, long col);
+    void (*doctype)(struct _saxDrive *dr, long pos, long line, long col);
+    void (*comment)(struct _saxDrive *dr, long pos, long line, long col);
+    void (*cdata)(struct _saxDrive *dr, long pos, long line, long col);
+    void (*error)(struct _saxDrive *dr, const char *msg, long pos, long line, long col);
+
+    rb_encoding *encoding;
+    int          err;
+    int          blocked;
+    bool         abort;
+    bool         utf8;
+    bool         want_attr_name;
+    bool         has_text;
+    bool         has_value;
+    bool         has_start_element;
+    bool         has_end_element;
+
+} *SaxDrive;
+
+extern const rb_data_type_t ox_sax_value_type;
+
+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, long pos, long line, long col);
+
+extern VALUE ox_sax_value_class;
+
+extern VALUE str2sym(SaxDrive dr, const char *str, size_t len, const char **strp);
+
+#endif /* OX_SAX_H */

data/ext/ox/sax_as.c

@@ -0,0 +1,270 @@
+/* sax_as.c
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <strings.h>
+#include <sys/types.h>
+#if HAVE_SYS_UIO_H
+#include <sys/uio.h>
+#endif
+#include <time.h>
+#include <unistd.h>
+
+#include "ox.h"
+#include "ruby.h"
+#include "ruby/version.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;
+    }
+    return rb_time_nano_new(v, v2);
+}
+
+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];
+    return rb_time_nano_new(mktime(&tm), cargs[6]);
+}
+
+/* call-seq: as_s()
+ *
+ * *return* value as an String.
+ */
+static VALUE sax_value_as_s(VALUE self) {
+    SaxDrive dr;
+    VALUE    rs;
+
+    TypedData_Get_Struct(self, struct _saxDrive, &ox_sax_value_type, dr);
+
+    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 (0 != dr->encoding) {
+        rb_enc_associate(rs, dr->encoding);
+    }
+    return rs;
+}
+
+/* call-seq: as_sym()
+ *
+ * *return* value as an Symbol.
+ */
+static VALUE sax_value_as_sym(VALUE self) {
+    SaxDrive dr;
+
+    TypedData_Get_Struct(self, struct _saxDrive, &ox_sax_value_type, dr);
+
+    if ('\0' == *dr->buf.str) {
+        return Qnil;
+    }
+    return str2sym(dr, dr->buf.str, strlen(dr->buf.str), 0);
+}
+
+/* call-seq: as_f()
+ *
+ * *return* value as an Float.
+ */
+static VALUE sax_value_as_f(VALUE self) {
+    SaxDrive dr;
+
+    TypedData_Get_Struct(self, struct _saxDrive, &ox_sax_value_type, dr);
+
+    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;
+    const char *s;
+    long        n   = 0;
+    int         neg = 0;
+
+    TypedData_Get_Struct(self, struct _saxDrive, &ox_sax_value_type, dr);
+    s = dr->buf.str;
+
+    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;
+    const char *str;
+    VALUE       t;
+
+    TypedData_Get_Struct(self, struct _saxDrive, &ox_sax_value_type, dr);
+    str = dr->buf.str;
+
+    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) {
+    SaxDrive dr;
+
+    TypedData_Get_Struct(self, struct _saxDrive, &ox_sax_value_type, dr);
+    return (0 == strcasecmp("true", dr->buf.str)) ? Qtrue : Qfalse;
+}
+
+/* call-seq: empty()
+ *
+ * *return* true if the value is empty.
+ */
+static VALUE sax_value_empty(VALUE self) {
+    SaxDrive dr;
+
+    TypedData_Get_Struct(self, struct _saxDrive, &ox_sax_value_type, dr);
+    return ('\0' == *dr->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(void) {
+#if 0
+    ox = rb_define_module("Ox");
+#if RUBY_API_VERSION_CODE >= 30200
+    sax_module = rb_define_class_under(ox, "Sax", rb_cObject);
+#endif
+#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);
+#if RUBY_API_VERSION_CODE >= 30200
+    rb_undef_alloc_func(ox_sax_value_class);
+#endif
+
+    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,209 @@
+/* sax_buf.c
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <strings.h>
+#include <sys/types.h>
+#if HAVE_SYS_UIO_H
+#include <sys/uio.h>
+#endif
+#include <time.h>
+#include <unistd.h>
+
+#include "ox.h"
+#include "ruby.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 %ld, column %ld\n", (long)buf->line, (long)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 int read_from_str(Buf buf) {
+    size_t max = buf->end - buf->tail - 1;
+    char  *s;
+    size_t cnt;
+
+    if ('\0' == *buf->in.str) {
+        return -1;
+    }
+    cnt = strlen(buf->in.str) + 1;
+    if (max < cnt) {
+        cnt = max;
+    }
+    memcpy(buf->tail, buf->in.str, cnt);
+    s   = buf->tail + cnt - 1;
+    *s  = '\0';
+    cnt = s - buf->tail;
+    buf->in.str += cnt;
+    buf->read_end = buf->tail + cnt;
+
+    return 0;
+}