fast-xml 1.0.0

data/ext/fastxml/xh_string.h

@@ -0,0 +1,105 @@
+#ifndef _XH_STRING_H_
+#define _XH_STRING_H_
+
+#include "xh_config.h"
+#include "xh_core.h"
+
+#define xh_str_equal2(p, c0, c1)                                        \
+    ((((uint32_t *) (p))[0] & 0xffff) == ((c1 << 8) | c0))
+
+#define xh_str_equal3(p, c0, c1, c2)                                    \
+    ((((uint32_t *) (p))[0]  & 0xffffff) == ((c2 << 16) | (c1 << 8) | c0))
+
+#define xh_str_equal4(p, c0, c1, c2, c3)                                \
+    (*(uint32_t *) (p) == ((c3 << 24) | (c2 << 16) | (c1 << 8) | c0))
+
+#define xh_str_equal5(p, c0, c1, c2, c3, c4)                            \
+    (xh_str_equal4(p, c0, c1, c2, c3) && (p)[4] == c4)
+
+#define xh_str_equal6(p, c0, c1, c2, c3, c4, c5)                        \
+    (xh_str_equal4(p, c0, c1, c2, c3) && xh_str_equal2(&p[4], c4, c5))
+
+#define xh_str_equal7(p, c0, c1, c2, c3, c4, c5, c6)                    \
+    (xh_str_equal4(p, c0, c1, c2, c3) && xh_str_equal3(&p[4], c4, c5, c6))
+
+#define xh_str_equal8(p, c0, c1, c2, c3, c4, c5, c6, c7)                \
+    (xh_str_equal4(p, c0, c1, c2, c3) && xh_str_equal4(&p[4], c4, c5, c6, c7))
+
+#define xh_str_equal9(p, c0, c1, c2, c3, c4, c5, c6, c7, c8)            \
+    (xh_str_equal8(p, c0, c1, c2, c3, c4, c5, c6, c7) && (p)[8] == c8)
+
+#define xh_str_equal10(p, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9)       \
+    (xh_str_equal8(p, c0, c1, c2, c3, c4, c5, c6, c7) && xh_str_equal2(&p[8], c8, c9))
+
+#define xh_str_equal11(p, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10)  \
+    (xh_str_equal8(p, c0, c1, c2, c3, c4, c5, c6, c7) && xh_str_equal3(&p[8], c8, c9, c10))
+
+#define xh_str_equal12(p, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11)\
+    (xh_str_equal8(p, c0, c1, c2, c3, c4, c5, c6, c7) && xh_str_equal4(&p[8], c8, c9, c10, c11))
+
+#define xh_str_equal13(p, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12)\
+    (xh_str_equal8(p, c0, c1, c2, c3, c4, c5, c6, c7) && xh_str_equal5(&p[8], c8, c9, c10, c11, c12))
+
+
+#define xh_strcmp(s1, s2)       strcmp((const char *) (s1), (const char *) (s2))
+#define xh_strcasecmp(s1, s2)   strcasecmp((const char *) (s1), (const char *) (s2))
+#define xh_strncmp(s1, s2, n)   strncmp((const char *) (s1), (const char *) (s2), (n))
+#define xh_strlen(s)            strlen((const char *) (s))
+#define xh_strcpy(d, s)         strcpy((char *) (d), (const char *) (s))
+#define xh_strncpy(d, s, n)     strncpy((char *) (d), (const char *) (s), (n))
+
+XH_INLINE xh_char_t *
+xh_str_trim(xh_char_t *s, size_t *len)
+{
+    xh_char_t *end, ch;
+
+    end = s + *len;
+
+    while ((ch = *s++) == ' ' || ch == '\t' || ch == '\n' || ch == '\r');
+    if (ch == '\0') {
+        *len = 0;
+        return s - 1;
+    }
+
+    s--;
+
+    while (--end != s && ((ch = *end) == ' ' || ch == '\t' || ch == '\n' || ch == '\r'));
+
+    *len = end - s + 1;
+
+    return s;
+}
+
+XH_INLINE xh_char_t *
+xh_str_copy(xh_char_t *dest, const xh_char_t *src, size_t n)
+{
+    dest[--n] = '\0';
+    return XH_CHAR_CAST strncpy((char *) dest, (const char *) src, n);
+}
+
+XH_INLINE xh_char_t *
+xh_str_range_copy(xh_char_t *dest, const xh_char_t *src, size_t l, size_t n)
+{
+    if (l < n) n = l + 1;
+    dest[--n] = '\0';
+    return XH_CHAR_CAST strncpy((char *) dest, (const char *) src, n);
+}
+
+XH_INLINE void
+xh_memmove(xh_char_t *dest, const xh_char_t *src, size_t n)
+{
+    while (n--) *dest++ = *src++;
+}
+
+XH_INLINE xh_bool_t
+xh_str_is_xml(xh_char_t *s)
+{
+    xh_char_t ch;
+
+    while ((ch = *s++) == ' ' || ch =='\t' || ch == '\n' || ch == '\r');
+    if (ch == '<') return TRUE;
+
+    return FALSE;
+}
+
+#endif /* _XH_STRING_H_ */

