ox 2.14.14 → 2.14.17

data/ext/ox/ox.c

@@ -23,7 +23,7 @@
 typedef struct _yesNoOpt {
     VALUE sym;
     char *attr;
-} * YesNoOpt;
+} *YesNoOpt;
 
 void Init_ox();
 
@@ -73,11 +73,6 @@ ID ox_start_element_id;
 ID ox_string_id;
 ID ox_text_id;
 ID ox_to_c_id;
-ID ox_to_s_id;
-ID ox_to_sym_id;
-ID ox_tv_nsec_id;
-ID ox_tv_sec_id;
-ID ox_tv_usec_id;
 ID ox_value_id;
 
 VALUE ox_encoding_sym;
@@ -107,7 +102,7 @@ VALUE ox_struct_class;
 VALUE ox_syntax_error_class;
 VALUE ox_time_class;
 
-SlotCache ox_class_cache  = 0;
+SlotCache ox_class_cache = 0;
 
 static VALUE abort_sym;
 static VALUE active_sym;
@@ -687,17 +682,13 @@ static VALUE to_obj(VALUE self, VALUE ruby_xml) {
         xml = ALLOCA_N(char, len);
     }
     memcpy(xml, x, len);
-#ifdef RB_GC_GUARD
     rb_gc_disable();
-#endif
     obj = ox_parse(xml, len - 1, ox_obj_callbacks, 0, &options, &err);
     if (SMALL_XML < len) {
         xfree(xml);
     }
-#ifdef RB_GC_GUARD
     RB_GC_GUARD(obj);
     rb_gc_enable();
-#endif
     if (err_has(&err)) {
         ox_err_raise(&err);
     }
@@ -740,130 +731,123 @@ static VALUE to_gen(VALUE self, VALUE ruby_xml) {
     return obj;
 }
 
