fast-xml 1.0.0

data/ext/fastxml/xh.h

@@ -0,0 +1,58 @@
+#ifndef _XH_H_
+#define _XH_H_
+
+#include "xh_config.h"
+#include "xh_core.h"
+
+#define XH_INTERNAL_ENCODING "utf-8"
+
+typedef enum {
+    XH_METHOD_NATIVE = 0,
+    XH_METHOD_LX
+} xh_method_t;
+
+typedef struct {
+    xh_method_t            method;
+    xh_bool_t              use_attr;
+
+    /* native options */
+    xh_char_t              version[XH_PARAM_LEN];
+    xh_char_t              encoding[XH_PARAM_LEN];
+    xh_char_t              root[XH_PARAM_LEN];
+    xh_bool_t              utf8;
+    xh_bool_t              xml_decl;
+    xh_bool_t              keep_root;
+    xh_bool_t              canonical;
+    xh_char_t              content[XH_PARAM_LEN];
+    xh_int_t               indent;
+    VALUE                  output;
+#ifdef XH_HAVE_DOM
+    xh_bool_t              doc;
+#endif
+    xh_int_t               max_depth;
+    xh_int_t               buf_size;
+    xh_pattern_t           force_array;
+    xh_bool_t              force_content;
+    xh_bool_t              merge_text;
+    xh_pattern_t           filter;
+    VALUE                  cb;
+
+    /* LX options */
+    xh_char_t              attr[XH_PARAM_LEN];
+    size_t                 attr_len;
+    xh_char_t              text[XH_PARAM_LEN];
+    xh_bool_t              trim;
+    xh_char_t              cdata[XH_PARAM_LEN];
+    xh_char_t              comm[XH_PARAM_LEN];
+} xh_opts_t;
+
+xh_opts_t *xh_create_opts(void);
+void xh_destroy_opts(xh_opts_t *opts);
+xh_bool_t xh_init_opts(xh_opts_t *opts);
+void xh_parse_args(xh_opts_t *opts, xh_int_t *nparam, xh_int_t argc, VALUE *argv);
+void xh_copy_opts(xh_opts_t *dst, xh_opts_t *src);
+void *xh_get_obj_param(xh_int_t *nparam, xh_int_t argc, VALUE *argv, const char *class);
+VALUE xh_get_hash_param(xh_int_t *nparam, xh_int_t argc, VALUE *argv);
+void xh_merge_opts(xh_opts_t *ctx_opts, xh_opts_t *opts, xh_int_t *nparam, xh_int_t argc, VALUE *argv);
+
+#endif /* _XH_H_ */

data/ext/fastxml/xh_buffer.c

@@ -0,0 +1,40 @@
+#include "xh_config.h"
+#include "xh_core.h"
+
+void
+xh_buffer_init(xh_buffer_t *buf, size_t size)
+{
+    buf->start = buf->cur = malloc(size);
+    if (buf->start == NULL) {
+        rb_raise(rb_eNoMemError, "Memory allocation error");
+    }
+    buf->end = buf->start + size;
+
+    xh_log_debug2("buf: %p size: %lu", buf->start, size);
+}
+
+void
+xh_buffer_grow(xh_buffer_t *buf, size_t inc)
+{
+    size_t size, use;
+
+    if (inc <= (size_t) (buf->end - buf->cur)) {
+        return;
+    }
+
+    size = buf->end - buf->start;
+    use  = buf->cur - buf->start;
+
+    xh_log_debug2("old buf: %p size: %lu", buf->start, size);
+
+    size += inc < size ? size : inc;
+
+    buf->start = realloc(buf->start, size);
+    if (buf->start == NULL) {
+        rb_raise(rb_eNoMemError, "Memory allocation error");
+    }
+    buf->cur   = buf->start + use;
+    buf->end   = buf->start + size;
+
+    xh_log_debug2("new buf: %p size: %lu", buf->start, size);
+}

data/ext/fastxml/xh_buffer.h