data/ext/fastxml/xh_writer.c

@@ -0,0 +1,94 @@
+#include "xh_config.h"
+#include "xh_core.h"
+
+void
+xh_writer_resize_buffer(xh_writer_t *writer, size_t inc)
+{
+    (void) xh_writer_flush(writer);
+
+    xh_ruby_buffer_grow(&writer->main_buf, inc);
+}
+
+VALUE
+xh_writer_flush_buffer(xh_writer_t *writer, xh_ruby_buffer_t *buf)
+{
+    size_t use = xh_writer_flush_ruby_buffer(buf);
+
+    if (writer->ruby_io != Qnil) {
+        if (use > 0) xh_writer_flush_ruby_io(buf, writer->ruby_io, use);
+        return Qnil;
+    }
+
+    return buf->scalar;
+}
+
+#ifdef XH_HAVE_ENCODER
+void
+xh_writer_encode_buffer(xh_writer_t *writer, xh_ruby_buffer_t *main_buf, xh_ruby_buffer_t *enc_buf)
+{
+    size_t len;
+
+    /* 1 char -> 4 chars and '\0' */
+    len = xh_buffer_use(main_buf) * 4 + 1;
+
+    if (len > (size_t) (enc_buf->end - enc_buf->cur)) {
+        xh_writer_flush_buffer(writer, enc_buf);
+
+        xh_ruby_buffer_grow(enc_buf, len);
+    }
+
+    xh_encoder_encode_ruby_buffer(writer->encoder, main_buf, enc_buf);
+}
+#endif
+
+VALUE
+xh_writer_flush(xh_writer_t *writer)
+{
+    xh_ruby_buffer_t *buf;
+
+#ifdef XH_HAVE_ENCODER
+    if (writer->encoder != NULL) {
+        xh_writer_encode_buffer(writer, &writer->main_buf, &writer->enc_buf);
+        buf = &writer->enc_buf;
+    }
+    else {
+        buf = &writer->main_buf;
+    }
+#else
+    buf = &writer->main_buf;
+#endif
+
+    return xh_writer_flush_buffer(writer, buf);
+}
+
+void
+xh_writer_destroy(xh_writer_t *writer)
+{
+#ifdef XH_HAVE_ENCODER
+    xh_encoder_destroy(writer->encoder);
+#endif
+}
+
+void
+xh_writer_init(xh_writer_t *writer, xh_char_t *encoding, VALUE output, size_t size, xh_uint_t indent, xh_bool_t trim)
+{
+    writer->indent = indent;
+    writer->trim   = trim;
+
+    xh_ruby_buffer_init(&writer->main_buf, size);
+
+    if (encoding[0] != '\0' && xh_strcasecmp(encoding, XH_INTERNAL_ENCODING) != 0) {
+#ifdef XH_HAVE_ENCODER
+        writer->encoder = xh_encoder_create(encoding, XH_CHAR_CAST XH_INTERNAL_ENCODING);
+        if (writer->encoder == NULL) {
+            rb_raise(xh_parse_error_class, "Can't create encoder for '%s'", encoding);
+        }
+
+        xh_ruby_buffer_init(&writer->enc_buf, size * 4);
+#else
+        rb_raise(xh_parse_error_class, "Can't create encoder for '%s'", encoding);
+#endif
+    }
+
+    writer->ruby_io = output;
+}

