ox-bundlecachetest 2.14.23

data/ext/ox/err.c

@@ -0,0 +1,46 @@
+/* err.c
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#include "err.h"
+
+#include <stdarg.h>
+
+void ox_err_set(Err e, VALUE clas, const char *format, ...) {
+    va_list ap;
+
+    va_start(ap, format);
+    e->clas = clas;
+    vsnprintf(e->msg, sizeof(e->msg) - 1, format, ap);
+    va_end(ap);
+}
+
+#if __GNUC__ > 4
+_Noreturn void
+#else
+void
+#endif
+ox_err_raise(Err e) {
+    rb_raise(e->clas, "%s", e->msg);
+}
+
+void _ox_err_set_with_location(Err         err,
+                               const char *msg,
+                               const char *xml,
+                               const char *current,
+                               const char *file,
+                               int         line) {
+    int xline = 1;
+    int col   = 1;
+
+    for (; xml < current && '\n' != *current; current--) {
+        col++;
+    }
+    for (; xml < current; current--) {
+        if ('\n' == *current) {
+            xline++;
+        }
+    }
+    ox_err_set(err, ox_parse_error_class, "%s at line %d, column %d [%s:%d]\n", msg, xline, col, file, line);
+}

data/ext/ox/err.h

@@ -0,0 +1,36 @@
+/* err.h
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#ifndef OX_ERR_H
+#define OX_ERR_H
+
+#include "ruby.h"
+
+#define set_error(err, msg, xml, current) _ox_err_set_with_location(err, msg, xml, current, __FILE__, __LINE__)
+
+typedef struct _err {
+    VALUE clas;
+    char  msg[128];
+} *Err;
+
+extern VALUE ox_arg_error_class;
+extern VALUE ox_parse_error_class;
+extern VALUE ox_syntax_error_class;
+
+extern void ox_err_set(Err e, VALUE clas, const char *format, ...);
+extern void
+_ox_err_set_with_location(Err err, const char *msg, const char *xml, const char *current, const char *file, int line);
+extern void ox_err_raise(Err e);
+
+inline static void err_init(Err e) {
+    e->clas = Qnil;
+    *e->msg = '\0';
+}
+
+inline static int err_has(Err e) {
+    return (Qnil != e->clas);
+}
+
+#endif /* OX_ERR_H */

data/ext/ox/extconf.rb

@@ -0,0 +1,47 @@
+require 'mkmf'
+
+extension_name = 'ox'
+dir_config(extension_name)
+
+parts = RUBY_DESCRIPTION.split(' ')
+type = parts[0].downcase
+type = 'ree' if 'ruby' == type && RUBY_DESCRIPTION.include?('Ruby Enterprise Edition')
+platform = RUBY_PLATFORM
+version = RUBY_VERSION.split('.')
+puts ">>>>> Creating Makefile for #{type} version #{RUBY_VERSION} on #{platform} <<<<<"
+
+dflags = {
+  'RUBY_TYPE' => type,
+  (type.upcase + '_RUBY') => nil,
+  'RUBY_VERSION' => RUBY_VERSION,
+  'RUBY_VERSION_MAJOR' => version[0],
+  'RUBY_VERSION_MINOR' => version[1],
+  'RUBY_VERSION_MICRO' => version[2]
+}
+
+dflags.each do |k, v|
+  if v.nil?
+    $CPPFLAGS += " -D#{k}"
+  else
+    $CPPFLAGS += " -D#{k}=#{v}"
+  end
+end
+$CPPFLAGS += ' -Wall'
+# puts "*** $CPPFLAGS: #{$CPPFLAGS}"
+CONFIG['warnflags'].slice!(/ -Wsuggest-attribute=format/)
+CONFIG['warnflags'].slice!(/ -Wdeclaration-after-statement/)
+CONFIG['warnflags'].slice!(/ -Wmissing-noreturn/)
+
+have_func('rb_ext_ractor_safe', 'ruby.h')
+have_func('pthread_mutex_init')
+have_func('rb_enc_interned_str')
+have_func('index')
+
+have_header('ruby/st.h')
+have_header('sys/uio.h')
+
+have_struct_member('struct tm', 'tm_gmtoff')
+
+create_makefile("ox/#{extension_name}")
+
+`make clean`

data/ext/ox/gen_load.c