@@ -0,0 +1,38 @@
+#ifndef _XH_BUFFER_H_
+#define _XH_BUFFER_H_
+
+#include "xh_config.h"
+#include "xh_core.h"
+
+typedef struct _xh_buffer_t xh_buffer_t;
+struct _xh_buffer_t {
+    xh_char_t *start;
+    xh_char_t *cur;
+    xh_char_t *end;
+};
+
+void xh_buffer_init(xh_buffer_t *buf, size_t size);
+void xh_buffer_grow(xh_buffer_t *buf, size_t inc);
+
+XH_INLINE void
+xh_buffer_destroy(xh_buffer_t *buf)
+{
+    if (buf->start != NULL) {
+        xh_log_debug1("free enc buf: %p", buf->start);
+        free(buf->start);
+    }
+}
+
+#define xh_buffer_avail(b)    ((b)->end - (b)->cur)
+#define xh_buffer_use(b)      ((b)->cur - (b)->start)
+#define xh_buffer_start(b)    ((b)->start)
+#define xh_buffer_pos(b)      ((b)->cur)
+#define xh_buffer_end(b)      ((b)->end)
+#define xh_buffer_size(b)     ((b)->end - (b)->start)
+#define xh_buffer_reset(b)    do { (b)->cur = (b)->start; } while (0)
+#define xh_buffer_seek(b, p)  (b)->cur = p
+#define xh_buffer_seek_eof(b) (b)->cur = (b)->end
+#define xh_buffer_seek_top(b) (b)->cur = (b)->start
+#define xh_buffer_grow50(b)   xh_buffer_grow((b), xh_buffer_size(b) / 2)
+
+#endif /* _XH_BUFFER_H_ */

data/ext/fastxml/xh_buffer_helper.h

@@ -0,0 +1,97 @@
+#ifndef _XH_BUFFER_HELPER_H_
+#define _XH_BUFFER_HELPER_H_
+
+#include "xh_config.h"
+#include "xh_core.h"
+
+#define XH_BUFFER_WRITE_LONG_STRING(b, s, l)                           \
+    memcpy(b->cur, s, l);                                              \
+    b->cur += l;
+#define XH_BUFFER_WRITE_SHORT_STRING(b, s, l)                          \
+    while (l--) {                                                      \
+        *b->cur++ = *s++;                                              \
+    }
+#define XH_BUFFER_WRITE_STRING(b, s, l)                                \
+    if (l < 17) {                                                      \
+        XH_BUFFER_WRITE_SHORT_STRING(b, s, l)                          \
+    }                                                                  \
+    else {                                                             \
+        XH_BUFFER_WRITE_LONG_STRING(b, s, l)                           \
+    }
+#define XH_BUFFER_WRITE_CHAR(b, c)                                     \
+    *b->cur++ = c;
+#define XH_BUFFER_WRITE_CHAR2(b, s)                                    \
+    *((uint16_t *) b->cur) = *((uint16_t *) (s));                      \
+    b->cur += 2;
+#define XH_BUFFER_WRITE_CHAR3(b, s)                                    \
+    XH_BUFFER_WRITE_CHAR2(b, s)                                        \
+    XH_BUFFER_WRITE_CHAR(b, s[2])
+#define XH_BUFFER_WRITE_CHAR4(b, s)                                    \
+    *((uint32_t *) b->cur) = *((uint32_t *) (s));                      \
+    b->cur += 4;
+#define XH_BUFFER_WRITE_CHAR5(b, s)                                    \
+    XH_BUFFER_WRITE_CHAR4(b, s)                                        \
+    XH_BUFFER_WRITE_CHAR(b, s[4])
+#define XH_BUFFER_WRITE_CHAR6(b, s)                                    \
+    XH_BUFFER_WRITE_CHAR4(b, s)                                        \
+    XH_BUFFER_WRITE_CHAR2(b, s + 4)
+#define XH_BUFFER_WRITE_CHAR7(b, s)                                    \
+    XH_BUFFER_WRITE_CHAR6(b, s)                                        \
+    XH_BUFFER_WRITE_CHAR(b, s[6])
+#define XH_BUFFER_WRITE_CHAR8(b, s)                                    \
+    XH_BUFFER_WRITE_CHAR4(b, s)                                        \
+    XH_BUFFER_WRITE_CHAR4(b, s + 4)
+#define XH_BUFFER_WRITE_CHAR9(b, s)                                    \
+    XH_BUFFER_WRITE_CHAR8(b, s)                                        \
+    XH_BUFFER_WRITE_CHAR(b, s[8])
+#define XH_BUFFER_WRITE_ESCAPE_STRING(b, s, l)                         \
+    while (l--) {                                                      \
+        switch (*b->cur = *s++) {                                      \
+            case '\r':                                                 \
+                XH_BUFFER_WRITE_CHAR5(b, "&#13;")                      \
+                break;                                                 \
+            case '<':                                                  \
+                XH_BUFFER_WRITE_CHAR4(b, "&lt;")                       \
+                break;                                                 \
+            case '>':                                                  \
+                XH_BUFFER_WRITE_CHAR4(b, "&gt;")                       \
+                break;                                                 \
+            case '&':                                                  \
+                XH_BUFFER_WRITE_CHAR5(b, "&amp;")                      \
+                break;                                                 \
+            default:                                                   \
+                b->cur++;                                              \
+        }                                                              \
+    }
+#define XH_BUFFER_WRITE_ESCAPE_ATTR(b, s, l)                           \
+    while (l--) {                                                      \
+        switch (*b->cur = *s++) {                                      \
+            case '\n':                                                 \
+                XH_BUFFER_WRITE_CHAR5(b, "&#10;")                      \
+                break;                                                 \
+            case '\r':                                                 \
+                XH_BUFFER_WRITE_CHAR5(b, "&#13;")                      \
+                break;                                                 \
+            case '\t':                                                 \
+                XH_BUFFER_WRITE_CHAR4(b, "&#9;")                       \
+                break;                                                 \
+            case '<':                                                  \
+                XH_BUFFER_WRITE_CHAR4(b, "&lt;")                       \
+                break;                                                 \
+            case '>':                                                  \
+                XH_BUFFER_WRITE_CHAR4(b, "&gt;")                       \
+                break;                                                 \
+            case '&':                                                  \
+                XH_BUFFER_WRITE_CHAR5(b, "&amp;")                      \
+                break;                                                 \
+            case '"':                                                  \
+                XH_BUFFER_WRITE_CHAR6(b, "&quot;")                     \
+                break;                                                 \
+            default:                                                   \
+                b->cur++;                                              \
+        }                                                              \
+    }
+#define XH_BUFFER_WRITE_CONSTANT(b, s)                                 \
+    XH_BUFFER_WRITE_LONG_STRING(b, s, sizeof(s) - 1)
+
+#endif /* _XH_BUFFER_HELPER_H_ */

