fast-xml 1.0.0

data/ext/fastxml/xh_encoder.h

@@ -0,0 +1,56 @@
+#ifndef _XH_ENCODER_H_
+#define _XH_ENCODER_H_
+
+#include "xh_config.h"
+#include "xh_core.h"
+
+#ifdef XH_HAVE_ENCODER
+
+#ifdef XH_HAVE_ICONV
+#if defined(__MINGW32__) || defined(_WIN32)
+#define LIBICONV_STATIC
+#endif
+#include <iconv.h>
+#endif
+#ifdef XH_HAVE_ICU
+#include <unicode/utypes.h>
+#include <unicode/ucnv.h>
+#endif
+
+typedef enum {
+    XH_ENC_ICONV,
+    XH_ENC_ICU
+} xh_encoder_type_t;
+
+typedef enum {
+    XH_ENC_OK = 0,
+    XH_ENC_BUFFER_OVERFLOW,
+    XH_ENC_TRUNCATED_CHAR_FOUND
+} xh_encoder_state_t;
+
+typedef struct _xh_encoder_t xh_encoder_t;
+struct _xh_encoder_t {
+    xh_encoder_type_t  type;
+    xh_encoder_state_t state;
+    xh_char_t          fromcode[XH_PARAM_LEN];
+    xh_char_t          tocode[XH_PARAM_LEN];
+#ifdef XH_HAVE_ICONV
+    iconv_t            iconv;
+#endif
+#ifdef XH_HAVE_ICU
+    UConverter        *uconv_from;
+    UConverter        *uconv_to;
+    UChar              pivotBuffer[1024];
+    const UChar       *pivotLimit;
+    UChar             *pivotSource, *pivotTarget, *pivotStart;
+#endif
+};
+
+void xh_encoder_destroy(xh_encoder_t *encoder);
+xh_encoder_t *xh_encoder_create(xh_char_t *tocode, xh_char_t *fromcode);
+void xh_encoder_encode_ruby_buffer(xh_encoder_t *encoder, xh_ruby_buffer_t *main_buf, xh_ruby_buffer_t *enc_buf);
+void xh_encoder_encode_string(xh_encoder_t *encoder, xh_char_t **src, size_t *src_left, xh_char_t **dst, size_t *dst_left);
+
+#endif /* XH_HAVE_ENCODER */
+
+#endif /* _XH_ENCODER_H_ */

data/ext/fastxml/xh_h2x.c

@@ -0,0 +1,62 @@
+#include "xh_config.h"
+#include "xh_core.h"
+
+static VALUE
+xh_h2x_exec(VALUE arg)
+{
+    xh_h2x_ctx_t *ctx = (xh_h2x_ctx_t *) arg;
+
+    xh_writer_init(&ctx->writer, ctx->opts.encoding, ctx->opts.output, ctx->opts.buf_size, ctx->opts.indent, ctx->opts.trim);
+
+    if (ctx->opts.xml_decl) {
+        xh_xml_write_xml_declaration(&ctx->writer, ctx->opts.version, ctx->opts.encoding);
+    }
+
+    switch (ctx->opts.method) {
+        case XH_METHOD_NATIVE:
+            if (ctx->opts.use_attr) {
+                xh_h2x_native_attr(ctx, ctx->opts.root, xh_strlen(ctx->opts.root), ctx->hash, XH_H2X_F_COMPLEX);
+            }
+            else {
+                xh_h2x_native(ctx, ctx->opts.root, xh_strlen(ctx->opts.root), ctx->hash);
+            }
+            break;
+        case XH_METHOD_LX:
+            //xh_h2x_lx(ctx, ctx->hash, NULL, 0, XH_H2X_F_NONE);
+            break;
+        default:
+            rb_raise(rb_eArgError, "Invalid method");
+    }
+
+    return Qnil;
+}
+
+VALUE
+xh_h2x(xh_h2x_ctx_t *ctx)
+{
+    VALUE result;
+    int   state;
+
+    result = rb_protect(xh_h2x_exec, (VALUE) ctx, &state);
+
+    if (state) {
+        result = xh_writer_flush(&ctx->writer);
+        xh_writer_destroy(&ctx->writer);
+        rb_exc_raise(rb_errinfo());
+    }
+
+    result = xh_writer_flush(&ctx->writer);
+    if (result != Qnil && ctx->opts.utf8) {
+#ifdef XH_HAVE_ENCODER
+        if (ctx->writer.encoder == NULL) {
+            XH_FORCE_UTF8(result);
+        }
+#else
+        XH_FORCE_UTF8(result);
+#endif
+    }
+
+    xh_writer_destroy(&ctx->writer);
+
+    return result;
+}

