rsvg2 1.1.5-x86-mingw32 → 1.1.6-x86-mingw32

data/vendor/local/share/doc/libxml2-2.9.0/html/reader3.res

@@ -0,0 +1,13 @@
+<?xml version="1.0"?>
+<doc><parent><preserved/><preserved>
+      content1
+      <child1/>
+      <child2>content2</child2>
+      <preserved>too</preserved>
+      <child2>content3</child2>
+      <preserved/>
+      <child2>content4</child2>
+      <preserved/>
+      <child2>content5</child2>
+      content6
+    </preserved><preserved/><preserved/></parent></doc>

data/vendor/local/share/doc/libxml2-2.9.0/html/reader4.c

@@ -0,0 +1,122 @@
+/**
+ * section: xmlReader
+ * synopsis: Parse multiple XML files reusing an xmlReader
+ * purpose: Demonstrate the use of xmlReaderForFile() and
+ * xmlReaderNewFile to parse XML files while reusing the reader object
+ * and parser context.  (Note that the XMLReader functions require
+ * libxml2 version later than 2.6.)
+ * usage: reader4 <filename> [ filename ... ]
+ * test: reader4 test1.xml test2.xml test3.xml > reader4.tmp && diff reader4.tmp $(srcdir)/reader4.res
+ * author: Graham Bennett
+ * copy: see Copyright for the status of this software.
+ */
+
+#include <stdio.h>
+#include <libxml/xmlreader.h>
+
+#ifdef LIBXML_READER_ENABLED
+
+static void processDoc(xmlTextReaderPtr readerPtr) {
+    int ret;
+    xmlDocPtr docPtr;
+    const xmlChar *URL;
+
+    ret = xmlTextReaderRead(readerPtr);
+    while (ret == 1) {
+      ret = xmlTextReaderRead(readerPtr);
+    }
+
+    /*
+     * One can obtain the document pointer to get insteresting
+     * information about the document like the URL, but one must also
+     * be sure to clean it up at the end (see below).
+     */
+    docPtr = xmlTextReaderCurrentDoc(readerPtr);
+    if (NULL == docPtr) {
+      fprintf(stderr, "failed to obtain document\n");      
+      return;
+    }
+      
+    URL = docPtr->URL;
+    if (NULL == URL) {
+      fprintf(stderr, "Failed to obtain URL\n");      
+    }
+
+    if (ret != 0) {
+      fprintf(stderr, "%s: Failed to parse\n", URL);
+      return;
+    }
+
+    printf("%s: Processed ok\n", (const char *)URL);
+}
+
+int main(int argc, char **argv) {
+    xmlTextReaderPtr readerPtr;
+    int i;
+    xmlDocPtr docPtr;
+
+    if (argc < 2)
+        return(1);
+
+    /*
+     * this initialises the library and check potential ABI mismatches
+     * between the version it was compiled for and the actual shared
+     * library used.
+     */
+    LIBXML_TEST_VERSION
+
+    /*
+     * Create a new reader for the first file and process the
+     * document.
+     */
+    readerPtr = xmlReaderForFile(argv[1], NULL, 0);
+    if (NULL == readerPtr) {
+      fprintf(stderr, "%s: failed to create reader\n", argv[1]);      
+      return(1);
+    }
+    processDoc(readerPtr);
+
+    /*
+     * The reader can be reused for subsequent files.
+     */
+    for (i=2; i < argc; ++i) {
+      	xmlReaderNewFile(readerPtr, argv[i], NULL, 0);
+	if (NULL == readerPtr) {
+	  fprintf(stderr, "%s: failed to create reader\n", argv[i]);      
+	  return(1);
+	}
+        processDoc(readerPtr);
+    }
+
+    /*
+     * Since we've called xmlTextReaderCurrentDoc, we now have to
+     * clean up after ourselves.  We only have to do this the last
+     * time, because xmlReaderNewFile calls xmlCtxtReset which takes
+     * care of it.
+     */
+    docPtr = xmlTextReaderCurrentDoc(readerPtr);
+    if (docPtr != NULL)
+      xmlFreeDoc(docPtr);
+
+    /*
+     * Clean up the reader.
+     */
+    xmlFreeTextReader(readerPtr);
+
+    /*
+     * Cleanup function for the XML library.
+     */
+    xmlCleanupParser();
+    /*
+     * this is to debug memory for regression tests
+     */
+    xmlMemoryDump();
+    return(0);
+}
+
+#else
+int main(void) {
+    fprintf(stderr, "xmlReader support not compiled in\n");
+    exit(1);
+}
+#endif

data/vendor/local/share/doc/libxml2-2.9.0/html/reader4.res

@@ -0,0 +1,3 @@
+test1.xml: Processed ok
+test2.xml: Processed ok
+test3.xml: Processed ok

data/vendor/local/share/doc/libxml2-2.9.0/html/test1.xml

@@ -0,0 +1 @@
+<doc/>

data/vendor/local/share/doc/libxml2-2.9.0/html/test2.xml

