ox 1.0.0

data/ext/ox/ox.c

@@ -0,0 +1,456 @@
+/* ox.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 <string.h>
+
+#include "ruby.h"
+#include "ox.h"
+
+void Init_ox();
+
+VALUE    Ox = Qnil;
+
+ID      at_id;
+ID      attributes_id;
+ID      beg_id;
+ID      den_id;
+ID      end_id;
+ID      excl_id;
+ID      inspect_id;
+ID      keys_id;
+ID      local_id;
+ID      nodes_id;
+ID      num_id;
+ID      parse_id;
+ID      to_c_id;
+ID      to_s_id;
+ID      tv_sec_id;
+ID      tv_usec_id;
+ID      value_id;
+
+VALUE   version_sym;
+VALUE   standalone_sym;
+VALUE   encoding_sym;
+VALUE   indent_sym;
+VALUE   xsd_date_sym;
+VALUE   opt_format_sym;
+VALUE   circular_sym;
+VALUE   mode_sym;
+VALUE   auto_sym;
+VALUE   optimized_sym;
+VALUE   object_sym;
+VALUE   generic_sym;
+VALUE   limited_sym;
+VALUE   best_effort_sym;
+VALUE   trace_sym;
+VALUE   empty_string;
+VALUE   zero_fixnum;
+
+VALUE   ox_cdata_clas;
+VALUE   ox_comment_clas;
+VALUE   ox_doctype_clas;
+VALUE   ox_document_clas;
+VALUE   ox_element_clas;
+VALUE   ox_text_clas;
+VALUE   struct_class;
+VALUE   time_class;
+
+Cache   symbol_cache = 0;
+Cache   class_cache = 0;
+Cache   attr_cache = 0;
+
+extern ParseCallbacks   ox_obj_callbacks;
+extern ParseCallbacks   ox_gen_callbacks;
+extern ParseCallbacks   ox_limited_callbacks;
+
+static void     parse_dump_options(VALUE options, int *indent, int *xsd_date, int *circular);
+
+/* call-seq: parse_obj(xml) => Object
+ *
+ * Parses an XML document String that is in the object format and returns an
+ * Object of the type represented by the XML. This function expects an
+ * optimized XML formated String. For other formats use the more generic
+ * Ox.load() method.  Raises an exception if the XML is malformed or the
+ * classes specified in the file are not valid.
+ * [xml] XML String in optimized Object format.
+ */
+static VALUE
+to_obj(VALUE self, VALUE ruby_xml) {
+    VALUE       obj;
+    char        *xml;
+
+    Check_Type(ruby_xml, T_STRING);
+    // the xml string gets modified so make a copy of it
+    xml = strdup(StringValuePtr(ruby_xml));
+    obj = parse(xml, ox_obj_callbacks, 0, 0, 0);
+    free(xml);
+    return obj;
+}
+
+/* call-seq: parse(xml) => Ox::Document or Ox::Element
+ *
+ * Parses and XML document String into an Ox::Document or Ox::Element.
+ * Raises an exception if the XML is malformed.
+ * [xml] XML String
+ */
+static VALUE
+to_gen(VALUE self, VALUE ruby_xml) {
+    VALUE       obj;
+    char        *xml;
+
+    Check_Type(ruby_xml, T_STRING);
+    // the xml string gets modified so make a copy of it
+    xml = strdup(StringValuePtr(ruby_xml));
+    obj = parse(xml, ox_gen_callbacks, 0, 0, 0);
+    free(xml);
+    return obj;
+}
+
+typedef enum {
+    AutoMode = 0, // not supported
+    ObjMode  = 1,
+    GenMode  = 2,
+    LimMode  = 3,
+} LoadMode;
+
+static VALUE
+load(char *xml, int argc, VALUE *argv, VALUE self) {
+    VALUE       obj;
+    int         mode = AutoMode;
+    int         trace = 0;
+    int         best_effort = 0;
+    
+    if (1 == argc && rb_cHash == rb_obj_class(*argv)) {
+        VALUE   h = *argv;
+        VALUE   v;
+        
+        if (Qnil != (v = rb_hash_lookup(h, mode_sym))) {
+            if (auto_sym == v) {
+                mode = AutoMode;
+            } else if (object_sym == v) {
+                mode = ObjMode;
+            } else if (optimized_sym == v) {
+                mode = ObjMode;
+            } else if (generic_sym == v) {
+                mode = GenMode;
+            } else if (limited_sym == v) {
+                mode = LimMode;
+            } else {
+                rb_raise(rb_eArgError, ":mode must be :generic, :object, or :limited.\n");
+            }
+        }
+        if (Qnil != (v = rb_hash_lookup(h, trace_sym))) {
+            Check_Type(v, T_FIXNUM);
+            trace = FIX2INT(v);
+        }
+        if (Qnil != (v = rb_hash_lookup(h, best_effort_sym))) {
+            best_effort = (Qfalse != v);
+        }
+    }
+    switch (mode) {
+    case ObjMode:
+        obj = parse(xml, ox_obj_callbacks, 0, trace, best_effort);
+        break;
+    case GenMode:
+        obj = parse(xml, ox_gen_callbacks, 0, trace, 0);
+        break;
+    case LimMode:
+        obj = parse(xml, ox_limited_callbacks, 0, trace, best_effort);
+        break;
+    case AutoMode:
+    default:
+        obj = parse(xml, ox_gen_callbacks, 0, trace, 0);
+        break;
+    }
+    free(xml);
+
+    return obj;
+}
+
+/* call-seq: load(xml, options) => Ox::Document or Ox::Element or Object
+ *
+ * Parses and XML document String into an Ox::Document, or Ox::Element, or
+ * Object depending on the options.  Raises an exception if the XML is
+ * malformed or the classes specified are not valid.
+ * [xml]     XML String
+ * [options] load options
+ *           [:mode]        format expected
+ *                          [:object]  object format
+ *                          [:generic] read as a generic XML file
+ *                          [:limited] read as a generic XML file but with callbacks on text and elements events only
+ *           [:trace]       trace level as a Fixnum, default: 0 (silent)
+ *           [:best_effort] use best effort to create Objects using nil if undefined Class, default: 0
+ */
+static VALUE
+load_str(int argc, VALUE *argv, VALUE self) {
+    char        *xml;
+    
+    Check_Type(*argv, T_STRING);
+    // the xml string gets modified so make a copy of it
+    xml = strdup(StringValuePtr(*argv));
+
+    return load(xml, argc - 1, argv + 1, self);
+}
+
+/* call-seq: load_file(file_path, xml, options) => Ox::Document or Ox::Element or Object
+ *
+ * Parses and XML document from a file into an Ox::Document, or Ox::Element,
+ * or Object depending on the options.  Raises an exception if the XML is
+ * malformed or the classes specified are not valid.
+ * [file_path] file path to read the XML document from
+ * [xml]       XML String
+ * [options] load options
+ *           [:mode]        format expected
+ *                          [:object]  object format
+ *                          [:generic] read as a generic XML file
+ *                          [:limited] read as a generic XML file but with callbacks on text and elements events only
+ *           [:trace]       trace level as a Fixnum, default: 0 (silent)
+ *           [:best_effort] use best effort to create Objects using nil if undefined Class, default: 0
+ */
+static VALUE
+load_file(int argc, VALUE *argv, VALUE self) {
+    char                *path;
+    char                *xml;
+    FILE                *f;
+    unsigned long       len;
+    
+    Check_Type(*argv, T_STRING);
+    path = StringValuePtr(*argv);
+    if (0 == (f = fopen(path, "r"))) {
+        rb_raise(rb_eIOError, "%s\n", strerror(errno));
+    }
+    fseek(f, 0, SEEK_END);
+    len = ftell(f);
+    if (0 == (xml = malloc(len + 1))) {
+        fclose(f);
+        rb_raise(rb_eNoMemError, "Could not allocate memory for %ld byte file.\n", len);
+    }
+    fseek(f, 0, SEEK_SET);
+    if (len != fread(xml, 1, len, f)) {
+        fclose(f);
+        rb_raise(rb_eLoadError, "Failed to read %ld bytes from %s.\n", len, path);
+    }
+    fclose(f);
+    xml[len] = '\0';
+
+    return load(xml, argc - 1, argv + 1, self);
+}
+
+static void
+parse_dump_options(VALUE options, int *indent, int *xsd_date, int *circular) {
+    if (rb_cHash == rb_obj_class(options)) {
+        VALUE   v;
+        
+        if (Qnil != (v = rb_hash_lookup(options, indent_sym))) {
+            if (rb_cFixnum != rb_obj_class(v)) {
+                rb_raise(rb_eArgError, ":indent must be a Fixnum.\n");
+            }
+            *indent = NUM2INT(v);
+        }
+        if (Qnil != (v = rb_hash_lookup(options, xsd_date_sym))) {
+            VALUE       c = rb_obj_class(v);
+            
+            if (rb_cTrueClass == c) {
+                *xsd_date = 1;
+            } else if (rb_cFalseClass == c) {
+                *xsd_date = 0;
+            } else {
+                rb_raise(rb_eArgError, ":xsd_date must be true or false.\n");
+            }
+        }
+        if (Qnil != (v = rb_hash_lookup(options, circular_sym))) {
+            VALUE       c = rb_obj_class(v);
+            
+            if (rb_cTrueClass == c) {
+                *circular = 1;
+            } else if (rb_cFalseClass == c) {
+                *circular = 0;
+            } else {
+                rb_raise(rb_eArgError, ":circular must be true or false.\n");
+            }
+        }
+    }
+ }
+
+/* call-seq: dump(obj, options) => xml-string
+ *
+ * Dumps an Object (obj) to a string.
+ * [obj]     Object to serialize as an XML document String
+ * [options] formating options
+ *           [:indent]   number of spaces to use as the standard indention, default: 2
+ *           [:xsd_date] use XSD date format if true, default: false
+ *           [:circular] allow circular references, default: false
+ */
+static VALUE
+dump(int argc, VALUE *argv, VALUE self) {
+    char        *xml;
+    int         indent = 2;
+    int         xsd_date = 0;
+    int         circular = 0;
+    VALUE       rstr;
+    
+    if (2 == argc) {
+        parse_dump_options(argv[1], &indent, &xsd_date, &circular);
+    }
+    if (0 == (xml = write_obj_to_str(*argv, indent, xsd_date, circular))) {
+        rb_raise(rb_eNoMemError, "Not enough memory.\n");
+    }
+    rstr = rb_str_new2(xml);
+    free(xml);
+
+    return rstr;
+}
+
+/* call-seq: to_file(file_path, obj, options)
+ *
+ * Dumps and Object to the specified file.
+ * [file_path] file path to write the XML document to
+ * [obj]       Object to serialize as an XML document String
+ * [options]   formating options
+ *             [:indent]   number of spaces to use as the standard indention, default: 2
+ *             [:xsd_date] use XSD date format if true, default: false
+ *             [:circular] allow circular references, default: false
+ */
+static VALUE
+to_file(int argc, VALUE *argv, VALUE self) {
+    int         indent = 2;
+    int         xsd_date = 0;
+    int         circular = 0;
+    
+    if (3 == argc) {
+        parse_dump_options(argv[2], &indent, &xsd_date, &circular);
+    }
+    Check_Type(*argv, T_STRING);
+    write_obj_to_file(argv[1], StringValuePtr(*argv), indent, xsd_date, circular);
+
+    return Qnil;
+}
+
+extern void     ox_cache_test(void);
+
+static VALUE
+cache_test(VALUE self) {
+    ox_cache_test();
+    return Qnil;
+}
+
+extern void     ox_cache8_test(void);
+
+static VALUE
+cache8_test(VALUE self) {
+    ox_cache8_test();
+    return Qnil;
+}
+
+void Init_ox() {
+    Ox = rb_define_module("Ox");
+    rb_define_module_function(Ox, "parse_obj", to_obj, 1);
+    rb_define_module_function(Ox, "parse", to_gen, 1);
+    rb_define_module_function(Ox, "load", load_str, -1);
+
+    rb_define_module_function(Ox, "to_xml", dump, -1);
+    rb_define_module_function(Ox, "dump", dump, -1);
+
+    rb_define_module_function(Ox, "load_file", load_file, -1);
+    rb_define_module_function(Ox, "to_file", to_file, -1);
+
+    rb_require("time");
+    parse_id = rb_intern("parse");
+    local_id = rb_intern("local");
+    at_id = rb_intern("at");
+    inspect_id = rb_intern("inspect");
+    beg_id = rb_intern("@beg");
+    end_id = rb_intern("@end");
+    den_id = rb_intern("@den");
+    excl_id = rb_intern("@excl");
+    value_id = rb_intern("@value");
+    nodes_id = rb_intern("@nodes");
+    num_id = rb_intern("@num");
+    attributes_id = rb_intern("@attributes");
+    keys_id = rb_intern("keys");
+    tv_sec_id = rb_intern("tv_sec");
+    tv_usec_id = rb_intern("tv_usec");
+    to_c_id = rb_intern("to_c");
+    to_s_id = rb_intern("to_s");
+
+    time_class = rb_const_get(rb_cObject, rb_intern("Time"));
+    struct_class = rb_const_get(rb_cObject, rb_intern("Struct"));
+
+    version_sym = ID2SYM(rb_intern("version"));
+    standalone_sym = ID2SYM(rb_intern("standalone"));
+    encoding_sym = ID2SYM(rb_intern("encoding"));
+    indent_sym = ID2SYM(rb_intern("indent"));
+    xsd_date_sym = ID2SYM(rb_intern("xsd_date"));
+    opt_format_sym = ID2SYM(rb_intern("opt_format"));
+    mode_sym = ID2SYM(rb_intern("mode"));
+    auto_sym = ID2SYM(rb_intern("auto"));
+    optimized_sym = ID2SYM(rb_intern("optimized"));
+    object_sym = ID2SYM(rb_intern("object"));
+    circular_sym = ID2SYM(rb_intern("circular"));
+    generic_sym = ID2SYM(rb_intern("generic"));
+    limited_sym = ID2SYM(rb_intern("limited"));
+    trace_sym = ID2SYM(rb_intern("trace"));
+    best_effort_sym = ID2SYM(rb_intern("best_effort"));
+    empty_string = rb_str_new2("");
+    zero_fixnum = INT2NUM(0);
+    
+    //rb_require("node"); // generic xml node classes
+    ox_document_clas = rb_const_get(Ox, rb_intern("Document"));
+    ox_element_clas = rb_const_get(Ox, rb_intern("Element"));
+    ox_comment_clas = rb_const_get(Ox, rb_intern("Comment"));
+    ox_doctype_clas = rb_const_get(Ox, rb_intern("DocType"));
+    ox_cdata_clas = rb_const_get(Ox, rb_intern("CData"));
+
+    ox_cache_new(&symbol_cache);
+    ox_cache_new(&class_cache);
+    ox_cache_new(&attr_cache);
+
+    rb_define_module_function(Ox, "cache_test", cache_test, 0);
+    rb_define_module_function(Ox, "cache8_test", cache8_test, 0);
+}
+
+void
+_raise_error(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++;
+        }
+    }
+    rb_raise(rb_eEncodingError, "%s at line %d, column %d [%s:%d]\n", msg, xline, col, file, line);
+}