ox 2.14.6 → 2.14.10

data/ext/ox/sax.h

@@ -8,46 +8,60 @@
 
 #include <stdbool.h>
 
+#include "ox.h"
 #include "sax_buf.h"
-#include "sax_has.h"
-#include "sax_stack.h"
 #include "sax_hint.h"
-#include "ox.h"
+#include "sax_stack.h"
 
 typedef struct _saxOptions {
-    int			symbolize;
-    int			convert_special;
-    int			smart;
-    SkipMode		skip;
-    char		strip_ns[64];
-    Hints		hints;
-} *SaxOptions;
+    int      symbolize;
+    int      convert_special;
+    int      smart;
+    SkipMode skip;
+    char     strip_ns[64];
+    Hints    hints;
+} * SaxOptions;
 
 typedef struct _saxDrive {
-    struct _buf		buf;
-    struct _nStack	stack;	/* element name stack */
-    VALUE		handler;
-    VALUE		value_obj;
-    struct _saxOptions	options;
-    int			err;
-    int			blocked;
-    bool		abort;
-    struct _has		has;
-#if HAVE_RB_ENC_ASSOCIATE
+    struct _buf        buf;
+    struct _nStack     stack; /* element name stack */
+    VALUE              handler;
+    VALUE              value_obj;
+    struct _saxOptions options;
+    VALUE (*get_name)(const char *name, size_t len, rb_encoding *encoding, const char **namep);
+    void (*set_pos)(VALUE handler, long pos);
+    void (*set_line)(VALUE handler, long line);
+    void (*set_col)(VALUE handler, long col);
+    void (*attr_cb)(struct _saxDrive *dr, VALUE name, char *value, long pos, long line, long col);
+    void (*attrs_done)(VALUE handler);
+    VALUE (*instruct)(struct _saxDrive *dr, const char *target, long pos, long line, long col);
+    void (*end_instruct)(struct _saxDrive *dr, VALUE target, long pos, long line, long col);
+    void (*doctype)(struct _saxDrive *dr, long pos, long line, long col);
+    void (*comment)(struct _saxDrive *dr, long pos, long line, long col);
+    void (*cdata)(struct _saxDrive *dr, long pos, long line, long col);
+    void (*error)(struct _saxDrive *dr, const char *msg, long pos, long line, long col);
+
     rb_encoding *encoding;
-#else
-    const char	*encoding;
-#endif
-} *SaxDrive;
+    int          err;
+    int          blocked;
+    bool         abort;
+    bool         utf8;
+    bool         want_attr_name;
+    bool         has_text;
+    bool         has_value;
+    bool         has_start_element;
+    bool         has_end_element;
+
+} * SaxDrive;
 
-extern void	ox_collapse_return(char *str);
-extern void	ox_sax_parse(VALUE handler, VALUE io, SaxOptions options);
-extern void	ox_sax_drive_cleanup(SaxDrive dr);
-extern void	ox_sax_drive_error(SaxDrive dr, const char *msg);
-extern int	ox_sax_collapse_special(SaxDrive dr, char *str, long pos, long line, long col);
+extern void ox_collapse_return(char *str);
+extern void ox_sax_parse(VALUE handler, VALUE io, SaxOptions options);
+extern void ox_sax_drive_cleanup(SaxDrive dr);
+extern void ox_sax_drive_error(SaxDrive dr, const char *msg);
+extern int  ox_sax_collapse_special(SaxDrive dr, char *str, long pos, long line, long col);
 
-extern VALUE	ox_sax_value_class;
+extern VALUE ox_sax_value_class;
 
-extern VALUE	str2sym(SaxDrive dr, const char *str, const char **strp);
+extern VALUE str2sym(SaxDrive dr, const char *str, size_t len, const char **strp);
 
 #endif /* OX_SAX_H */

data/ext/ox/sax_as.c

