ox 2.14.14 → 2.14.17

data/ext/ox/sax.c

@@ -55,7 +55,7 @@ static char read_text(SaxDrive dr);
 static char read_jump(SaxDrive dr, const char *pat);
 static char read_attrs(SaxDrive dr, char c, char termc, char term2, int is_xml, int eq_req, Hint h);
 static char read_name_token(SaxDrive dr);
-static char read_quoted_value(SaxDrive dr);
+static char read_quoted_value(SaxDrive dr, bool inst);
 
 static void hint_clear_empty(SaxDrive dr);
 static Nv   hint_try_close(SaxDrive dr, const char *name);
@@ -469,7 +469,7 @@ DONE:
         Nv   sp;
 
         for (sp = dr->stack.tail - 1; dr->stack.head <= sp; sp--) {
-            snprintf(msg, sizeof(msg) - 1, "%selement '%s' not closed", EL_MISMATCH, sp->name);
+            snprintf(msg, sizeof(msg) - 1, "%selement '%s' not closed", EL_MISMATCH, nv_name(sp));
             ox_sax_drive_error_at(dr, msg, dr->buf.pos, dr->buf.line, dr->buf.col);
             end_element_cb(dr, sp->val, dr->buf.pos, dr->buf.line, dr->buf.col, sp->hint);
         }
