ox 2.14.14 → 2.14.16

data/ext/ox/hash_load.c

@@ -3,24 +3,23 @@
  * All rights reserved.
  */
 
-#include <stdbool.h>
-#include <stdlib.h>
 #include <errno.h>
+#include <stdarg.h>
+#include <stdbool.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
-#include <stdarg.h>
 
-#include "ruby.h"
 #include "ox.h"
+#include "ruby.h"
 
-#define MARK_INC	256
+#define MARK_INC 256
 
 // The approach taken for the hash and has_no_attrs parsing is to push just
 // the key on to the stack and then decide what to do on the way up/out.
 
-static VALUE
-create_top(PInfo pi) {
-    volatile VALUE       top = rb_hash_new();
+static VALUE create_top(PInfo pi) {
+    volatile VALUE top = rb_hash_new();
 
     helper_stack_push(&pi->helpers, 0, top, HashCode);
     pi->obj = top;
@@ -28,221 +27,204 @@ create_top(PInfo pi) {
     return top;
 }
 
-static void
-mark_value(PInfo pi, VALUE val) {
+static void mark_value(PInfo pi, VALUE val) {
     if (NULL == pi->marked) {
-	pi->marked = ALLOC_N(VALUE, MARK_INC);
-	pi->mark_size = MARK_INC;
+        pi->marked    = ALLOC_N(VALUE, MARK_INC);
+        pi->mark_size = MARK_INC;
     } else if (pi->mark_size <= pi->mark_cnt) {
-	pi->mark_size += MARK_INC;
-	REALLOC_N(pi->marked, VALUE, pi->mark_size);
+        pi->mark_size += MARK_INC;
+        REALLOC_N(pi->marked, VALUE, pi->mark_size);
     }
     pi->marked[pi->mark_cnt] = val;
     pi->mark_cnt++;
 }
 
-static bool
-marked(PInfo pi, VALUE val) {
+static bool marked(PInfo pi, VALUE val) {
     if (NULL != pi->marked) {
-	VALUE	*vp = pi->marked + pi->mark_cnt - 1;
+        VALUE *vp = pi->marked + pi->mark_cnt - 1;
 
-	for (; pi->marked <= vp; vp--) {
-	    if (val == *vp) {
-		return true;
-	    }
-	}
+        for (; pi->marked <= vp; vp--) {
+            if (val == *vp) {
+                return true;
+            }
+        }
     }
     return false;
 }
 
-static void
-unmark(PInfo pi, VALUE val) {
+static void unmark(PInfo pi, VALUE val) {
     if (NULL != pi->marked) {
-	VALUE	*vp = pi->marked + pi->mark_cnt - 1;
-	int		i;
-
-	for (i = 0; pi->marked <= vp; vp--, i++) {
-	    if (val == *vp) {
-		for (; 0 < i; i--, vp++) {
-		    *vp = *(vp + 1);
-		}
-		pi->mark_cnt--;
-		break;
-	    }
-	}
+        VALUE *vp = pi->marked + pi->mark_cnt - 1;
+        int    i;
+
+        for (i = 0; pi->marked <= vp; vp--, i++) {
+            if (val == *vp) {
+                for (; 0 < i; i--, vp++) {
+                    *vp = *(vp + 1);
+                }
+                pi->mark_cnt--;
+                break;
+            }
+        }
     }
 }
 
-static void
-add_str(PInfo pi, VALUE s) {
-    Helper		parent = helper_stack_peek(&pi->helpers);
-    volatile VALUE	a;
+static void add_str(PInfo pi, VALUE s) {
+    Helper         parent = helper_stack_peek(&pi->helpers);
+    volatile VALUE a;
 
     if (0 != pi->options->rb_enc) {
         rb_enc_associate(s, pi->options->rb_enc);
     }
     switch (parent->type) {
     case NoCode:
-	parent->obj = s;
-	parent->type = StringCode;
-	break;
-    case ArrayCode:
-	rb_ary_push(parent->obj, s);
-	break;
+        parent->obj  = s;
+        parent->type = StringCode;
+        break;
+    case ArrayCode: rb_ary_push(parent->obj, s); break;
     default:
-	a = rb_ary_new();
-	rb_ary_push(a, parent->obj);
-	rb_ary_push(a, s);
-	parent->obj = a;
-	parent->type = ArrayCode;
-	break;
+        a = rb_ary_new();
+        rb_ary_push(a, parent->obj);
+        rb_ary_push(a, s);
+        parent->obj  = a;
+        parent->type = ArrayCode;
+        break;
     }
 }
 
-static void
-add_text(PInfo pi, char *text, int closed) {
+static void add_text(PInfo pi, char *text, int closed) {
     add_str(pi, rb_str_new2(text));
 }
 
-static void
-add_cdata(PInfo pi, const char *text, size_t len) {
+static void add_cdata(PInfo pi, const char *text, size_t len) {
     add_str(pi, rb_str_new(text, len));
 }
 
-static void
-add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
+static void add_element(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
     if (helper_stack_empty(&pi->helpers)) {
-	create_top(pi);
+        create_top(pi);
     }
     if (NULL != attrs && NULL != attrs->name) {
-	volatile VALUE	h = rb_hash_new();
-        volatile VALUE	key;
-	volatile VALUE	val;
-	volatile VALUE	a;
+        volatile VALUE h = rb_hash_new();
+        volatile VALUE key;
+        volatile VALUE val;
+        volatile VALUE a;
 
         for (; 0 != attrs->name; attrs++) {
-	    if (Qnil != pi->options->attr_key_mod) {
-		key = rb_funcall(pi->options->attr_key_mod, ox_call_id, 1, rb_str_new2(attrs->name));
-	    } else if (Yes == pi->options->sym_keys) {
-		key = rb_id2sym(rb_intern(attrs->name));
-	    } else {
-		key = rb_str_new2(attrs->name);
-	    }
-	    val = rb_str_new2(attrs->value);
-	    if (0 != pi->options->rb_enc) {
-		rb_enc_associate(val, pi->options->rb_enc);
-	    }
-	    rb_hash_aset(h, key, val);
-	}
-	a = rb_ary_new();
-	rb_ary_push(a, h);
-	mark_value(pi, a);
-	helper_stack_push(&pi->helpers, rb_intern(ename), a, ArrayCode);
+            if (Qnil != pi->options->attr_key_mod) {
+                key = rb_funcall(pi->options->attr_key_mod, ox_call_id, 1, rb_str_new2(attrs->name));
+            } else if (Yes == pi->options->sym_keys) {
+                key = rb_id2sym(rb_intern(attrs->name));
+            } else {
+                key = rb_str_new2(attrs->name);
+            }
+            val = rb_str_new2(attrs->value);
+            if (0 != pi->options->rb_enc) {
+                rb_enc_associate(val, pi->options->rb_enc);
+            }
+            rb_hash_aset(h, key, val);
+        }
+        a = rb_ary_new();
+        rb_ary_push(a, h);
+        mark_value(pi, a);
+        helper_stack_push(&pi->helpers, rb_intern(ename), a, ArrayCode);
     } else {
-	helper_stack_push(&pi->helpers, rb_intern(ename), Qnil, NoCode);
+        helper_stack_push(&pi->helpers, rb_intern(ename), Qnil, NoCode);
     }
 }
 
-static void
-add_element_no_attrs(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
+static void add_element_no_attrs(PInfo pi, const char *ename, Attr attrs, int hasChildren) {
     if (helper_stack_empty(&pi->helpers)) {
-	create_top(pi);
+        create_top(pi);
     }
     helper_stack_push(&pi->helpers, rb_intern(ename), Qnil, NoCode);
 }
 
-static int
-umark_hash_cb(VALUE key, VALUE value, VALUE x) {
+static int umark_hash_cb(VALUE key, VALUE value, VALUE x) {
     unmark((PInfo)x, value);
 
     return ST_CONTINUE;
 }
 
-static void
-end_element_core(PInfo pi, const char *ename, bool check_marked) {
-    Helper		e = helper_stack_pop(&pi->helpers);
-    Helper		parent = helper_stack_peek(&pi->helpers);
-    volatile VALUE	pobj = parent->obj;
-    volatile VALUE	found = Qundef;
-    volatile VALUE	key;
-    volatile VALUE	a;
+static void end_element_core(PInfo pi, const char *ename, bool check_marked) {
+    Helper         e      = helper_stack_pop(&pi->helpers);
+    Helper         parent = helper_stack_peek(&pi->helpers);
+    volatile VALUE pobj   = parent->obj;
+    volatile VALUE found  = Qundef;
+    volatile VALUE key;
+    volatile VALUE a;
 
     if (NoCode == e->type) {
-	e->obj = Qnil;
+        e->obj = Qnil;
     }
     if (Qnil != pi->options->element_key_mod) {
-	key = rb_funcall(pi->options->element_key_mod, ox_call_id, 1, rb_id2str(e->var));
+        key = rb_funcall(pi->options->element_key_mod, ox_call_id, 1, rb_id2str(e->var));
     } else if (Yes == pi->options->sym_keys) {
-	key = rb_id2sym(e->var);
+        key = rb_id2sym(e->var);
     } else {
-	key = rb_id2str(e->var);
+        key = rb_id2str(e->var);
     }
     // Make sure the parent is a Hash. If not set then make a Hash. If an
     // Array or non-Hash then append to array or create and append.
     switch (parent->type) {
     case NoCode:
-	pobj = rb_hash_new();
-	parent->obj = pobj;
-	parent->type = HashCode;
-	break;
+        pobj         = rb_hash_new();
+        parent->obj  = pobj;
+        parent->type = HashCode;
+        break;
     case ArrayCode:
-	pobj = rb_hash_new();
-	rb_ary_push(parent->obj, pobj);
-	break;
-    case HashCode:
-	found = rb_hash_lookup2(parent->obj, key, Qundef);
-	break;
+        pobj = rb_hash_new();
+        rb_ary_push(parent->obj, pobj);
+        break;
+    case HashCode: found = rb_hash_lookup2(parent->obj, key, Qundef); break;
     default:
-	a = rb_ary_new();
-	rb_ary_push(a, parent->obj);
-	pobj = rb_hash_new();
-	rb_ary_push(a, pobj);
-	parent->obj = a;
-	parent->type = ArrayCode;
-	break;
+        a = rb_ary_new();
+        rb_ary_push(a, parent->obj);
+        pobj = rb_hash_new();
+        rb_ary_push(a, pobj);
+        parent->obj  = a;
+        parent->type = ArrayCode;
+        break;
     }
     if (Qundef == found) {
-	rb_hash_aset(pobj, key, e->obj);
+        rb_hash_aset(pobj, key, e->obj);
     } else if (RUBY_T_ARRAY == rb_type(found)) {
-	if (check_marked && marked(pi, found)) {
-	    unmark(pi, found);
-	    a = rb_ary_new();
-	    rb_ary_push(a, found);
-	    rb_ary_push(a, e->obj);
-	    rb_hash_aset(pobj, key, a);
-	} else {
-	    rb_ary_push(found, e->obj);
-	}
-    } else { // something there other than an array
-	if (check_marked && marked(pi, e->obj)) {
-	    unmark(pi, e->obj);
-	}
-	a = rb_ary_new();
-	rb_ary_push(a, found);
-	rb_ary_push(a, e->obj);
-	rb_hash_aset(pobj, key, a);
+        if (check_marked && marked(pi, found)) {
+            unmark(pi, found);
+            a = rb_ary_new();
+            rb_ary_push(a, found);
+            rb_ary_push(a, e->obj);
+            rb_hash_aset(pobj, key, a);
+        } else {
+            rb_ary_push(found, e->obj);
+        }
+    } else {  // something there other than an array
+        if (check_marked && marked(pi, e->obj)) {
+            unmark(pi, e->obj);
+        }
+        a = rb_ary_new();
+        rb_ary_push(a, found);
+        rb_ary_push(a, e->obj);
+        rb_hash_aset(pobj, key, a);
     }
     if (check_marked && NULL != pi->marked && RUBY_T_HASH == rb_type(e->obj)) {
-	rb_hash_foreach(e->obj, umark_hash_cb, (VALUE)pi);
+        rb_hash_foreach(e->obj, umark_hash_cb, (VALUE)pi);
     }
 }
 
-static void
-end_element(PInfo pi, const char *ename) {
+static void end_element(PInfo pi, const char *ename) {
     end_element_core(pi, ename, true);
 }
 
-static void
-end_element_no_attrs(PInfo pi, const char *ename) {
+static void end_element_no_attrs(PInfo pi, const char *ename) {
     end_element_core(pi, ename, false);
 }
 
-static void
-finish(PInfo pi) {
+static void finish(PInfo pi) {
     xfree(pi->marked);
 }
 
-struct _parseCallbacks   _ox_hash_callbacks = {
+struct _parseCallbacks _ox_hash_callbacks = {
     NULL,
     NULL,
     NULL,
@@ -253,9 +235,9 @@ struct _parseCallbacks   _ox_hash_callbacks = {
     finish,
 };
 
-ParseCallbacks   ox_hash_callbacks = &_ox_hash_callbacks;
+ParseCallbacks ox_hash_callbacks = &_ox_hash_callbacks;
 
-struct _parseCallbacks   _ox_hash_cdata_callbacks = {
+struct _parseCallbacks _ox_hash_cdata_callbacks = {
     NULL,
     NULL,
     NULL,
@@ -266,9 +248,9 @@ struct _parseCallbacks   _ox_hash_cdata_callbacks = {
     finish,
 };
 
-ParseCallbacks   ox_hash_cdata_callbacks = &_ox_hash_cdata_callbacks;
+ParseCallbacks ox_hash_cdata_callbacks = &_ox_hash_cdata_callbacks;
 
-struct _parseCallbacks   _ox_hash_no_attrs_callbacks = {
+struct _parseCallbacks _ox_hash_no_attrs_callbacks = {
     NULL,
     NULL,
     NULL,
@@ -279,9 +261,9 @@ struct _parseCallbacks   _ox_hash_no_attrs_callbacks = {
     NULL,
 };
 
-ParseCallbacks   ox_hash_no_attrs_callbacks = &_ox_hash_no_attrs_callbacks;
+ParseCallbacks ox_hash_no_attrs_callbacks = &_ox_hash_no_attrs_callbacks;
 
-struct _parseCallbacks   _ox_hash_no_attrs_cdata_callbacks = {
+struct _parseCallbacks _ox_hash_no_attrs_cdata_callbacks = {
     NULL,
     NULL,
     NULL,
@@ -292,4 +274,4 @@ struct _parseCallbacks   _ox_hash_no_attrs_cdata_callbacks = {
     NULL,
 };
 
-ParseCallbacks   ox_hash_no_attrs_cdata_callbacks = &_ox_hash_no_attrs_cdata_callbacks;
+ParseCallbacks ox_hash_no_attrs_cdata_callbacks = &_ox_hash_no_attrs_cdata_callbacks;

data/ext/ox/helper.h

@@ -8,82 +8,75 @@
 
 #include "type.h"
 
-#define HELPER_STACK_INC	16
+#define HELPER_STACK_INC 16
 
 typedef struct _helper {
-    ID		var;	/* Object var ID */
-    VALUE	obj;	/* object created or Qundef if not appropriate */
-    Type	type;	/* type of object in obj */
+    ID    var;  /* Object var ID */
+    VALUE obj;  /* object created or Qundef if not appropriate */
+    Type  type; /* type of object in obj */
 } *Helper;
 
 typedef struct _helperStack {
-    struct _helper	base[HELPER_STACK_INC];
-    Helper		head;	/* current stack */
-    Helper		end;	/* stack end */
-    Helper		tail;	/* pointer to one past last element name on stack */
+    struct _helper base[HELPER_STACK_INC];
+    Helper         head; /* current stack */
+    Helper         end;  /* stack end */
+    Helper         tail; /* pointer to one past last element name on stack */
 } *HelperStack;
 
-inline static void
-helper_stack_init(HelperStack stack) {
+inline static void helper_stack_init(HelperStack stack) {
     stack->head = stack->base;
-    stack->end = stack->base + sizeof(stack->base) / sizeof(struct _helper);
+    stack->end  = stack->base + sizeof(stack->base) / sizeof(struct _helper);
     stack->tail = stack->head;
 }
 
-inline static int
-helper_stack_empty(HelperStack stack) {
+inline static int helper_stack_empty(HelperStack stack) {
     return (stack->head == stack->tail);
 }
 
-inline static int
-helper_stack_depth(HelperStack stack) {
+inline static int helper_stack_depth(HelperStack stack) {
     return (int)(stack->tail - stack->head);
 }
 
-inline static void
-helper_stack_cleanup(HelperStack stack) {
+inline static void helper_stack_cleanup(HelperStack stack) {
     if (stack->base != stack->head) {
         xfree(stack->head);
-	stack->head = stack->base;
+        stack->head = stack->base;
     }
 }
 
-inline static Helper
-helper_stack_push(HelperStack stack, ID var, VALUE obj, Type type) {
+inline static Helper helper_stack_push(HelperStack stack, ID var, VALUE obj, Type type) {
     if (stack->end <= stack->tail) {
-	size_t	len = stack->end - stack->head;
-	size_t	toff = stack->tail - stack->head;
+        size_t len  = stack->end - stack->head;
+        size_t toff = stack->tail - stack->head;
 
-	if (stack->base == stack->head) {
-	    stack->head = ALLOC_N(struct _helper, len + HELPER_STACK_INC);
-	    memcpy(stack->head, stack->base, sizeof(struct _helper) * len);
-	} else {
-	    REALLOC_N(stack->head, struct _helper, len + HELPER_STACK_INC);
-	}
-	stack->tail = stack->head + toff;
-	stack->end = stack->head + len + HELPER_STACK_INC;
+        if (stack->base == stack->head) {
+            stack->head = ALLOC_N(struct _helper, len + HELPER_STACK_INC);
+            memcpy(stack->head, stack->base, sizeof(struct _helper) * len);
+        } else {
+            REALLOC_N(stack->head, struct _helper, len + HELPER_STACK_INC);
+        }
+        stack->tail = stack->head + toff;
+        stack->end  = stack->head + len + HELPER_STACK_INC;
     }
-    stack->tail->var = var;
-    stack->tail->obj = obj;
+    stack->tail->var  = var;
+    stack->tail->obj  = obj;
     stack->tail->type = type;
     stack->tail++;
 
     return stack->tail - 1;
 }
 
-inline static Helper
-helper_stack_peek(HelperStack stack) {
+inline static Helper helper_stack_peek(HelperStack stack) {
     if (stack->head < stack->tail) {
-	return stack->tail - 1;
+        return stack->tail - 1;
     }
     return 0;
 }
 
-inline static Helper
-helper_stack_pop(HelperStack stack) {
+inline static Helper helper_stack_pop(HelperStack stack) {
     if (stack->head < stack->tail) {
-	stack->tail--;
-	return stack->tail;
+        stack->tail--;
+        return stack->tail;
     }
     return 0;
 }

data/ext/ox/intern.c

@@ -5,10 +5,9 @@
 
 #include <stdint.h>
 
-#include "ruby/version.h"
-
 #include "cache.h"
 #include "ox.h"
+#include "ruby/version.h"
 
 // These are statics but in an attempt to stop the cross linking or maybe
 // something in Ruby they all have been given an ox prefix.