data/ext/fastxml/xh_h2x.h

@@ -0,0 +1,93 @@
+#ifndef _XH_H2X_H_
+#define _XH_H2X_H_
+
+#include "xh_config.h"
+#include "xh_core.h"
+
+#define XH_H2X_F_NONE                   0
+#define XH_H2X_F_SIMPLE                 1
+#define XH_H2X_F_COMPLEX                2
+#define XH_H2X_F_CONTENT                4
+#define XH_H2X_F_ATTR_ONLY              8
+
+#define XH_H2X_T_SCALAR                 1
+#define XH_H2X_T_HASH                   2
+#define XH_H2X_T_ARRAY                  4
+//#define XH_H2X_T_BLESSED                8
+#define XH_H2X_T_RAW                    16
+#define XH_H2X_T_NOT_NULL               (XH_H2X_T_SCALAR | XH_H2X_T_ARRAY | XH_H2X_T_HASH)
+
+#define XH_H2X_STASH_SIZE               16
+
+typedef struct {
+    xh_opts_t    opts;
+    xh_int_t     depth;
+    xh_writer_t  writer;
+    xh_stack_t   stash;
+    VALUE        hash;
+} xh_h2x_ctx_t;
+
+XH_INLINE VALUE
+xh_h2x_resolve_value(xh_h2x_ctx_t *ctx, VALUE value, xh_uint_t *type)
+{
+    *type = 0;
+
+    while (RB_TYPE_P(value, RUBY_T_DATA) || RB_TYPE_P(value, RUBY_T_OBJECT)) {
+        if (rb_obj_is_kind_of(value, rb_cProc) || rb_obj_is_kind_of(value, rb_cMethod)) {
+            value = rb_funcall(value, rb_intern("call"), 0);
+        }
+        else {
+            break;
+        }
+
+        if (++ctx->depth > ctx->opts.max_depth)
+            rb_raise(xh_parse_error_class, "Maximum recursion depth exceeded");
+    }
+
+    if (rb_cHash == rb_obj_class(value)) {
+        *type |= XH_H2X_T_HASH;
+    }
+    else if (rb_cArray == rb_obj_class(value)) {
+        *type |= XH_H2X_T_ARRAY;
+    }
+    else if (!RTEST(value)) {
+        *type = 0;
+    }
+    else {
+        *type |= XH_H2X_T_SCALAR;
+    }
+
+/*
+    if (SvOBJECT(value))
+        *type |= XH_H2X_T_BLESSED;
+*/
+    return value;
+}
+
+VALUE xh_h2x(xh_h2x_ctx_t *ctx);
+void xh_h2x_native(xh_h2x_ctx_t *ctx, xh_char_t *key, size_t key_len, VALUE value);
+xh_int_t xh_h2x_native_attr(xh_h2x_ctx_t *ctx, xh_char_t *key, size_t key_len, VALUE value, xh_int_t flag);
+/*
+void xh_h2x_lx(xh_h2x_ctx_t *ctx, SV *value, xh_char_t *key, I32 key_len, xh_int_t flag);
+*/
+
+XH_INLINE void
+xh_h2x_destroy_ctx(xh_h2x_ctx_t *ctx)
+{
+    xh_destroy_opts(&ctx->opts);
+}
+
+XH_INLINE void
+xh_h2x_init_ctx(xh_h2x_ctx_t *ctx, xh_int_t argc, VALUE *argv)
+{
+    xh_opts_t *opts = NULL;
+    xh_int_t   nparam = 0;
+
+    memset(ctx, 0, sizeof(xh_h2x_ctx_t));
+
+    //opts = (xh_opts_t *) xh_get_obj_param(&nparam, ax, items, "XML::Hash::XS");
+    ctx->hash = xh_get_hash_param(&nparam, argc, argv);
+    xh_merge_opts(&ctx->opts, opts, &nparam, argc, argv);
+}
+
+#endif /* _XH_H2X_H_ */

data/ext/fastxml/xh_h2x_native.c