@@ -0,0 +1,342 @@
+/* gen_load.c
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#include <errno.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "intern.h"
+#include "ox.h"
+#include "ruby.h"
+#include "ruby/encoding.h"
+
+static void instruct(PInfo pi, const char *target, Attr attrs, const char *content);
+static void create_doc(PInfo pi);
+static void create_prolog_doc(PInfo pi, const char *target, Attr attrs);
+static void nomode_instruct(PInfo pi, const char *target, Attr attrs, const char *content);
+static void add_doctype(PInfo pi, const char *docType);
+static void add_comment(PInfo pi, const char *comment);
+static void add_cdata(PInfo pi, const char *cdata, size_t len);
+static void add_text(PInfo pi, char *text, int closed);
+static void add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren);
+static void end_element(PInfo pi, const char *ename);
+static void add_instruct(PInfo pi, const char *name, Attr attrs, const char *content);
+
+extern ParseCallbacks ox_obj_callbacks;
+
+struct _parseCallbacks _ox_gen_callbacks = {
+    instruct, /* instruct, */
+    add_doctype,
+    add_comment,
+    add_cdata,
+    add_text,
+    add_element,
+    end_element,
+    NULL,
+};
+
+ParseCallbacks ox_gen_callbacks = &_ox_gen_callbacks;
+
+struct _parseCallbacks _ox_limited_callbacks = {
+    0,
+    0,
+    0,
+    0,
+    add_text,
+    add_element,
+    end_element,
+    NULL,
+};
+
+ParseCallbacks ox_limited_callbacks = &_ox_limited_callbacks;
+
+struct _parseCallbacks _ox_nomode_callbacks = {
+    nomode_instruct,
+    add_doctype,
+    add_comment,
+    add_cdata,
+    add_text,
+    add_element,
+    end_element,
+    NULL,
+};
+
+ParseCallbacks ox_nomode_callbacks = &_ox_nomode_callbacks;
+
+static void create_doc(PInfo pi) {
+    VALUE doc;
+    VALUE nodes;
+
+    helper_stack_init(&pi->helpers);
+    doc = rb_obj_alloc(ox_document_clas);
+    RB_GC_GUARD(doc);
+    nodes = rb_ary_new();
+    rb_ivar_set(doc, ox_attributes_id, rb_hash_new());
+    rb_ivar_set(doc, ox_nodes_id, nodes);
+    helper_stack_push(&pi->helpers, 0, nodes, NoCode);
+    pi->obj = doc;
+}
+
+static void create_prolog_doc(PInfo pi, const char *target, Attr attrs) {
+    volatile VALUE doc;
+    volatile VALUE ah;
+    volatile VALUE nodes;
+    volatile VALUE sym;
+
+    if (!helper_stack_empty(&pi->helpers)) { /* top level object */
+        ox_err_set(&pi->err, ox_syntax_error_class, "Prolog must be the first element in an XML document.\n");
+        return;
+    }
+    doc = rb_obj_alloc(ox_document_clas);
+    ah  = rb_hash_new();
+    for (; 0 != attrs->name; attrs++) {
+        if (Qnil != pi->options->attr_key_mod) {
+            sym = rb_funcall(pi->options->attr_key_mod, ox_call_id, 1, rb_str_new2(attrs->name));
+            rb_hash_aset(ah, sym, rb_str_new2(attrs->value));
+        } else if (Yes == pi->options->sym_keys) {
+            if (0 != pi->options->rb_enc) {
+                VALUE rstr = rb_str_new2(attrs->name);
+
+                rb_enc_associate(rstr, pi->options->rb_enc);
+                sym = rb_str_intern(rstr);
+            } else {
+                sym = ID2SYM(rb_intern(attrs->name));
+            }
+            sym = ID2SYM(rb_intern(attrs->name));
+            rb_hash_aset(ah, sym, rb_str_new2(attrs->value));
+        } else {
+            volatile VALUE rstr = rb_str_new2(attrs->name);
+
+            if (0 != pi->options->rb_enc) {
+                rb_enc_associate(rstr, pi->options->rb_enc);
+            }
+            rb_hash_aset(ah, rstr, rb_str_new2(attrs->value));
+        }
+        if (0 == strcmp("encoding", attrs->name)) {
+            pi->options->rb_enc = rb_enc_find(attrs->value);
+        }
+    }
+    nodes = rb_ary_new();
+    rb_ivar_set(doc, ox_attributes_id, ah);
+    rb_ivar_set(doc, ox_nodes_id, nodes);
+    helper_stack_push(&pi->helpers, 0, nodes, ArrayCode);
+    pi->obj = doc;
+}
+
+static void instruct(PInfo pi, const char *target, Attr attrs, const char *content) {
+    if (0 == strcmp("xml", target)) {
+        create_prolog_doc(pi, target, attrs);
+    } else if (0 == strcmp("ox", target)) {
+        for (; 0 != attrs->name; attrs++) {
+            if (0 == strcmp("version", attrs->name)) {
+                if (0 != strcmp("1.0", attrs->value)) {
+                    ox_err_set(&pi->err,
+                               ox_syntax_error_class,
+                               "Only Ox XML Object version 1.0 supported, not %s.\n",
+                               attrs->value);
+                    return;
+                }
+            }
+            /* ignore other instructions */
+        }
+    } else {
+        add_instruct(pi, target, attrs, content);
+    }
+}
+
+static void nomode_instruct(PInfo pi, const char *target, Attr attrs, const char *content) {
+    if (0 == strcmp("xml", target)) {
+        create_prolog_doc(pi, target, attrs);
+    } else if (0 == strcmp("ox", target)) {
+        for (; 0 != attrs->name; attrs++) {
+            if (0 == strcmp("version", attrs->name)) {
+                if (0 != strcmp("1.0", attrs->value)) {
+                    ox_err_set(&pi->err,
+                               ox_syntax_error_class,
+                               "Only Ox XML Object version 1.0 supported, not %s.\n",
+                               attrs->value);
+                    return;
+                }
+            } else if (0 == strcmp("mode", attrs->name)) {
+                if (0 == strcmp("object", attrs->value)) {
+                    pi->pcb = ox_obj_callbacks;
+                    pi->obj = Qnil;
+                    helper_stack_init(&pi->helpers);
+                } else if (0 == strcmp("generic", attrs->value)) {
+                    pi->pcb = ox_gen_callbacks;
+                } else if (0 == strcmp("limited", attrs->value)) {
+                    pi->pcb = ox_limited_callbacks;
+                    pi->obj = Qnil;
+                    helper_stack_init(&pi->helpers);
+                } else {
+                    ox_err_set(&pi->err,
+                               ox_syntax_error_class,
+                               "%s is not a valid processing instruction mode.\n",
+                               attrs->value);
+                    return;
+                }
+            }
+        }
+    } else {
+        if (TRACE <= pi->options->trace) {
+            printf("Processing instruction %s ignored.\n", target);
+        }
+    }
+}
+
+static void add_doctype(PInfo pi, const char *docType) {
+    VALUE n = rb_obj_alloc(ox_doctype_clas);
+    VALUE s = rb_str_new2(docType);
+
+    if (0 != pi->options->rb_enc) {
+        rb_enc_associate(s, pi->options->rb_enc);
+    }
+    rb_ivar_set(n, ox_at_value_id, s);
+    if (helper_stack_empty(&pi->helpers)) { /* top level object */
+        create_doc(pi);
+    }
+    rb_ary_push(helper_stack_peek(&pi->helpers)->obj, n);
+}
+
+static void add_comment(PInfo pi, const char *comment) {
+    VALUE n = rb_obj_alloc(ox_comment_clas);
+    VALUE s = rb_str_new2(comment);
+
+    if (0 != pi->options->rb_enc) {
+        rb_enc_associate(s, pi->options->rb_enc);
+    }
+    rb_ivar_set(n, ox_at_value_id, s);
+    if (helper_stack_empty(&pi->helpers)) { /* top level object */
+        create_doc(pi);
+    }
+    rb_ary_push(helper_stack_peek(&pi->helpers)->obj, n);
+}
+
+static void add_cdata(PInfo pi, const char *cdata, size_t len) {
+    VALUE n = rb_obj_alloc(ox_cdata_clas);
+    VALUE s = rb_str_new2(cdata);
+
+    if (0 != pi->options->rb_enc) {
+        rb_enc_associate(s, pi->options->rb_enc);
+    }
+    rb_ivar_set(n, ox_at_value_id, s);
+    if (helper_stack_empty(&pi->helpers)) { /* top level object */
+        create_doc(pi);
+    }
+    rb_ary_push(helper_stack_peek(&pi->helpers)->obj, n);
+}
+
+static void add_text(PInfo pi, char *text, int closed) {
+    VALUE s = rb_str_new2(text);
+
+    if (0 != pi->options->rb_enc) {
+        rb_enc_associate(s, pi->options->rb_enc);
+    }
+    if (helper_stack_empty(&pi->helpers)) { /* top level object */
+        create_doc(pi);
+    }
+    rb_ary_push(helper_stack_peek(&pi->helpers)->obj, s);
+}
+
+static void add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
+    VALUE e;
+    VALUE s = rb_str_new2(ename);
+
+    if (Qnil != pi->options->element_key_mod) {
+        s = rb_funcall(pi->options->element_key_mod, ox_call_id, 1, s);
+    }
+    if (0 != pi->options->rb_enc) {
+        rb_enc_associate(s, pi->options->rb_enc);
+    }
+    e = rb_obj_alloc(ox_element_clas);
+    rb_ivar_set(e, ox_at_value_id, s);
+    if (0 != attrs->name) {
+        volatile VALUE ah = rb_hash_new();
+
+        for (; 0 != attrs->name; attrs++) {
+            volatile VALUE sym;
+
+            if (Qnil != pi->options->attr_key_mod) {
+                sym = rb_funcall(pi->options->attr_key_mod, ox_call_id, 1, rb_str_new2(attrs->name));
+            } else if (Yes == pi->options->sym_keys) {
+                sym = ox_sym_intern(attrs->name, strlen(attrs->name), NULL);
+            } else {
+                sym = ox_str_intern(attrs->name, strlen(attrs->name), NULL);
+            }
+            s = rb_str_new2(attrs->value);
+            if (0 != pi->options->rb_enc) {
+                rb_enc_associate(s, pi->options->rb_enc);
+            }
+            rb_hash_aset(ah, sym, s);
+        }
+        rb_ivar_set(e, ox_attributes_id, ah);
+    }
+    if (helper_stack_empty(&pi->helpers)) { /* top level object */
+        pi->obj = e;
+    } else {
+        rb_ary_push(helper_stack_peek(&pi->helpers)->obj, e);
+    }
+    if (hasChildren) {
+        VALUE nodes = rb_ary_new();
+
+        rb_ivar_set(e, ox_nodes_id, nodes);
+        helper_stack_push(&pi->helpers, 0, nodes, NoCode);
+    } else {
+        helper_stack_push(&pi->helpers, 0, Qnil, NoCode);  // will be popped in end_element
+    }
+}
+
+static void end_element(PInfo pi, const char *ename) {
+    if (!helper_stack_empty(&pi->helpers)) {
+        helper_stack_pop(&pi->helpers);
+    }
+}
+
+static void add_instruct(PInfo pi, const char *name, Attr attrs, const char *content) {
+    VALUE inst;
+    VALUE s = rb_str_new2(name);
+    VALUE c = Qnil;
+
+    if (0 != content) {
+        c = rb_str_new2(content);
+    }
+    if (0 != pi->options->rb_enc) {
+        rb_enc_associate(s, pi->options->rb_enc);
+        if (0 != content) {
+            rb_enc_associate(c, pi->options->rb_enc);
+        }
+    }
+    inst = rb_obj_alloc(ox_instruct_clas);
+    rb_ivar_set(inst, ox_at_value_id, s);
+    if (0 != content) {
+        rb_ivar_set(inst, ox_at_content_id, c);
+    } else if (0 != attrs->name) {
+        volatile VALUE ah = rb_hash_new();
+
+        for (; 0 != attrs->name; attrs++) {
+            volatile VALUE sym;
+
+            if (Qnil != pi->options->attr_key_mod) {
+                sym = rb_funcall(pi->options->attr_key_mod, ox_call_id, 1, rb_str_new2(attrs->name));
+            } else if (Yes == pi->options->sym_keys) {
+                sym = ox_sym_intern(attrs->name, strlen(attrs->name), NULL);
+            } else {
+                sym = ox_str_intern(attrs->name, strlen(attrs->name), NULL);
+            }
+            s = rb_str_new2(attrs->value);
+            if (0 != pi->options->rb_enc) {
+                rb_enc_associate(s, pi->options->rb_enc);
+            }
+            rb_hash_aset(ah, sym, s);
+        }
+        rb_ivar_set(inst, ox_attributes_id, ah);
+    }
+    if (helper_stack_empty(&pi->helpers)) { /* top level object */
+        create_doc(pi);
+    }
+    rb_ary_push(helper_stack_peek(&pi->helpers)->obj, inst);
+}