@@ -43,7 +43,7 @@ parse_double_time(const char *text) {
     for (; text - dot <= 9; text++) {
         v2 *= 10;
     }
-#if HAS_NANO_TIME
+#if HAVE_RB_TIME_NANO_NEW
     return rb_time_nano_new(v, v2);
 #else
     return rb_time_new(v, v2 / 1000);
@@ -103,7 +103,7 @@ parse_xsd_time(const char *text) {
     tm.tm_hour = (int)cargs[3];
     tm.tm_min = (int)cargs[4];
     tm.tm_sec = (int)cargs[5];
-#if HAS_NANO_TIME
+#if HAVE_RB_TIME_NANO_NEW
     return rb_time_nano_new(mktime(&tm), cargs[6]);
 #else
     return rb_time_new(mktime(&tm), cargs[6] / 1000);
@@ -136,11 +136,9 @@ sax_value_as_s(VALUE self) {
 	break;
     }
     rs = rb_str_new2(dr->buf.str);
-#if HAVE_RB_ENC_ASSOCIATE
     if (0 != dr->encoding) {
 	rb_enc_associate(rs, dr->encoding);
     }
-#endif
     return rs;
 }
 
@@ -155,7 +153,7 @@ sax_value_as_sym(VALUE self) {
     if ('\0' == *dr->buf.str) {
 	return Qnil;
     }
-    return str2sym(dr, dr->buf.str, 0);
+    return str2sym(dr, dr->buf.str, strlen(dr->buf.str), 0);
 }
 
 /* call-seq: as_f()

data/ext/ox/sax_buf.c

@@ -194,30 +194,21 @@ read_from_fd(Buf buf) {
     return 0;
 }
 
-static char*
-ox_stpncpy(char *dest, const char *src, size_t n) {
-    size_t	cnt = strlen(src) + 1;
-
-    if (n < cnt) {
-	cnt = n;
-    }
-    strncpy(dest, src, cnt);
-
-    return dest + cnt - 1;
-}
-
-
 static int
 read_from_str(Buf buf) {
     size_t      max = buf->end - buf->tail - 1;
     char	*s;
-    long	cnt;
+    size_t	cnt;
 
     if ('\0' == *buf->in.str) {
-	/* done */
 	return -1;
     }
-    s = ox_stpncpy(buf->tail, buf->in.str, max);
+    cnt = strlen(buf->in.str) + 1;
+    if (max < cnt) {
+	cnt = max;
+    }
+    strncpy(buf->tail, buf->in.str, cnt);
+    s = buf->tail + cnt - 1;
     *s = '\0';
     cnt = s - buf->tail;
     buf->in.str += cnt;

data/ext/ox/slotcache.c