data/ext/fastxml/xh_writer.h

@@ -0,0 +1,49 @@
+#ifndef _XH_WRITER_H_
+#define _XH_WRITER_H_
+
+#include "xh_config.h"
+#include "xh_core.h"
+
+#define XH_WRITER_RESIZE_BUFFER(w, b, l)                                \
+    if (((l) + 1) > (size_t) xh_buffer_avail(b)) {                      \
+        xh_writer_resize_buffer(w, (l) + 1);                            \
+    }
+
+typedef struct _xh_writer_t xh_writer_t;
+struct _xh_writer_t {
+#ifdef XH_HAVE_ENCODER
+    xh_encoder_t          *encoder;
+    xh_ruby_buffer_t       enc_buf;
+#endif
+    VALUE                  ruby_io;
+    xh_ruby_buffer_t       main_buf;
+    xh_int_t               indent;
+    xh_int_t               indent_count;
+    xh_bool_t              trim;
+};
+
+VALUE xh_writer_flush_buffer(xh_writer_t *writer, xh_ruby_buffer_t *buf);
+VALUE xh_writer_flush(xh_writer_t *writer);
+void xh_writer_resize_buffer(xh_writer_t *writer, size_t inc);
+void xh_writer_destroy(xh_writer_t *writer);
+void xh_writer_init(xh_writer_t *writer, xh_char_t *encoding, VALUE output, size_t size, xh_uint_t indent, xh_bool_t trim);
+
+XH_INLINE void
+xh_writer_flush_ruby_io(xh_ruby_buffer_t *buf, VALUE ruby_io, size_t use)
+{
+    rb_io_write(ruby_io, buf->scalar);
+    xh_buffer_reset(buf);
+}
+
+XH_INLINE size_t
+xh_writer_flush_ruby_buffer(xh_ruby_buffer_t *buf)
+{
+    size_t use = xh_buffer_use(buf);
+
+    *buf->cur = '\0';
+    rb_str_set_len(buf->scalar, use);
+
+    return use;
+}
+
+#endif /* _XH_WRITER_H_ */

data/ext/fastxml/xh_xml.h