-static VALUE load(char *xml, size_t len, int argc, VALUE *argv, VALUE self, VALUE encoding, Err err) {
-    VALUE           obj;
-    struct _options options = ox_default_options;
-
-    if (1 == argc && rb_cHash == rb_obj_class(*argv)) {
-        VALUE h = *argv;
-        VALUE v;
-
-        if (Qnil != (v = rb_hash_lookup(h, mode_sym))) {
-            if (object_sym == v) {
-                options.mode = ObjMode;
-            } else if (optimized_sym == v) {
-                options.mode = ObjMode;
-            } else if (generic_sym == v) {
-                options.mode = GenMode;
-            } else if (limited_sym == v) {
-                options.mode = LimMode;
-            } else if (hash_sym == v) {
-                options.mode = HashMode;
-            } else if (hash_no_attrs_sym == v) {
-                options.mode = HashNoAttrMode;
-            } else {
-                rb_raise(ox_parse_error_class, ":mode must be :generic, :object, :limited, :hash, :hash_no_attrs.\n");
-            }
-        }
-        if (Qnil != (v = rb_hash_lookup(h, effort_sym))) {
-            if (auto_define_sym == v) {
-                options.effort = AutoEffort;
-            } else if (tolerant_sym == v) {
-                options.effort = TolerantEffort;
-            } else if (strict_sym == v) {
-                options.effort = StrictEffort;
-            } else {
-                rb_raise(ox_parse_error_class, ":effort must be :strict, :tolerant, or :auto_define.\n");
-            }
-        }
-        if (Qnil != (v = rb_hash_lookup(h, skip_sym))) {
-            if (skip_none_sym == v) {
-                options.skip = NoSkip;
-            } else if (skip_off_sym == v) {
-                options.skip = OffSkip;
-            } else if (skip_return_sym == v) {
-                options.skip = CrSkip;
-            } else if (skip_white_sym == v) {
-                options.skip = SpcSkip;
-            } else {
-                rb_raise(ox_parse_error_class, ":skip must be :skip_none, :skip_return, :skip_white, or :skip_off.\n");
-            }
-        }
-
-        if (Qnil != (v = rb_hash_lookup(h, trace_sym))) {
-            Check_Type(v, T_FIXNUM);
-            options.trace = FIX2INT(v);
-        }
-        if (Qnil != (v = rb_hash_lookup(h, symbolize_keys_sym))) {
-            options.sym_keys = (Qfalse == v) ? No : Yes;
+static int load_options_cb(VALUE k, VALUE v, VALUE opts) {
+    Options copts = (Options)opts;
+
+    if (mode_sym == k) {
+        if (object_sym == v) {
+            copts->mode = ObjMode;
+        } else if (optimized_sym == v) {
+            copts->mode = ObjMode;
+        } else if (generic_sym == v) {
+            copts->mode = GenMode;
+        } else if (limited_sym == v) {
+            copts->mode = LimMode;
+        } else if (hash_sym == v) {
+            copts->mode = HashMode;
+        } else if (hash_no_attrs_sym == v) {
+            copts->mode = HashNoAttrMode;
+        } else {
+            rb_raise(ox_parse_error_class, ":mode must be :generic, :object, :limited, :hash, :hash_no_attrs.\n");
         }
-        options.element_key_mod = rb_hash_lookup2(h, element_key_mod_sym, options.element_key_mod);
-        options.attr_key_mod    = rb_hash_lookup2(h, attr_key_mod_sym, options.attr_key_mod);
-
-        if (Qnil != (v = rb_hash_lookup(h, convert_special_sym))) {
-            options.convert_special = (Qfalse != v);
+    } else if (effort_sym == k) {
+        if (auto_define_sym == v) {
+            copts->effort = AutoEffort;
+        } else if (tolerant_sym == v) {
+            copts->effort = TolerantEffort;
+        } else if (strict_sym == v) {
+            copts->effort = StrictEffort;
+        } else {
+            rb_raise(ox_parse_error_class, ":effort must be :strict, :tolerant, or :auto_define.\n");
         }
-        if (Qnil != (v = rb_hash_lookup(h, no_empty_sym))) {
-            options.no_empty = (Qfalse != v);
+    } else if (skip_sym == k) {
+        if (skip_none_sym == v) {
+            copts->skip = NoSkip;
+        } else if (skip_off_sym == v) {
+            copts->skip = OffSkip;
+        } else if (skip_return_sym == v) {
+            copts->skip = CrSkip;
+        } else if (skip_white_sym == v) {
+            copts->skip = SpcSkip;
+        } else {
+            rb_raise(ox_parse_error_class, ":skip must be :skip_none, :skip_return, :skip_white, or :skip_off.\n");
         }
-
-        v = rb_hash_lookup(h, invalid_replace_sym);
+    } else if (trace_sym == k) {
+        Check_Type(v, T_FIXNUM);
+        copts->trace = FIX2INT(v);
+    } else if (symbolize_keys_sym == k) {
+        copts->sym_keys = (Qfalse == v) ? No : Yes;
+    } else if (element_key_mod_sym == k) {
+        copts->element_key_mod = v;
+    } else if (attr_key_mod_sym == k) {
+        copts->attr_key_mod = v;
+    } else if (convert_special_sym == k) {
+        copts->convert_special = (Qfalse != v);
+    } else if (no_empty_sym == k) {
+        copts->no_empty = (Qfalse != v);
+    } else if (invalid_replace_sym == k) {
         if (Qnil == v) {
-            if (Qtrue == rb_funcall(h, has_key_id, 1, invalid_replace_sym)) {
-                options.allow_invalid = Yes;
-            }
+            copts->allow_invalid = Yes;
         } else {
             long slen;
 
             Check_Type(v, T_STRING);
             slen = RSTRING_LEN(v);
-            if (sizeof(options.inv_repl) - 2 < (size_t)slen) {
+            if (sizeof(copts->inv_repl) - 2 < (size_t)slen) {
                 rb_raise(ox_parse_error_class,
                          ":invalid_replace can be no longer than %d characters.",
-                         (int)sizeof(options.inv_repl) - 2);
+                         (int)sizeof(copts->inv_repl) - 2);
             }
-            strncpy(options.inv_repl + 1, StringValuePtr(v), sizeof(options.inv_repl) - 1);
-            options.inv_repl[sizeof(options.inv_repl) - 1] = '\0';
-            *options.inv_repl                              = (char)slen;
-            options.allow_invalid                          = No;
+            strncpy(copts->inv_repl + 1, StringValuePtr(v), sizeof(copts->inv_repl) - 1);
+            copts->inv_repl[sizeof(copts->inv_repl) - 1] = '\0';
+            *copts->inv_repl                             = (char)slen;
+            copts->allow_invalid                         = No;
         }
-        v = rb_hash_lookup(h, strip_namespace_sym);
+    } else if (strip_namespace_sym == k) {
         if (Qfalse == v) {
-            *options.strip_ns = '\0';
+            *copts->strip_ns = '\0';
         } else if (Qtrue == v) {
-            *options.strip_ns   = '*';
-            options.strip_ns[1] = '\0';
+            *copts->strip_ns   = '*';
+            copts->strip_ns[1] = '\0';
         } else if (Qnil != v) {
             long slen;
 
             Check_Type(v, T_STRING);
             slen = RSTRING_LEN(v);
-            if (sizeof(options.strip_ns) - 1 < (size_t)slen) {
+            if (sizeof(copts->strip_ns) - 1 < (size_t)slen) {
                 rb_raise(ox_parse_error_class,
                          ":strip_namespace can be no longer than %d characters.",
-                         (int)sizeof(options.strip_ns) - 1);
+                         (int)sizeof(copts->strip_ns) - 1);
             }
-            strncpy(options.strip_ns, StringValuePtr(v), sizeof(options.strip_ns) - 1);
-            options.strip_ns[sizeof(options.strip_ns) - 1] = '\0';
+            strncpy(copts->strip_ns, StringValuePtr(v), sizeof(copts->strip_ns) - 1);
+            copts->strip_ns[sizeof(copts->strip_ns) - 1] = '\0';
         }
-        v = rb_hash_lookup(h, margin_sym);
-        if (Qnil != v) {
-            long slen;
+    } else if (margin_sym == k) {
+        long slen;
 
-            Check_Type(v, T_STRING);
-            slen = RSTRING_LEN(v);
-            if (sizeof(options.margin) - 1 < (size_t)slen) {
-                rb_raise(ox_parse_error_class,
-                         ":margin can be no longer than %d characters.",
-                         (int)sizeof(options.margin) - 1);
-            }
-            strncpy(options.margin, StringValuePtr(v), sizeof(options.margin) - 1);
-            options.margin[sizeof(options.margin) - 1] = '\0';
-            options.margin_len                         = strlen(options.margin);
-        }
-        if (Qnil != (v = rb_hash_lookup(h, with_cdata_sym))) {
-            options.with_cdata = (Qtrue == v);
+        Check_Type(v, T_STRING);
+        slen = RSTRING_LEN(v);
+        if (sizeof(copts->margin) - 1 < (size_t)slen) {
+            rb_raise(ox_parse_error_class,
+                     ":margin can be no longer than %d characters.",
+                     (int)sizeof(copts->margin) - 1);
         }
+        strncpy(copts->margin, StringValuePtr(v), sizeof(copts->margin) - 1);
+        copts->margin[sizeof(copts->margin) - 1] = '\0';
+        copts->margin_len                        = strlen(copts->margin);
+    } else if (with_cdata_sym == k) {
+        copts->with_cdata = (Qtrue == v);
+    }
+
+    return ST_CONTINUE;
+}
+
+static VALUE load(char *xml, size_t len, int argc, VALUE *argv, VALUE self, VALUE encoding, Err err) {
+    VALUE           obj;
+    struct _options options = ox_default_options;
+
+    if (1 == argc && rb_cHash == rb_obj_class(*argv)) {
+        rb_hash_foreach(*argv, load_options_cb, (VALUE)&options);
     }
     if ('\0' == *options.encoding) {
         if (Qnil != encoding) {
@@ -877,14 +861,10 @@ static VALUE load(char *xml, size_t len, int argc, VALUE *argv, VALUE self, VALU
     xml = defuse_bom(xml, &options);
     switch (options.mode) {
     case ObjMode:
-#ifdef RB_GC_GUARD
         rb_gc_disable();
-#endif
         obj = ox_parse(xml, len, ox_obj_callbacks, 0, &options, err);
-#ifdef RB_GC_GUARD
         RB_GC_GUARD(obj);
         rb_gc_enable();
-#endif
         break;
     case GenMode: obj = ox_parse(xml, len, ox_gen_callbacks, 0, &options, err); break;
     case LimMode: obj = ox_parse(xml, len, ox_limited_callbacks, 0, &options, err); break;
@@ -952,11 +932,7 @@ static VALUE load_str(int argc, VALUE *argv, VALUE self) {
     } else {
         xml = ALLOCA_N(char, len);
     }
-#if HAVE_RB_OBJ_ENCODING
     encoding = rb_obj_encoding(*argv);
-#else
-    encoding = Qnil;
-#endif
     memcpy(xml, StringValuePtr(*argv), len);
     xml[len - 1] = '\0';
     obj          = load(xml, len - 1, argc - 1, argv + 1, self, encoding, &err);
@@ -1201,21 +1177,13 @@ static void parse_dump_options(VALUE ropts, Options copts) {
         VALUE v;
 
         if (Qnil != (v = rb_hash_lookup(ropts, ox_indent_sym))) {
-#ifdef RUBY_INTEGER_UNIFICATION
             if (rb_cInteger != rb_obj_class(v) && T_FIXNUM != rb_type(v)) {
-#else
-            if (rb_cFixnum != rb_obj_class(v)) {
-#endif
                 rb_raise(ox_parse_error_class, ":indent must be a Fixnum.\n");
             }
             copts->indent = NUM2INT(v);
         }
         if (Qnil != (v = rb_hash_lookup(ropts, trace_sym))) {
-#ifdef RUBY_INTEGER_UNIFICATION
             if (rb_cInteger != rb_obj_class(v) && T_FIXNUM != rb_type(v)) {
-#else
-            if (rb_cFixnum != rb_obj_class(v)) {
-#endif
                 rb_raise(ox_parse_error_class, ":trace must be a Fixnum.\n");
             }
             copts->trace = NUM2INT(v);
@@ -1469,11 +1437,6 @@ void Init_ox() {
     ox_string_id            = rb_intern("string");
     ox_text_id              = rb_intern("text");
     ox_to_c_id              = rb_intern("to_c");
-    ox_to_s_id              = rb_intern("to_s");
-    ox_to_sym_id            = rb_intern("to_sym");
-    ox_tv_nsec_id           = rb_intern("tv_nsec");
-    ox_tv_sec_id            = rb_intern("tv_sec");
-    ox_tv_usec_id           = rb_intern("tv_usec");
     ox_value_id             = rb_intern("value");
 
     encoding_id = rb_intern("encoding");
@@ -1675,8 +1638,6 @@ _ox_raise_error(const char *msg, const char *xml, const char *current, const cha
             xline++;
         }
     }
-#ifdef RB_GC_GUARD
     rb_gc_enable();
-#endif
     rb_raise(ox_parse_error_class, "%s at line %d, column %d [%s:%d]\n", msg, xline, col, file, line);
 }

data/ext/ox/ox.h

@@ -94,14 +94,14 @@ typedef struct _parseCallbacks {
     void (*add_element)(PInfo pi, const char *ename, Attr attrs, int hasChildren);
     void (*end_element)(PInfo pi, const char *ename);
     void (*finish)(PInfo pi);
-} * ParseCallbacks;
+} *ParseCallbacks;
 
 typedef struct _circArray {
     VALUE         obj_array[1024];
     VALUE        *objs;
     unsigned long size; /* allocated size or initial array size */
     unsigned long cnt;
-} * CircArray;
+} *CircArray;
 
 typedef struct _options {
     char           encoding[64];     // encoding, stored in the option to avoid GC invalidation in default values
@@ -128,8 +128,8 @@ typedef struct _options {
     struct _hints *html_hints;       // html hints
     VALUE          attr_key_mod;
     VALUE          element_key_mod;
-    rb_encoding *rb_enc;
-} * Options;
+    rb_encoding   *rb_enc;
+} *Options;
 
 // parse information structure
 struct _pInfo {
@@ -146,7 +146,7 @@ struct _pInfo {
     VALUE              *marked;
     int                 mark_size;  // allocated size
     int                 mark_cnt;
-    char                last;  // last character read, rarely set
+    char                last;       // last character read, rarely set
 };
 
 extern VALUE ox_parse(char *xml, size_t len, ParseCallbacks pcb, char **endp, Options options, Err err);
@@ -205,11 +205,6 @@ extern ID ox_start_element_id;
 extern ID ox_string_id;
 extern ID ox_text_id;
 extern ID ox_to_c_id;
-extern ID ox_to_s_id;
-extern ID ox_to_sym_id;
-extern ID ox_tv_sec_id;
-extern ID ox_tv_nsec_id;
-extern ID ox_tv_usec_id;
 extern ID ox_value_id;
 
 extern rb_encoding *ox_utf8_encoding;