data/ext/fastxml/xh_config.h

@@ -0,0 +1,74 @@
+#ifndef _XH_CONFIG_H_
+#define _XH_CONFIG_H_
+
+#include "ruby.h"
+#if HAVE_RUBY_ENCODING_H
+#include "ruby/encoding.h"
+#endif
+#include <stdint.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#ifdef WIN32
+#include <windows.h>
+#include <io.h>
+#else
+#include <sys/mman.h>
+#endif
+
+#if __GNUC__ >= 3
+# define expect(expr,value)         __builtin_expect ((expr), (value))
+# define XH_INLINE                  static inline
+# define XH_UNUSED(v)               x __attribute__((unused))
+#else
+# define expect(expr,value)         (expr)
+# define XH_INLINE                  static
+# define XH_UNUSED(v)               v
+#endif
+
+#ifdef _MSC_VER
+#define _CRT_SECURE_NO_WARNINGS
+#define _CRT_NONSTDC_NO_DEPRECATE
+#define strncasecmp _strnicmp
+#define strcasecmp _stricmp
+#endif
+
+#define expect_false(expr) expect ((expr) != 0, 0)
+#define expect_true(expr)  expect ((expr) != 0, 1)
+
+typedef uintptr_t xh_bool_t;
+typedef uintptr_t xh_uint_t;
+typedef intptr_t  xh_int_t;
+typedef u_char    xh_char_t;
+
+#define XH_CHAR_CAST    (xh_char_t *)
+#define XH_EMPTY_STRING (XH_CHAR_CAST "")
+
+#if defined(XH_HAVE_ICONV) || defined(XH_HAVE_ICU)
+#define XH_HAVE_ENCODER
+#endif
+
+#ifdef HAVE_RUBY_ENCODING_H
+#define XH_FORCE_UTF8(s) rb_enc_set_index(s, rb_utf8_encindex())
+#else
+#define XH_FORCE_UTF8(s)
+#endif
+
+#if defined(XH_HAVE_XML2) && defined(XH_HAVE_XML__LIBXML)
+#define XH_HAVE_DOM
+#endif
+
+#ifdef XH_HAVE_DOM
+#include <libxml/parser.h>
+#endif
+
+#define XH_HAVE_MMAP
+
+extern VALUE xh_module;
+extern VALUE xh_parse_error_class;
+extern ID    xh_id_next;
+
+#endif /* _XH_CONFIG_H_ */

data/ext/fastxml/xh_core.h