@@ -0,0 +1,453 @@
+#ifndef _XH_XML_H_
+#define _XH_XML_H_
+
+#include "xh_config.h"
+#include "xh_core.h"
+
+static const xh_char_t indent_string[60] = "                                                            ";
+
+XH_INLINE void
+xh_xml_write_xml_declaration(xh_writer_t *writer, xh_char_t *version, xh_char_t *encoding)
+{
+    xh_ruby_buffer_t *buf;
+    size_t            ver_len, enc_len;
+
+    buf     = &writer->main_buf;
+    ver_len = xh_strlen(version);
+    if (encoding[0] == '\0')
+        encoding = XH_CHAR_CAST XH_INTERNAL_ENCODING;
+    enc_len = xh_strlen(encoding);
+
+    XH_WRITER_RESIZE_BUFFER(writer, buf, sizeof("<?xml version=\"\" encoding=\"\"?>\n") - 1 + ver_len * 6 + enc_len * 6)
+
+    XH_BUFFER_WRITE_CONSTANT(buf, "<?xml version=\"")
+    XH_BUFFER_WRITE_ESCAPE_ATTR(buf, version, ver_len);
+    XH_BUFFER_WRITE_CONSTANT(buf, "\" encoding=\"")
+    XH_BUFFER_WRITE_ESCAPE_ATTR(buf, encoding, enc_len);
+    XH_BUFFER_WRITE_CHAR4(buf, "\"?>\n");
+
+}
+
+XH_INLINE void
+xh_xml_write_node(xh_writer_t *writer, xh_char_t *name, size_t name_len, VALUE value, xh_bool_t raw)
+{
+    size_t            indent_len;
+    xh_ruby_buffer_t *buf;
+    xh_char_t        *content;
+    size_t            content_len;
+
+    buf         = &writer->main_buf;
+    value       = rb_obj_as_string(value);
+    content     = XH_CHAR_CAST RSTRING_PTR(value);
+    content_len = RSTRING_LEN(value);
+
+    if (writer->trim && content_len) {
+        content = xh_str_trim(content, &content_len);
+    }
+
+    if (writer->indent) {
+        indent_len = writer->indent_count * writer->indent;
+        if (indent_len > sizeof(indent_string)) {
+            indent_len = sizeof(indent_string);
+        }
+
+        /* "</" + "_" + ">" + "\n" */
+        XH_WRITER_RESIZE_BUFFER(writer, buf, indent_len + name_len * 2 + 10 + (raw ? content_len : content_len * 5))
+
+        XH_BUFFER_WRITE_LONG_STRING(buf, indent_string, indent_len);
+    }
+    else {
+        /* "</" + "_" + ">" + "\n" */
+        XH_WRITER_RESIZE_BUFFER(writer, buf, name_len * 2 + 10 + (raw ? content_len : content_len * 5))
+    }
+
+    XH_BUFFER_WRITE_CHAR(buf, '<')
+
+    if (name[0] >= '0' && name[0] <= '9') {
+        XH_BUFFER_WRITE_CHAR(buf, '_')
+    }
+
+    XH_BUFFER_WRITE_LONG_STRING(buf, name, name_len)
+
+    XH_BUFFER_WRITE_CHAR(buf, '>')
+
+    if (raw) {
+        XH_BUFFER_WRITE_LONG_STRING(buf, content, content_len)
+    }
+    else {
+        XH_BUFFER_WRITE_ESCAPE_STRING(buf, content, content_len)
+    }
+
+    XH_BUFFER_WRITE_CHAR2(buf, "</")
+
+    if (name[0] >= '0' && name[0] <= '9') {
+        XH_BUFFER_WRITE_CHAR(buf, '_')
+    }
+
+    XH_BUFFER_WRITE_LONG_STRING(buf, name, name_len)
+
+    XH_BUFFER_WRITE_CHAR(buf, '>')
+
+    if (writer->indent) {
+        XH_BUFFER_WRITE_CHAR(buf, '\n')
+    }
+}
+
+XH_INLINE void
+xh_xml_write_empty_node(xh_writer_t *writer, xh_char_t *name, size_t name_len)
+{
+    size_t            indent_len;
+    xh_ruby_buffer_t *buf;
+
+    buf = &writer->main_buf;
+
+    if (writer->indent) {
+        indent_len = writer->indent_count * writer->indent;
+        if (indent_len > sizeof(indent_string)) {
+            indent_len = sizeof(indent_string);
+        }
+
+        /* "</" + "_" + ">" + "\n" */
+        XH_WRITER_RESIZE_BUFFER(writer, buf, indent_len + name_len + 5)
+
+        XH_BUFFER_WRITE_LONG_STRING(buf, indent_string, indent_len);
+    }
+    else {
+        /* "</" + "_" + ">" + "\n" */
+        XH_WRITER_RESIZE_BUFFER(writer, buf, name_len + 5)
+    }
+
+    XH_BUFFER_WRITE_CHAR(buf, '<')
+
+    if (name[0] >= '0' && name[0] <= '9') {
+        XH_BUFFER_WRITE_CHAR(buf, '_')
+    }
+
+    XH_BUFFER_WRITE_LONG_STRING(buf, name, name_len)
+
+    XH_BUFFER_WRITE_CHAR2(buf, "/>")
+
+    if (writer->indent) {
+        XH_BUFFER_WRITE_CHAR(buf, '\n')
+    }
+}
+
+XH_INLINE void
+xh_xml_write_start_node(xh_writer_t *writer, xh_char_t *name, size_t name_len)
+{
+    size_t            indent_len;
+    xh_ruby_buffer_t *buf;
+
+    buf = &writer->main_buf;
+
+    if (writer->indent) {
+        indent_len = writer->indent_count++ * writer->indent;
+        if (indent_len > sizeof(indent_string)) {
+            indent_len = sizeof(indent_string);
+        }
+
+        /* "</" + "_" + ">" + "\n" */
+        XH_WRITER_RESIZE_BUFFER(writer, buf, indent_len + name_len + 5)
+
+        XH_BUFFER_WRITE_LONG_STRING(buf, indent_string, indent_len);
+    }
+    else {
+        /* "</" + "_" + ">" + "\n" */
+        XH_WRITER_RESIZE_BUFFER(writer, buf, name_len + 5)
+    }
+
+    XH_BUFFER_WRITE_CHAR(buf, '<')
+
+    if (name[0] >= '0' && name[0] <= '9') {
+        XH_BUFFER_WRITE_CHAR(buf, '_')
+    }
+
+    XH_BUFFER_WRITE_LONG_STRING(buf, name, name_len)
+
+    XH_BUFFER_WRITE_CHAR(buf, '>')
+
+    if (writer->indent) {
+        XH_BUFFER_WRITE_CHAR(buf, '\n')
+    }
+}
+
+XH_INLINE void
+xh_xml_write_end_node(xh_writer_t *writer, xh_char_t *name, size_t name_len)
+{
+    size_t            indent_len;
+    xh_ruby_buffer_t *buf;
+
+    buf = &writer->main_buf;
+
+    if (writer->indent) {
+        indent_len = --writer->indent_count * writer->indent;
+        if (indent_len > sizeof(indent_string)) {
+            indent_len = sizeof(indent_string);
+        }
+
+        /* "</" + "_" + ">" + "\n" */
+        XH_WRITER_RESIZE_BUFFER(writer, buf, indent_len + name_len + 5)
+
+        XH_BUFFER_WRITE_LONG_STRING(buf, indent_string, indent_len);
+    }
+    else {
+        /* "</" + "_" + ">" + "\n" */
+        XH_WRITER_RESIZE_BUFFER(writer, buf, name_len + 5)
+    }
+
+    XH_BUFFER_WRITE_CHAR2(buf, "</")
+
+    if (name[0] >= '0' && name[0] <= '9') {
+        XH_BUFFER_WRITE_CHAR(buf, '_')
+    }
+
+    XH_BUFFER_WRITE_LONG_STRING(buf, name, name_len)
+
+    XH_BUFFER_WRITE_CHAR(buf, '>')
+
+    if (writer->indent) {
+        XH_BUFFER_WRITE_CHAR(buf, '\n')
+    }
+}
+
+XH_INLINE void
+xh_xml_write_content(xh_writer_t *writer, VALUE value)
+{
+    size_t         indent_len;
+    xh_ruby_buffer_t *buf;
+    xh_char_t        *content;
+    size_t            content_len;
+
+    buf         = &writer->main_buf;
+    value       = rb_obj_as_string(value);
+    content     = XH_CHAR_CAST RSTRING_PTR(value);
+    content_len = RSTRING_LEN(value);
+
+    if (writer->trim) {
+        content = xh_str_trim(content, &content_len);
+    }
+
+    if (writer->indent) {
+        indent_len = writer->indent_count * writer->indent;
+        if (indent_len > sizeof(indent_string)) {
+            indent_len = sizeof(indent_string);
+        }
+
+        XH_WRITER_RESIZE_BUFFER(writer, buf, indent_len + content_len * 5)
+
+        XH_BUFFER_WRITE_LONG_STRING(buf, indent_string, indent_len);
+    }
+    else {
+        XH_WRITER_RESIZE_BUFFER(writer, buf, content_len * 5)
+    }
+
+    XH_BUFFER_WRITE_ESCAPE_STRING(buf, content, content_len);
+
+    if (writer->indent) {
+        XH_BUFFER_WRITE_CHAR(buf, '\n')
+    }
+}
+
+XH_INLINE void
+xh_xml_write_comment(xh_writer_t *writer, VALUE value)
+{
+    size_t            indent_len;
+    xh_ruby_buffer_t *buf;
+    xh_char_t        *content;
+    size_t            content_len;
+
+    buf = &writer->main_buf;
+
+    if (value == Qnil) {
+        content     = XH_EMPTY_STRING;
+        content_len = 0;
+    }
+    else {
+      value       = rb_obj_as_string(value);
+      content     = XH_CHAR_CAST RSTRING_PTR(value);
+      content_len = RSTRING_LEN(value);
+    }
+
+    if (writer->trim && content_len) {
+        content = xh_str_trim(content, &content_len);
+    }
+
+    if (writer->indent) {
+        indent_len = writer->indent_count * writer->indent;
+        if (indent_len > sizeof(indent_string)) {
+            indent_len = sizeof(indent_string);
+        }
+
+        /* "<!--" + "-->" */
+        XH_WRITER_RESIZE_BUFFER(writer, buf, indent_len + content_len + 7)
+
+        XH_BUFFER_WRITE_LONG_STRING(buf, indent_string, indent_len);
+    }
+    else {
+        /* "<!--" + "-->" */
+        XH_WRITER_RESIZE_BUFFER(writer, buf, content_len + 7)
+    }
+
+    XH_BUFFER_WRITE_CHAR4(buf, "<!--")
+    XH_BUFFER_WRITE_LONG_STRING(buf, content, content_len);
+    XH_BUFFER_WRITE_CHAR3(buf, "-->")
+
+    if (writer->indent) {
+        XH_BUFFER_WRITE_CHAR(buf, '\n')
+    }
+}
+
+XH_INLINE void
+xh_xml_write_cdata(xh_writer_t *writer, VALUE value)
+{
+    size_t            indent_len;
+    xh_ruby_buffer_t *buf;
+    xh_char_t        *content;
+    size_t            content_len;
+
+    buf = &writer->main_buf;
+
+    if (value == Qnil) {
+        content     = XH_EMPTY_STRING;
+        content_len = 0;
+    }
+    else {
+        value       = rb_obj_as_string(value);
+        content     = XH_CHAR_CAST RSTRING_PTR(value);
+        content_len = RSTRING_LEN(value);
+    }
+
+    if (writer->trim && content_len) {
+        content = xh_str_trim(content, &content_len);
+    }
+
+    if (writer->indent) {
+        indent_len = writer->indent_count * writer->indent;
+        if (indent_len > sizeof(indent_string)) {
+            indent_len = sizeof(indent_string);
+        }
+
+        /* "<![CDATA[" + "]]>" */
+        XH_WRITER_RESIZE_BUFFER(writer, buf, indent_len + content_len + 12)
+
+        XH_BUFFER_WRITE_LONG_STRING(buf, indent_string, indent_len);
+    }
+    else {
+        /* "<![CDATA[" + "]]>" */
+        XH_WRITER_RESIZE_BUFFER(writer, buf, content_len + 12)
+    }
+
+    XH_BUFFER_WRITE_CHAR9(buf, "<![CDATA[")
+    XH_BUFFER_WRITE_LONG_STRING(buf, content, content_len);
+    XH_BUFFER_WRITE_CHAR3(buf, "]]>")
+
+    if (writer->indent) {
+        XH_BUFFER_WRITE_CHAR(buf, '\n')
+    }
+}
+
+XH_INLINE void
+xh_xml_write_start_tag(xh_writer_t *writer, xh_char_t *name, size_t name_len)
+{
+    size_t            indent_len;
+    xh_ruby_buffer_t *buf;
+
+    buf = &writer->main_buf;
+
+    if (writer->indent) {
+        indent_len = writer->indent_count * writer->indent;
+        if (indent_len > sizeof(indent_string)) {
+            indent_len = sizeof(indent_string);
+        }
+
+        /* "<" + "_" */
+        XH_WRITER_RESIZE_BUFFER(writer, buf, indent_len + name_len + 2)
+
+        XH_BUFFER_WRITE_LONG_STRING(buf, indent_string, indent_len);
+    }
+    else {
+        /* "<" + "_" */
+        XH_WRITER_RESIZE_BUFFER(writer, buf, name_len + 2)
+    }
+
+    XH_BUFFER_WRITE_CHAR(buf, '<')
+
+    if (name[0] >= '0' && name[0] <= '9') {
+        XH_BUFFER_WRITE_CHAR(buf, '_')
+    }
+
+    XH_BUFFER_WRITE_LONG_STRING(buf, name, name_len)
+}
+
+XH_INLINE void
+xh_xml_write_end_tag(xh_writer_t *writer)
+{
+    xh_ruby_buffer_t *buf;
+
+    buf = &writer->main_buf;
+
+    XH_WRITER_RESIZE_BUFFER(writer, buf, 2)
+
+    if (writer->indent) {
+        XH_BUFFER_WRITE_CHAR2(buf, ">\n");
+        writer->indent_count++;
+    }
+    else {
+        XH_BUFFER_WRITE_CHAR(buf, '>')
+    }
+}
+
+XH_INLINE void
+xh_xml_write_closed_end_tag(xh_writer_t *writer)
+{
+    xh_ruby_buffer_t *buf;
+
+    buf = &writer->main_buf;
+
+    XH_WRITER_RESIZE_BUFFER(writer, buf, 3)
+
+    if (writer->indent) {
+        XH_BUFFER_WRITE_CHAR3(buf, "/>\n");
+    }
+    else {
+        XH_BUFFER_WRITE_CHAR2(buf, "/>");
+    }
+}
+
+XH_INLINE void
+xh_xml_write_attribute(xh_writer_t *writer, xh_char_t *name, size_t name_len, VALUE value)
+{
+    xh_ruby_buffer_t *buf;
+    xh_char_t        *content;
+    size_t            content_len;
+
+    buf = &writer->main_buf;
+
+    if (value == Qnil) {
+        content     = XH_EMPTY_STRING;
+        content_len = 0;
+    }
+    else {
+        value       = rb_obj_as_string(value);
+        content     = XH_CHAR_CAST RSTRING_PTR(value);
+        content_len = RSTRING_LEN(value);
+    }
+
+    /* ' =""' */
+    XH_WRITER_RESIZE_BUFFER(writer, buf, name_len + content_len * 6 + 4)
+
+    XH_BUFFER_WRITE_CHAR(buf, ' ')
+
+    XH_BUFFER_WRITE_LONG_STRING(buf, name, name_len)
+
+    if (content_len == 0) {
+        XH_BUFFER_WRITE_CHAR3(buf, "=\"\"");
+    }
+    else {
+        XH_BUFFER_WRITE_CHAR2(buf, "=\"");
+        XH_BUFFER_WRITE_ESCAPE_ATTR(buf, content, content_len);
+        XH_BUFFER_WRITE_CHAR(buf, '"');
+    }
+}
+
+#endif /* _XH_XML_H_ */