ox 2.14.13 → 2.14.15

data/ext/ox/err.c

@@ -3,13 +3,12 @@
  * All rights reserved.
  */
 
-#include <stdarg.h>
-
 #include "err.h"
 
-void
-ox_err_set(Err e, VALUE clas, const char *format, ...) {
-    va_list	ap;
+#include <stdarg.h>
+
+void ox_err_set(Err e, VALUE clas, const char *format, ...) {
+    va_list ap;
 
     va_start(ap, format);
     e->clas = clas;
@@ -26,18 +25,22 @@ 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;
+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++;
+        col++;
     }
     for (; xml < current; current--) {
-	if ('\n' == *current) {
-	    xline++;
-	}
+        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

@@ -11,26 +11,25 @@
 #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];
+    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 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);
+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) {
+inline static void err_init(Err e) {
     e->clas = Qnil;
     *e->msg = '\0';
 }
 
-inline static int
-err_has(Err e) {
+inline static int err_has(Err e) {
     return (Qnil != e->clas);
 }
 

data/ext/ox/extconf.rb

@@ -4,7 +4,7 @@ extension_name = 'ox'
 dir_config(extension_name)
 
 parts = RUBY_DESCRIPTION.split(' ')
-type = parts[0].downcase()
+type = parts[0].downcase
 type = 'ree' if 'ruby' == type && RUBY_DESCRIPTION.include?('Ruby Enterprise Edition')
 platform = RUBY_PLATFORM
 version = RUBY_VERSION.split('.')
@@ -16,10 +16,10 @@ dflags = {
   'RUBY_VERSION' => RUBY_VERSION,
   'RUBY_VERSION_MAJOR' => version[0],
   'RUBY_VERSION_MINOR' => version[1],
-  'RUBY_VERSION_MICRO' => version[2],
+  'RUBY_VERSION_MICRO' => version[2]
 }
 
-dflags.each do |k,v|
+dflags.each do |k, v|
   if v.nil?
     $CPPFLAGS += " -D#{k}"
   else
@@ -27,7 +27,7 @@ dflags.each do |k,v|
   end
 end
 $CPPFLAGS += ' -Wall'
-#puts "*** $CPPFLAGS: #{$CPPFLAGS}"
+# puts "*** $CPPFLAGS: #{$CPPFLAGS}"
 CONFIG['warnflags'].slice!(/ -Wsuggest-attribute=format/)
 CONFIG['warnflags'].slice!(/ -Wdeclaration-after-statement/)
 CONFIG['warnflags'].slice!(/ -Wmissing-noreturn/)
@@ -49,4 +49,4 @@ have_struct_member('struct tm', 'tm_gmtoff')
 
 create_makefile(extension_name)
 
-%x{make clean}
+`make clean`

data/ext/ox/gen_load.c

@@ -3,32 +3,32 @@
  * All rights reserved.
  */
 
-#include <stdlib.h>
 #include <errno.h>
+#include <stdarg.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
-#include <stdarg.h>
 
+#include "intern.h"
+#include "ox.h"
 #include "ruby.h"
 #include "ruby/encoding.h"
-#include "ox.h"
-#include "intern.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 = {
+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,
@@ -39,9 +39,9 @@ struct _parseCallbacks   _ox_gen_callbacks = {
     NULL,
 };
 
-ParseCallbacks   ox_gen_callbacks = &_ox_gen_callbacks;
+ParseCallbacks ox_gen_callbacks = &_ox_gen_callbacks;
 
-struct _parseCallbacks   _ox_limited_callbacks = {
+struct _parseCallbacks _ox_limited_callbacks = {
     0,
     0,
     0,
@@ -52,9 +52,9 @@ struct _parseCallbacks   _ox_limited_callbacks = {
     NULL,
 };
 
-ParseCallbacks   ox_limited_callbacks = &_ox_limited_callbacks;
+ParseCallbacks ox_limited_callbacks = &_ox_limited_callbacks;
 
-struct _parseCallbacks   _ox_nomode_callbacks = {
+struct _parseCallbacks _ox_nomode_callbacks = {
     nomode_instruct,
     add_doctype,
     add_comment,
@@ -65,12 +65,11 @@ struct _parseCallbacks   _ox_nomode_callbacks = {
     NULL,
 };
 
-ParseCallbacks   ox_nomode_callbacks = &_ox_nomode_callbacks;
+ParseCallbacks ox_nomode_callbacks = &_ox_nomode_callbacks;
 
-static void
-create_doc(PInfo pi) {
-    VALUE       doc;
-    VALUE       nodes;
+static void create_doc(PInfo pi) {
+    VALUE doc;
+    VALUE nodes;
 
     helper_stack_init(&pi->helpers);
     doc = rb_obj_alloc(ox_document_clas);
@@ -84,45 +83,44 @@ create_doc(PInfo pi) {
     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;
+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;
+        return;
     }
     doc = rb_obj_alloc(ox_document_clas);
-    ah = rb_hash_new();
+    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_funcall(rstr, ox_to_sym_id, 0);
-	    } 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);
-	}
+        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_funcall(rstr, ox_to_sym_id, 0);
+            } 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);
@@ -131,50 +129,57 @@ create_prolog_doc(PInfo pi, const char *target, Attr attrs) {
     pi->obj = doc;
 }
 
-static void
-instruct(PInfo pi, const char *target, Attr attrs, const char *content) {
+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;
+                    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);
+        add_instruct(pi, target, attrs, content);
     }
 }
 
-static void
-nomode_instruct(PInfo pi, const char *target, Attr attrs, const char *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;
+                    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);
+                    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);
+                    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;
+                    ox_err_set(&pi->err,
+                               ox_syntax_error_class,
+                               "%s is not a valid processing instruction mode.\n",
+                               attrs->value);
+                    return;
                 }
             }
         }