@@ -0,0 +1,158 @@
+/* slotcache.c
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#include "slotcache.h"
+
+#include <errno.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+
+struct _slotCache {
+    /* The key is a length byte followed by the key as a string. If the key is longer than 254 characters then the
+       length is 255. The key can be for a premature value and in that case the length byte is greater than the length
+       of the key. */
+    char              *key;
+    VALUE              value;
+    struct _slotCache *slots[16];
+};
+
+static void slot_print(SlotCache cache, unsigned int depth);
+
+static char *form_key(const char *s) {
+    size_t len = strlen(s);
+    char  *d   = ALLOC_N(char, len + 2);
+
+    *(uint8_t *)d = (255 <= len) ? 255 : len;
+    memcpy(d + 1, s, len + 1);
+
+    return d;
+}
+
+void slot_cache_new(SlotCache *cache) {
+    *cache          = ALLOC(struct _slotCache);
+    (*cache)->key   = 0;
+    (*cache)->value = Qundef;
+    memset((*cache)->slots, 0, sizeof((*cache)->slots));
+}
+
+VALUE
+slot_cache_get(SlotCache cache, const char *key, VALUE **slot, const char **keyp) {
+    unsigned char *k = (unsigned char *)key;
+    SlotCache     *cp;
+
+    for (; '\0' != *k; k++) {
+        cp = cache->slots + (unsigned int)(*k >> 4); /* upper 4 bits */
+        if (0 == *cp) {
+            slot_cache_new(cp);
+        }
+        cache = *cp;
+        cp    = cache->slots + (unsigned int)(*k & 0x0F); /* lower 4 bits */
+        if (0 == *cp) { /* nothing on this tree so set key and value as a premature key/value pair */
+            slot_cache_new(cp);
+            cache      = *cp;
+            cache->key = form_key(key);
+            break;
+        } else {
+            int depth = (int)(k - (unsigned char *)key + 1);
+
+            cache = *cp;
+
+            if ('\0' == *(k + 1)) {    /* exact match */
+                if (0 == cache->key) { /* nothing in this spot so take it */
+                    cache->key = form_key(key);
+                    break;
+                } else if ((depth == *cache->key || 255 < depth) && 0 == strcmp(key, cache->key + 1)) { /* match */
+                    break;
+                } else { /* have to move the current premature key/value deeper */
+                    unsigned char *ck   = (unsigned char *)(cache->key + depth + 1);
+                    SlotCache      orig = *cp;
+
+                    cp = (*cp)->slots + (*ck >> 4);
+                    slot_cache_new(cp);
+                    cp = (*cp)->slots + (*ck & 0x0F);
+                    slot_cache_new(cp);
+                    (*cp)->key   = cache->key;
+                    (*cp)->value = cache->value;
+                    orig->key    = form_key(key);
+                    orig->value  = Qundef;
+                }
+            } else {                   /* not exact match but on the path */
+                if (0 != cache->key) { /* there is a key/value here already */
+                    if (depth == *cache->key || (255 <= depth && 0 == strncmp(cache->key, key, depth) &&
+                                                 '\0' == cache->key[depth])) { /* key belongs here */
+                        continue;
+                    } else {
+                        unsigned char *ck   = (unsigned char *)(cache->key + depth + 1);
+                        SlotCache      orig = *cp;
+
+                        cp = (*cp)->slots + (*ck >> 4);
+                        slot_cache_new(cp);
+                        cp = (*cp)->slots + (*ck & 0x0F);
+                        slot_cache_new(cp);
+                        (*cp)->key   = cache->key;
+                        (*cp)->value = cache->value;
+                        orig->key    = 0;
+                        orig->value  = Qundef;
+                    }
+                }
+            }
+        }
+    }
+    *slot = &cache->value;
+    if (0 != keyp) {
+        if (0 == cache->key) {
+            printf("*** Error: failed to set the key for '%s'\n", key);
+            *keyp = 0;
+        } else {
+            *keyp = cache->key + 1;
+        }
+    }
+    return cache->value;
+}
+
+void slot_cache_print(SlotCache cache) {
+    /*printf("-------------------------------------------\n");*/
+    slot_print(cache, 0);
+}
+
+static void slot_print(SlotCache c, unsigned int depth) {
+    char         indent[256];
+    SlotCache   *cp;
+    unsigned int i;
+
+    if (sizeof(indent) - 1 < depth) {
+        depth = ((int)sizeof(indent) - 1);
+    }
+    memset(indent, ' ', depth);
+    indent[depth] = '\0';
+    for (i = 0, cp = c->slots; i < 16; i++, cp++) {
+        if (0 == *cp) {
+            /*printf("%s%02u:\n", indent, i);*/
+        } else {
+            if (0 == (*cp)->key && Qundef == (*cp)->value) {
+                printf("%s%02u:\n", indent, i);
+            } else {
+                const char *vs;
+                const char *clas;
+
+                if (Qundef == (*cp)->value) {
+                    vs   = "undefined";
+                    clas = "";
+                } else {
+                    VALUE rs = rb_funcall2((*cp)->value, rb_intern("to_s"), 0, 0);
+
+                    vs   = StringValuePtr(rs);
+                    clas = rb_class2name(rb_obj_class((*cp)->value));
+                }
+                printf("%s%02u: %s = %s (%s)\n", indent, i, (*cp)->key, vs, clas);
+            }
+            slot_print(*cp, depth + 2);
+        }
+    }
+}

data/ext/ox/slotcache.h