@@ -0,0 +1,53 @@
+#ifndef _XH_CORE_H_
+#define _XH_CORE_H_
+
+/*
+ * Concatenate preprocessor tokens A and B without expanding macro definitions
+ * (however, if invoked from a macro, macro arguments are expanded).
+ */
+#define XH_PPCAT_NX(A, B) A ## B
+
+/*
+ * Concatenate preprocessor tokens A and B after macro-expanding them.
+ */
+#define XH_PPCAT(A, B) XH_PPCAT_NX(A, B)
+
+/*
+ * Turn A into a string literal without expanding macro definitions
+ * (however, if invoked from a macro, macro arguments are expanded).
+ */
+#define XH_STRINGIZE_NX(A) #A
+
+/*
+ * Turn A into a string literal after macro-expanding it.
+ */
+#define XH_STRINGIZE(A) XH_STRINGIZE_NX(A)
+
+#ifndef FALSE
+#define FALSE (0)
+#endif
+
+#ifndef TRUE
+#define TRUE  (1)
+#endif
+
+#include "xh_log.h"
+#include "xh_string.h"
+#include "xh_sort.h"
+#include "xh_stack.h"
+//#include "xh_stash.h"
+#include "xh_param.h"
+#include "xh_buffer_helper.h"
+#include "xh_buffer.h"
+#include "xh_ruby_buffer.h"
+#include "xh_encoder.h"
+//#include "xh_reader.h"
+#include "xh_writer.h"
+#include "xh.h"
+#include "xh_h2x.h"
+#include "xh_xml.h"
+/*
+#include "xh_x2h.h"
+#include "xh_dom.h"
+*/
+#endif /* _XH_CORE_H_ */

data/ext/fastxml/xh_encoder.c