@@ -0,0 +1,13 @@
+<!DOCTYPE doc [
+<!ELEMENT doc (src | dest)*>
+<!ELEMENT src EMPTY>
+<!ELEMENT dest EMPTY>
+<!ATTLIST src ref IDREF #IMPLIED>
+<!ATTLIST dest id ID #IMPLIED>
+]>
+<doc>
+  <src ref="foo"/>
+  <dest id="foo"/>
+  <src ref="foo"/>
+</doc>
+

data/vendor/local/share/doc/libxml2-2.9.0/html/test3.xml

@@ -0,0 +1,39 @@
+<doc>
+  <parent>
+    <discarded>
+      <discarded/>
+    </discarded>
+    <preserved/>
+    This text node must be discarded
+    <discarded>
+      <discarded/>
+    </discarded>
+    <preserved>
+      content1
+      <child1></child1>
+      <child2>content2</child2>
+      <preserved>too</preserved>
+      <child2>content3</child2>
+      <preserved></preserved>
+      <child2>content4</child2>
+      <preserved/>
+      <child2>content5</child2>
+      content6
+    </preserved>
+    This text node must be discarded
+    <discarded>
+      <discarded/>
+    </discarded>
+    This text node must be discarded
+    <preserved></preserved>
+    This text node must be discarded
+    <preserved/>
+    This text node must be discarded
+    <discarded>
+      <discarded/>
+    </discarded>
+    This text node must be discarded
+  </parent>
+</doc>
+
+      

data/vendor/local/share/doc/libxml2-2.9.0/html/testWriter.c

