libxml-ruby 2.4.0-x86-mingw32 → 2.5.0-x86-mingw32

data/HISTORY

@@ -1,5 +1,19 @@
 = Release History
 
+== 2.5.0 / 2013-01-27 Charlie Savage
+
+* Compatibility with older versions for IO::write (rb_io_bufwrite is specific to ruby >= 1.9.3?)
+  and symbols are VALUE not ID (julp).
+* Fix version for xmlTextWriterSetQuoteChar, it appeared in libxml2 2.9.0, last version (julp)
+* Update use of LIBXML_VERSION (julp).
+* Fix misuse of rb_scan_args (julp).
+* Update documentation, including DTD docs and added XML Writer (julp).
+* Added a new XML::Writer class (julp).
+* Improved xml reader api and add namespace support.  Note that passing a numeric value
+  to XML::Reader::move_to_attribute has been deprecated. Instead you should now
+  use #move_to_attribute_no.  (julp).
+* Improve error handling and messages (Jarl Friis)
+
 == 2.4.0 / 2012-12-14 Charlie Savage
 
 * Support libxml 2.9.0 (Daniel Veillard)

data/LICENSE

@@ -1,4 +1,4 @@
-  Copyright (c) 2008-2011 Charlie Savage and contributors
+  Copyright (c) 2008-2013 Charlie Savage and contributors
   Copyright (c) 2002-2007 Sean Chittenden and contributors
   Copyright (c) 2001 Wai-Sun "Squidster" Chia
 

data/README.rdoc

@@ -30,14 +30,15 @@ The easiest way to install libxml-ruby is via Ruby Gems.  To install:
 <tt>gem install libxml-ruby</tt>
 
 If you are running Windows, make sure to install the Win32 RubyGem
-which includes prebuilt extensions for Ruby 1.8 and Ruby 1.9.  These
-extensions are built with MinGW32 against libxml2 version 2.7.8,
+which includes prebuilt extensions for Ruby 1.8, 1.9 and 2.0 preview.  These
+extensions are built with MinGW32 against libxml2 version 2.9.0,
 iconv version 1.13 and zlib version 1.2.5.  Note these binaries
 are available in the lib\libs directory.  To use them, put them
 someplace on your path.
 
-The gem also includes a Microsoft VC++ 2010
-solution (useful for debugging).
+The gem also includes a Microsoft VC++ 2012 solution (useful for debugging).
+
+libxml-ruby's source codes lives on Github at https://github.com/xml4r/libxml-ruby.
 
 == Getting Started
 Using libxml is easy. First decide what parser you want to use:
@@ -72,11 +73,11 @@ This can be done using libxml's powerful set of validators:
 
 Finally, if you'd like to use XSL Transformations to process data,
 then install the libxslt gem which is available at
-http://rubyforge.org/projects/libxsl/.
+https://github.com/xml4r/libxslt-ruby.
 
 == Usage
 For information about using libxml-ruby please refer to its documentation at
-http://xml4r.github.com/libxml-ruby/rdoc/index.html Some tutorials are also
+http://xml4r.github.com/libxml-ruby/rdoc/index.html. Some tutorials are also
 available at https://github.com/xml4r/libxml-ruby/wiki.
 
 All libxml classes are in the LibXML::XML module. The easiest
@@ -165,25 +166,19 @@ From https://svn.concord.org/svn/projects/trunk/common/ruby/xml_benchmarks/
 Documentation is available via rdoc, and is installed automatically with the
 gem.
 
-libxml-ruby's online documentation is generated using Hanna.  To generate
-documentation from source:
-
-  gem install hanna
-  rake rdoc
+libxml-ruby's online documentation is generated using Hanna, which is a
+development gem dependency.
 
 Note that older versions of Rdoc, which ship with Ruby 1.8.x, will report
-a number of errors.  To avoid them, install Rdoc 2.1 or higher from
-RubyForge (http://rdoc.rubyforge.org/).  Once you have installed the gem,
-you'll have to disable the version of Rdoc that Ruby 1.8.x includes.  An
-easy way to do that is rename the directory uby/lib/ruby/1.8/rdoc to
+a number of errors.  To avoid them, install Rdoc 2.1 or higher.  Once you have
+installed the gem, you'll have to disable the version of Rdoc that Ruby 1.8.x
+includes.  An easy way to do that is rename the directory ruby/lib/ruby/1.8/rdoc to
 ruby/lib/ruby/1.8/rdoc_old.
 
 == Support
 
-If you have any questions about using libxml-ruby, please send them to
-libxml-devel@rubyforge.org.  If you have found any bugs in libxml-devel,
-or have developed new patches, please submit them to Git Hub at
-https://github.com/xml4r/libxml-ruby/issues.
+If you have any questions about using libxml-ruby, please report them to
+Git Hub at https://github.com/xml4r/libxml-ruby/issues
 
 == License
 See LICENSE for license information.

data/Rakefile

@@ -53,10 +53,12 @@ end
 # RDoc Task
 desc "Generate rdoc documentation"
 RDoc::Task.new("rdoc") do |rdoc|
-  rdoc.rdoc_dir = 'doc/libxml-ruby/rdoc'
+  rdoc.rdoc_dir = 'website/_site/rdoc'
   rdoc.title    = "LibXML"
   # Show source inline with line numbers
   rdoc.options << "--line-numbers"
+  rdoc.options << "--charset=utf-8"
+  rdoc.options << "--format=hanna"
   # Make the readme file the start page for the generated html
   rdoc.main = 'README.rdoc'
   rdoc.rdoc_files.include('doc/*.rdoc',
@@ -73,7 +75,4 @@ end
 Rake::TestTask.new do |t|
   t.libs << "test"
   t.verbose = true
-end
-
-desc "Build docs, and publish the website"
-task :publish_with_docs => [:rdoc, :publish]
+end

data/ext/libxml/extconf.rb

@@ -103,6 +103,8 @@ need libxml2.
 EOL
 end
 
+have_func('rb_io_bufwrite', 'ruby/io.h')
+
 # For FreeBSD add /usr/local/include
 $INCFLAGS << " -I/usr/local/include"
 

data/ext/libxml/libxml.c

@@ -72,4 +72,5 @@ void Init_libxml_ruby(void)
   rxml_init_schema();
   rxml_init_relaxng();
   rxml_init_reader();
+  rxml_init_writer();
 }

data/ext/libxml/ruby_libxml.h

@@ -55,6 +55,7 @@
 #include "ruby_xml_html_parser_options.h"
 #include "ruby_xml_html_parser_context.h"
 #include "ruby_xml_reader.h"
+#include "ruby_xml_writer.h"
 #include "ruby_xml_sax2_handler.h"
 #include "ruby_xml_sax_parser.h"
 #include "ruby_xml_xinclude.h"

data/ext/libxml/ruby_xml_io.c

@@ -1,8 +1,12 @@
 /* Please see the LICENSE file for copyright and distribution information */
 
+#include "extconf.h"
 #include "ruby_libxml.h"
 
 static ID READ_METHOD;
+#ifndef HAVE_RB_IO_BUFWRITE
+static ID WRITE_METHOD;
+#endif /* !HAVE_RB_IO_BUFWRITE */
 
 /* This method is called by libxml when it wants to read
  more data from a stream. We go with the duck typing
@@ -22,7 +26,25 @@ int rxml_read_callback(void *context, char *buffer, int len)
   return size;
 }
 
+int rxml_write_callback(void *context, const char *buffer, int len)
+{
+#ifndef HAVE_RB_IO_BUFWRITE
+  VALUE io, written, string;
+
+  io = (VALUE) context;
+  string = rb_str_new(buffer, len);
+  written = rb_funcall(io, WRITE_METHOD, 1, string);
+
+  return NUM2INT(written);
+#else
+  return rb_io_bufwrite((VALUE) context, buffer, (size_t) len);
+#endif /* !HAVE_RB_IO_BUFWRITE */
+}
+
 void rxml_init_io(void)
 {
   READ_METHOD = rb_intern("read");
+#ifndef HAVE_RB_IO_BUFWRITE
+  WRITE_METHOD = rb_intern("write");
+#endif /* !HAVE_RB_IO_BUFWRITE */
 }