@@ -0,0 +1,89 @@
+#include "xh_config.h"
+#include "xh_core.h"
+
+static int
+xh_h2x_native_hash_iter(VALUE key, VALUE value, VALUE arg)
+{
+    xh_h2x_ctx_t *ctx = (xh_h2x_ctx_t *) arg;
+
+    if (SYMBOL_P(key)) {
+        key = rb_sym2str(key);
+    }
+    else {
+        key = rb_obj_as_string(key);
+    }
+
+    xh_h2x_native(ctx, XH_CHAR_CAST RSTRING_PTR(key), RSTRING_LEN(key), value);
+
+    return ST_CONTINUE;
+}
+
+static VALUE
+xh_h2x_native_call_next(VALUE obj)
+{
+    return rb_funcall(obj, xh_id_next, 0);
+}
+
+static VALUE
+xh_h2x_native_call_stop(VALUE obj)
+{
+    return Qnil;
+}
+
+void
+xh_h2x_native(xh_h2x_ctx_t *ctx, xh_char_t *key, size_t key_len, VALUE value)
+{
+    xh_uint_t       type;
+    size_t          i, len;
+    VALUE           next_value;
+    xh_sort_hash_t  sorted_hash;
+
+    value = xh_h2x_resolve_value(ctx, value, &type);
+
+    if (rb_obj_is_kind_of(value, rb_cEnumerator)) {
+        while (1) {
+            next_value = rb_rescue2(xh_h2x_native_call_next, value, xh_h2x_native_call_stop, value, rb_eStopIteration, (VALUE) 0);
+            if (next_value == Qnil) break;
+            xh_h2x_native(ctx, key, key_len, next_value);
+        }
+        goto FINISH;
+    }
+
+    if (type & XH_H2X_T_SCALAR) {
+        xh_xml_write_node(&ctx->writer, key, key_len, value, type & XH_H2X_T_RAW);
+    }
+    else if (type & XH_H2X_T_HASH) {
+        len = RHASH_SIZE(value);
+        if (len == 0) goto ADD_EMPTY_NODE;
+
+        xh_xml_write_start_node(&ctx->writer, key, key_len);
+
+        if (len > 1 && ctx->opts.canonical) {
+            sorted_hash.elts = alloca(sizeof(xh_sort_hash_elt_t) * len);
+
+            xh_sort_hash(&sorted_hash, value);
+
+            for (i = 0; i < sorted_hash.nelts; i++) {
+                xh_h2x_native(ctx, sorted_hash.elts[i].key, sorted_hash.elts[i].key_len, sorted_hash.elts[i].value);
+            }
+        }
+        else {
+            rb_hash_foreach(value, xh_h2x_native_hash_iter, (VALUE) ctx);
+        }
+
+        xh_xml_write_end_node(&ctx->writer, key, key_len);
+    }
+    else if (type & XH_H2X_T_ARRAY) {
+        len = RARRAY_LEN(value);
+        for (i = 0; i < len; i++) {
+            xh_h2x_native(ctx, key, key_len, RARRAY_AREF(value, i));
+        }
+    }
+    else {
+ADD_EMPTY_NODE:
+        xh_xml_write_empty_node(&ctx->writer, key, key_len);
+    }
+
+FINISH:
+    ctx->depth--;
+}

data/ext/fastxml/xh_h2x_native_attr.c