@@ -185,71 +190,66 @@ nomode_instruct(PInfo pi, const char *target, Attr attrs, const char *content) {
     }
 }
 
-static void
-add_doctype(PInfo pi, const char *docType) {
-    VALUE       n = rb_obj_alloc(ox_doctype_clas);
-    VALUE       s = rb_str_new2(docType);
+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);
+        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);
+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);
+        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);
+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);
+        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);
+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);
+        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);
+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);
+        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);
@@ -257,18 +257,18 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
     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();
+        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);
-	    }
+            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);
@@ -278,59 +278,57 @@ add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
         rb_ivar_set(e, ox_attributes_id, ah);
     }
     if (helper_stack_empty(&pi->helpers)) { /* top level object */
-	pi->obj = e;
+        pi->obj = e;
     } else {
-	rb_ary_push(helper_stack_peek(&pi->helpers)->obj, e);
+        rb_ary_push(helper_stack_peek(&pi->helpers)->obj, e);
     }
     if (hasChildren) {
-        VALUE   nodes = rb_ary_new();
+        VALUE nodes = rb_ary_new();
 
         rb_ivar_set(e, ox_nodes_id, nodes);
-	helper_stack_push(&pi->helpers, 0, nodes, NoCode);
+        helper_stack_push(&pi->helpers, 0, nodes, NoCode);
     } else {
-	helper_stack_push(&pi->helpers, 0, Qnil, NoCode); // will be popped in end_element
+        helper_stack_push(&pi->helpers, 0, Qnil, NoCode);  // will be popped in end_element
     }
 }
 
-static void
-end_element(PInfo pi, const char *ename) {
+static void end_element(PInfo pi, const char *ename) {
     if (!helper_stack_empty(&pi->helpers)) {
-	helper_stack_pop(&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;
+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);
+        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);
-	}
+        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);
+        rb_ivar_set(inst, ox_at_content_id, c);
     } else if (0 != attrs->name) {
-        volatile VALUE   ah = rb_hash_new();
+        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);
-	    }
+            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);
@@ -340,7 +338,7 @@ add_instruct(PInfo pi, const char *name, Attr attrs, const char *content) {
         rb_ivar_set(inst, ox_attributes_id, ah);
     }
     if (helper_stack_empty(&pi->helpers)) { /* top level object */
-	create_doc(pi);
+        create_doc(pi);
     }
     rb_ary_push(helper_stack_peek(&pi->helpers)->obj, inst);
 }