@@ -0,0 +1,193 @@
+#include "xh_config.h"
+#include "xh_core.h"
+
+#ifdef XH_HAVE_ENCODER
+
+#ifdef XH_HAVE_ICU
+static void
+xh_encoder_uconv_destroy(UConverter *uconv)
+{
+    if (uconv != NULL) {
+        ucnv_close(uconv);
+    }
+}
+
+static UConverter *
+xh_encoder_uconv_create(xh_char_t *encoding, xh_bool_t toUnicode)
+{
+    UConverter *uconv;
+    UErrorCode  status = U_ZERO_ERROR;
+
+    uconv = ucnv_open((char *) encoding, &status);
+    if ( U_FAILURE(status) ) {
+        return NULL;
+    }
+
+    if (toUnicode) {
+        ucnv_setToUCallBack(uconv, UCNV_TO_U_CALLBACK_STOP,
+                            NULL, NULL, NULL, &status);
+    }
+    else {
+        ucnv_setFromUCallBack(uconv, UCNV_FROM_U_CALLBACK_STOP,
+                              NULL, NULL, NULL, &status);
+    }
+
+    return uconv;
+}
+#endif
+
+void
+xh_encoder_destroy(xh_encoder_t *encoder)
+{
+    if (encoder != NULL) {
+#ifdef XH_HAVE_ICONV
+        if (encoder->iconv != NULL) {
+            xh_log_debug0("destroy iconv encoder");
+            iconv_close(encoder->iconv);
+        }
+#endif
+
+#ifdef XH_HAVE_ICU
+        if (encoder->uconv_from != NULL) {
+            xh_log_debug0("destroy icu encoder");
+            xh_encoder_uconv_destroy(encoder->uconv_from);
+            xh_encoder_uconv_destroy(encoder->uconv_to);
+        }
+#endif
+        free(encoder);
+    }
+}
+
+xh_encoder_t *
+xh_encoder_create(xh_char_t *tocode, xh_char_t *fromcode)
+{
+    xh_encoder_t *encoder;
+
+    encoder = malloc(sizeof(xh_encoder_t));
+    if (encoder == NULL) {
+        return NULL;
+    }
+    memset(encoder, 0, sizeof(xh_encoder_t));
+
+    xh_str_copy(encoder->tocode, tocode, XH_PARAM_LEN);
+    xh_str_copy(encoder->fromcode, fromcode, XH_PARAM_LEN);
+
+#ifdef XH_HAVE_ICONV
+    xh_log_debug2("create iconv encoder from: '%s' to: '%s'", fromcode, tocode);
+    encoder->iconv = iconv_open((char *) tocode, (char *) fromcode);
+    if (encoder->iconv != (iconv_t) -1) {
+        encoder->type = XH_ENC_ICONV;
+        return encoder;
+    }
+    encoder->iconv = NULL;
+#endif
+
+#ifdef XH_HAVE_ICU
+    xh_log_debug2("create icu encoder from: '%s' to: '%s'", fromcode, tocode);
+    encoder->uconv_to = xh_encoder_uconv_create(tocode, 1);
+    if (encoder->uconv_to != NULL) {
+        encoder->uconv_from = xh_encoder_uconv_create(fromcode, 0);
+        if (encoder->uconv_from != NULL) {
+            encoder->type        = XH_ENC_ICU;
+            encoder->pivotSource = encoder->pivotTarget = encoder->pivotStart = encoder->pivotBuffer;
+            encoder->pivotLimit  = encoder->pivotBuffer + sizeof(encoder->pivotBuffer) / sizeof(encoder->pivotBuffer[0]);
+            return encoder;
+        }
+    }
+#endif
+
+    xh_encoder_destroy(encoder);
+
+    return NULL;
+}
+
+void
+xh_encoder_encode_ruby_buffer(xh_encoder_t *encoder, xh_ruby_buffer_t *main_buf, xh_ruby_buffer_t *enc_buf)
+{
+    xh_char_t *src  = main_buf->start;
+
+#ifdef XH_HAVE_ICONV
+    if (encoder->type == XH_ENC_ICONV) {
+        size_t in_left  = main_buf->cur - main_buf->start;
+        size_t out_left = enc_buf->end - enc_buf->cur;
+
+        size_t converted = iconv(encoder->iconv, (char **) &src, &in_left, (char **) &enc_buf->cur, &out_left);
+        if (converted == (size_t) -1) {
+            rb_raise(xh_parse_error_class, "Encoding error");
+        }
+        return;
+    }
+#endif
+
+#ifdef XH_HAVE_ICU
+    UErrorCode  err  = U_ZERO_ERROR;
+    ucnv_convertEx(encoder->uconv_to, encoder->uconv_from, (char **) &enc_buf->cur, (char *) enc_buf->end,
+                   (const char **) &src, (char *) main_buf->cur, NULL, NULL, NULL, NULL,
+                   FALSE, TRUE, &err);
+
+    if ( U_FAILURE(err) ) {
+        rb_raise(xh_parse_error_class, "Encoding error: %d", err);
+    }
+#endif
+}
+
+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)
+{
+#ifdef XH_HAVE_ICONV
+    if (encoder->type == XH_ENC_ICONV) {
+        size_t converted = iconv(encoder->iconv, (char **) src, src_left, (char **) dst, dst_left);
+        if (converted == (size_t) -1) {
+            switch (errno) {
+                case EILSEQ:
+                    rb_raise(xh_parse_error_class, "Encoding error: invalid char found");
+                case E2BIG:
+                    encoder->state = XH_ENC_BUFFER_OVERFLOW;
+                    break;
+                case EINVAL:
+                    encoder->state = XH_ENC_TRUNCATED_CHAR_FOUND;
+                    break;
+                default:
+                    rb_raise(xh_parse_error_class, "Encoding error");
+            }
+        }
+        else {
+            encoder->state = XH_ENC_OK;
+        }
+        return;
+    }
+#endif
+
+#ifdef XH_HAVE_ICU
+    UErrorCode  err = U_ZERO_ERROR;
+    xh_char_t  *old_src = *src;
+    xh_char_t  *old_dst = *dst;
+
+    ucnv_convertEx(encoder->uconv_to, encoder->uconv_from, (char **) dst, (char *) (*dst + *dst_left),
+                   (const char **) src, (char *) (*src + *src_left), encoder->pivotStart, &encoder->pivotSource, &encoder->pivotTarget, encoder->pivotLimit,
+                   FALSE, FALSE, &err);
+
+    *src_left -= *src - old_src;
+    *dst_left -= *dst - old_dst;
+
+    if ( U_FAILURE(err) ) {
+        switch (err) {
+            case U_INVALID_CHAR_FOUND:
+                rb_raise(xh_parse_error_class, "Encoding error: invalid char found");
+            case U_BUFFER_OVERFLOW_ERROR:
+                encoder->state = XH_ENC_BUFFER_OVERFLOW;
+                break;
+            case U_TRUNCATED_CHAR_FOUND:
+                encoder->state = XH_ENC_TRUNCATED_CHAR_FOUND;
+                break;
+            default:
+                rb_raise(xh_parse_error_class, "Encoding error: %d", err);
+        }
+    }
+    else {
+        encoder->state = XH_ENC_OK;
+    }
+#endif
+}
+
+#endif /* XH_HAVE_ENCODER */