fast-xml 1.0.0

data/ext/fastxml/xh_log.c

@@ -0,0 +1,31 @@
+#include "xh_config.h"
+#include "xh_core.h"
+
+#define XH_LOG_LEVEL   XH_LOG_TRACE
+
+static const char *LOG_LEVEL_NAME[7] = {
+    "CRITIC",
+    "ERROR",
+    "WARN",
+    "NOTICE",
+    "INFO",
+    "DEBUG",
+    "TRACE",
+};
+
+void
+xh_log(xh_log_level_t log_level, const char *func, xh_int_t line, const char *msg, ...)
+{
+    va_list args;
+
+    if (log_level > XH_LOG_LEVEL) return;
+
+    (void) fprintf(stderr, "(%s) %s[%.0d]: ", LOG_LEVEL_NAME[log_level], func, (int) line);
+
+    va_start(args, msg);
+    (void) vfprintf(stderr, msg, args);
+    if (msg[strlen(msg) - 1] != '\n') {
+        (void) fprintf(stderr, "\n");
+    }
+    va_end(args);
+}

data/ext/fastxml/xh_log.h

@@ -0,0 +1,100 @@
+#include "xh_config.h"
+#include "xh_core.h"
+
+#ifndef _XH_LOG_H_
+#define _XH_LOG_H_
+
+typedef enum {
+    XH_LOG_CRITIC = 0,
+    XH_LOG_ERROR,
+    XH_LOG_WARN,
+    XH_LOG_NOTICE,
+    XH_LOG_INFO,
+    XH_LOG_DEBUG,
+    XH_LOG_TRACE
+} xh_log_level_t;
+
+#ifdef WITH_TRACE
+#define xh_log_debug0(msg)                                                 \
+        xh_log(XH_LOG_DEBUG, __FUNCTION__, __LINE__, msg)
+#define xh_log_debug1(msg, arg1)                                           \
+        xh_log(XH_LOG_DEBUG, __FUNCTION__, __LINE__, msg, arg1)
+#define xh_log_debug2(msg, arg1, arg2)                                     \
+        xh_log(XH_LOG_DEBUG, __FUNCTION__, __LINE__, msg, arg1, arg2)
+#define xh_log_debug3(msg, arg1, arg2, arg3)                               \
+        xh_log(XH_LOG_DEBUG, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3)
+#define xh_log_debug4(msg, arg1, arg2, arg3, arg4)                         \
+        xh_log(XH_LOG_DEBUG, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4)
+#define xh_log_debug5(msg, arg1, arg2, arg3, arg4, arg5)                   \
+        xh_log(XH_LOG_DEBUG, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5)
+#define xh_log_debug6(msg, arg1, arg2, arg3, arg4, arg5, arg6)             \
+        xh_log(XH_LOG_DEBUG, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6)
+#define xh_log_debug7(msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7)       \
+        xh_log(XH_LOG_DEBUG, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+#define xh_log_debug8(msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
+        xh_log(XH_LOG_DEBUG, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+#else
+#define xh_log_debug0(msg)
+#define xh_log_debug1(msg, arg1)
+#define xh_log_debug2(msg, arg1, arg2)
+#define xh_log_debug3(msg, arg1, arg2, arg3)
+#define xh_log_debug4(msg, arg1, arg2, arg3, arg4)
+#define xh_log_debug5(msg, arg1, arg2, arg3, arg4, arg5)
+#define xh_log_debug6(msg, arg1, arg2, arg3, arg4, arg5, arg6)
+#define xh_log_debug7(msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+#define xh_log_debug8(msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+#endif
+
+#ifdef WITH_TRACE
+#define xh_log_trace0(msg)                                                 \
+        xh_log(XH_LOG_TRACE, __FUNCTION__, __LINE__, msg)
+#define xh_log_trace1(msg, arg1)                                           \
+        xh_log(XH_LOG_TRACE, __FUNCTION__, __LINE__, msg, arg1)
+#define xh_log_trace2(msg, arg1, arg2)                                     \
+        xh_log(XH_LOG_TRACE, __FUNCTION__, __LINE__, msg, arg1, arg2)
+#define xh_log_trace3(msg, arg1, arg2, arg3)                               \
+        xh_log(XH_LOG_TRACE, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3)
+#define xh_log_trace4(msg, arg1, arg2, arg3, arg4)                         \
+        xh_log(XH_LOG_TRACE, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4)
+#define xh_log_trace5(msg, arg1, arg2, arg3, arg4, arg5)                   \
+        xh_log(XH_LOG_TRACE, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5)
+#define xh_log_trace6(msg, arg1, arg2, arg3, arg4, arg5, arg6)             \
+        xh_log(XH_LOG_TRACE, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6)
+#define xh_log_trace7(msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7)       \
+        xh_log(XH_LOG_TRACE, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+#define xh_log_trace8(msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
+        xh_log(XH_LOG_TRACE, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+#else
+#define xh_log_trace0(msg)
+#define xh_log_trace1(msg, arg1)
+#define xh_log_trace2(msg, arg1, arg2)
+#define xh_log_trace3(msg, arg1, arg2, arg3)
+#define xh_log_trace4(msg, arg1, arg2, arg3, arg4)
+#define xh_log_trace5(msg, arg1, arg2, arg3, arg4, arg5)
+#define xh_log_trace6(msg, arg1, arg2, arg3, arg4, arg5, arg6)
+#define xh_log_trace7(msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+#define xh_log_trace8(msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+#endif
+
+#define xh_log_error0(msg)                                                 \
+        xh_log(XH_LOG_ERROR, __FUNCTION__, __LINE__, msg)
+#define xh_log_error1(msg, arg1)                                           \
+        xh_log(XH_LOG_ERROR, __FUNCTION__, __LINE__, msg, arg1)
+#define xh_log_error2(msg, arg1, arg2)                                     \
+        xh_log(XH_LOG_ERROR, __FUNCTION__, __LINE__, msg, arg1, arg2)
+#define xh_log_error3(msg, arg1, arg2, arg3)                               \
+        xh_log(XH_LOG_ERROR, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3)
+#define xh_log_error4(msg, arg1, arg2, arg3, arg4)                         \
+        xh_log(XH_LOG_ERROR, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4)
+#define xh_log_error5(msg, arg1, arg2, arg3, arg4, arg5)                   \
+        xh_log(XH_LOG_ERROR, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5)
+#define xh_log_error6(msg, arg1, arg2, arg3, arg4, arg5, arg6)             \
+        xh_log(XH_LOG_ERROR, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6)
+#define xh_log_error7(msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7)       \
+        xh_log(XH_LOG_ERROR, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+#define xh_log_error8(msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
+        xh_log(XH_LOG_ERROR, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+
+void xh_log(xh_log_level_t log_level, const char *func, xh_int_t line, const char *msg, ...);
+
+#endif /* _XH_LOG_H_ */

data/ext/fastxml/xh_param.c

@@ -0,0 +1,77 @@
+#include "xh_config.h"
+#include "xh_core.h"
+
+void
+xh_param_assign_string(xh_char_t param[], VALUE value)
+{
+    xh_char_t *str;
+
+    if ( RTEST(value) ) {
+        str = (xh_char_t *) StringValueCStr(value);
+        xh_str_copy(param, str, XH_PARAM_LEN);
+    }
+    else {
+        *param = 0;
+    }
+}
+
+void
+xh_param_assign_int(xh_char_t *name, xh_int_t *param, VALUE value)
+{
+    Check_Type(value, T_FIXNUM);
+    *param = FIX2INT(value);
+}
+
+xh_bool_t
+xh_param_assign_bool(VALUE value)
+{
+    if ( RTEST(value) )
+        return TRUE;
+
+    return FALSE;
+}
+
+void
+xh_param_assign_pattern(xh_pattern_t *patt, VALUE value)
+{
+    if ( RTEST(value) ) {
+        patt->enable = TRUE;
+        if ( RB_TYPE_P(value, T_REGEXP) || RB_TYPE_P(value, T_ARRAY) ) {
+            patt->always = FALSE;
+            patt->expr   = value;
+        }
+        else {
+            patt->always = TRUE;
+        }
+    }
+    else {
+        patt->enable = FALSE;
+    }
+}
+
+void
+xh_param_assign_filter(xh_pattern_t *patt, VALUE value)
+{
+    if ( RTEST(value) ) {
+        patt->enable = TRUE;
+        patt->always = FALSE;
+        patt->expr   = value;
+    }
+    else {
+        patt->enable = FALSE;
+    }
+}
+
+VALUE
+xh_param_assign_cb(VALUE value)
+{
+    if ( !RTEST(value) )
+        return Qnil;
+
+    if (rb_cProc != rb_class_of(value) && rb_cMethod != rb_class_of(value))
+      rb_raise(rb_eArgError, "Expected Proc or Method callback");
+
+    //rb_funcall(value, rb_intern("call"), 0);
+
+    return value;
+}

data/ext/fastxml/xh_param.h

@@ -0,0 +1,56 @@
+#ifndef _XH_PARAM_H_
+#define _XH_PARAM_H_
+
+#include "xh_config.h"
+#include "xh_core.h"
+
+typedef struct {
+    xh_bool_t              enable;
+    xh_bool_t              always;
+    VALUE                  expr;
+} xh_pattern_t;
+
+void xh_param_assign_string(xh_char_t param[], VALUE value);
+void xh_param_assign_int(xh_char_t *name, xh_int_t *param, VALUE value);
+xh_bool_t xh_param_assign_bool(VALUE value);
+void xh_param_assign_pattern(xh_pattern_t *param, VALUE value);
+void xh_param_assign_filter(xh_pattern_t *param, VALUE value);
+VALUE xh_param_assign_cb(VALUE value);
+
+#define XH_PARAM_LEN 32
+
+#define XH_PARAM_READ_INIT                              \
+    VALUE      value;                                   \
+    xh_char_t *str;
+
+#define XH_PARAM_READ_STRING(var, name)                 \
+    value = rb_iv_get(xh_module, name);                 \
+    if ( RTEST(value) ) {                               \
+        str = XH_CHAR_CAST StringValueCStr(value);      \
+        xh_str_copy(var, str, XH_PARAM_LEN);            \
+    }                                                   \
+    else {                                              \
+        var[0] = '\0';                                  \
+    }
+
+#define XH_PARAM_READ_BOOL(var, name)                   \
+    value = rb_iv_get(xh_module, name);                 \
+    if ( RTEST(value) ) {                               \
+        var = TRUE;                                     \
+    }                                                   \
+    else {                                              \
+        var = FALSE;                                    \
+    }
+
+#define XH_PARAM_READ_INT(var, name)                    \
+    value = rb_iv_get(xh_module, name);                 \
+    var = FIX2INT(value);
+
+#define XH_PARAM_READ_REF(var, name)                    \
+    var = rb_iv_get(xh_module, name);
+
+#define XH_PARAM_READ_PATTERN(var, name)                \
+    value = rb_iv_get(xh_module, name);                 \
+    xh_param_assign_pattern(&(var), value);
+
+#endif /* _XH_PARAM_H_ */

data/ext/fastxml/xh_ruby_buffer.c

@@ -0,0 +1,51 @@
+#include "xh_config.h"
+#include "xh_core.h"
+
+void
+xh_ruby_buffer_init(xh_ruby_buffer_t *buf, size_t size)
+{
+    buf->scalar = rb_str_new(NULL, size);
+
+    buf->start = buf->cur = XH_CHAR_CAST RSTRING_PTR(buf->scalar);
+    buf->end   = buf->start + size;
+
+    xh_log_debug2("buf: %p size: %lu", buf->start, size);
+}
+
+void
+xh_ruby_buffer_grow(xh_ruby_buffer_t *buf, size_t inc)
+{
+    size_t size, use;
+
+    if (inc <= (size_t) (buf->end - buf->cur))
+        return;
+
+    size = xh_ruby_buffer_size(buf);
+    use  = xh_ruby_buffer_use(buf);
+
+    xh_log_debug2("old buf: %p size: %lu", buf->start, size);
+
+    size += inc < size ? size : inc;
+
+    rb_str_set_len(buf->scalar, use);
+    rb_str_resize(buf->scalar, size);
+
+    buf->start = XH_CHAR_CAST RSTRING_PTR(buf->scalar);
+    buf->cur   = buf->start + use;
+    buf->end   = buf->start + size;
+
+    xh_log_debug2("new buf: %p size: %lu", buf->start, size);
+}
+
+void
+xh_ruby_buffer_sync(xh_ruby_buffer_t *buf)
+{
+    size_t use  = buf->cur - buf->start;
+    size_t size = RSTRING_LEN(buf->scalar);
+
+    buf->start  = XH_CHAR_CAST RSTRING_PTR(buf->scalar);
+    buf->end    = buf->start + size;
+    buf->cur    = buf->start + use;
+
+    xh_log_debug2("buf: %p size: %lu", buf->start, size);
+}

data/ext/fastxml/xh_ruby_buffer.h

@@ -0,0 +1,30 @@
+#ifndef _XH_RUBY_BUFFER_H_
+#define _XH_RUBY_BUFFER_H_
+
+#include "xh_config.h"
+#include "xh_core.h"
+
+typedef struct _xh_ruby_buffer_t xh_ruby_buffer_t;
+struct _xh_ruby_buffer_t {
+    VALUE      scalar;
+    xh_char_t *start;
+    xh_char_t *cur;
+    xh_char_t *end;
+};
+
+void xh_ruby_buffer_init(xh_ruby_buffer_t *buf, size_t size);
+void xh_ruby_buffer_grow(xh_ruby_buffer_t *buf, size_t inc);
+void xh_ruby_buffer_sync(xh_ruby_buffer_t *buf);
+
+#define xh_ruby_buffer_avail(b)    ((b)->end - (b)->cur)
+#define xh_ruby_buffer_start(b)    ((b)->start)
+#define xh_ruby_buffer_pos(b)      ((b)->cur)
+#define xh_ruby_buffer_end(b)      ((b)->end)
+#define xh_ruby_buffer_size(b)     ((b)->end - (b)->start)
+#define xh_ruby_buffer_use(b)      ((b)->cur - (b)->start)
+#define xh_ruby_buffer_seek(b, p)  (b)->cur = p
+#define xh_ruby_buffer_seek_eof(b) (b)->cur = (b)->end
+#define xh_ruby_buffer_seek_top(b) (b)->cur = (b)->start
+#define xh_ruby_buffer_grow50(b)   xh_ruby_buffer_grow((b), xh_ruby_buffer_size(b) / 2)
+
+#endif /* _XH_RUBY_BUFFER_H_ */

data/ext/fastxml/xh_sort.c

@@ -0,0 +1,40 @@
+#include "xh_config.h"
+#include "xh_core.h"
+
+static int
+xh_sort_hash_cmp(const void *p1, const void *p2)
+{
+    return xh_strcmp(((xh_sort_hash_elt_t *) p1)->key, ((xh_sort_hash_elt_t *) p2)->key);
+}
+
+static int
+xh_sort_hash_iter(VALUE key, VALUE value, VALUE arg)
+{
+    xh_sort_hash_t *sorted_hash = (xh_sort_hash_t *) arg;
+
+    if (SYMBOL_P(key)) {
+        key = rb_sym2str(key);
+    }
+    else {
+        key = rb_obj_as_string(key);
+    }
+
+    key = StringValue(key);
+
+    sorted_hash->elts[sorted_hash->nelts].value   = value;
+    sorted_hash->elts[sorted_hash->nelts].key     = XH_CHAR_CAST StringValueCStr(key);
+    sorted_hash->elts[sorted_hash->nelts].key_len = RSTRING_LEN(key);
+    sorted_hash->nelts++;
+
+    return ST_CONTINUE;
+}
+
+void
+xh_sort_hash(xh_sort_hash_t *sorted_hash, VALUE hash)
+{
+    sorted_hash->nelts = 0;
+
+    rb_hash_foreach(hash, xh_sort_hash_iter, (VALUE) sorted_hash);
+
+    qsort(sorted_hash->elts, sorted_hash->nelts, sizeof(xh_sort_hash_elt_t), xh_sort_hash_cmp);
+}

data/ext/fastxml/xh_sort.h

@@ -0,0 +1,20 @@
+#ifndef _XH_SORT_H_
+#define _XH_SORT_H_
+
+#include "xh_config.h"
+#include "xh_core.h"
+
+typedef struct {
+    xh_char_t        *key;
+    size_t            key_len;
+    VALUE             value;
+} xh_sort_hash_elt_t;
+
+typedef struct {
+    xh_sort_hash_elt_t *elts;
+    size_t              nelts;
+} xh_sort_hash_t;
+
+void xh_sort_hash(xh_sort_hash_t *sorted_hash, VALUE hash);
+
+#endif /* _XH_SORT_H_ */

data/ext/fastxml/xh_stack.c

@@ -0,0 +1,19 @@
+#include "xh_config.h"
+#include "xh_core.h"
+
+void
+xh_stack_init(xh_stack_t *st, xh_uint_t nelts, size_t size)
+{
+    if ((st->elts = malloc(nelts * size)) == NULL) {
+        rb_raise(rb_eNoMemError, "Memory allocation error");
+    }
+    st->size  = size;
+    st->nelts = nelts;
+    st->top   = 0;
+}
+
+void
+xh_stack_destroy(xh_stack_t *st)
+{
+    free(st->elts);
+}

data/ext/fastxml/xh_stack.h

@@ -0,0 +1,41 @@
+#ifndef _XH_STACK_H_
+#define _XH_STACK_H_
+
+#include "xh_config.h"
+#include "xh_core.h"
+
+typedef struct {
+    void             *elts;
+    size_t            size;
+    size_t            nelts;
+    size_t            top;
+} xh_stack_t;
+
+XH_INLINE void *
+xh_stack_push(xh_stack_t *st)
+{
+    if (st->top >= st->nelts) {
+        st->nelts *= 2;
+        if ((st->elts = realloc(st->elts, st->nelts * st->size)) == NULL) {
+            rb_raise(rb_eNoMemError, "Memory allocation error");
+        }
+    }
+    return (void *) (XH_CHAR_CAST st->elts + st->top++ * st->size);
+}
+
+XH_INLINE void *
+xh_stack_pop(xh_stack_t *st)
+{
+    return st->top == 0 ? NULL : (void *) (XH_CHAR_CAST st->elts + --st->top * st->size);
+}
+
+XH_INLINE xh_bool_t
+xh_stack_empty(xh_stack_t *st)
+{
+    return st->top == 0 ? TRUE : FALSE;
+}
+
+void xh_stack_init(xh_stack_t *st, xh_uint_t nelts, size_t size);
+void xh_stack_destroy(xh_stack_t *st);
+
+#endif /* _XH_STACK_H_ */