@@ -761,17 +761,19 @@ CB:
  * code.
  */
 static char read_element_start(SaxDrive dr) {
-    const char    *ename = 0;
+    const char    *ename = NULL;
+    char           ebuf[128];
     size_t         nlen;
-    volatile VALUE name  = Qnil;
+    volatile VALUE name = Qnil;
     char           c;
-    int            closed;
     long           pos       = (long)(dr->buf.pos);
     long           line      = (long)(dr->buf.line);
     long           col       = (long)(dr->buf.col);
     Hint           h         = NULL;
     int            stackless = 0;
     Nv             parent    = stack_peek(&dr->stack);
+    bool           closed;
+    bool           efree = false;
 
     if ('\0' == (c = read_name_token(dr))) {
         return '\0';
@@ -827,7 +829,7 @@ static char read_element_start(SaxDrive dr) {
             if (0 != top_nv) {
                 char msg[256];
 
-                if (!h->nest && NestOverlay != h->overlay && 0 == strcasecmp(top_nv->name, h->name)) {
+                if (!h->nest && NestOverlay != h->overlay && nv_same_name(top_nv, h->name, true)) {
                     snprintf(msg,
                              sizeof(msg) - 1,
                              "%s%s can not be nested in a %s document, closing previous.",
@@ -844,7 +846,7 @@ static char read_element_start(SaxDrive dr) {
                     int          ok = 0;
 
                     for (p = h->parents; 0 != *p; p++) {
-                        if (0 == strcasecmp(*p, top_nv->name)) {
+                        if (nv_same_name(top_nv, *p, true)) {
                             ok = 1;
                             break;
                         }
@@ -855,7 +857,7 @@ static char read_element_start(SaxDrive dr) {
                                  "%s%s can not be a child of a %s in a %s document.",
                                  INV_ELEMENT,
                                  h->name,
-                                 top_nv->name,
+                                 nv_name(top_nv),
                                  dr->options.hints->name);
                         ox_sax_drive_error(dr, msg);
                     }
@@ -864,6 +866,16 @@ static char read_element_start(SaxDrive dr) {
         }
     }
     name = str2sym(dr, dr->buf.str, nlen, &ename);
+    if (NULL == ename) {
+        if (sizeof(ebuf) <= nlen) {
+            ename = ox_strndup(dr->buf.str, nlen);
+            efree = true;
+        } else {
+            memcpy(ebuf, dr->buf.str, nlen);
+            ebuf[nlen] = '\0';
+            ename      = ebuf;
+        }
+    }
     if (dr->has_start_element && 0 >= dr->blocked &&
         (NULL == h || ActiveOverlay == h->overlay || NestOverlay == h->overlay)) {
         VALUE args[1];
@@ -875,9 +887,9 @@ static char read_element_start(SaxDrive dr) {
         rb_funcall2(dr->handler, ox_start_element_id, 1, args);
     }
     if ('/' == c) {
-        closed = 1;
+        closed = true;
     } else if ('>' == c) {
-        closed = 0;
+        closed = false;
     } else {
         buf_protect(&dr->buf);
         c = read_attrs(dr, c, '/', '>', 0, 0, h);
@@ -906,11 +918,14 @@ static char read_element_start(SaxDrive dr) {
     } else {
         stack_push(&dr->stack, ename, nlen, name, h);
     }
+    if (efree) {
+        free((char *)ename);
+    }
     if ('>' != c) {
         ox_sax_drive_error(dr, WRONG_CHAR "element not closed");
         return c;
     }
-    dr->buf.str = 0;
+    dr->buf.str = NULL;
 
     return buf_get(&dr->buf);
 }
@@ -919,7 +934,7 @@ static Nv stack_rev_find(SaxDrive dr, const char *name) {
     Nv nv;
 
     for (nv = dr->stack.tail - 1; dr->stack.head <= nv; nv--) {
-        if (0 == (dr->options.smart ? strcasecmp(name, nv->name) : strcmp(name, nv->name))) {
+        if (nv_same_name(nv, name, dr->options.smart)) {
             return nv;
         }
     }
@@ -944,7 +959,7 @@ static char read_element_end(SaxDrive dr) {
     // c should be > and current is one past so read another char
     c  = buf_get(&dr->buf);
     nv = stack_peek(&dr->stack);
-    if (0 != nv && 0 == (dr->options.smart ? strcasecmp(dr->buf.str, nv->name) : strcmp(dr->buf.str, nv->name))) {
+    if (0 != nv && nv_same_name(nv, dr->buf.str, dr->options.smart)) {
         name = nv->val;
         h    = nv->hint;
         stack_pop(&dr->stack);
@@ -997,7 +1012,7 @@ static char read_element_end(SaxDrive dr) {
                          "%selement '%s' close does not match '%s' open",
                          EL_MISMATCH,
                          dr->buf.str,
-                         nv->name);
+                         nv_name(nv));
                 ox_sax_drive_error_at(dr, msg, pos, line, col);
                 for (nv = stack_pop(&dr->stack); match < nv; nv = stack_pop(&dr->stack)) {
                     end_element_cb(dr, nv->val, pos, line, col, nv->hint);
@@ -1204,6 +1219,7 @@ static char read_attrs(SaxDrive dr, char c, char termc, char term2, int is_xml,
             c = buf_next_non_white(&dr->buf);
         }
         if ('=' != c) {
+	    // TBD allow in smart mode
             if (eq_req) {
                 dr->err = 1;
                 return c;
@@ -1215,7 +1231,7 @@ static char read_attrs(SaxDrive dr, char c, char termc, char term2, int is_xml,
             pos        = dr->buf.pos + 1;
             line       = dr->buf.line;
             col        = dr->buf.col + 1;
-            c          = read_quoted_value(dr);
+            c          = read_quoted_value(dr, '?' == termc);
             attr_value = dr->buf.str;
 
             if (is_encoding) {
@@ -1282,10 +1298,11 @@ static char read_name_token(SaxDrive dr) {
     return '\0';
 }
 
-/* The character after the quote or if there is no quote, the character after the word is returned. dr->buf.tail is one
- * past that. dr->buf.str will point to the token which will be '\0' terminated.
+/* The character after the quote or if there is no quote, the character after
+ * the word is returned. dr->buf.tail is one past that. dr->buf.str will point
+ * to the token which will be '\0' terminated.
  */
-static char read_quoted_value(SaxDrive dr) {
+static char read_quoted_value(SaxDrive dr, bool inst) {
     char c;
 
     c = buf_get(&dr->buf);
@@ -1309,19 +1326,27 @@ static char read_quoted_value(SaxDrive dr) {
     }
     // not quoted, look for something that terminates the string
     dr->buf.str = dr->buf.tail - 1;
-    ox_sax_drive_error(dr, WRONG_CHAR "attribute value not in quotes");
+    // TBD if smart or html then no error
+    if (!(dr->options.smart && ox_hints_html() != dr->options.hints)) {
+	ox_sax_drive_error(dr, WRONG_CHAR "attribute value not in quotes");
+    }
     while ('\0' != (c = buf_get(&dr->buf))) {
         switch (c) {
         case ' ':
             // case '/':
         case '>':
-        case '?':  // for instructions
         case '\t':
         case '\n':
         case '\r':
             *(dr->buf.tail - 1) = '\0'; /* terminate value */
             // dr->buf.tail is in the correct position, one after the word terminator
             return c;
+        case '?':  // for instructions
+	    if (inst) {
+		*(dr->buf.tail - 1) = '\0'; /* terminate value */
+		return c;
+	    }
+	    break;
         default: break;
         }
     }
@@ -1465,18 +1490,18 @@ int ox_sax_collapse_special(SaxDrive dr, char *str, long pos, long line, long co
             break;
         }
         case '\r':
-	    s++;
+            s++;
             if ('\n' == *s) {
-		continue;
-	    }
-	    line++;
-	    col = 1;
+                continue;
+            }
+            line++;
+            col  = 1;
             *b++ = '\n';
-	    break;
-	case '\n':
-	    line++;
-	    col = 0;
-	    // fall through
+            break;
+        case '\n':
+            line++;
+            col = 0;
+            // fall through
         default:
             col++;
             *b++ = *s++;
@@ -1512,7 +1537,7 @@ static Nv hint_try_close(SaxDrive dr, const char *name) {
         return 0;
     }
     for (nv = stack_peek(&dr->stack); 0 != nv; nv = stack_peek(&dr->stack)) {
-        if (0 == strcasecmp(name, nv->name)) {
+        if (nv_same_name(nv, name, true)) {
             stack_pop(&dr->stack);
             return nv;
         }

data/ext/ox/sax.h

@@ -20,7 +20,7 @@ typedef struct _saxOptions {
     SkipMode skip;
     char     strip_ns[64];
     Hints    hints;
-} * SaxOptions;
+} *SaxOptions;
 
 typedef struct _saxDrive {
     struct _buf        buf;
@@ -52,7 +52,7 @@ typedef struct _saxDrive {
     bool         has_start_element;
     bool         has_end_element;
 
-} * SaxDrive;
+} *SaxDrive;
 
 extern void ox_collapse_return(char *str);
 extern void ox_sax_parse(VALUE handler, VALUE io, SaxOptions options);

data/ext/ox/sax_as.c

@@ -3,27 +3,26 @@
  * All rights reserved.
  */
 
-#include <stdlib.h>
 #include <errno.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <strings.h>
 #include <sys/types.h>
 #if HAVE_SYS_UIO_H
 #include <sys/uio.h>
 #endif
-#include <unistd.h>
 #include <time.h>
+#include <unistd.h>
 
+#include "ox.h"
 #include "ruby.h"
 #include "ruby/version.h"
-#include "ox.h"
 #include "sax.h"
 
-static VALUE
-parse_double_time(const char *text) {
-    long        v = 0;
-    long        v2 = 0;
-    const char  *dot = 0;
+static VALUE parse_double_time(const char *text) {
+    long        v   = 0;
+    long        v2  = 0;
+    const char *dot = 0;
     char        c;
 
     for (; '.' != *text; text++) {
@@ -44,101 +43,86 @@ parse_double_time(const char *text) {
     for (; text - dot <= 9; text++) {
         v2 *= 10;
     }
-#if HAVE_RB_TIME_NANO_NEW
     return rb_time_nano_new(v, v2);
-#else
-    return rb_time_new(v, v2 / 1000);
-#endif
 }
 
 typedef struct _tp {
-    int         cnt;
-    char        end;
-    char        alt;
+    int  cnt;
+    char end;
+    char alt;
 } *Tp;
 
-static VALUE
-parse_xsd_time(const char *text) {
-    long        cargs[10];
-    long        *cp = cargs;
-    long        v;
-    int         i;
-    char        c = '\0';
-    struct _tp  tpa[10] = { { 4, '-', '-' },
-                           { 2, '-', '-' },
-                           { 2, 'T', ' ' },
-                           { 2, ':', ':' },
-                           { 2, ':', ':' },
-                           { 2, '.', '.' },
-                           { 9, '+', '-' },
-                           { 2, ':', ':' },
-                           { 2, '\0', '\0' },
-                           { 0, '\0', '\0' } };
-    Tp          tp = tpa;
-    struct tm   tm;
+static VALUE parse_xsd_time(const char *text) {
+    long       cargs[10];
+    long      *cp = cargs;
+    long       v;
+    int        i;
+    char       c       = '\0';
+    struct _tp tpa[10] = {{4, '-', '-'},
+                          {2, '-', '-'},
+                          {2, 'T', ' '},
+                          {2, ':', ':'},
+                          {2, ':', ':'},
+                          {2, '.', '.'},
+                          {9, '+', '-'},
+                          {2, ':', ':'},
+                          {2, '\0', '\0'},
+                          {0, '\0', '\0'}};
+    Tp         tp      = tpa;
+    struct tm  tm;
 
     memset(cargs, 0, sizeof(cargs));
     for (; 0 != tp->cnt; tp++) {
-        for (i = tp->cnt, v = 0; 0 < i ; text++, i--) {
+        for (i = tp->cnt, v = 0; 0 < i; text++, i--) {
             c = *text;
             if (c < '0' || '9' < c) {
                 if ('\0' == c || tp->end == c || tp->alt == c) {
                     break;
                 }
-		return Qnil;
+                return Qnil;
             }
             v = 10 * v + (long)(c - '0');
         }
-	if ('\0' == c) {
-	    break;
-	}
+        if ('\0' == c) {
+            break;
+        }
         c = *text++;
         if (tp->end != c && tp->alt != c) {
-	    return Qnil;
+            return Qnil;
         }
         *cp++ = v;
     }
     tm.tm_year = (int)cargs[0] - 1900;
-    tm.tm_mon = (int)cargs[1] - 1;
+    tm.tm_mon  = (int)cargs[1] - 1;
     tm.tm_mday = (int)cargs[2];
     tm.tm_hour = (int)cargs[3];
-    tm.tm_min = (int)cargs[4];
-    tm.tm_sec = (int)cargs[5];
-#if HAVE_RB_TIME_NANO_NEW
+    tm.tm_min  = (int)cargs[4];
+    tm.tm_sec  = (int)cargs[5];
     return rb_time_nano_new(mktime(&tm), cargs[6]);
-#else
-    return rb_time_new(mktime(&tm), cargs[6] / 1000);
-#endif
 }
 
 /* call-seq: as_s()
  *
  * *return* value as an String.
  */
-static VALUE
-sax_value_as_s(VALUE self) {
-    SaxDrive	dr = DATA_PTR(self);
-    VALUE	rs;
+static VALUE sax_value_as_s(VALUE self) {
+    SaxDrive dr = DATA_PTR(self);
+    VALUE    rs;
 
     if ('\0' == *dr->buf.str) {
-	return Qnil;
+        return Qnil;
     }
     if (dr->options.convert_special) {
-	ox_sax_collapse_special(dr, dr->buf.str, dr->buf.pos, dr->buf.line, dr->buf.col);
+        ox_sax_collapse_special(dr, dr->buf.str, dr->buf.pos, dr->buf.line, dr->buf.col);
     }
     switch (dr->options.skip) {
-    case CrSkip:
-	buf_collapse_return(dr->buf.str);
-	break;
-    case SpcSkip:
-	buf_collapse_white(dr->buf.str);
-	break;
-    default:
-	break;
+    case CrSkip: buf_collapse_return(dr->buf.str); break;
+    case SpcSkip: buf_collapse_white(dr->buf.str); break;
+    default: break;
     }
     rs = rb_str_new2(dr->buf.str);
     if (0 != dr->encoding) {
-	rb_enc_associate(rs, dr->encoding);
+        rb_enc_associate(rs, dr->encoding);
     }
     return rs;
 }
@@ -147,12 +131,11 @@ sax_value_as_s(VALUE self) {
  *
  * *return* value as an Symbol.
  */
-static VALUE
-sax_value_as_sym(VALUE self) {
-    SaxDrive	dr = DATA_PTR(self);
+static VALUE sax_value_as_sym(VALUE self) {
+    SaxDrive dr = DATA_PTR(self);
 
     if ('\0' == *dr->buf.str) {
-	return Qnil;
+        return Qnil;
     }
     return str2sym(dr, dr->buf.str, strlen(dr->buf.str), 0);
 }
@@ -161,12 +144,11 @@ sax_value_as_sym(VALUE self) {
  *
  * *return* value as an Float.
  */
-static VALUE
-sax_value_as_f(VALUE self) {
-    SaxDrive	dr = DATA_PTR(self);
+static VALUE sax_value_as_f(VALUE self) {
+    SaxDrive dr = DATA_PTR(self);
 
     if ('\0' == *dr->buf.str) {
-	return Qnil;
+        return Qnil;
     }
     return rb_float_new(strtod(dr->buf.str, 0));
 }
@@ -175,31 +157,30 @@ sax_value_as_f(VALUE self) {
  *
  * *return* value as an Fixnum.
  */
-static VALUE
-sax_value_as_i(VALUE self) {
-    SaxDrive	dr = DATA_PTR(self);
-    const char	*s = dr->buf.str;
-    long	n = 0;
-    int		neg = 0;
+static VALUE sax_value_as_i(VALUE self) {
+    SaxDrive    dr  = DATA_PTR(self);
+    const char *s   = dr->buf.str;
+    long        n   = 0;
+    int         neg = 0;
 
     if ('\0' == *s) {
-	return Qnil;
+        return Qnil;
     }
     if ('-' == *s) {
-	neg = 1;
-	s++;
+        neg = 1;
+        s++;
     } else if ('+' == *s) {
-	s++;
+        s++;
     }
     for (; '\0' != *s; s++) {
-	if ('0' <= *s && *s <= '9') {
-	    n = n * 10 + (*s - '0');
-	} else {
-	    rb_raise(ox_arg_error_class, "Not a valid Fixnum.\n");
-	}
+        if ('0' <= *s && *s <= '9') {
+            n = n * 10 + (*s - '0');
+        } else {
+            rb_raise(ox_arg_error_class, "Not a valid Fixnum.\n");
+        }
     }
     if (neg) {
-	n = -n;
+        n = -n;
     }
     return LONG2NUM(n);
 }
@@ -208,22 +189,20 @@ sax_value_as_i(VALUE self) {
  *
  * *return* value as an Time.
  */
-static VALUE
-sax_value_as_time(VALUE self) {
-    SaxDrive	dr = DATA_PTR(self);
-    const char	*str = dr->buf.str;
+static VALUE sax_value_as_time(VALUE self) {
+    SaxDrive    dr  = DATA_PTR(self);
+    const char *str = dr->buf.str;
     VALUE       t;
 
     if ('\0' == *str) {
-	return Qnil;
+        return Qnil;
     }
-    if (Qnil == (t = parse_double_time(str)) &&
-	Qnil == (t = parse_xsd_time(str))) {
-        VALUE       args[1];
+    if (Qnil == (t = parse_double_time(str)) && Qnil == (t = parse_xsd_time(str))) {
+        VALUE args[1];
 
         /*printf("**** time parse\n"); */
         *args = rb_str_new2(str);
-        t = rb_funcall2(ox_time_class, ox_parse_id, 1, args);
+        t     = rb_funcall2(ox_time_class, ox_parse_id, 1, args);
     }
     return t;
 }
@@ -232,8 +211,7 @@ sax_value_as_time(VALUE self) {
  *
  * *return* value as an boolean.
  */
-static VALUE
-sax_value_as_bool(VALUE self) {
+static VALUE sax_value_as_bool(VALUE self) {
     return (0 == strcasecmp("true", ((SaxDrive)DATA_PTR(self))->buf.str)) ? Qtrue : Qfalse;
 }
 
@@ -241,8 +219,7 @@ sax_value_as_bool(VALUE self) {
  *
  * *return* true if the value is empty.
  */
-static VALUE
-sax_value_empty(VALUE self) {
+static VALUE sax_value_empty(VALUE self) {
     return ('\0' == *((SaxDrive)DATA_PTR(self))->buf.str) ? Qtrue : Qfalse;
 }
 
@@ -251,15 +228,14 @@ sax_value_empty(VALUE self) {
  * Values in the SAX callbacks. They can be converted to various different
  * types. with the _as_x()_ methods.
  */
-void
-ox_sax_define() {
+void ox_sax_define() {
 #if 0
     ox = rb_define_module("Ox");
 #if RUBY_API_VERSION_CODE >= 30200
     sax_module = rb_define_class_under(ox, "Sax", rb_cObject);
 #endif
 #endif
-    VALUE	sax_module = rb_const_get_at(Ox, rb_intern("Sax"));
+    VALUE sax_module = rb_const_get_at(Ox, rb_intern("Sax"));
 
     ox_sax_value_class = rb_define_class_under(sax_module, "Value", rb_cObject);
 #if RUBY_API_VERSION_CODE >= 30200