data/ext/libxml/ruby_xml_io.h

@@ -4,6 +4,7 @@
 #define __RXML_IO__
 
 int rxml_read_callback(void *context, char *buffer, int len);
+int rxml_write_callback(void *context, const char *buffer, int len);
 void rxml_init_io(void);
 
 #endif

data/ext/libxml/ruby_xml_reader.c

@@ -287,28 +287,67 @@ static VALUE rxml_reader_close(VALUE self)
 
 /*
  * call-seq:
- *   reader.move_to_attribute(val) -> code
+ *   reader.move_to_attribute_no(index) -> code
  *
  * Move the position of the current instance to the attribute with the
- * specified index (if +val+ is an integer) or name (if +val+ is a string)
- * relative to the containing element.
+ * specified index relative to the containing element.
  */
-static VALUE rxml_reader_move_to_attr(VALUE self, VALUE val)
+static VALUE rxml_reader_move_to_attr_no(VALUE self, VALUE index)
 {
-  xmlTextReaderPtr xreader;
   int ret;
+  xmlTextReaderPtr xreader;
 
   xreader = rxml_text_reader_get(self);
+  ret = xmlTextReaderMoveToAttributeNo(xreader, FIX2INT(index));
+
+  return INT2FIX(ret);
+}
 
+/*
+ * call-seq:
+ *   reader.move_to_attribute(localName) -> code
+ *
+ * Move the position of the current instance to the attribute with the
+ * specified name relative to the containing element.
+ */
+static VALUE rxml_reader_move_to_attr(VALUE self, VALUE val)
+{
   if (TYPE(val) == T_FIXNUM)
   {
-    ret = xmlTextReaderMoveToAttributeNo(xreader, FIX2INT(val));
+    rb_warn("%s::move_to_attribute with a Fixnum argument is deprecated. "
+      "Please, consider move_to_attribute_no method instead.",
+      rb_class2name(cXMLReader));
+    return rxml_reader_move_to_attr_no(self, val);
   }
   else
   {
+    int ret;
+    xmlTextReaderPtr xreader;
+
+    xreader = rxml_text_reader_get(self);
     ret = xmlTextReaderMoveToAttribute(xreader,
         (const xmlChar *) StringValueCStr(val));
+
+    return INT2FIX(ret);
   }
+}
+
+/*
+ * call-seq:
+ *   reader.move_to_attribute_ns(localName, namespaceURI) -> code
+ *
+ * Move the position of the current instance to the attribute with the
+ * specified name and namespace relative to the containing element.
+ */
+static VALUE rxml_reader_move_to_attr_ns(VALUE self, VALUE name, VALUE ns)
+{
+  int ret;
+  xmlTextReaderPtr xreader;
+
+  xreader = rxml_text_reader_get(self);
+  ret = xmlTextReaderMoveToAttributeNs(xreader,
+      (const xmlChar *) StringValueCStr(name),
+      (const xmlChar *) StringValueCStr(ns));
 
   return INT2FIX(ret);
 }
@@ -862,6 +901,71 @@ static VALUE rxml_reader_attribute(VALUE self, VALUE key)
   return result;
 }
 
+/*
+ * call-seq:
+ *    reader.get_attribute(localName) -> value
+ *
+ * Provide the value of the attribute with the specified name
+ * relative to the containing element.
+ */
+static VALUE rxml_reader_get_attribute(VALUE self, VALUE name)
+{
+  VALUE result = Qnil;
+  xmlChar *xattr;
+  xmlTextReaderPtr xReader = rxml_text_reader_get(self);
+  const xmlChar *xencoding = xmlTextReaderConstEncoding(xReader);
+
+  xattr = xmlTextReaderGetAttribute(xReader,
+    (const xmlChar *) StringValueCStr(name));
+  if (xattr)
+  {
+    result = rxml_new_cstr(xattr, xencoding);
+    xmlFree(xattr);
+  }
+  return result;
+}
+
+/*
+ * call-seq:
+ *    reader.get_attribute_no(index) -> value
+ *
+ * Provide the value of the attribute with the specified index
+ * relative to the containing element.
+ */
+static VALUE rxml_reader_get_attribute_no(VALUE self, VALUE index)
+{
+  VALUE result = Qnil;
+  xmlChar *xattr;
+  xmlTextReaderPtr xReader = rxml_text_reader_get(self);
+  const xmlChar *xencoding = xmlTextReaderConstEncoding(xReader);
+
+  xattr = xmlTextReaderGetAttributeNo(xReader, FIX2INT(index));
+  if (xattr)
+  {
+    result = rxml_new_cstr(xattr, xencoding);
+    xmlFree(xattr);
+  }
+  return result;
+}
+
+static VALUE rxml_reader_get_attribute_ns(VALUE self, VALUE name, VALUE ns)
+{
+  VALUE result = Qnil;
+  xmlChar *xattr;
+  xmlTextReaderPtr xReader = rxml_text_reader_get(self);
+  const xmlChar *xencoding = xmlTextReaderConstEncoding(xReader);
+
+  xattr = xmlTextReaderGetAttributeNs(xReader,
+    (const xmlChar *) StringValueCStr(name),
+    (const xmlChar *) StringValueCStr(ns));
+  if (xattr)
+  {
+    result = rxml_new_cstr(xattr, xencoding);
+    xmlFree(xattr);
+  }
+  return result;
+}
+
 /*
  * call-seq:
  *    reader.lookup_namespace(prefix) -> value
@@ -1040,6 +1144,9 @@ void rxml_init_reader(void)
   rb_define_method(cXMLReader, "depth", rxml_reader_depth, 0);
   rb_define_method(cXMLReader, "encoding", rxml_reader_encoding, 0);
   rb_define_method(cXMLReader, "expand", rxml_reader_expand, 0);
+  rb_define_method(cXMLReader, "get_attribute", rxml_reader_get_attribute, 1);
+  rb_define_method(cXMLReader, "get_attribute_no", rxml_reader_get_attribute_no, 1);
+  rb_define_method(cXMLReader, "get_attribute_ns", rxml_reader_get_attribute_ns, 2);
   rb_define_method(cXMLReader, "has_attributes?", rxml_reader_has_attributes, 0);
   rb_define_method(cXMLReader, "has_value?", rxml_reader_has_value, 0);
 #if LIBXML_VERSION >= 20617
@@ -1048,6 +1155,8 @@ void rxml_init_reader(void)
   rb_define_method(cXMLReader, "local_name", rxml_reader_local_name, 0);
   rb_define_method(cXMLReader, "lookup_namespace",       rxml_reader_lookup_namespace, 1);
   rb_define_method(cXMLReader, "move_to_attribute", rxml_reader_move_to_attr, 1);
+  rb_define_method(cXMLReader, "move_to_attribute_no", rxml_reader_move_to_attr_no, 1);
+  rb_define_method(cXMLReader, "move_to_attribute_ns", rxml_reader_move_to_attr_ns, 2);
   rb_define_method(cXMLReader, "move_to_first_attribute",       rxml_reader_move_to_first_attr, 0);
   rb_define_method(cXMLReader, "move_to_next_attribute",       rxml_reader_move_to_next_attr, 0);
   rb_define_method(cXMLReader, "move_to_element", rxml_reader_move_to_element,       0);

data/ext/libxml/ruby_xml_schema.c

@@ -15,7 +15,7 @@
  * The XML::Schema class is used to prepare XML Schemas for validation of xml
  * documents.
  *
- * Schemas can be created from XML documents, strings or URIs using the
+ * Schemas can be created from XML documents, strinings or URIs using the
  * corresponding methods (new for URIs).
  *
  * Once a schema is prepared, an XML document can be validated by the

data/ext/libxml/ruby_xml_schema_type.c

@@ -238,6 +238,13 @@ rxml_schema_type_attributes(VALUE self)
 
 void rxml_init_schema_type(void)
 {
+  /* Add in infinity support for ruby 1.8.7 */
+  #if !defined(RUBY_VM) && defined(INFINITY)
+  ID infinityId = rb_intern("INFINITY");
+  if (rb_const_defined(rb_cFloat, infinityId) == Qfalse)
+    rb_define_const(rb_cFloat, "INFINITY", rb_float_new(INFINITY));
+  #endif
+
   cXMLSchemaType = rb_define_class_under(cXMLSchema, "Type", rb_cObject);
 
   rb_define_method(cXMLSchemaType, "namespace", rxml_schema_type_namespace, 0);