@@ -0,0 +1,161 @@
+#include "xh_config.h"
+#include "xh_core.h"
+
+typedef struct {
+    xh_h2x_ctx_t *ctx;
+    xh_int_t      flag;
+    size_t       *done;
+} xh_iter_ctx_t;
+
+static int
+xh_h2x_native_attr_hash_iter(VALUE key, VALUE value, VALUE arg)
+{
+    xh_iter_ctx_t *iter_ctx = (xh_iter_ctx_t *) arg;
+
+    if (SYMBOL_P(key)) {
+        key = rb_sym2str(key);
+    }
+    else {
+        key = rb_obj_as_string(key);
+    }
+
+    *iter_ctx->done += xh_h2x_native_attr(iter_ctx->ctx, XH_CHAR_CAST RSTRING_PTR(key), RSTRING_LEN(key), value, iter_ctx->flag);
+
+    return ST_CONTINUE;
+}
+
+static VALUE
+xh_h2x_native_attr_call_next(VALUE obj)
+{
+    return rb_funcall(obj, xh_id_next, 0);
+}
+
+static VALUE
+xh_h2x_native_attr_call_stop(VALUE obj)
+{
+    return Qnil;
+}
+
+xh_int_t
+xh_h2x_native_attr(xh_h2x_ctx_t *ctx, xh_char_t *key, size_t key_len, VALUE value, xh_int_t flag)
+{
+    xh_uint_t       type;
+    size_t          len, i, nattrs, done;
+    xh_sort_hash_t  sorted_hash;
+    VALUE           next_value;
+    xh_iter_ctx_t   iter_ctx;
+
+    nattrs = 0;
+
+    if (ctx->opts.content[0] != '\0' && xh_strcmp(key, ctx->opts.content) == 0)
+        flag = flag | XH_H2X_F_CONTENT;
+
+    value = xh_h2x_resolve_value(ctx, value, &type);
+
+    if (rb_obj_is_kind_of(value, rb_cEnumerator)) {
+        if (!(flag & XH_H2X_F_COMPLEX)) goto FINISH;
+
+        while (1) {
+            next_value = rb_rescue2(xh_h2x_native_attr_call_next, value, xh_h2x_native_attr_call_stop, value, rb_eStopIteration, (VALUE) 0);
+            if (next_value == Qnil) break;
+            (void) xh_h2x_native_attr(ctx, key, key_len, next_value, XH_H2X_F_SIMPLE | XH_H2X_F_COMPLEX);
+        }
+
+        nattrs++;
+
+        goto FINISH;
+    }
+
+    if (type & XH_H2X_T_SCALAR) {
+        if (flag & XH_H2X_F_COMPLEX && (flag & XH_H2X_F_SIMPLE || type & XH_H2X_T_RAW)) {
+            xh_xml_write_node(&ctx->writer, key, key_len, value, type & XH_H2X_T_RAW);
+        }
+        else if (flag & XH_H2X_F_COMPLEX && flag & XH_H2X_F_CONTENT) {
+            xh_xml_write_content(&ctx->writer, value);
+        }
+        else if (flag & XH_H2X_F_SIMPLE && !(flag & XH_H2X_F_CONTENT) && !(type & XH_H2X_T_RAW)) {
+            xh_xml_write_attribute(&ctx->writer, key, key_len, value);
+            nattrs++;
+        }
+    }
+    else if (type & XH_H2X_T_HASH) {
+        if (!(flag & XH_H2X_F_COMPLEX)) goto FINISH;
+
+        len = RHASH_SIZE(value);
+        if (len == 0) {
+            xh_xml_write_empty_node(&ctx->writer, key, key_len);
+            goto FINISH;
+        }
+
+        xh_xml_write_start_tag(&ctx->writer, key, key_len);
+
+        done = 0;
+        iter_ctx.ctx = ctx;
+        iter_ctx.done = &done;
+
+        if (len > 1 && ctx->opts.canonical) {
+            sorted_hash.elts = alloca(sizeof(xh_sort_hash_elt_t) * len);
+
+            xh_sort_hash(&sorted_hash, value);
+
+            for (i = 0; i < sorted_hash.nelts; i++) {
+                done += xh_h2x_native_attr(ctx, sorted_hash.elts[i].key, sorted_hash.elts[i].key_len, sorted_hash.elts[i].value, XH_H2X_F_SIMPLE);
+            }
+
+            if (done == len) {
+                xh_xml_write_closed_end_tag(&ctx->writer);
+            }
+            else {
+                xh_xml_write_end_tag(&ctx->writer);
+
+                for (i = 0; i < sorted_hash.nelts; i++) {
+                    (void) xh_h2x_native_attr(ctx, sorted_hash.elts[i].key, sorted_hash.elts[i].key_len, sorted_hash.elts[i].value, XH_H2X_F_COMPLEX);
+                }
+
+                xh_xml_write_end_node(&ctx->writer, key, key_len);
+            }
+        }
+        else {
+            iter_ctx.flag = XH_H2X_F_SIMPLE;
+            rb_hash_foreach(value, xh_h2x_native_attr_hash_iter, (VALUE) &iter_ctx);
+
+            if (done == len) {
+                xh_xml_write_closed_end_tag(&ctx->writer);
+            }
+            else {
+                xh_xml_write_end_tag(&ctx->writer);
+
+                iter_ctx.flag = XH_H2X_F_COMPLEX;
+                rb_hash_foreach(value, xh_h2x_native_attr_hash_iter, (VALUE) &iter_ctx);
+
+                xh_xml_write_end_node(&ctx->writer, key, key_len);
+            }
+        }
+
+        nattrs++;
+    }
+    else if (type & XH_H2X_T_ARRAY) {
+        if (!(flag & XH_H2X_F_COMPLEX)) goto FINISH;
+
+        len = RARRAY_LEN(value);
+        for (i = 0; i < len; i++) {
+            (void) xh_h2x_native_attr(ctx, key, key_len, RARRAY_AREF(value, i), XH_H2X_F_SIMPLE | XH_H2X_F_COMPLEX);
+        }
+
+        nattrs++;
+    }
+    else {
+        if (flag & XH_H2X_F_SIMPLE && flag & XH_H2X_F_COMPLEX) {
+            xh_xml_write_empty_node(&ctx->writer, key, key_len);
+        }
+        else if (flag & XH_H2X_F_SIMPLE && !(flag & XH_H2X_F_CONTENT)) {
+            xh_xml_write_attribute(&ctx->writer, key, key_len, Qnil);
+            nattrs++;
+        }
+    }
+
+FINISH:
+    ctx->depth--;
+
+    return nattrs;
+}