@@ -0,0 +1,1198 @@
+/**
+ * section: xmlWriter
+ * synopsis: use various APIs for the xmlWriter
+ * purpose: tests a number of APIs for the xmlWriter, especially
+ *          the various methods to write to a filename, to a memory
+ *          buffer, to a new document, or to a subtree. It shows how to
+ *          do encoding string conversions too. The resulting
+ *          documents are then serialized.
+ * usage: testWriter
+ * test: testWriter && for i in 1 2 3 4 ; do diff $(srcdir)/writer.xml writer$$i.tmp || break ; done
+ * author: Alfred Mickautsch
+ * copy: see Copyright for the status of this software.
+ */
+#include <stdio.h>
+#include <string.h>
+#include <libxml/encoding.h>
+#include <libxml/xmlwriter.h>
+
+#if defined(LIBXML_WRITER_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
+
+#define MY_ENCODING "ISO-8859-1"
+
+void testXmlwriterFilename(const char *uri);
+void testXmlwriterMemory(const char *file);
+void testXmlwriterDoc(const char *file);
+void testXmlwriterTree(const char *file);
+xmlChar *ConvertInput(const char *in, const char *encoding);
+
+int
+main(void)
+{
+    /*
+     * this initialize the library and check potential ABI mismatches
+     * between the version it was compiled for and the actual shared
+     * library used.
+     */
+    LIBXML_TEST_VERSION
+
+    /* first, the file version */
+    testXmlwriterFilename("writer1.tmp");
+
+    /* next, the memory version */
+    testXmlwriterMemory("writer2.tmp");
+
+    /* next, the DOM version */
+    testXmlwriterDoc("writer3.tmp");
+
+    /* next, the tree version */
+    testXmlwriterTree("writer4.tmp");
+
+    /*
+     * Cleanup function for the XML library.
+     */
+    xmlCleanupParser();
+    /*
+     * this is to debug memory for regression tests
+     */
+    xmlMemoryDump();
+    return 0;
+}
+
+/**
+ * testXmlwriterFilename:
+ * @uri: the output URI
+ *
+ * test the xmlWriter interface when writing to a new file
+ */
+void
+testXmlwriterFilename(const char *uri)
+{
+    int rc;
+    xmlTextWriterPtr writer;
+    xmlChar *tmp;
+
+    /* Create a new XmlWriter for uri, with no compression. */
+    writer = xmlNewTextWriterFilename(uri, 0);
+    if (writer == NULL) {
+        printf("testXmlwriterFilename: Error creating the xml writer\n");
+        return;
+    }
+
+    /* Start the document with the xml default for the version,
+     * encoding ISO 8859-1 and the default for the standalone
+     * declaration. */
+    rc = xmlTextWriterStartDocument(writer, NULL, MY_ENCODING, NULL);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterStartDocument\n");
+        return;
+    }
+
+    /* Start an element named "EXAMPLE". Since thist is the first
+     * element, this will be the root element of the document. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "EXAMPLE");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Write a comment as child of EXAMPLE.
+     * Please observe, that the input to the xmlTextWriter functions
+     * HAS to be in UTF-8, even if the output XML is encoded
+     * in iso-8859-1 */
+    tmp = ConvertInput("This is a comment with special chars: <���>",
+                       MY_ENCODING);
+    rc = xmlTextWriterWriteComment(writer, tmp);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterWriteComment\n");
+        return;
+    }
+    if (tmp != NULL) xmlFree(tmp);
+
+    /* Start an element named "ORDER" as child of EXAMPLE. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "ORDER");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Add an attribute with name "version" and value "1.0" to ORDER. */
+    rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "version",
+                                     BAD_CAST "1.0");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterWriteAttribute\n");
+        return;
+    }
+
+    /* Add an attribute with name "xml:lang" and value "de" to ORDER. */
+    rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "xml:lang",
+                                     BAD_CAST "de");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterWriteAttribute\n");
+        return;
+    }
+
+    /* Write a comment as child of ORDER */
+    tmp = ConvertInput("<���>", MY_ENCODING);
+    rc = xmlTextWriterWriteFormatComment(writer,
+		     "This is another comment with special chars: %s",
+		     tmp);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterWriteFormatComment\n");
+        return;
+    }
+    if (tmp != NULL) xmlFree(tmp);
+
+    /* Start an element named "HEADER" as child of ORDER. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "HEADER");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Write an element named "X_ORDER_ID" as child of HEADER. */
+    rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "X_ORDER_ID",
+                                         "%010d", 53535);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterWriteFormatElement\n");
+        return;
+    }
+
+    /* Write an element named "CUSTOMER_ID" as child of HEADER. */
+    rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "CUSTOMER_ID",
+                                         "%d", 1010);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterWriteFormatElement\n");
+        return;
+    }
+
+    /* Write an element named "NAME_1" as child of HEADER. */
+    tmp = ConvertInput("M�ller", MY_ENCODING);
+    rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_1", tmp);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterWriteElement\n");
+        return;
+    }
+    if (tmp != NULL) xmlFree(tmp);
+
+    /* Write an element named "NAME_2" as child of HEADER. */
+    tmp = ConvertInput("J�rg", MY_ENCODING);
+    rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_2", tmp);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterWriteElement\n");
+        return;
+    }
+    if (tmp != NULL) xmlFree(tmp);
+
+    /* Close the element named HEADER. */
+    rc = xmlTextWriterEndElement(writer);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterEndElement\n");
+        return;
+    }
+
+    /* Start an element named "ENTRIES" as child of ORDER. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRIES");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Start an element named "ENTRY" as child of ENTRIES. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Write an element named "ARTICLE" as child of ENTRY. */
+    rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
+                                   BAD_CAST "<Test>");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterWriteElement\n");
+        return;
+    }
+
+    /* Write an element named "ENTRY_NO" as child of ENTRY. */
+    rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
+                                         10);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterWriteFormatElement\n");
+        return;
+    }
+
+    /* Close the element named ENTRY. */
+    rc = xmlTextWriterEndElement(writer);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterEndElement\n");
+        return;
+    }
+
+    /* Start an element named "ENTRY" as child of ENTRIES. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Write an element named "ARTICLE" as child of ENTRY. */
+    rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
+                                   BAD_CAST "<Test 2>");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterWriteElement\n");
+        return;
+    }
+
+    /* Write an element named "ENTRY_NO" as child of ENTRY. */
+    rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
+                                         20);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterWriteFormatElement\n");
+        return;
+    }
+
+    /* Close the element named ENTRY. */
+    rc = xmlTextWriterEndElement(writer);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterEndElement\n");
+        return;
+    }
+
+    /* Close the element named ENTRIES. */
+    rc = xmlTextWriterEndElement(writer);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterEndElement\n");
+        return;
+    }
+
+    /* Start an element named "FOOTER" as child of ORDER. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "FOOTER");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Write an element named "TEXT" as child of FOOTER. */
+    rc = xmlTextWriterWriteElement(writer, BAD_CAST "TEXT",
+                                   BAD_CAST "This is a text.");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterWriteElement\n");
+        return;
+    }
+
+    /* Close the element named FOOTER. */
+    rc = xmlTextWriterEndElement(writer);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterEndElement\n");
+        return;
+    }
+
+    /* Here we could close the elements ORDER and EXAMPLE using the
+     * function xmlTextWriterEndElement, but since we do not want to
+     * write any other elements, we simply call xmlTextWriterEndDocument,
+     * which will do all the work. */
+    rc = xmlTextWriterEndDocument(writer);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterFilename: Error at xmlTextWriterEndDocument\n");
+        return;
+    }
+
+    xmlFreeTextWriter(writer);
+}
+
+/**
+ * testXmlwriterMemory:
+ * @file: the output file
+ *
+ * test the xmlWriter interface when writing to memory
+ */
+void
+testXmlwriterMemory(const char *file)
+{
+    int rc;
+    xmlTextWriterPtr writer;
+    xmlBufferPtr buf;
+    xmlChar *tmp;
+    FILE *fp;
+
+    /* Create a new XML buffer, to which the XML document will be
+     * written */
+    buf = xmlBufferCreate();
+    if (buf == NULL) {
+        printf("testXmlwriterMemory: Error creating the xml buffer\n");
+        return;
+    }
+
+    /* Create a new XmlWriter for memory, with no compression.
+     * Remark: there is no compression for this kind of xmlTextWriter */
+    writer = xmlNewTextWriterMemory(buf, 0);
+    if (writer == NULL) {
+        printf("testXmlwriterMemory: Error creating the xml writer\n");
+        return;
+    }
+
+    /* Start the document with the xml default for the version,
+     * encoding ISO 8859-1 and the default for the standalone
+     * declaration. */
+    rc = xmlTextWriterStartDocument(writer, NULL, MY_ENCODING, NULL);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterMemory: Error at xmlTextWriterStartDocument\n");
+        return;
+    }
+
+    /* Start an element named "EXAMPLE". Since thist is the first
+     * element, this will be the root element of the document. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "EXAMPLE");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterMemory: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Write a comment as child of EXAMPLE.
+     * Please observe, that the input to the xmlTextWriter functions
+     * HAS to be in UTF-8, even if the output XML is encoded
+     * in iso-8859-1 */
+    tmp = ConvertInput("This is a comment with special chars: <���>",
+                       MY_ENCODING);
+    rc = xmlTextWriterWriteComment(writer, tmp);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterMemory: Error at xmlTextWriterWriteComment\n");
+        return;
+    }
+    if (tmp != NULL) xmlFree(tmp);
+
+    /* Start an element named "ORDER" as child of EXAMPLE. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "ORDER");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterMemory: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Add an attribute with name "version" and value "1.0" to ORDER. */
+    rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "version",
+                                     BAD_CAST "1.0");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterMemory: Error at xmlTextWriterWriteAttribute\n");
+        return;
+    }
+
+    /* Add an attribute with name "xml:lang" and value "de" to ORDER. */
+    rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "xml:lang",
+                                     BAD_CAST "de");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterMemory: Error at xmlTextWriterWriteAttribute\n");
+        return;
+    }
+
+    /* Write a comment as child of ORDER */
+    tmp = ConvertInput("<���>", MY_ENCODING);
+    rc = xmlTextWriterWriteFormatComment(writer,
+		     "This is another comment with special chars: %s",
+                                         tmp);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterMemory: Error at xmlTextWriterWriteFormatComment\n");
+        return;
+    }
+    if (tmp != NULL) xmlFree(tmp);
+
+    /* Start an element named "HEADER" as child of ORDER. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "HEADER");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterMemory: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Write an element named "X_ORDER_ID" as child of HEADER. */
+    rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "X_ORDER_ID",
+                                         "%010d", 53535);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterMemory: Error at xmlTextWriterWriteFormatElement\n");
+        return;
+    }
+
+    /* Write an element named "CUSTOMER_ID" as child of HEADER. */
+    rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "CUSTOMER_ID",
+                                         "%d", 1010);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterMemory: Error at xmlTextWriterWriteFormatElement\n");
+        return;
+    }
+
+    /* Write an element named "NAME_1" as child of HEADER. */
+    tmp = ConvertInput("M�ller", MY_ENCODING);
+    rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_1", tmp);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterMemory: Error at xmlTextWriterWriteElement\n");
+        return;
+    }
+    if (tmp != NULL) xmlFree(tmp);
+
+    /* Write an element named "NAME_2" as child of HEADER. */
+    tmp = ConvertInput("J�rg", MY_ENCODING);
+    rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_2", tmp);
+
+    if (rc < 0) {
+        printf
+            ("testXmlwriterMemory: Error at xmlTextWriterWriteElement\n");
+        return;
+    }
+    if (tmp != NULL) xmlFree(tmp);
+
+    /* Close the element named HEADER. */
+    rc = xmlTextWriterEndElement(writer);
+    if (rc < 0) {
+        printf("testXmlwriterMemory: Error at xmlTextWriterEndElement\n");
+        return;
+    }
+
+    /* Start an element named "ENTRIES" as child of ORDER. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRIES");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterMemory: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Start an element named "ENTRY" as child of ENTRIES. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterMemory: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Write an element named "ARTICLE" as child of ENTRY. */
+    rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
+                                   BAD_CAST "<Test>");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterMemory: Error at xmlTextWriterWriteElement\n");
+        return;
+    }
+
+    /* Write an element named "ENTRY_NO" as child of ENTRY. */
+    rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
+                                         10);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterMemory: Error at xmlTextWriterWriteFormatElement\n");
+        return;
+    }
+
+    /* Close the element named ENTRY. */
+    rc = xmlTextWriterEndElement(writer);
+    if (rc < 0) {
+        printf("testXmlwriterMemory: Error at xmlTextWriterEndElement\n");
+        return;
+    }
+
+    /* Start an element named "ENTRY" as child of ENTRIES. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterMemory: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Write an element named "ARTICLE" as child of ENTRY. */
+    rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
+                                   BAD_CAST "<Test 2>");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterMemory: Error at xmlTextWriterWriteElement\n");
+        return;
+    }
+
+    /* Write an element named "ENTRY_NO" as child of ENTRY. */
+    rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
+                                         20);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterMemory: Error at xmlTextWriterWriteFormatElement\n");
+        return;
+    }
+
+    /* Close the element named ENTRY. */
+    rc = xmlTextWriterEndElement(writer);
+    if (rc < 0) {
+        printf("testXmlwriterMemory: Error at xmlTextWriterEndElement\n");
+        return;
+    }
+
+    /* Close the element named ENTRIES. */
+    rc = xmlTextWriterEndElement(writer);
+    if (rc < 0) {
+        printf("testXmlwriterMemory: Error at xmlTextWriterEndElement\n");
+        return;
+    }
+
+    /* Start an element named "FOOTER" as child of ORDER. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "FOOTER");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterMemory: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Write an element named "TEXT" as child of FOOTER. */
+    rc = xmlTextWriterWriteElement(writer, BAD_CAST "TEXT",
+                                   BAD_CAST "This is a text.");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterMemory: Error at xmlTextWriterWriteElement\n");
+        return;
+    }
+
+    /* Close the element named FOOTER. */
+    rc = xmlTextWriterEndElement(writer);
+    if (rc < 0) {
+        printf("testXmlwriterMemory: Error at xmlTextWriterEndElement\n");
+        return;
+    }
+
+    /* Here we could close the elements ORDER and EXAMPLE using the
+     * function xmlTextWriterEndElement, but since we do not want to
+     * write any other elements, we simply call xmlTextWriterEndDocument,
+     * which will do all the work. */
+    rc = xmlTextWriterEndDocument(writer);
+    if (rc < 0) {
+        printf("testXmlwriterMemory: Error at xmlTextWriterEndDocument\n");
+        return;
+    }
+
+    xmlFreeTextWriter(writer);
+
+    fp = fopen(file, "w");
+    if (fp == NULL) {
+        printf("testXmlwriterMemory: Error at fopen\n");
+        return;
+    }
+
+    fprintf(fp, "%s", (const char *) buf->content);
+
+    fclose(fp);
+
+    xmlBufferFree(buf);
+}
+
+/**
+ * testXmlwriterDoc:
+ * @file: the output file
+ *
+ * test the xmlWriter interface when creating a new document
+ */
+void
+testXmlwriterDoc(const char *file)
+{
+    int rc;
+    xmlTextWriterPtr writer;
+    xmlChar *tmp;
+    xmlDocPtr doc;
+
+
+    /* Create a new XmlWriter for DOM, with no compression. */
+    writer = xmlNewTextWriterDoc(&doc, 0);
+    if (writer == NULL) {
+        printf("testXmlwriterDoc: Error creating the xml writer\n");
+        return;
+    }
+
+    /* Start the document with the xml default for the version,
+     * encoding ISO 8859-1 and the default for the standalone
+     * declaration. */
+    rc = xmlTextWriterStartDocument(writer, NULL, MY_ENCODING, NULL);
+    if (rc < 0) {
+        printf("testXmlwriterDoc: Error at xmlTextWriterStartDocument\n");
+        return;
+    }
+
+    /* Start an element named "EXAMPLE". Since thist is the first
+     * element, this will be the root element of the document. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "EXAMPLE");
+    if (rc < 0) {
+        printf("testXmlwriterDoc: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Write a comment as child of EXAMPLE.
+     * Please observe, that the input to the xmlTextWriter functions
+     * HAS to be in UTF-8, even if the output XML is encoded
+     * in iso-8859-1 */
+    tmp = ConvertInput("This is a comment with special chars: <���>",
+                       MY_ENCODING);
+    rc = xmlTextWriterWriteComment(writer, tmp);
+    if (rc < 0) {
+        printf("testXmlwriterDoc: Error at xmlTextWriterWriteComment\n");
+        return;
+    }
+    if (tmp != NULL) xmlFree(tmp);
+
+    /* Start an element named "ORDER" as child of EXAMPLE. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "ORDER");
+    if (rc < 0) {
+        printf("testXmlwriterDoc: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Add an attribute with name "version" and value "1.0" to ORDER. */
+    rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "version",
+                                     BAD_CAST "1.0");
+    if (rc < 0) {
+        printf("testXmlwriterDoc: Error at xmlTextWriterWriteAttribute\n");
+        return;
+    }
+
+    /* Add an attribute with name "xml:lang" and value "de" to ORDER. */
+    rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "xml:lang",
+                                     BAD_CAST "de");
+    if (rc < 0) {
+        printf("testXmlwriterDoc: Error at xmlTextWriterWriteAttribute\n");
+        return;
+    }
+
+    /* Write a comment as child of ORDER */
+    tmp = ConvertInput("<���>", MY_ENCODING);
+    rc = xmlTextWriterWriteFormatComment(writer,
+		 "This is another comment with special chars: %s",
+		                         tmp);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterDoc: Error at xmlTextWriterWriteFormatComment\n");
+        return;
+    }
+    if (tmp != NULL) xmlFree(tmp);
+
+    /* Start an element named "HEADER" as child of ORDER. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "HEADER");
+    if (rc < 0) {
+        printf("testXmlwriterDoc: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Write an element named "X_ORDER_ID" as child of HEADER. */
+    rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "X_ORDER_ID",
+                                         "%010d", 53535);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterDoc: Error at xmlTextWriterWriteFormatElement\n");
+        return;
+    }
+
+    /* Write an element named "CUSTOMER_ID" as child of HEADER. */
+    rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "CUSTOMER_ID",
+                                         "%d", 1010);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterDoc: Error at xmlTextWriterWriteFormatElement\n");
+        return;
+    }
+
+    /* Write an element named "NAME_1" as child of HEADER. */
+    tmp = ConvertInput("M�ller", MY_ENCODING);
+    rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_1", tmp);
+    if (rc < 0) {
+        printf("testXmlwriterDoc: Error at xmlTextWriterWriteElement\n");
+        return;
+    }
+    if (tmp != NULL) xmlFree(tmp);
+
+    /* Write an element named "NAME_2" as child of HEADER. */
+    tmp = ConvertInput("J�rg", MY_ENCODING);
+    rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_2", tmp);
+    if (rc < 0) {
+        printf("testXmlwriterDoc: Error at xmlTextWriterWriteElement\n");
+        return;
+    }
+    if (tmp != NULL) xmlFree(tmp);
+
+    /* Close the element named HEADER. */
+    rc = xmlTextWriterEndElement(writer);
+    if (rc < 0) {
+        printf("testXmlwriterDoc: Error at xmlTextWriterEndElement\n");
+        return;
+    }
+
+    /* Start an element named "ENTRIES" as child of ORDER. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRIES");
+    if (rc < 0) {
+        printf("testXmlwriterDoc: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Start an element named "ENTRY" as child of ENTRIES. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
+    if (rc < 0) {
+        printf("testXmlwriterDoc: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Write an element named "ARTICLE" as child of ENTRY. */
+    rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
+                                   BAD_CAST "<Test>");
+    if (rc < 0) {
+        printf("testXmlwriterDoc: Error at xmlTextWriterWriteElement\n");
+        return;
+    }
+
+    /* Write an element named "ENTRY_NO" as child of ENTRY. */
+    rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
+                                         10);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterDoc: Error at xmlTextWriterWriteFormatElement\n");
+        return;
+    }
+
+    /* Close the element named ENTRY. */
+    rc = xmlTextWriterEndElement(writer);
+    if (rc < 0) {
+        printf("testXmlwriterDoc: Error at xmlTextWriterEndElement\n");
+        return;
+    }
+
+    /* Start an element named "ENTRY" as child of ENTRIES. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
+    if (rc < 0) {
+        printf("testXmlwriterDoc: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Write an element named "ARTICLE" as child of ENTRY. */
+    rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
+                                   BAD_CAST "<Test 2>");
+    if (rc < 0) {
+        printf("testXmlwriterDoc: Error at xmlTextWriterWriteElement\n");
+        return;
+    }
+
+    /* Write an element named "ENTRY_NO" as child of ENTRY. */
+    rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
+                                         20);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterDoc: Error at xmlTextWriterWriteFormatElement\n");
+        return;
+    }
+
+    /* Close the element named ENTRY. */
+    rc = xmlTextWriterEndElement(writer);
+    if (rc < 0) {
+        printf("testXmlwriterDoc: Error at xmlTextWriterEndElement\n");
+        return;
+    }
+
+    /* Close the element named ENTRIES. */
+    rc = xmlTextWriterEndElement(writer);
+    if (rc < 0) {
+        printf("testXmlwriterDoc: Error at xmlTextWriterEndElement\n");
+        return;
+    }
+
+    /* Start an element named "FOOTER" as child of ORDER. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "FOOTER");
+    if (rc < 0) {
+        printf("testXmlwriterDoc: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Write an element named "TEXT" as child of FOOTER. */
+    rc = xmlTextWriterWriteElement(writer, BAD_CAST "TEXT",
+                                   BAD_CAST "This is a text.");
+    if (rc < 0) {
+        printf("testXmlwriterDoc: Error at xmlTextWriterWriteElement\n");
+        return;
+    }
+
+    /* Close the element named FOOTER. */
+    rc = xmlTextWriterEndElement(writer);
+    if (rc < 0) {
+        printf("testXmlwriterDoc: Error at xmlTextWriterEndElement\n");
+        return;
+    }
+
+    /* Here we could close the elements ORDER and EXAMPLE using the
+     * function xmlTextWriterEndElement, but since we do not want to
+     * write any other elements, we simply call xmlTextWriterEndDocument,
+     * which will do all the work. */
+    rc = xmlTextWriterEndDocument(writer);
+    if (rc < 0) {
+        printf("testXmlwriterDoc: Error at xmlTextWriterEndDocument\n");
+        return;
+    }
+
+    xmlFreeTextWriter(writer);
+
+    xmlSaveFileEnc(file, doc, MY_ENCODING);
+
+    xmlFreeDoc(doc);
+}
+
+/**
+ * testXmlwriterTree:
+ * @file: the output file
+ *
+ * test the xmlWriter interface when writing to a subtree
+ */
+void
+testXmlwriterTree(const char *file)
+{
+    int rc;
+    xmlTextWriterPtr writer;
+    xmlDocPtr doc;
+    xmlNodePtr node;
+    xmlChar *tmp;
+
+    /* Create a new XML DOM tree, to which the XML document will be
+     * written */
+    doc = xmlNewDoc(BAD_CAST XML_DEFAULT_VERSION);
+    if (doc == NULL) {
+        printf
+            ("testXmlwriterTree: Error creating the xml document tree\n");
+        return;
+    }
+
+    /* Create a new XML node, to which the XML document will be
+     * appended */
+    node = xmlNewDocNode(doc, NULL, BAD_CAST "EXAMPLE", NULL);
+    if (node == NULL) {
+        printf("testXmlwriterTree: Error creating the xml node\n");
+        return;
+    }
+
+    /* Make ELEMENT the root node of the tree */
+    xmlDocSetRootElement(doc, node);
+
+    /* Create a new XmlWriter for DOM tree, with no compression. */
+    writer = xmlNewTextWriterTree(doc, node, 0);
+    if (writer == NULL) {
+        printf("testXmlwriterTree: Error creating the xml writer\n");
+        return;
+    }
+
+    /* Start the document with the xml default for the version,
+     * encoding ISO 8859-1 and the default for the standalone
+     * declaration. */
+    rc = xmlTextWriterStartDocument(writer, NULL, MY_ENCODING, NULL);
+    if (rc < 0) {
+        printf("testXmlwriterTree: Error at xmlTextWriterStartDocument\n");
+        return;
+    }
+
+    /* Write a comment as child of EXAMPLE.
+     * Please observe, that the input to the xmlTextWriter functions
+     * HAS to be in UTF-8, even if the output XML is encoded
+     * in iso-8859-1 */
+    tmp = ConvertInput("This is a comment with special chars: <���>",
+                       MY_ENCODING);
+    rc = xmlTextWriterWriteComment(writer, tmp);
+    if (rc < 0) {
+        printf("testXmlwriterTree: Error at xmlTextWriterWriteComment\n");
+        return;
+    }
+    if (tmp != NULL) xmlFree(tmp);
+
+    /* Start an element named "ORDER" as child of EXAMPLE. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "ORDER");
+    if (rc < 0) {
+        printf("testXmlwriterTree: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Add an attribute with name "version" and value "1.0" to ORDER. */
+    rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "version",
+                                     BAD_CAST "1.0");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterTree: Error at xmlTextWriterWriteAttribute\n");
+        return;
+    }
+
+    /* Add an attribute with name "xml:lang" and value "de" to ORDER. */
+    rc = xmlTextWriterWriteAttribute(writer, BAD_CAST "xml:lang",
+                                     BAD_CAST "de");
+    if (rc < 0) {
+        printf
+            ("testXmlwriterTree: Error at xmlTextWriterWriteAttribute\n");
+        return;
+    }
+
+    /* Write a comment as child of ORDER */
+    tmp = ConvertInput("<���>", MY_ENCODING);
+    rc = xmlTextWriterWriteFormatComment(writer,
+			 "This is another comment with special chars: %s",
+					  tmp);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterTree: Error at xmlTextWriterWriteFormatComment\n");
+        return;
+    }
+    if (tmp != NULL) xmlFree(tmp);
+
+    /* Start an element named "HEADER" as child of ORDER. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "HEADER");
+    if (rc < 0) {
+        printf("testXmlwriterTree: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Write an element named "X_ORDER_ID" as child of HEADER. */
+    rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "X_ORDER_ID",
+                                         "%010d", 53535);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterTree: Error at xmlTextWriterWriteFormatElement\n");
+        return;
+    }
+
+    /* Write an element named "CUSTOMER_ID" as child of HEADER. */
+    rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "CUSTOMER_ID",
+                                         "%d", 1010);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterTree: Error at xmlTextWriterWriteFormatElement\n");
+        return;
+    }
+
+    /* Write an element named "NAME_1" as child of HEADER. */
+    tmp = ConvertInput("M�ller", MY_ENCODING);
+    rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_1", tmp);
+    if (rc < 0) {
+        printf("testXmlwriterTree: Error at xmlTextWriterWriteElement\n");
+        return;
+    }
+    if (tmp != NULL) xmlFree(tmp);
+
+    /* Write an element named "NAME_2" as child of HEADER. */
+    tmp = ConvertInput("J�rg", MY_ENCODING);
+    rc = xmlTextWriterWriteElement(writer, BAD_CAST "NAME_2", tmp);
+    if (rc < 0) {
+        printf("testXmlwriterTree: Error at xmlTextWriterWriteElement\n");
+        return;
+    }
+    if (tmp != NULL) xmlFree(tmp);
+
+    /* Close the element named HEADER. */
+    rc = xmlTextWriterEndElement(writer);
+    if (rc < 0) {
+        printf("testXmlwriterTree: Error at xmlTextWriterEndElement\n");
+        return;
+    }
+
+    /* Start an element named "ENTRIES" as child of ORDER. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRIES");
+    if (rc < 0) {
+        printf("testXmlwriterTree: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Start an element named "ENTRY" as child of ENTRIES. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
+    if (rc < 0) {
+        printf("testXmlwriterTree: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Write an element named "ARTICLE" as child of ENTRY. */
+    rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
+                                   BAD_CAST "<Test>");
+    if (rc < 0) {
+        printf("testXmlwriterTree: Error at xmlTextWriterWriteElement\n");
+        return;
+    }
+
+    /* Write an element named "ENTRY_NO" as child of ENTRY. */
+    rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
+                                         10);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterTree: Error at xmlTextWriterWriteFormatElement\n");
+        return;
+    }
+
+    /* Close the element named ENTRY. */
+    rc = xmlTextWriterEndElement(writer);
+    if (rc < 0) {
+        printf("testXmlwriterTree: Error at xmlTextWriterEndElement\n");
+        return;
+    }
+
+    /* Start an element named "ENTRY" as child of ENTRIES. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "ENTRY");
+    if (rc < 0) {
+        printf("testXmlwriterTree: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Write an element named "ARTICLE" as child of ENTRY. */
+    rc = xmlTextWriterWriteElement(writer, BAD_CAST "ARTICLE",
+                                   BAD_CAST "<Test 2>");
+    if (rc < 0) {
+        printf("testXmlwriterTree: Error at xmlTextWriterWriteElement\n");
+        return;
+    }
+
+    /* Write an element named "ENTRY_NO" as child of ENTRY. */
+    rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "ENTRY_NO", "%d",
+                                         20);
+    if (rc < 0) {
+        printf
+            ("testXmlwriterTree: Error at xmlTextWriterWriteFormatElement\n");
+        return;
+    }
+
+    /* Close the element named ENTRY. */
+    rc = xmlTextWriterEndElement(writer);
+    if (rc < 0) {
+        printf("testXmlwriterTree: Error at xmlTextWriterEndElement\n");
+        return;
+    }
+
+    /* Close the element named ENTRIES. */
+    rc = xmlTextWriterEndElement(writer);
+    if (rc < 0) {
+        printf("testXmlwriterTree: Error at xmlTextWriterEndElement\n");
+        return;
+    }
+
+    /* Start an element named "FOOTER" as child of ORDER. */
+    rc = xmlTextWriterStartElement(writer, BAD_CAST "FOOTER");
+    if (rc < 0) {
+        printf("testXmlwriterTree: Error at xmlTextWriterStartElement\n");
+        return;
+    }
+
+    /* Write an element named "TEXT" as child of FOOTER. */
+    rc = xmlTextWriterWriteElement(writer, BAD_CAST "TEXT",
+                                   BAD_CAST "This is a text.");
+    if (rc < 0) {
+        printf("testXmlwriterTree: Error at xmlTextWriterWriteElement\n");
+        return;
+    }
+
+    /* Close the element named FOOTER. */
+    rc = xmlTextWriterEndElement(writer);
+    if (rc < 0) {
+        printf("testXmlwriterTree: Error at xmlTextWriterEndElement\n");
+        return;
+    }
+
+    /* Here we could close the elements ORDER and EXAMPLE using the
+     * function xmlTextWriterEndElement, but since we do not want to
+     * write any other elements, we simply call xmlTextWriterEndDocument,
+     * which will do all the work. */
+    rc = xmlTextWriterEndDocument(writer);
+    if (rc < 0) {
+        printf("testXmlwriterTree: Error at xmlTextWriterEndDocument\n");
+        return;
+    }
+
+    xmlFreeTextWriter(writer);
+
+    xmlSaveFileEnc(file, doc, MY_ENCODING);
+
+    xmlFreeDoc(doc);
+}
+
+/**
+ * ConvertInput:
+ * @in: string in a given encoding
+ * @encoding: the encoding used
+ *
+ * Converts @in into UTF-8 for processing with libxml2 APIs
+ *
+ * Returns the converted UTF-8 string, or NULL in case of error.
+ */
+xmlChar *
+ConvertInput(const char *in, const char *encoding)
+{
+    xmlChar *out;
+    int ret;
+    int size;
+    int out_size;
+    int temp;
+    xmlCharEncodingHandlerPtr handler;
+
+    if (in == 0)
+        return 0;
+
+    handler = xmlFindCharEncodingHandler(encoding);
+
+    if (!handler) {
+        printf("ConvertInput: no encoding handler found for '%s'\n",
+               encoding ? encoding : "");
+        return 0;
+    }
+
+    size = (int) strlen(in) + 1;
+    out_size = size * 2 - 1;
+    out = (unsigned char *) xmlMalloc((size_t) out_size);
+
+    if (out != 0) {
+        temp = size - 1;
+        ret = handler->input(out, &out_size, (const xmlChar *) in, &temp);
+        if ((ret < 0) || (temp - size + 1)) {
+            if (ret < 0) {
+                printf("ConvertInput: conversion wasn't successful.\n");
+            } else {
+                printf
+                    ("ConvertInput: conversion wasn't successful. converted: %i octets.\n",
+                     temp);
+            }
+
+            xmlFree(out);
+            out = 0;
+        } else {
+            out = (unsigned char *) xmlRealloc(out, out_size + 1);
+            out[out_size] = 0;  /*null terminating out */
+        }
+    } else {
+        printf("ConvertInput: no mem\n");
+    }
+
+    return out;
+}
+
+#else
+int main(void) {
+    fprintf(stderr, "Writer or output support not compiled in\n");
+    exit(1);
+}
+#endif