@@ -0,0 +1,19 @@
+/* slotcache.h
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#ifndef SLOT_CACHE_H
+#define SLOT_CACHE_H
+
+#include "ruby.h"
+
+typedef struct _slotCache   *SlotCache;
+
+extern void     slot_cache_new(SlotCache *cache);
+
+extern VALUE    slot_cache_get(SlotCache cache, const char *key, VALUE **slot, const char **keyp);
+
+extern void     slot_cache_print(SlotCache cache);
+
+#endif /* SLOT_CACHE_H */

data/lib/ox/version.rb

@@ -1,5 +1,5 @@
 
 module Ox
   # Current version of the module.
-  VERSION = '2.14.6'
+  VERSION = '2.14.10'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ox
 version: !ruby/object:Gem::Version
-  version: 2.14.6
+  version: 2.14.10
 platform: ruby
 authors:
 - Peter Ohler
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-03 00:00:00.000000000 Z
+date: 2022-03-10 00:00:00.000000000 Z
 dependencies: []
 description: "A fast XML parser and object serializer that uses only standard C lib.\n\nOptimized
   XML (Ox), as the name implies was written to provide speed optimized\nXML handling.
@@ -41,6 +41,8 @@ files:
 - ext/ox/gen_load.c
 - ext/ox/hash_load.c
 - ext/ox/helper.h
+- ext/ox/intern.c
+- ext/ox/intern.h
 - ext/ox/obj_load.c
 - ext/ox/ox.c
 - ext/ox/ox.h
@@ -50,10 +52,11 @@ files:
 - ext/ox/sax_as.c
 - ext/ox/sax_buf.c
 - ext/ox/sax_buf.h
-- ext/ox/sax_has.h
 - ext/ox/sax_hint.c
 - ext/ox/sax_hint.h
 - ext/ox/sax_stack.h
+- ext/ox/slotcache.c
+- ext/ox/slotcache.h
 - ext/ox/special.c
 - ext/ox/special.h
 - ext/ox/type.h
@@ -101,7 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: A fast XML parser and object serializer.

data/ext/ox/sax_has.h

@@ -1,53 +0,0 @@
-/* sax_has.h
- * Copyright (c) 2011, Peter Ohler
- * All rights reserved.
- */
-
-#ifndef OX_SAX_HAS_H
-#define OX_SAX_HAS_H
-
-typedef struct _has {
-    int         instruct;
-    int         end_instruct;
-    int         attr;
-    int         attrs_done;
-    int         attr_value;
-    int         doctype;
-    int         comment;
-    int         cdata;
-    int         text;
-    int         value;
-    int         start_element;
-    int         end_element;
-    int         error;
-    int		pos;
-    int		line;
-    int		column;
-} *Has;
-
-inline static int
-respond_to(VALUE obj, ID method) {
-    return rb_respond_to(obj, method);
-}
-
-inline static void
-has_init(Has has, VALUE handler) {
-    has->instruct = respond_to(handler, ox_instruct_id);
-    has->end_instruct = respond_to(handler, ox_end_instruct_id);
-    has->attr = respond_to(handler, ox_attr_id);
-    has->attr_value = respond_to(handler, ox_attr_value_id);
-    has->attrs_done = respond_to(handler, ox_attrs_done_id);
-    has->doctype = respond_to(handler, ox_doctype_id);
-    has->comment = respond_to(handler, ox_comment_id);
-    has->cdata = respond_to(handler, ox_cdata_id);
-    has->text = respond_to(handler, ox_text_id);
-    has->value = respond_to(handler, ox_value_id);
-    has->start_element = respond_to(handler, ox_start_element_id);
-    has->end_element = respond_to(handler, ox_end_element_id);
-    has->error = respond_to(handler, ox_error_id);
-    has->pos = (Qtrue == rb_ivar_defined(handler, ox_at_pos_id));
-    has->line = (Qtrue == rb_ivar_defined(handler, ox_at_line_id));
-    has->column = (Qtrue == rb_ivar_defined(handler, ox_at_column_id));
-}
-
-#endif /* OX_SAX_HAS_H */