data/ext/libxml/ruby_xml_version.h

@@ -1,9 +1,9 @@
 /* Don't nuke this block!  It is used for automatically updating the
  * versions below. VERSION = string formatting, VERNUM = numbered
  * version for inline testing: increment both or none at all.*/
-#define RUBY_LIBXML_VERSION  "2.4.0"
-#define RUBY_LIBXML_VERNUM   240
+#define RUBY_LIBXML_VERSION  "2.5.0"
+#define RUBY_LIBXML_VERNUM   250
 #define RUBY_LIBXML_VER_MAJ   2
-#define RUBY_LIBXML_VER_MIN   4
+#define RUBY_LIBXML_VER_MIN   5
 #define RUBY_LIBXML_VER_MIC   0
 #define RUBY_LIBXML_VER_PATCH 0

data/ext/libxml/ruby_xml_writer.c

@@ -0,0 +1,1072 @@
+#include <libxml/xmlversion.h>
+
+#ifdef LIBXML_WRITER_ENABLED
+
+/*
+ * Document-class: LibXML::XML::Writer
+ *
+ * The XML::Writer class provides a simpler, alternative way to build a valid
+ * XML document from scratch (forward-only) compared to a DOM approach (based
+ * on XML::Document class).
+ *
+ * For a more in depth tutorial, albeit in C, see http://xmlsoft.org/xmlwriter.html
+ */
+
+# include <libxml/xmlwriter.h>
+
+# include "ruby_libxml.h"
+# include "ruby_xml_io.h"
+# include "ruby_xml_document.h"
+# include "ruby_xml_writer.h"
+
+VALUE cXMLWriter;
+static VALUE sEncoding, sStandalone;
+
+typedef enum {
+    RXMLW_OUTPUT_NONE,
+    RXMLW_OUTPUT_IO,
+    RXMLW_OUTPUT_DOC,
+    RXMLW_OUTPUT_STRING
+} rxmlw_output_type;
+
+typedef struct {
+    VALUE output;
+    xmlBufferPtr buffer;
+    xmlTextWriterPtr writer;
+    rxmlw_output_type output_type;
+} rxml_writer_object;
+
+# ifdef HAVE_RUBY_ENCODING_H
+
+#  define /*VALUE*/ rxml_writer_c_to_ruby_string(/*const xmlChar **/ string, /*long*/ string_len) \
+    rb_external_str_new_with_enc(string, string_len, rb_utf8_encoding())
+
+#  define /*VALUE*/ rxml_writer_ruby_string_to_utf8(/*VALUE*/ string) \
+    rb_str_conv_enc(string, rb_enc_get(string), rb_utf8_encoding())
+// rb_str_export_to_enc(string, rb_utf8_encoding())
+
+#  define /*void*/ rxml_writer_free_utf8_string(/*VALUE*/ orig, /*VALUE*/ utf8) \
+    do {                       \
+        if (orig != utf8) {    \
+            rb_str_free(utf8); \
+        }                      \
+    } while (0);
+
+# else
+
+#  define /*VALUE*/ rxml_writer_c_to_ruby_string(/*const xmlChar **/ string, /*long*/ string_len) \
+    rb_str_new(string, string_len)
+
+#  define /*VALUE*/ rxml_writer_ruby_string_to_utf8(/*VALUE*/ string) \
+    string
+
+#  define /*void*/ rxml_writer_free_utf8_string(/*VALUE*/ orig, /*VALUE*/ utf8) \
+    /* NOP */
+
+# endif /* HAVE_RUBY_ENCODING_H */
+
+static void rxml_writer_free(rxml_writer_object *rwo)
+{
+#if 0 /* seems to be done by xmlFreeTextWriter */
+    if (NULL != rwo->buffer) {
+        xmlBufferFree(rwo->buffer);
+    }
+#endif
+    xmlFreeTextWriter(rwo->writer);
+    xfree(rwo);
+}
+
+static void rxml_writer_mark(rxml_writer_object *rwo)
+{
+    if (!NIL_P(rwo->output)) {
+        rb_gc_mark(rwo->output);
+    }
+}
+
+static VALUE rxml_writer_wrap(rxml_writer_object *rwo)
+{
+    return Data_Wrap_Struct(cXMLWriter, rxml_writer_mark, rxml_writer_free, rwo);
+}
+
+static rxml_writer_object *rxml_textwriter_get(VALUE obj)
+{
+    rxml_writer_object *rwo;
+
+    Data_Get_Struct(obj, rxml_writer_object, rwo);
+
+    return rwo;
+}
+
+/* ===== public class methods ===== */
+
+/* call-seq:
+ *    XML::Writer::io(io) -> XML::Writer
+ *
+ * Creates a XML::Writer which will write XML directly into an IO object.
+ */
+static VALUE rxml_writer_io(VALUE klass, VALUE io)
+{
+#if 0
+typedef int (*xmlOutputCloseCallback)(void * context);
+typedef int (*xmlOutputWriteCallback)(void * context, const char * buffer, int len);
+
+ssize_t rb_io_bufwrite(VALUE io, const void *buf, size_t size);
+
+xmlOutputBufferPtr xmlOutputBufferCreateIO(xmlOutputWriteCallback iowrite, xmlOutputCloseCallback ioclose, void * ioctx, xmlCharEncodingHandlerPtr encoder)
+
+xmlCharEncodingHandlerPtr xmlFindCharEncodingHandler(const char * name);
+#endif
+    xmlOutputBufferPtr out;
+    rxml_writer_object *rwo;
+
+    rwo = ALLOC(rxml_writer_object);
+    rwo->output = io;
+    rwo->buffer = NULL;
+    rwo->output_type = RXMLW_OUTPUT_IO;
+    if (NULL == (out = xmlOutputBufferCreateIO(rxml_write_callback, NULL, (void *) io, NULL))) {
+        rxml_raise(&xmlLastError);
+    }
+    if (NULL == (rwo->writer = xmlNewTextWriter(out))) {
+        rxml_raise(&xmlLastError);
+    }
+
+    return rxml_writer_wrap(rwo);
+}
+
+
+/* call-seq:
+ *    XML::Writer::file(path) -> XML::Writer
+ *
+ * Creates a XML::Writer object which will write XML into the file with
+ * the given name.
+ */
+static VALUE rxml_writer_file(VALUE klass, VALUE filename)
+{
+    rxml_writer_object *rwo;
+
+    rwo = ALLOC(rxml_writer_object);
+    rwo->output = Qnil;
+    rwo->buffer = NULL;
+    rwo->output_type = RXMLW_OUTPUT_NONE;
+    if (NULL == (rwo->writer = xmlNewTextWriterFilename(StringValueCStr(filename), 0))) {
+        rxml_raise(&xmlLastError);
+    }
+
+    return rxml_writer_wrap(rwo);
+}
+
+/* call-seq:
+ *    XML::Writer::string -> XML::Writer
+ *
+ * Creates a XML::Writer which will write XML into memory, as string.
+ */
+static VALUE rxml_writer_string(VALUE klass)
+{
+    rxml_writer_object *rwo;
+
+    rwo = ALLOC(rxml_writer_object);
+    rwo->output = Qnil;
+    rwo->output_type = RXMLW_OUTPUT_STRING;
+    if (NULL == (rwo->buffer = xmlBufferCreate())) {
+        rxml_raise(&xmlLastError);
+    }
+    if (NULL == (rwo->writer = xmlNewTextWriterMemory(rwo->buffer, 0))) {
+        xmlBufferFree(rwo->buffer);
+        rxml_raise(&xmlLastError);
+    }
+
+    return rxml_writer_wrap(rwo);
+}
+
+/* call-seq:
+ *    XML::Writer::document -> XML::Writer
+ *
+ * Creates a XML::Writer which will write into an in memory XML::Document
+ */
+static VALUE rxml_writer_doc(VALUE klass)
+{
+    xmlDocPtr doc;
+    rxml_writer_object *rwo;
+
+    rwo = ALLOC(rxml_writer_object);
+    rwo->buffer = NULL;
+    rwo->output = Qnil;
+    rwo->output_type = RXMLW_OUTPUT_DOC;
+    if (NULL == (rwo->writer = xmlNewTextWriterDoc(&doc, 0))) {
+        rxml_raise(&xmlLastError);
+    }
+    rwo->output = rxml_document_wrap(doc);
+
+    return rxml_writer_wrap(rwo);
+}
+
+/* ===== public instance methods ===== */
+
+/* call-seq:
+ *    writer.flush -> (true|false)
+ *
+ * Flushes the output buffer.
+ */
+static VALUE rxml_writer_flush(VALUE self)
+{
+    int ret;
+    rxml_writer_object *rwo;
+
+    rwo = rxml_textwriter_get(self);
+    ret = xmlTextWriterFlush(rwo->writer);
+
+    return (-1 == ret ? Qfalse : Qtrue);
+}
+
+/* call-seq:
+ *    writer.result -> (XML::Document|"string"|nil)
+ *
+ * Returns the associated result object to the XML::Writer creation.
+ * A String for a XML::Writer object created with XML::Writer::string,
+ * a XML::Document with XML::Writer::document, etc.
+ */
+static VALUE rxml_writer_result(VALUE self)
+{
+    VALUE ret;
+    rxml_writer_object *rwo;
+
+    ret = Qnil;
+    rwo = rxml_textwriter_get(self);
+    switch (rwo->output_type) {
+        case RXMLW_OUTPUT_DOC:
+            ret = rwo->output;
+            break;
+        case RXMLW_OUTPUT_STRING:
+            ret = rxml_writer_c_to_ruby_string(rwo->buffer->content, rwo->buffer->use);
+            break;
+        case RXMLW_OUTPUT_IO:
+        case RXMLW_OUTPUT_NONE:
+            break;
+        default:
+            rb_bug("unexpected output");
+            break;
+    }
+
+    return ret;
+}
+
+/* ===== private helpers ===== */
+
+static VALUE numeric_rxml_writer_void(VALUE obj, int (*fn)(xmlTextWriterPtr))
+{
+    int ret;
+    rxml_writer_object *rwo;
+
+    rwo = rxml_textwriter_get(obj);
+    ret = fn(rwo->writer);
+
+    return (-1 == ret ? Qfalse : Qtrue);
+}
+
+# define numeric_rxml_writer_string(/*VALUE*/ obj, /*VALUE*/ name_or_content, /*int (**/fn/*)(xmlTextWriterPtr, const xmlChar *)*/) \
+    numeric_rxml_writer_va_strings(obj, Qnil, 1, fn, name_or_content)
+
+/**
+ * This is quite ugly but thanks to libxml2 coding style, all xmlTextWriter*
+ * calls can be redirected to a single function. This can be convenient to:
+ * - avoid repeating yourself
+ * - convert strings to UTF-8
+ * - validate names
+ * and so on
+ **/
+# define XMLWRITER_MAX_STRING_ARGS 5
+static VALUE numeric_rxml_writer_va_strings(VALUE obj, VALUE pe, size_t strings_count, int (*fn)(ANYARGS), ...)
+{
+    va_list ap;
+    int argc, ret;
+    rxml_writer_object *rwo;
+    const xmlChar *argv[XMLWRITER_MAX_STRING_ARGS];
+    VALUE utf8[XMLWRITER_MAX_STRING_ARGS], orig[XMLWRITER_MAX_STRING_ARGS];
+
+    if (strings_count > XMLWRITER_MAX_STRING_ARGS) {
+        rb_bug("more arguments than expected");
+    }
+    ret = -1;
+    va_start(ap, fn);
+    rwo = rxml_textwriter_get(obj);
+    for (argc = 0; argc < strings_count; argc++) {
+        VALUE arg;
+
+        arg = va_arg(ap, VALUE);
+        orig[argc] = arg;
+        if (NIL_P(arg)) {
+            utf8[argc] = Qnil;
+            argv[argc] = NULL;
+        } else {
+            utf8[argc] = rxml_writer_ruby_string_to_utf8(orig[argc]);
+            argv[argc] = BAD_CAST StringValueCStr(utf8[argc]);
+        }
+    }
+    va_end(ap);
+
+    if (NIL_P(pe)) {
+        switch (strings_count) {
+            case 0:
+                ret = fn(rwo->writer);
+                break;
+            case 1:
+                ret = fn(rwo->writer, argv[0]);
+                break;
+            case 2:
+                ret = fn(rwo->writer, argv[0], argv[1]);
+                break;
+            case 3:
+                ret = fn(rwo->writer, argv[0], argv[1], argv[2]);
+                break;
+            case 4:
+                ret = fn(rwo->writer, argv[0], argv[1], argv[2], argv[3]);
+                break;
+            case 5:
+                ret = fn(rwo->writer, argv[0], argv[1], argv[2], argv[3], argv[4]);
+                break;
+            default:
+                break;
+        }
+    } else {
+        int xpe;
+
+        xpe = RTEST(pe);
+        switch (strings_count) { /* strings_count doesn't include pe */
+            case 0:
+                ret = fn(rwo->writer, xpe);
+                break;
+            case 1:
+                ret = fn(rwo->writer, xpe, argv[0]);
+                break;
+            case 2:
+                ret = fn(rwo->writer, xpe, argv[0], argv[1]);
+                break;
+            case 3:
+                ret = fn(rwo->writer, xpe, argv[0], argv[1], argv[2]);
+                break;
+            case 4:
+                ret = fn(rwo->writer, xpe, argv[0], argv[1], argv[2], argv[3]);
+                break;
+            case 5:
+                ret = fn(rwo->writer, xpe, argv[0], argv[1], argv[2], argv[3], argv[4]);
+                break;
+            default:
+                break;
+        }
+    }
+# ifdef HAVE_RUBY_ENCODING_H
+    while (--strings_count > 0) {
+        if (!NIL_P(orig[strings_count])) {
+            rxml_writer_free_utf8_string(orig[strings_count], utf8[strings_count]);
+        }
+    }
+# endif /* HAVE_RUBY_ENCODING_H */
+
+    return (-1 == ret ? Qfalse : Qtrue);
+}
+
+/* ===== public instance methods ===== */
+
+# if LIBXML_VERSION >= 20605
+/* call-seq:
+ *    writer.set_indent(indentation) -> (true|false)
+ *
+ * Toggles indentation on or off. Returns +false+ on failure.
+ *
+ * Availability: libxml2 >= 2.6.5
+ */
+static VALUE rxml_writer_set_indent(VALUE self, VALUE indentation)
+{
+    int ret;
+    rxml_writer_object *rwo;
+
+    rwo = rxml_textwriter_get(self);
+    ret = xmlTextWriterSetIndent(rwo->writer, RTEST(indentation));
+
+    return (-1 == ret ? Qfalse : Qtrue);
+}
+
+/* call-seq:
+ *    writer.set_indent_string(string) -> (true|false)
+ *
+ * Sets the string to use to indent each element of the document.
+ * Don't forget to enable indentation with set_indent. Returns
+ * +false+ on failure.
+ *
+ * Availability: libxml2 >= 2.6.5
+ */
+static VALUE rxml_writer_set_indent_string(VALUE self, VALUE indentation)
+{
+    return numeric_rxml_writer_string(self, indentation, xmlTextWriterSetIndentString);
+}
+# endif /* LIBXML_VERSION >= 20605 */
+
+/* ===== public full tag interface ===== */
+
+/* write_<X> = start_<X> + write_string + end_<X> */
+
+/* call-seq:
+ *    writer.write_comment(content) -> (true|false)
+ *
+ * Writes a full comment tag, all at once. Returns +false+ on failure.
+ * This is equivalent to start_comment + write_string(content) + end_comment.
+ */
+static VALUE rxml_writer_write_comment(VALUE self, VALUE content)
+{
+    return numeric_rxml_writer_string(self, content, xmlTextWriterWriteComment);
+}
+
+/* call-seq:
+ *    writer.write_cdata(content) -> (true|false)
+ *
+ * Writes a full CDATA section, all at once. Returns +false+ on failure.
+ * This is equivalent to start_cdata + write_string(content) + end_cdata.
+ */
+static VALUE rxml_writer_write_cdata(VALUE self, VALUE content)
+{
+    return numeric_rxml_writer_string(self, content, xmlTextWriterWriteCDATA);
+}
+
+static VALUE rxml_writer_start_element(VALUE, VALUE);
+static VALUE rxml_writer_start_element_ns(int, VALUE *, VALUE);
+static VALUE rxml_writer_end_element(VALUE);
+
+/* call-seq:
+ *    writer.write_element(name, content) -> (true|false)
+ *
+ * Writes a full element tag, all at once. Returns +false+ on failure.
+ * This is equivalent to start_element(name) + write_string(content) +
+ * end_element.
+ */
+static VALUE rxml_writer_write_element(int argc, VALUE *argv, VALUE self)
+{
+    VALUE name, content;
+
+    rb_scan_args(argc, argv, "11", &name, &content);
+    if (Qnil == content) {
+        if (Qfalse == rxml_writer_start_element(self, name)) {
+            return Qfalse;
+        }
+        return rxml_writer_end_element(self);
+    } else {
+        return numeric_rxml_writer_va_strings(self, Qnil, 2, xmlTextWriterWriteElement, name, content);
+    }
+}
+
+# define ARRAY_SIZE(array) \
+    (sizeof(array) / sizeof((array)[0]))
+
+/* call-seq:
+ *    writer.write_element_ns(prefix, name, namespaceURI, content) -> (true|false)
+ *
+ * Writes a full namespaced element tag, all at once. Returns +false+ on failure.
+ * This is a shortcut for start_element_ns(prefix, name, namespaceURI) +
+ * write_string(content) + end_element.
+ *
+ * Notes:
+ * - by default, the xmlns: definition is repeated on every element. If you want
+ * the prefix, but don't want the xmlns: declaration repeated, set +namespaceURI+
+ * to nil or omit it. Don't forget to declare the namespace prefix somewhere
+ * earlier.
+ * - +content+ can be omitted for an empty tag
+ */
+static VALUE rxml_writer_write_element_ns(int argc, VALUE *argv, VALUE self)
+{
+    VALUE prefix, name, namespaceURI, content;
+
+    rb_scan_args(argc, argv, "22", &prefix, &name, &namespaceURI, &content);
+    if (Qnil == content) {
+        VALUE argv[3] = { prefix, name, namespaceURI };
+
+        if (Qfalse == rxml_writer_start_element_ns(ARRAY_SIZE(argv), argv, self)) {
+            return Qfalse;
+        }
+        return rxml_writer_end_element(self);
+    } else {
+        return numeric_rxml_writer_va_strings(self, Qnil, 4, xmlTextWriterWriteElementNS, prefix, name, namespaceURI, content);
+    }
+}
+
+/* call-seq:
+ *    writer.write_attribute(name, content) -> (true|false)
+ *
+ * Writes a full attribute, all at once. Returns +false+ on failure.
+ * Same as start_attribute(name) + write_string(content) + end_attribute.
+ */
+static VALUE rxml_writer_write_attribute(VALUE self, VALUE name, VALUE content)
+{
+    return numeric_rxml_writer_va_strings(self, Qnil, 2, xmlTextWriterWriteAttribute, name, content);
+}
+
+/* call-seq:
+ *    writer.write_attribute_ns(prefix, name, namespaceURI, content) -> (true|false)
+ *
+ * Writes a full namespaced attribute, all at once. Returns +false+ on failure.
+ * Same as start_attribute_ns(prefix, name, namespaceURI) +
+ * write_string(content) + end_attribute.
+ *
+ * Notes:
+ * - by default, the xmlns: definition is repeated on every element. If you want
+ * the prefix, but don't want the xmlns: declaration repeated, set +namespaceURI+
+ * to nil or omit it. Don't forget to declare the namespace prefix somewhere
+ * earlier.
+ * - +content+ can be omitted too for an empty attribute
+ */
+static VALUE rxml_writer_write_attribute_ns(int argc, VALUE *argv, VALUE self)
+{
+    VALUE prefix, name, namespaceURI, content;
+
+    rb_scan_args(argc, argv, "22", &prefix, &name, &namespaceURI, &content);
+
+    return numeric_rxml_writer_va_strings(self, Qnil, 4, xmlTextWriterWriteAttributeNS, prefix, name, namespaceURI, content);
+}
+
+/* call-seq:
+ *    writer.write_pi(target, content) -> (true|false)
+ *
+ * Writes a full CDATA tag, all at once. Returns +false+ on failure.
+ * This is a shortcut for start_pi(target) + write_string(content) + end_pi.
+ */
+static VALUE rxml_writer_write_pi(VALUE self, VALUE target, VALUE content)
+{
+    return numeric_rxml_writer_va_strings(self, Qnil, 2, xmlTextWriterWritePI, target, content);
+}
+
+/* ===== public start/end interface ===== */
+
+/* call-seq:
+ *    writer.write_string(content) -> (true|false)
+ *
+ * Safely (problematic characters are internally translated to their
+ * associated named entities) writes a string into the current node
+ * (attribute, element, comment, ...). Returns +false+ on failure.
+ */
+static VALUE rxml_writer_write_string(VALUE self, VALUE content)
+{
+    return numeric_rxml_writer_string(self, content, xmlTextWriterWriteString);
+}
+
+/* call-seq:
+ *    writer.write_raw(content) -> (true|false)
+ *
+ * Writes the string +content+ as is, reserved characters are not
+ * translated to their associated entities. Returns +false+ on failure.
+ * Consider write_string to handle them.
+ */
+static VALUE rxml_writer_write_raw(VALUE self, VALUE content)
+{
+    return numeric_rxml_writer_string(self, content, xmlTextWriterWriteRaw);
+}
+
+/* call-seq:
+ *    writer.start_attribute(name) -> (true|false)
+ *
+ * Starts an attribute. Returns +false+ on failure.
+ */
+static VALUE rxml_writer_start_attribute(VALUE self, VALUE name)
+{
+    return numeric_rxml_writer_string(self, name, xmlTextWriterStartAttribute);
+}
+
+/* call-seq:
+ *    writer.start_attribute_ns(prefix, name, namespaceURI) -> (true|false)
+ *
+ * Starts a namespaced attribute. Returns +false+ on failure.
+ *
+ * Note: by default, the xmlns: definition is repeated on every element. If
+ * you want the prefix, but don't want the xmlns: declaration repeated, set
+ * +namespaceURI+ to nil or omit it. Don't forget to declare the namespace
+ * prefix somewhere earlier.
+ */
+static VALUE rxml_writer_start_attribute_ns(int argc, VALUE *argv, VALUE self)
+{
+    VALUE prefix, name, namespaceURI;
+
+    rb_scan_args(argc, argv, "21", &prefix, &name, &namespaceURI);
+
+    return numeric_rxml_writer_va_strings(self, Qnil, 3, xmlTextWriterStartAttributeNS, prefix, name, namespaceURI);
+}
+
+/* call-seq:
+ *    writer.end_attribute -> (true|false)
+ *
+ * Ends an attribute, namespaced or not. Returns +false+ on failure.
+ */
+static VALUE rxml_writer_end_attribute(VALUE self)
+{
+    return numeric_rxml_writer_void(self, xmlTextWriterEndAttribute);
+}
+
+# if LIBXML_VERSION >= 20607
+/* call-seq:
+ *    writer.start_comment -> (true|false)
+ *
+ * Starts a comment. Returns +false+ on failure.
+ * Note: libxml2 >= 2.6.7 required
+ */
+static VALUE rxml_writer_start_comment(VALUE self)
+{
+    return numeric_rxml_writer_void(self, xmlTextWriterStartComment);
+}
+
+/* call-seq:
+ *    writer.end_comment -> (true|false)
+ *
+ * Ends current comment, returns +false+ on failure.
+ * Note: libxml2 >= 2.6.7 required
+ */
+static VALUE rxml_writer_end_comment(VALUE self)
+{
+    return numeric_rxml_writer_void(self, xmlTextWriterEndComment);
+}
+# endif /* LIBXML_VERSION >= 20607 */
+
+/* call-seq:
+ *    writer.start_element(name) -> (true|false)
+ *
+ * Starts a new element. Returns +false+ on failure.
+ */
+static VALUE rxml_writer_start_element(VALUE self, VALUE name)
+{
+    return numeric_rxml_writer_string(self, name, xmlTextWriterStartElement);
+}
+
+/* call-seq:
+ *    writer.start_element_ns(prefix, name, namespaceURI) -> (true|false)
+ *
+ * Starts a new namespaced element. Returns +false+ on failure.
+ *
+ * Note: by default, the xmlns: definition is repeated on every element. If
+ * you want the prefix, but don't want the xmlns: declaration repeated, set
+ * +namespaceURI+ to nil or omit it. Don't forget to declare the namespace
+ * prefix somewhere earlier.
+ */
+static VALUE rxml_writer_start_element_ns(int argc, VALUE *argv, VALUE self)
+{
+    VALUE prefix, name, namespaceURI;
+
+    rb_scan_args(argc, argv, "21", &prefix, &name, &namespaceURI);
+
+    return numeric_rxml_writer_va_strings(self, Qnil, 3, xmlTextWriterStartElementNS, prefix, name, namespaceURI);
+}
+
+/* call-seq:
+ *    writer.end_element -> (true|false)
+ *
+ * Ends current element, namespaced or not. Returns +false+ on failure.
+ */
+static VALUE rxml_writer_end_element(VALUE self)
+{
+    return numeric_rxml_writer_void(self, xmlTextWriterEndElement);
+}
+
+/* call-seq:
+ *    writer.write_full_end_element -> (true|false)
+ *
+ * Ends current element, namespaced or not. Returns +false+ on failure.
+ * This method writes an end tag even if the element is empty (<foo></foo>),
+ * end_element does not (<foo/>).
+ */
+static VALUE rxml_writer_full_end_element(VALUE self)
+{
+    return numeric_rxml_writer_void(self, xmlTextWriterFullEndElement);
+}
+
+/* call-seq:
+ *    writer.start_cdata -> (true|false)
+ *
+ * Starts a new CDATA section. Returns +false+ on failure.
+ */
+static VALUE rxml_writer_start_cdata(VALUE self)
+{
+    return numeric_rxml_writer_void(self, xmlTextWriterStartCDATA);
+}
+
+/* call-seq:
+ *    writer.end_cdata -> (true|false)
+ *
+ * Ends current CDATA section. Returns +false+ on failure.
+ */
+static VALUE rxml_writer_end_cdata(VALUE self)
+{
+    return numeric_rxml_writer_void(self, xmlTextWriterEndCDATA);
+}
+
+/* call-seq:
+ *    writer.start_document -> (true|false)
+ *    writer.start_document(:encoding => XML::Encoding::UTF_8,
+ *    :standalone => true) -> (true|false)
+ *
+ * Starts a new document. Returns +false+ on failure.
+ *
+ * You may provide an optional hash table to control XML header that will be
+ * generated. Valid options are:
+ * - encoding: the output document encoding, defaults to nil (= UTF-8). Valid
+ * values are the encoding constants defined on XML::Encoding
+ * - standalone: nil (default) or a boolean to indicate if the document is
+ * standalone or not
+ */
+static VALUE rxml_writer_start_document(int argc, VALUE *argv, VALUE self)
+{
+    int ret;
+    VALUE options;
+    rxml_writer_object *rwo;
+    const char *xencoding, *xstandalone;
+
+    options = Qnil;
+    xstandalone = xencoding = NULL;
+    rb_scan_args(argc, argv, "01", &options);
+    if (!NIL_P(options)) {
+        VALUE encoding, standalone;
+
+        encoding = standalone = Qnil;
+        Check_Type(options, T_HASH);
+        encoding = rb_hash_aref(options, sEncoding);
+        xencoding = NIL_P(encoding) ? NULL : xmlGetCharEncodingName(NUM2INT(encoding));
+        standalone = rb_hash_aref(options, sStandalone);
+        if (NIL_P(standalone)) {
+            xstandalone = NULL;
+        } else {
+            xstandalone = RTEST(standalone) ? "yes" : "no";
+        }
+    }
+    rwo = rxml_textwriter_get(self);
+    ret = xmlTextWriterStartDocument(rwo->writer, NULL, xencoding, xstandalone);
+
+    return (-1 == ret ? Qfalse : Qtrue);
+}
+
+/* call-seq:
+ *    writer.end_document -> (true|false)
+ *
+ * Ends current document. Returns +false+ on failure.
+ */
+static VALUE rxml_writer_end_document(VALUE self)
+{
+    return numeric_rxml_writer_void(self, xmlTextWriterEndDocument);
+}
+
+/* call-seq:
+ *    writer.start_pi(target) -> (true|false)
+ *
+ * Starts a new processing instruction. Returns +false+ on failure.
+ */
+static VALUE rxml_writer_start_pi(VALUE self, VALUE target)
+{
+    return numeric_rxml_writer_string(self, target, xmlTextWriterStartPI);
+}
+
+/* call-seq:
+ *    writer.end_pi -> (true|false)
+ *
+ * Ends current processing instruction. Returns +false+ on failure.
+ */
+static VALUE rxml_writer_end_pi(VALUE self)
+{
+    return numeric_rxml_writer_void(self, xmlTextWriterEndPI);
+}
+
+/* call-seq:
+ *    writer.start_dtd(qualifiedName, publicId, systemId) -> (true|false)
+ *
+ * Starts a DTD. Returns +false+ on failure.
+ */
+static VALUE rxml_writer_start_dtd(int argc, VALUE *argv, VALUE self)
+{
+    VALUE name, pubid, sysid;
+
+    rb_scan_args(argc, argv, "12", &name, &pubid, &sysid);
+
+    return numeric_rxml_writer_va_strings(self, Qnil, 3, xmlTextWriterStartDTD, name, pubid, sysid);
+}
+
+/* call-seq:
+ *    writer.start_dtd_element(qualifiedName) -> (true|false)
+ *
+ * Starts a DTD element (<!ELEMENT ... >). Returns +false+ on failure.
+ */
+static VALUE rxml_writer_start_dtd_element(VALUE self, VALUE name)
+{
+    return numeric_rxml_writer_string(self, name, xmlTextWriterStartDTDElement);
+}
+
+/* call-seq:
+ *    writer.start_dtd_entity(name, pe = false) -> (true|false)
+ *
+ * Starts a DTD entity (<!ENTITY ... >). Returns +false+ on failure.
+ */
+static VALUE rxml_writer_start_dtd_entity(int argc, VALUE *argv, VALUE self)
+{
+    VALUE name, pe;
+
+    rb_scan_args(argc, argv, "11", &name, &pe);
+    if (NIL_P(pe)) {
+        pe = Qfalse;
+    }
+
+    return numeric_rxml_writer_va_strings(self, pe, 1, xmlTextWriterStartDTDEntity, name);
+}
+
+/* call-seq:
+ *    writer.start_dtd_attlist(name) -> (true|false)
+ *
+ * Starts a DTD attribute list (<!ATTLIST ... >). Returns +false+ on failure.
+ */
+static VALUE rxml_writer_start_dtd_attlist(VALUE self, VALUE name)
+{
+    return numeric_rxml_writer_string(self, name, xmlTextWriterStartDTDAttlist);
+}
+
+/* call-seq:
+ *    writer.end_dtd -> (true|false)
+ *
+ * Ends current DTD, returns +false+ on failure.
+ */
+static VALUE rxml_writer_end_dtd(VALUE self)
+{
+    return numeric_rxml_writer_void(self, xmlTextWriterEndDTD);
+}
+
+/* call-seq:
+ *    writer.end_dtd_entity -> (true|false)
+ *
+ * Ends current DTD entity, returns +false+ on failure.
+ */
+static VALUE rxml_writer_end_dtd_entity(VALUE self)
+{
+    return numeric_rxml_writer_void(self, xmlTextWriterEndDTDEntity);
+}
+
+/* call-seq:
+ *    writer.end_dtd_attlist -> (true|false)
+ *
+ * Ends current DTD attribute list, returns +false+ on failure.
+ */
+static VALUE rxml_writer_end_dtd_attlist(VALUE self)
+{
+    return numeric_rxml_writer_void(self, xmlTextWriterEndDTDAttlist);
+}
+
+/* call-seq:
+ *    writer.end_dtd_element -> (true|false)
+ *
+ * Ends current DTD element, returns +false+ on failure.
+ */
+static VALUE rxml_writer_end_dtd_element(VALUE self)
+{
+    return numeric_rxml_writer_void(self, xmlTextWriterEndDTDElement);
+}
+
+/* call-seq:
+ *    writer.write_dtd(name [ [ [, publicId ], systemId ], subset ]) -> (true|false)
+ *
+ * Writes a DTD, all at once. Returns +false+ on failure.
+ * - name: dtd name
+ * - publicId: external subset public identifier, use nil for a SYSTEM doctype
+ * - systemId: external subset system identifier
+ * - subset: content
+ *
+ * Examples:
+ *   writer.write_dtd 'html'
+ *     # => <!DOCTYPE html>
+ *   writer.write_dtd 'docbook', nil, 'http://www.docbook.org/xml/5.0/dtd/docbook.dtd'
+ *     # => <!DOCTYPE docbook SYSTEM "http://www.docbook.org/xml/5.0/dtd/docbook.dtd">
+ *   writer.write_dtd 'html', '-//W3C//DTD XHTML 1.1//EN', 'http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd'
+ *     # => <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+ *   writer.write_dtd 'person', nil, nil, '<!ELEMENT person (firstname,lastname)><!ELEMENT firstname (#PCDATA)><!ELEMENT lastname (#PCDATA)>'
+ *     # => <!DOCTYPE person [<!ELEMENT person (firstname,lastname)><!ELEMENT firstname (#PCDATA)><!ELEMENT lastname (#PCDATA)>]>
+ */
+static VALUE rxml_writer_write_dtd(int argc, VALUE *argv, VALUE self)
+{
+    VALUE name, pubid, sysid, subset;
+
+    rb_scan_args(argc, argv, "13", &name, &pubid, &sysid, &subset);
+
+    return numeric_rxml_writer_va_strings(self, Qnil, 4, xmlTextWriterWriteDTD, name, pubid, sysid, subset);
+}
+
+/* call-seq:
+ *    writer.write_dtd_attlist(name, content) -> (true|false)
+ *
+ * Writes a DTD attribute list, all at once. Returns +false+ on failure.
+ *   writer.write_dtd_attlist 'id', 'ID #IMPLIED'
+ *     # => <!ATTLIST id ID #IMPLIED>
+ */
+static VALUE rxml_writer_write_dtd_attlist(VALUE self, VALUE name, VALUE content)
+{
+    return numeric_rxml_writer_va_strings(self, Qnil, 2, xmlTextWriterWriteDTDAttlist, name, content);
+}
+
+/* call-seq:
+ *    writer.write_dtd_element(name, content) -> (true|false)
+ *
+ * Writes a full DTD element, all at once. Returns +false+ on failure.
+ *   writer.write_dtd_element 'person', '(firstname,lastname)'
+ *     # => <!ELEMENT person (firstname,lastname)>
+ */
+static VALUE rxml_writer_write_dtd_element(VALUE self, VALUE name, VALUE content)
+{
+    return numeric_rxml_writer_va_strings(self, Qnil, 2, xmlTextWriterWriteDTDElement, name, content);
+}
+
+/* call-seq:
+ *    writer.write_dtd_entity(name, publicId, systemId, ndataid, content, pe) -> (true|false)
+ *
+ * Writes a DTD entity, all at once. Returns +false+ on failure.
+ */
+static VALUE rxml_writer_write_dtd_entity(VALUE self, VALUE name, VALUE pubid, VALUE sysid, VALUE ndataid, VALUE content, VALUE pe)
+{
+    return numeric_rxml_writer_va_strings(self, pe, 5, xmlTextWriterWriteDTDEntity, name, pubid, sysid, ndataid, content);
+}
+
+/* call-seq:
+ *    writer.write_dtd_external_entity(name, publicId, systemId, ndataid, pe) -> (true|false)
+ *
+ * Writes a DTD external entity. The entity must have been started
+ * with start_dtd_entity. Returns +false+ on failure.
+ * - name: the name of the DTD entity
+ * - publicId: the public identifier, which is an alternative to the system identifier
+ * - systemId: the system identifier, which is the URI of the DTD
+ * - ndataid: the xml notation name
+ * - pe: +true+ if this is a parameter entity (to be used only in the DTD
+ * itself), +false+ if not
+ */
+static VALUE rxml_writer_write_dtd_external_entity(VALUE self, VALUE name, VALUE pubid, VALUE sysid, VALUE ndataid, VALUE pe)
+{
+    return numeric_rxml_writer_va_strings(self, pe, 4, xmlTextWriterWriteDTDExternalEntity, name, pubid, sysid, ndataid);
+}
+
+/* call-seq:
+ *    writer.write_dtd_external_entity_contents(publicId, systemId, ndataid) -> (true|false)
+ *
+ * Writes the contents of a DTD external entity, all at once. Returns +false+ on failure.
+ */
+static VALUE rxml_writer_write_dtd_external_entity_contents(VALUE self, VALUE pubid, VALUE sysid, VALUE ndataid)
+{
+    return numeric_rxml_writer_va_strings(self, Qnil, 3, xmlTextWriterWriteDTDExternalEntityContents, pubid, sysid, ndataid);
+}
+
+/* call-seq:
+ *    writer.write_dtd_internal_entity(name, content, pe) -> (true|false)
+ *
+ * Writes a DTD internal entity, all at once. Returns +false+ on failure.
+ *
+ * Examples:
+ *   writer.write_dtd_entity 'Shape', '(rect|circle|poly|default)', true
+ *     # => <!ENTITY % Shape "(rect|circle|poly|default)">
+ *   writer.write_dtd_entity 'delta', '&#948;', false
+ *     # => <!ENTITY delta "&#948;">
+ */
+static VALUE rxml_writer_write_dtd_internal_entity(VALUE self, VALUE name, VALUE content, VALUE pe)
+{
+    return numeric_rxml_writer_va_strings(self, pe, 2, xmlTextWriterWriteDTDInternalEntity, name, content);
+}
+
+/* call-seq:
+ *    writer.write_dtd_notation(name, publicId, systemId) -> (true|false)
+ *
+ * Writes a DTD entity, all at once. Returns +false+ on failure.
+ */
+static VALUE rxml_writer_write_dtd_notation(VALUE self, VALUE name, VALUE pubid, VALUE sysid)
+{
+    return numeric_rxml_writer_va_strings(self, Qnil, 3, xmlTextWriterWriteDTDNotation, name, pubid, sysid);
+}
+
+# if LIBXML_VERSION >= 20900
+/* call-seq:
+ *    writer.set_quote_char(...) -> (true|false)
+ *
+ * Sets the character used to quote attributes. Returns +false+ on failure.
+ *
+ * Notes:
+ * - only " (default) and ' characters are valid
+ * - availability: libxml2 >= 2.9.0
+ */
+static VALUE rxml_writer_set_quote_char(VALUE self, VALUE quotechar)
+{
+    int ret;
+    const char *xquotechar;
+    rxml_writer_object *rwo;
+
+    rwo = rxml_textwriter_get(self);
+    xquotechar = StringValueCStr(quotechar);
+    ret = xmlTextWriterSetQuoteChar(rwo->writer, (xmlChar) xquotechar[0]);
+
+    return (-1 == ret ? Qfalse : Qtrue);
+}
+# endif /* LIBXML_VERSION >= 20900 */
+
+/* grep -P 'xmlTextWriter(Start|End|Write)(?!DTD|V?Format)[^(]+' /usr/include/libxml2/libxml/xmlwriter.h */
+void rxml_init_writer(void)
+{
+    sEncoding = ID2SYM(rb_intern("encoding"));
+    sStandalone = ID2SYM(rb_intern("standalone"));
+
+    cXMLWriter = rb_define_class_under(mXML, "Writer", rb_cObject);
+
+    rb_define_singleton_method(cXMLWriter, "io", rxml_writer_io, 1);
+    rb_define_singleton_method(cXMLWriter, "file", rxml_writer_file, 1);
+    rb_define_singleton_method(cXMLWriter, "document", rxml_writer_doc, 0);
+    rb_define_singleton_method(cXMLWriter, "string", rxml_writer_string, 0);
+
+    /* misc */
+# if LIBXML_VERSION >= 20605
+    rb_define_method(cXMLWriter, "set_indent", rxml_writer_set_indent, 1);
+    rb_define_method(cXMLWriter, "set_indent_string", rxml_writer_set_indent_string, 1);
+# endif /* LIBXML_VERSION >= 20605 */
+# if LIBXML_VERSION >= 20900
+    rb_define_method(cXMLWriter, "set_quote_char", rxml_writer_set_quote_char, 1);
+# endif  /* LIBXML_VERSION >= 20900 */
+    rb_define_method(cXMLWriter, "flush", rxml_writer_flush, 0);
+    rb_define_method(cXMLWriter, "start_dtd", rxml_writer_start_dtd, -1);
+    rb_define_method(cXMLWriter, "start_dtd_entity", rxml_writer_start_dtd_entity, -1);
+    rb_define_method(cXMLWriter, "start_dtd_attlist", rxml_writer_start_dtd_attlist, 1);
+    rb_define_method(cXMLWriter, "start_dtd_element", rxml_writer_start_dtd_element, 1);
+    rb_define_method(cXMLWriter, "write_dtd", rxml_writer_write_dtd, -1);
+    rb_define_method(cXMLWriter, "write_dtd_attlist", rxml_writer_write_dtd_attlist, 2);
+    rb_define_method(cXMLWriter, "write_dtd_element", rxml_writer_write_dtd_element, 2);
+    rb_define_method(cXMLWriter, "write_dtd_entity", rxml_writer_write_dtd_entity, 6);
+    rb_define_method(cXMLWriter, "write_dtd_external_entity", rxml_writer_write_dtd_external_entity, 5);
+    rb_define_method(cXMLWriter, "write_dtd_external_entity_contents", rxml_writer_write_dtd_external_entity_contents, 3);
+    rb_define_method(cXMLWriter, "write_dtd_internal_entity", rxml_writer_write_dtd_internal_entity, 3);
+    rb_define_method(cXMLWriter, "write_dtd_notation", rxml_writer_write_dtd_notation, 3);
+    rb_define_method(cXMLWriter, "end_dtd", rxml_writer_end_dtd, 0);
+    rb_define_method(cXMLWriter, "end_dtd_entity", rxml_writer_end_dtd_entity, 0);
+    rb_define_method(cXMLWriter, "end_dtd_attlist", rxml_writer_end_dtd_attlist, 0);
+    rb_define_method(cXMLWriter, "end_dtd_element", rxml_writer_end_dtd_element, 0);
+
+    /* tag by parts */
+    rb_define_method(cXMLWriter, "write_raw", rxml_writer_write_raw, 1);
+    rb_define_method(cXMLWriter, "write_string", rxml_writer_write_string, 1);
+
+    rb_define_method(cXMLWriter, "start_cdata", rxml_writer_start_cdata, 0);
+    rb_define_method(cXMLWriter, "end_cdata", rxml_writer_end_cdata, 0);
+    rb_define_method(cXMLWriter, "start_attribute", rxml_writer_start_attribute, 1);
+    rb_define_method(cXMLWriter, "start_attribute_ns", rxml_writer_start_attribute_ns, -1);
+    rb_define_method(cXMLWriter, "end_attribute", rxml_writer_end_attribute, 0);
+    rb_define_method(cXMLWriter, "start_element", rxml_writer_start_element, 1);
+    rb_define_method(cXMLWriter, "start_element_ns", rxml_writer_start_element_ns, -1);
+    rb_define_method(cXMLWriter, "end_element", rxml_writer_end_element, 0);
+    rb_define_method(cXMLWriter, "full_end_element", rxml_writer_full_end_element, 0);
+    rb_define_method(cXMLWriter, "start_document", rxml_writer_start_document, -1);
+    rb_define_method(cXMLWriter, "end_document", rxml_writer_end_document, 0);
+# if LIBXML_VERSION >= 20607
+    rb_define_method(cXMLWriter, "start_comment", rxml_writer_start_comment, 0);
+    rb_define_method(cXMLWriter, "end_comment", rxml_writer_end_comment, 0);
+# endif /* LIBXML_VERSION >= 20607 */
+    rb_define_method(cXMLWriter, "start_pi", rxml_writer_start_pi, 1);
+    rb_define_method(cXMLWriter, "end_pi", rxml_writer_end_pi, 0);
+
+    /* full tag at once */
+    rb_define_method(cXMLWriter, "write_attribute", rxml_writer_write_attribute, 2);
+    rb_define_method(cXMLWriter, "write_attribute_ns", rxml_writer_write_attribute_ns, -1);
+    rb_define_method(cXMLWriter, "write_comment", rxml_writer_write_comment, 1);
+    rb_define_method(cXMLWriter, "write_cdata", rxml_writer_write_cdata, 1);
+    rb_define_method(cXMLWriter, "write_element", rxml_writer_write_element, -1);
+    rb_define_method(cXMLWriter, "write_element_ns", rxml_writer_write_element_ns, -1);
+    rb_define_method(cXMLWriter, "write_pi", rxml_writer_write_pi, 2);
+
+    rb_define_method(cXMLWriter, "result", rxml_writer_result, 0);
+}
+
+#endif /* LIBXML_WRITER_ENABLED */