xmlwriter.c

/*
 * xmlwriter.c: XML text writer implementation
 *
 * For license and disclaimer see the license and disclaimer of
 * libxml2.
 *
 * Author: Alfred Mickautsch
 */

#define IN_LIBXML
#include "libxml.h"

#include <string.h>

#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include <libxml/parserInternals.h>
#include <libxml/uri.h>
#include <libxml/HTMLtree.h>
#include <libxml/SAX2.h>

#ifdef LIBXML_WRITER_ENABLED

#include <libxml/xmlwriter.h>

#include "private/buf.h"
#include "private/enc.h"
#include "private/error.h"
#include "private/io.h"
#include "private/memory.h"
#include "private/save.h"
#include "private/string.h"

#define B64LINELEN 72
#define B64CRLF "\r\n"

#ifndef va_copy
  #ifdef __va_copy
    #define va_copy(dest, src) __va_copy(dest, src)
  #else
    #define va_copy(dest, src) memcpy(&(dest), &(src), sizeof(va_list))
  #endif
#endif

/*
 * Types are kept private
 */
typedef enum {
    XML_TEXTWRITER_NONE = 0,
    XML_TEXTWRITER_NAME,
    XML_TEXTWRITER_ATTRIBUTE,
    XML_TEXTWRITER_TEXT,
    XML_TEXTWRITER_PI,
    XML_TEXTWRITER_PI_TEXT,
    XML_TEXTWRITER_CDATA,
    XML_TEXTWRITER_DTD,
    XML_TEXTWRITER_DTD_TEXT,
    XML_TEXTWRITER_DTD_ELEM,
    XML_TEXTWRITER_DTD_ELEM_TEXT,
    XML_TEXTWRITER_DTD_ATTL,
    XML_TEXTWRITER_DTD_ATTL_TEXT,
    XML_TEXTWRITER_DTD_ENTY,    /* entity */
    XML_TEXTWRITER_DTD_ENTY_TEXT,
    XML_TEXTWRITER_DTD_PENT,    /* parameter entity */
    XML_TEXTWRITER_COMMENT
} xmlTextWriterState;

typedef struct _xmlTextWriterStackEntry xmlTextWriterStackEntry;

struct _xmlTextWriterStackEntry {
    xmlChar *name;
    xmlTextWriterState state;
};

typedef struct _xmlTextWriterNsStackEntry xmlTextWriterNsStackEntry;
struct _xmlTextWriterNsStackEntry {
    xmlChar *prefix;
    xmlChar *uri;
};

struct _xmlTextWriter {
    xmlOutputBufferPtr out;     /* output buffer */
    xmlTextWriterStackEntry *nodes;     /* element name stack */
    int nodesMax;
    int nodesNr;
    xmlTextWriterNsStackEntry *nsstack; /* name spaces stack */
    int nsstackMax;
    int nsstackNr;
    int indent;                 /* enable indent */
    int doindent;               /* internal indent flag */
    xmlChar *ichar;             /* indent character */
    char qchar;                 /* character used for quoting attribute values */
    xmlParserCtxtPtr ctxt;
    int no_doc_free;
    xmlParserErrors errNo;
};

static void xmlTextWriterOutputNSDecl(xmlTextWriterPtr writer);
static xmlSize xmlTextWriterWriteDocCallback(void *context,
                                             const char *str, xmlSize len);
static int xmlTextWriterCloseDocCallback(void *context);

static xmlChar *xmlTextWriterVSprintf(xmlTextWriter *writer,
                                      const char *format,
                                      va_list argptr) LIBXML_ATTR_FORMAT(2,0);
static void xmlOutputBufferWriteBase64(xmlOutputBufferPtr out, xmlSize len,
                                       const unsigned char *data);
static void xmlTextWriterWriteIndent(xmlTextWriterPtr writer);
static void
  xmlTextWriterHandleStateDependencies(xmlTextWriterPtr writer,
                                       xmlTextWriterStackEntry * p);

/**
 * Handle a writer error
 *
 * @param writer  a writer context
 * @param error  the error number
 */
static void
xmlWriterErr(xmlTextWriter *writer, xmlParserErrors error)
{
    if (writer == NULL)
        return;

    if (!xmlIsCatastrophicError(XML_ERR_FATAL, writer->errNo) ||
        writer->errNo == XML_ERR_ARGUMENT)
        writer->errNo = error;
}

/**
 * Create a new xmlTextWriter structure using an xmlOutputBuffer
 * NOTE: the `out` parameter will be deallocated when the writer is closed
 *       (if the call succeed.)
 *
 * @param out  an xmlOutputBuffer
 * @returns the new xmlTextWriter or NULL in case of error
 */
xmlTextWriter *
xmlNewTextWriter(xmlOutputBuffer *out)
{
    xmlTextWriterPtr ret;

    ret = (xmlTextWriterPtr) xmlMalloc(sizeof(xmlTextWriter));
    if (ret == NULL)
        return NULL;
    memset(ret, 0, sizeof(xmlTextWriter));

    ret->out = out;
    ret->ichar = xmlStrdup(BAD_CAST " ");
    ret->qchar = '"';

    if (!ret->ichar) {
        xmlFree(ret);
        return NULL;
    }

    ret->no_doc_free = 0;

    return ret;
}

/**
 * Create a new xmlTextWriter structure with `uri` as output
 *
 * @param uri  the URI of the resource for the output
 * @param compression  compress the output?
 * @returns the new xmlTextWriter or NULL in case of error
 */
xmlTextWriter *
xmlNewTextWriterFilename(const char *uri, int compression)
{
    xmlTextWriterPtr ret;
    xmlOutputBufferPtr out;

    out = xmlOutputBufferCreateFilename(uri, NULL, compression);
    if (out == NULL)
        return NULL;

    ret = xmlNewTextWriter(out);
    if (ret == NULL) {
        xmlOutputBufferClose(out);
        return NULL;
    }

    ret->indent = 0;
    ret->doindent = 0;
    return ret;
}

/**
 * Create a new xmlTextWriter structure with `buf` as output
 * TODO: handle compression
 *
 * @param buf  xmlBuffer
 * @param compression  compress the output?
 * @returns the new xmlTextWriter or NULL in case of error
 */
xmlTextWriter *
xmlNewTextWriterMemory(xmlBuffer *buf, int compression ATTRIBUTE_UNUSED)
{
    xmlTextWriterPtr ret;
    xmlOutputBufferPtr out;

/*::todo handle compression */
    out = xmlOutputBufferCreateBuffer(buf, NULL);

    if (out == NULL)
        return NULL;

    ret = xmlNewTextWriter(out);
    if (ret == NULL) {
        xmlOutputBufferClose(out);
        return NULL;
    }

    return ret;
}

/**
 * Create a new xmlTextWriter structure with `ctxt` as output
 * NOTE: the `ctxt` context will be freed with the resulting writer
 *       (if the call succeeds).
 * TODO: handle compression
 *
 * @deprecated Internal function, don't use.
 *
 * @param ctxt  xmlParserCtxt to hold the new XML document tree
 * @param compression  compress the output?
 * @returns the new xmlTextWriter or NULL in case of error
 */
xmlTextWriter *
xmlNewTextWriterPushParser(xmlParserCtxt *ctxt,
                           int compression ATTRIBUTE_UNUSED)
{
    xmlTextWriterPtr ret;
    xmlOutputBufferPtr out;

    if (ctxt == NULL)
        return NULL;

    out = xmlOutputBufferCreateIO(xmlTextWriterWriteDocCallback,
                                  xmlTextWriterCloseDocCallback,
                                  (void *) ctxt, NULL);
    if (out == NULL)
        return NULL;

    ret = xmlNewTextWriter(out);
    if (ret == NULL) {
        xmlOutputBufferClose(out);
        return NULL;
    }

    ret->ctxt = ctxt;

    return ret;
}

/**
 * Create a new xmlTextWriter structure with `doc` as output
 *
 * @param doc  address of a xmlDoc to hold the new XML document tree
 * @param compression  compress the output?
 * @returns the new xmlTextWriter or NULL in case of error
 */
xmlTextWriter *
xmlNewTextWriterDoc(xmlDoc ** doc, int compression)
{
    xmlTextWriterPtr ret;
    xmlParserCtxtPtr ctxt;

    ctxt = xmlCreatePushParserCtxt(NULL, NULL, NULL, 0, NULL);
    if (ctxt == NULL)
        return NULL;
    /*
     * For some reason this seems to completely break if node names
     * are interned.
     */
    xmlCtxtSetOptions(ctxt, XML_PARSE_NODICT | XML_PARSE_NOERROR);

    ctxt->myDoc = xmlNewDoc(BAD_CAST XML_DEFAULT_VERSION);
    if (ctxt->myDoc == NULL) {
        xmlFreeParserCtxt(ctxt);
        return NULL;
    }

    ret = xmlNewTextWriterPushParser(ctxt, compression);
    if (ret == NULL) {
        xmlFreeDoc(ctxt->myDoc);
        xmlFreeParserCtxt(ctxt);
        return NULL;
    }

    xmlSetDocCompressMode(ctxt->myDoc, compression);

    if (doc != NULL) {
        *doc = ctxt->myDoc;
	ret->no_doc_free = 1;
    }

    return ret;
}

/**
 * Create a new xmlTextWriter structure with `doc` as output
 * starting at `node`
 *
 * @param doc  xmlDoc
 * @param node  xmlNode or NULL for doc->children
 * @param compression  compress the output?
 * @returns the new xmlTextWriter or NULL in case of error
 */
xmlTextWriter *
xmlNewTextWriterTree(xmlDoc *doc, xmlNode *node, int compression)
{
    xmlTextWriterPtr ret;
    xmlParserCtxtPtr ctxt;

    if (doc == NULL)
        return NULL;

    ctxt = xmlCreatePushParserCtxt(NULL, NULL, NULL, 0, NULL);
    if (ctxt == NULL)
        return NULL;
    /*
     * For some reason this seems to completely break if node names
     * are interned.
     */
    xmlCtxtSetOptions(ctxt, XML_PARSE_NODICT | XML_PARSE_NOERROR);

    ret = xmlNewTextWriterPushParser(ctxt, compression);
    if (ret == NULL) {
        xmlFreeParserCtxt(ctxt);
        return NULL;
    }

    ctxt->myDoc = doc;
    ctxt->node = node;
    ret->no_doc_free = 1;

    xmlSetDocCompressMode(doc, compression);

    return ret;
}

static xmlTextWriterStackEntry *
xmlWriterPushNode(xmlTextWriter *writer, const xmlChar *name,
                  xmlTextWriterState state) {
    xmlTextWriterStackEntry *p;

    if (writer->nodesNr >= writer->nodesMax) {
        int newSize;
        xmlTextWriterStackEntry *tmp;

        newSize = xmlGrowCapacity(writer->nodesMax, sizeof(tmp[0]),
                                  10, XML_MAX_ITEMS);
        if (newSize < 0) {
            xmlWriterErr(writer, XML_ERR_RESOURCE_LIMIT);
            return NULL;
        }
        tmp = xmlRealloc(writer->nodes, newSize * sizeof(tmp[0]));
        if (tmp == NULL)
            goto err_memory;
        writer->nodes = tmp;
        writer->nodesMax = newSize;
    }

    p = &writer->nodes[writer->nodesNr];

    if (name == NULL) {
        p->name = NULL;
    } else {
        p->name = xmlStrdup(name);
        if (p->name == NULL)
            goto err_memory;
    }

    p->state = state;

    writer->nodesNr++;
    return p;

err_memory:
    xmlWriterErr(writer, XML_ERR_NO_MEMORY);
    return NULL;
}

static void
xmlWriterPopNode(xmlTextWriter *writer) {
    writer->nodesNr -= 1;
    xmlFree(writer->nodes[writer->nodesNr].name);
}

static xmlTextWriterNsStackEntry *
xmlWriterPushNs(xmlTextWriter *writer, const xmlChar *prefix,
                const xmlChar *uri) {
    xmlTextWriterNsStackEntry *p;

    if (writer->nsstackNr >= writer->nsstackMax) {
        int newSize;
        xmlTextWriterNsStackEntry *tmp;

        newSize = xmlGrowCapacity(writer->nsstackMax, sizeof(tmp[0]),
                                  10, XML_MAX_ITEMS);
        if (newSize < 0) {
            xmlWriterErr(writer, XML_ERR_RESOURCE_LIMIT);
            return NULL;
        }
        tmp = xmlRealloc(writer->nsstack, newSize * sizeof(tmp[0]));
        if (tmp == NULL)
            goto err_memory;
        writer->nsstack = tmp;
        writer->nsstackMax = newSize;
    }

    p = &writer->nsstack[writer->nsstackNr];

    if (prefix == NULL) {
        p->prefix = NULL;
    } else {
        p->prefix = xmlStrdup(prefix);
        if (p->prefix == NULL)
            goto err_memory;
    }

    p->uri = xmlStrdup(uri);
    if (p->uri == NULL)
        goto err_memory;

    writer->nsstackNr++;
    return p;

err_memory:
    xmlWriterErr(writer, XML_ERR_NO_MEMORY);
    return NULL;
}

static void
xmlWriterClearNsStack(xmlTextWriter *writer) {
    int i;

    for (i = 0; i < writer->nsstackNr; i++) {
        xmlFree(writer->nsstack[i].prefix);
        xmlFree(writer->nsstack[i].uri);
    }

    writer->nsstackNr = 0;
}

/**
 * Deallocate all the resources associated to the writer
 *
 * @param writer  the xmlTextWriter
 */
void
xmlFreeTextWriter(xmlTextWriter *writer)
{
    int i;

    if (writer == NULL)
        return;

    if (writer->out != NULL)
        xmlOutputBufferClose(writer->out);

    for (i = 0; i < writer->nodesNr; i++)
        xmlFree(writer->nodes[i].name);
    xmlFree(writer->nodes);

    xmlWriterClearNsStack(writer);
    xmlFree(writer->nsstack);

    if (writer->ctxt != NULL) {
        if ((writer->ctxt->myDoc != NULL) && (writer->no_doc_free == 0)) {
	    xmlFreeDoc(writer->ctxt->myDoc);
	    writer->ctxt->myDoc = NULL;
	}
        xmlFreeParserCtxt(writer->ctxt);
    }

    if (writer->ichar != NULL)
        xmlFree(writer->ichar);
    xmlFree(writer);
}

/**
 * Start a new xml document
 *
 * @param writer  the xmlTextWriter
 * @param version  the xml version ("1.0") or NULL for default ("1.0")
 * @param encoding  the encoding or NULL for default
 * @param standalone  "yes" or "no" or NULL for default
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterStartDocument(xmlTextWriter *writer, const char *version,
                           const char *encoding, const char *standalone)
{
    xmlSize oldWritten;
    xmlCharEncodingHandlerPtr encoder;

    if ((writer == NULL) || (writer->out == NULL)) {
        xmlWriterErr(writer, XML_ERR_ARGUMENT);
        return -1;
    }

    if (writer->nodesNr > 0) {
        xmlWriterErr(writer, XML_ERR_ARGUMENT);
        return -1;
    }

    encoder = NULL;
    if (encoding != NULL) {
        xmlParserErrors errNo;

        errNo = xmlOpenCharEncodingHandler(encoding, 1, &encoder);
        if (errNo != XML_ERR_OK) {
            xmlWriterErr(writer, errNo);
            return -1;
        }
        /* Normalize encoding */
        if (encoder == NULL)
            encoding = "UTF-8";
        else
            encoding = encoder->name;
    }

    if (writer->out->encoder != NULL)
        xmlCharEncCloseFunc(writer->out->encoder);
    writer->out->encoder = encoder;
    if (encoder != NULL) {
	if (writer->out->conv == NULL) {
	    writer->out->conv = xmlBufCreate(4000);
            if (writer->out->conv == NULL) {
                xmlWriterErr(writer, XML_ERR_NO_MEMORY);
                return -1;
            }
	}
        xmlEncOutputBufInit(encoder, writer->out->conv);
    } else {
        if (writer->out->conv != NULL)
            xmlBufFree(writer->out->conv);
        writer->out->conv = NULL;
    }

    oldWritten = writer->out->written;

    xmlWrite(writer->out, "<?xml version=", 14);
    xmlWrite(writer->out, &writer->qchar, 1);
    if (version != 0)
        xmlWrite(writer->out, version, strlen(version));
    else
        xmlWrite(writer->out, "1.0", 3);
    xmlWrite(writer->out, &writer->qchar, 1);
    if (encoding != NULL) {
        xmlWrite(writer->out, " encoding=", 10);
        xmlWrite(writer->out, &writer->qchar, 1);
        xmlWrite(writer->out, encoding, strlen(encoding));
        xmlWrite(writer->out, &writer->qchar, 1);
    }

    if (standalone != 0) {
        xmlWrite(writer->out, " standalone=", 12);
        xmlWrite(writer->out, &writer->qchar, 1);
        xmlWrite(writer->out, standalone, strlen(standalone));
        xmlWrite(writer->out, &writer->qchar, 1);
    }

    xmlWrite(writer->out, "?>\n", 3);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * End an xml document. All open elements are closed, and
 * the content is flushed to the output.
 *
 * @param writer  the xmlTextWriter
 * @returns the bytes written or -1 in case of error
 */
xmlSize
xmlTextWriterEndDocument(xmlTextWriter *writer)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL)
        return -1;

    oldWritten = writer->out->written;
    while (writer->nodesNr > 0) {
        p = &writer->nodes[writer->nodesNr-1];
        switch (p->state) {
            case XML_TEXTWRITER_NAME:
            case XML_TEXTWRITER_ATTRIBUTE:
            case XML_TEXTWRITER_TEXT:
                xmlTextWriterEndElement(writer);
                break;
            case XML_TEXTWRITER_PI:
            case XML_TEXTWRITER_PI_TEXT:
                xmlTextWriterEndPI(writer);
                break;
            case XML_TEXTWRITER_CDATA:
                xmlTextWriterEndCDATA(writer);
                break;
            case XML_TEXTWRITER_DTD:
            case XML_TEXTWRITER_DTD_TEXT:
            case XML_TEXTWRITER_DTD_ELEM:
            case XML_TEXTWRITER_DTD_ELEM_TEXT:
            case XML_TEXTWRITER_DTD_ATTL:
            case XML_TEXTWRITER_DTD_ATTL_TEXT:
            case XML_TEXTWRITER_DTD_ENTY:
            case XML_TEXTWRITER_DTD_ENTY_TEXT:
            case XML_TEXTWRITER_DTD_PENT:
                xmlTextWriterEndDTD(writer);
                break;
            case XML_TEXTWRITER_COMMENT:
                xmlTextWriterEndComment(writer);
                break;
            default:
                break;
        }
    }

    if (!writer->indent) {
        xmlWrite(writer->out, "\n", 1);
    }

    xmlTextWriterFlush(writer);


    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Start an xml comment.
 *
 * @param writer  the xmlTextWriter
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterStartComment(xmlTextWriter *writer)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL)
        return -1;

    oldWritten = writer->out->written;
    if (writer->nodesNr > 0) {
        p = &writer->nodes[writer->nodesNr-1];
        switch (p->state) {
            case XML_TEXTWRITER_TEXT:
            case XML_TEXTWRITER_NONE:
                break;
            case XML_TEXTWRITER_NAME:
                /* Output namespace declarations */
                xmlTextWriterOutputNSDecl(writer);
                xmlWrite(writer->out, ">", 1);
                if (writer->indent) {
                    xmlWrite(writer->out, "\n", 1);
                }
                p->state = XML_TEXTWRITER_TEXT;
                break;
            default:
                return -1;
        }
    }

    p = xmlWriterPushNode(writer, NULL, XML_TEXTWRITER_COMMENT);
    if (p == NULL)
        return -1;

    if (writer->indent) {
        xmlTextWriterWriteIndent(writer);
    }

    xmlWrite(writer->out, "<!--", 4);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * End the current xml comment.
 *
 * @param writer  the xmlTextWriter
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterEndComment(xmlTextWriter *writer)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL)
        return -1;

    if (writer->nodesNr <= 0) {
        xmlWriterErr(writer, XML_ERR_ARGUMENT);
        return -1;
    }

    p = &writer->nodes[writer->nodesNr-1];

    oldWritten = writer->out->written;
    switch (p->state) {
        case XML_TEXTWRITER_COMMENT:
            xmlWrite(writer->out, "-->", 3);
            break;
        default:
            return -1;
    }

    if (writer->indent) {
        xmlWrite(writer->out, "\n", 1);
    }

    xmlWriterPopNode(writer);
    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Write an xml comment.
 *
 * @param writer  the xmlTextWriter
 * @param format  format string (see printf)
 * @param ...  extra parameters for the format
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteFormatComment(xmlTextWriter *writer,
                                const char *format, ...)
{
    xmlSize rc;
    va_list ap;

    va_start(ap, format);

    rc = xmlTextWriterWriteVFormatComment(writer, format, ap);

    va_end(ap);
    return rc;
}

/**
 * Write an xml comment.
 *
 * @param writer  the xmlTextWriter
 * @param format  format string (see printf)
 * @param argptr  pointer to the first member of the variable argument list.
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteVFormatComment(xmlTextWriter *writer,
                                 const char *format, va_list argptr)
{
    xmlSize rc;
    xmlChar *buf;

    if (writer == NULL)
        return -1;

    buf = xmlTextWriterVSprintf(writer, format, argptr);
    if (buf == NULL)
        return -1;

    rc = xmlTextWriterWriteComment(writer, buf);

    xmlFree(buf);
    return rc;
}

/**
 * Write an xml comment.
 *
 * @param writer  the xmlTextWriter
 * @param content  comment string
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteComment(xmlTextWriter *writer, const xmlChar * content)
{
    xmlSize oldWritten;

    if (writer == NULL || writer->out == NULL)
        return -1;

    oldWritten = writer->out->written;
    xmlTextWriterStartComment(writer);
    xmlTextWriterWriteString(writer, content);
    xmlTextWriterEndComment(writer);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Start an xml element.
 *
 * @param writer  the xmlTextWriter
 * @param name  element name
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterStartElement(xmlTextWriter *writer, const xmlChar * name)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL ||
        name == NULL || *name == '\0')
        return -1;

    oldWritten = writer->out->written;
    if (writer->nodesNr > 0) {
        p = &writer->nodes[writer->nodesNr-1];
        switch (p->state) {
            case XML_TEXTWRITER_PI:
            case XML_TEXTWRITER_PI_TEXT:
                return -1;
            case XML_TEXTWRITER_NONE:
                break;
                            case XML_TEXTWRITER_ATTRIBUTE:
                                    xmlTextWriterEndAttribute(writer);
                                    /* fallthrough */
            case XML_TEXTWRITER_NAME:
                /* Output namespace declarations */
                xmlTextWriterOutputNSDecl(writer);
                xmlWrite(writer->out, ">", 1);
                if (writer->indent)
                    xmlWrite(writer->out, "\n", 1);
                p->state = XML_TEXTWRITER_TEXT;
                break;
            default:
                break;
        }
    }

    p = xmlWriterPushNode(writer, name, XML_TEXTWRITER_NAME);
    if (p == NULL)
        return -1;

    if (writer->indent) {
        xmlTextWriterWriteIndent(writer);
    }

    xmlWrite(writer->out, "<", 1);
    xmlWriteString(writer->out, p->name);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Start an xml element with namespace support.
 *
 * @param writer  the xmlTextWriter
 * @param prefix  namespace prefix or NULL
 * @param name  element local name
 * @param namespaceURI  namespace URI or NULL
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterStartElementNS(xmlTextWriter *writer,
                            const xmlChar * prefix, const xmlChar * name,
                            const xmlChar * namespaceURI)
{
    xmlSize oldWritten;
    xmlChar namebuf[50];
    xmlChar *qname;

    if (writer == NULL || writer->out == NULL ||
        name == NULL || *name == '\0')
        return -1;

    qname = xmlBuildQName(name, prefix, namebuf, sizeof(namebuf));
    if (qname == NULL) {
        xmlWriterErr(writer, XML_ERR_NO_MEMORY);
        return -1;
    }

    oldWritten = writer->out->written;
    xmlTextWriterStartElement(writer, qname);
    if (qname != name && qname != namebuf)
        xmlFree(qname);

    if (namespaceURI != 0) {
        xmlTextWriterNsStackEntry *p = xmlWriterPushNs(writer, prefix,
                                                       namespaceURI);
        if (p == NULL)
            return -1;
    }

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * End the current xml element.
 *
 * @param writer  the xmlTextWriter
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterEndElement(xmlTextWriter *writer)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL)
        return -1;

    if (writer->nodesNr <= 0) {
        xmlWriterErr(writer, XML_ERR_ARGUMENT);
        xmlWriterClearNsStack(writer);
        return -1;
    }

    p = &writer->nodes[writer->nodesNr-1];

    oldWritten = writer->out->written;
    switch (p->state) {
        case XML_TEXTWRITER_ATTRIBUTE:
            xmlTextWriterEndAttribute(writer);
            /* fallthrough */
        case XML_TEXTWRITER_NAME:
            /* Output namespace declarations */
            xmlTextWriterOutputNSDecl(writer);

            if (writer->indent) /* next element needs indent */
                writer->doindent = 1;
            xmlWrite(writer->out, "/>", 2);
            break;
        case XML_TEXTWRITER_TEXT:
            if ((writer->indent) && (writer->doindent)) {
                xmlTextWriterWriteIndent(writer);
                writer->doindent = 1;
            } else
                writer->doindent = 1;
            xmlWrite(writer->out, "</", 2);
            xmlWriteString(writer->out, p->name);
            xmlWrite(writer->out, ">", 1);
            break;
        default:
            return -1;
    }

    if (writer->indent) {
        xmlWrite(writer->out, "\n", 1);
    }

    xmlWriterPopNode(writer);
    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * End the current xml element. Writes an end tag even if the element is empty
 *
 * @param writer  the xmlTextWriter
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterFullEndElement(xmlTextWriter *writer)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL)
        return -1;

    if (writer->nodesNr <= 0) {
        xmlWriterErr(writer, XML_ERR_ARGUMENT);
        return -1;
    }

    p = &writer->nodes[writer->nodesNr-1];

    oldWritten = writer->out->written;
    switch (p->state) {
        case XML_TEXTWRITER_ATTRIBUTE:
            xmlTextWriterEndAttribute(writer);
            /* fallthrough */
        case XML_TEXTWRITER_NAME:
            /* Output namespace declarations */
            xmlTextWriterOutputNSDecl(writer);

            xmlWrite(writer->out, ">", 1);
            if (writer->indent)
                writer->doindent = 0;
            /* fallthrough */
        case XML_TEXTWRITER_TEXT:
            if ((writer->indent) && (writer->doindent)) {
                xmlTextWriterWriteIndent(writer);
                writer->doindent = 1;
            } else
                writer->doindent = 1;
            xmlWrite(writer->out, "</", 2);
            xmlWriteString(writer->out, p->name);
            xmlWrite(writer->out, ">", 1);
            break;
        default:
            return -1;
    }

    if (writer->indent) {
        xmlWrite(writer->out, "\n", 1);
    }

    xmlWriterPopNode(writer);
    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Write a formatted raw xml text.
 *
 * @param writer  the xmlTextWriter
 * @param format  format string (see printf)
 * @param ...  extra parameters for the format
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteFormatRaw(xmlTextWriter *writer, const char *format,
                            ...)
{
    xmlSize rc;
    va_list ap;

    va_start(ap, format);

    rc = xmlTextWriterWriteVFormatRaw(writer, format, ap);

    va_end(ap);
    return rc;
}

/**
 * Write a formatted raw xml text.
 *
 * @param writer  the xmlTextWriter
 * @param format  format string (see printf)
 * @param argptr  pointer to the first member of the variable argument list.
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteVFormatRaw(xmlTextWriter *writer, const char *format,
                             va_list argptr)
{
    xmlSize rc;
    xmlChar *buf;

    if (writer == NULL)
        return -1;

    buf = xmlTextWriterVSprintf(writer, format, argptr);
    if (buf == NULL)
        return -1;

    rc = xmlTextWriterWriteRaw(writer, buf);

    xmlFree(buf);
    return rc;
}

/**
 * Write an xml text.
 * TODO: what about entities and special chars??
 *
 * @param writer  the xmlTextWriter
 * @param content  text string
 * @param len  length of the text string
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteRawLen(xmlTextWriter *writer, const xmlChar * content,
                         xmlSize len)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL)
        return -1;

    if ((content == NULL) || (len < 0)) {
        xmlWriterErr(writer, XML_ERR_ARGUMENT);
        return -1;
    }

    oldWritten = writer->out->written;
    if (writer->nodesNr > 0) {
        p = &writer->nodes[writer->nodesNr-1];
        xmlTextWriterHandleStateDependencies(writer, p);
    }

    if (writer->indent)
        writer->doindent = 0;

    if (content != NULL) {
        xmlOutputBufferWriteInternal(writer->out, (const char *) content,
                                     len, XML_WRITE_ESCAPE);
    }

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Write a raw xml text.
 *
 * @param writer  the xmlTextWriter
 * @param content  text string
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteRaw(xmlTextWriter *writer, const xmlChar * content)
{
    size_t len = 0;

    if (content != NULL) {
        len = strlen((char *) content);
        if (len > INT_MAX) {
            xmlWriterErr(writer, XML_ERR_RESOURCE_LIMIT);
            return(-1);
        }
    }

    return xmlTextWriterWriteRawLen(writer, content, len);
}

/**
 * Write a formatted xml text.
 *
 * @param writer  the xmlTextWriter
 * @param format  format string (see printf)
 * @param ...  extra parameters for the format
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteFormatString(xmlTextWriter *writer, const char *format,
                               ...)
{
    xmlSize rc;
    va_list ap;

    if ((writer == NULL) || (format == NULL))
        return -1;

    va_start(ap, format);

    rc = xmlTextWriterWriteVFormatString(writer, format, ap);

    va_end(ap);
    return rc;
}

/**
 * Write a formatted xml text.
 *
 * @param writer  the xmlTextWriter
 * @param format  format string (see printf)
 * @param argptr  pointer to the first member of the variable argument list.
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteVFormatString(xmlTextWriter *writer,
                                const char *format, va_list argptr)
{
    xmlSize rc;
    xmlChar *buf;

    if ((writer == NULL) || (format == NULL))
        return -1;

    buf = xmlTextWriterVSprintf(writer, format, argptr);
    if (buf == NULL)
        return -1;

    rc = xmlTextWriterWriteString(writer, buf);

    xmlFree(buf);
    return rc;
}

/**
 * Write an xml text.
 *
 * @param writer  the xmlTextWriter
 * @param content  text string
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteString(xmlTextWriter *writer, const xmlChar * content)
{
    xmlSize offset;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL || content == NULL)
        return -1;

    offset = writer->out->written;

    if (writer->nodesNr > 0) {
        p = &writer->nodes[writer->nodesNr-1];
        xmlTextWriterHandleStateDependencies(writer, p);
    }

    if (writer->indent)
        writer->doindent = 0;

    if (writer->nodesNr > 0) {
        p = &writer->nodes[writer->nodesNr-1];
        switch (p->state) {
            case XML_TEXTWRITER_NAME:
            case XML_TEXTWRITER_TEXT:
                xmlSerializeText(writer->out, content, SIZE_MAX,
                                 XML_ESCAPE_QUOT);
                break;
            case XML_TEXTWRITER_ATTRIBUTE: {
                int flags = XML_ESCAPE_ATTR;

                if (writer->out->encoder == NULL)
                    flags |= XML_ESCAPE_NON_ASCII;
                xmlSerializeText(writer->out, content, SIZE_MAX, flags);
                break;
            }
            default: {
                xmlWriteText(writer->out, content);
                break;
            }
        }
    }

    if (writer->out->error != XML_ERR_OK)
        return -1;

    return writer->out->written - offset;
}

/**
 * Write base64 encoded data to an xmlOutputBuffer.
 * Adapted from John Walker's base64.c (http://www.fourmilab.ch/).
 *
 * @param out  the xmlOutputBuffer
 * @param data  binary data
 * @param len  the number of bytes to encode
 */
static void
xmlOutputBufferWriteBase64(xmlOutputBufferPtr out, xmlSize len,
                           const unsigned char *data)
{
    static const unsigned char dtable[64] =
            {'A','B','C','D','E','F','G','H','I','J','K','L','M',
	     'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
	     'a','b','c','d','e','f','g','h','i','j','k','l','m',
	     'n','o','p','q','r','s','t','u','v','w','x','y','z',
	     '0','1','2','3','4','5','6','7','8','9','+','/'};

    xmlSize i;
    xmlSize linelen;

    if ((out == NULL) || (len < 0) || (data == NULL))
        return;

    linelen = 0;

    i = 0;
    while (1) {
        unsigned char igroup[3];
        unsigned char ogroup[4];
        int c;
        xmlSize n;

        igroup[0] = igroup[1] = igroup[2] = 0;
        for (n = 0; n < 3 && i < len; n++, i++) {
            c = data[i];
            igroup[n] = (unsigned char) c;
        }

        if (n > 0) {
            ogroup[0] = dtable[igroup[0] >> 2];
            ogroup[1] = dtable[((igroup[0] & 3) << 4) | (igroup[1] >> 4)];
            ogroup[2] =
                dtable[((igroup[1] & 0xF) << 2) | (igroup[2] >> 6)];
            ogroup[3] = dtable[igroup[2] & 0x3F];

            if (n < 3) {
                ogroup[3] = '=';
                if (n < 2) {
                    ogroup[2] = '=';
                }
            }

            if (linelen >= B64LINELEN) {
                xmlWrite(out, B64CRLF, 2);
                linelen = 0;
            }
            xmlWrite(out, (const char *) ogroup, 4);

            linelen += 4;
        }

        if (i >= len)
            break;
    }
}

/**
 * Write an base64 encoded xml text.
 *
 * @param writer  the xmlTextWriter
 * @param data  binary data
 * @param start  the position within the data of the first byte to encode
 * @param len  the number of bytes to encode
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteBase64(xmlTextWriter *writer, const char *data,
                         xmlSize start, xmlSize len)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL ||
        data == NULL || start < 0 || len < 0)
        return -1;

    oldWritten = writer->out->written;
    if (writer->nodesNr > 0) {
        p = &writer->nodes[writer->nodesNr-1];
        xmlTextWriterHandleStateDependencies(writer, p);
    }

    if (writer->indent)
        writer->doindent = 0;

    xmlOutputBufferWriteBase64(writer->out, len,
                               (unsigned char *) data + start);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Write hqx encoded data to an xmlOutputBuffer.
 *
 * @param out  the xmlOutputBuffer
 * @param data  binary data
 * @param len  the number of bytes to encode
 */
static void
xmlOutputBufferWriteBinHex(xmlOutputBufferPtr out,
                           xmlSize len, const unsigned char *data)
{
    static const char hex[16] =
	{'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
    xmlSize i;

    if ((out == NULL) || (data == NULL) || (len < 0)) {
        return;
    }

    for (i = 0; i < len; i++) {
        xmlWrite(out, &hex[data[i] >> 4], 1);
        xmlWrite(out, &hex[data[i] & 0xF], 1);
    }
}

/**
 * Write a BinHex encoded xml text.
 *
 * @param writer  the xmlTextWriter
 * @param data  binary data
 * @param start  the position within the data of the first byte to encode
 * @param len  the number of bytes to encode
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteBinHex(xmlTextWriter *writer, const char *data,
                         xmlSize start, xmlSize len)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL ||
        data == NULL || start < 0 || len < 0)
        return -1;

    oldWritten = writer->out->written;
    if (writer->nodesNr > 0) {
        p = &writer->nodes[writer->nodesNr-1];
        xmlTextWriterHandleStateDependencies(writer, p);
    }

    if (writer->indent)
        writer->doindent = 0;

    xmlOutputBufferWriteBinHex(writer->out, len,
                               (unsigned char *) data + start);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Start an xml attribute.
 *
 * @param writer  the xmlTextWriter
 * @param name  element name
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterStartAttribute(xmlTextWriter *writer, const xmlChar * name)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL ||
        name == NULL || *name == '\0')
        return -1;

    oldWritten = writer->out->written;
    if (writer->nodesNr <= 0) {
        xmlWriterErr(writer, XML_ERR_ARGUMENT);
        return -1;
    }

    p = &writer->nodes[writer->nodesNr-1];

    switch (p->state) {
        case XML_TEXTWRITER_ATTRIBUTE:
            xmlTextWriterEndAttribute(writer);
            /* fallthrough */
        case XML_TEXTWRITER_NAME:
            xmlWrite(writer->out, " ", 1);
            xmlWriteString(writer->out, name);
            xmlWrite(writer->out, "=", 1);
            xmlWrite(writer->out, &writer->qchar, 1);
            p->state = XML_TEXTWRITER_ATTRIBUTE;
            break;
        default:
            return -1;
    }

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Start an xml attribute with namespace support.
 *
 * @param writer  the xmlTextWriter
 * @param prefix  namespace prefix or NULL
 * @param name  element local name
 * @param namespaceURI  namespace URI or NULL
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterStartAttributeNS(xmlTextWriter *writer,
                              const xmlChar * prefix, const xmlChar * name,
                              const xmlChar * namespaceURI)
{
    xmlSize oldWritten;
    xmlChar namebuf[50];
    xmlChar *qname;
    xmlTextWriterNsStackEntry *p;

    if (writer == NULL || writer->out == NULL ||
        name == NULL || *name == '\0')
        return -1;

    /* Handle namespace first in case of error */
    if (namespaceURI != 0) {
        xmlTextWriterNsStackEntry *curns = NULL;
        int i;

        for (i = 0; i < writer->nsstackNr; i++) {
            p = &writer->nsstack[i];
            if (strcmp((char *) p->prefix, (char *) prefix) == 0) {
                curns = p;
                break;
            }
        }

        if ((curns != NULL)) {
            if (strcmp((char *) curns->uri, (char *) namespaceURI) == 0) {
                /* Namespace already defined on element skip */
            } else {
                /* Prefix mismatch so error out */
                return -1;
            }
            /* Do not add namespace decl to list - it is already there */
        } else {
            p = xmlWriterPushNs(writer, prefix, namespaceURI);
            if (p == 0)
                return -1;
        }
    }

    qname = xmlBuildQName(name, prefix, namebuf, sizeof(namebuf));
    if (qname == NULL) {
        xmlWriterErr(writer, XML_ERR_NO_MEMORY);
        return -1;
    }

    oldWritten = writer->out->written;
    xmlTextWriterStartAttribute(writer, qname);
    if (qname != name && qname != namebuf)
        xmlFree(qname);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * End the current xml element.
 *
 * @param writer  the xmlTextWriter
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterEndAttribute(xmlTextWriter *writer)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL)
        return -1;

    if (writer->nodesNr <= 0) {
        xmlWriterErr(writer, XML_ERR_ARGUMENT);
        return -1;
    }

    p = &writer->nodes[writer->nodesNr-1];

    oldWritten = writer->out->written;
    switch (p->state) {
        case XML_TEXTWRITER_ATTRIBUTE:
            p->state = XML_TEXTWRITER_NAME;

            xmlWrite(writer->out, &writer->qchar, 1);
            break;
        default:
            return -1;
    }

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Write a formatted xml attribute.
 *
 * @param writer  the xmlTextWriter
 * @param name  attribute name
 * @param format  format string (see printf)
 * @param ...  extra parameters for the format
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteFormatAttribute(xmlTextWriter *writer,
                                  const xmlChar * name, const char *format,
                                  ...)
{
    xmlSize rc;
    va_list ap;

    va_start(ap, format);

    rc = xmlTextWriterWriteVFormatAttribute(writer, name, format, ap);

    va_end(ap);
    return rc;
}

/**
 * Write a formatted xml attribute.
 *
 * @param writer  the xmlTextWriter
 * @param name  attribute name
 * @param format  format string (see printf)
 * @param argptr  pointer to the first member of the variable argument list.
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteVFormatAttribute(xmlTextWriter *writer,
                                   const xmlChar * name,
                                   const char *format, va_list argptr)
{
    xmlSize rc;
    xmlChar *buf;

    if (writer == NULL)
        return -1;

    buf = xmlTextWriterVSprintf(writer, format, argptr);
    if (buf == NULL)
        return -1;

    rc = xmlTextWriterWriteAttribute(writer, name, buf);

    xmlFree(buf);
    return rc;
}

/**
 * Write an xml attribute.
 *
 * @param writer  the xmlTextWriter
 * @param name  attribute name
 * @param content  attribute content
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteAttribute(xmlTextWriter *writer, const xmlChar * name,
                            const xmlChar * content)
{
    xmlSize oldWritten;

    if (writer == NULL || writer->out == NULL)
        return -1;

    oldWritten = writer->out->written;
    xmlTextWriterStartAttribute(writer, name);
    xmlTextWriterWriteString(writer, content);
    xmlTextWriterEndAttribute(writer);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Write a formatted xml attribute.with namespace support
 *
 * @param writer  the xmlTextWriter
 * @param prefix  namespace prefix
 * @param name  attribute local name
 * @param namespaceURI  namespace URI
 * @param format  format string (see printf)
 * @param ...  extra parameters for the format
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteFormatAttributeNS(xmlTextWriter *writer,
                                    const xmlChar * prefix,
                                    const xmlChar * name,
                                    const xmlChar * namespaceURI,
                                    const char *format, ...)
{
    xmlSize rc;
    va_list ap;

    va_start(ap, format);

    rc = xmlTextWriterWriteVFormatAttributeNS(writer, prefix, name,
                                              namespaceURI, format, ap);

    va_end(ap);
    return rc;
}

/**
 * Write a formatted xml attribute.with namespace support
 *
 * @param writer  the xmlTextWriter
 * @param prefix  namespace prefix
 * @param name  attribute local name
 * @param namespaceURI  namespace URI
 * @param format  format string (see printf)
 * @param argptr  pointer to the first member of the variable argument list.
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteVFormatAttributeNS(xmlTextWriter *writer,
                                     const xmlChar * prefix,
                                     const xmlChar * name,
                                     const xmlChar * namespaceURI,
                                     const char *format, va_list argptr)
{
    xmlSize rc;
    xmlChar *buf;

    if (writer == NULL)
        return -1;

    buf = xmlTextWriterVSprintf(writer, format, argptr);
    if (buf == NULL)
        return -1;

    rc = xmlTextWriterWriteAttributeNS(writer, prefix, name, namespaceURI,
                                       buf);

    xmlFree(buf);
    return rc;
}

/**
 * Write an xml attribute.
 *
 * @param writer  the xmlTextWriter
 * @param prefix  namespace prefix
 * @param name  attribute local name
 * @param namespaceURI  namespace URI
 * @param content  attribute content
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteAttributeNS(xmlTextWriter *writer,
                              const xmlChar * prefix, const xmlChar * name,
                              const xmlChar * namespaceURI,
                              const xmlChar * content)
{
    xmlSize oldWritten;

    if (writer == NULL || writer->out == NULL ||
        name == NULL || *name == '\0')
        return -1;

    oldWritten = writer->out->written;
    xmlTextWriterStartAttributeNS(writer, prefix, name, namespaceURI);
    xmlTextWriterWriteString(writer, content);
    xmlTextWriterEndAttribute(writer);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Write a formatted xml element.
 *
 * @param writer  the xmlTextWriter
 * @param name  element name
 * @param format  format string (see printf)
 * @param ...  extra parameters for the format
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteFormatElement(xmlTextWriter *writer,
                                const xmlChar * name, const char *format,
                                ...)
{
    xmlSize rc;
    va_list ap;

    va_start(ap, format);

    rc = xmlTextWriterWriteVFormatElement(writer, name, format, ap);

    va_end(ap);
    return rc;
}

/**
 * Write a formatted xml element.
 *
 * @param writer  the xmlTextWriter
 * @param name  element name
 * @param format  format string (see printf)
 * @param argptr  pointer to the first member of the variable argument list.
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteVFormatElement(xmlTextWriter *writer,
                                 const xmlChar * name, const char *format,
                                 va_list argptr)
{
    xmlSize rc;
    xmlChar *buf;

    if (writer == NULL)
        return -1;

    buf = xmlTextWriterVSprintf(writer, format, argptr);
    if (buf == NULL)
        return -1;

    rc = xmlTextWriterWriteElement(writer, name, buf);

    xmlFree(buf);
    return rc;
}

/**
 * Write an xml element.
 *
 * @param writer  the xmlTextWriter
 * @param name  element name
 * @param content  element content
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteElement(xmlTextWriter *writer, const xmlChar * name,
                          const xmlChar * content)
{
    xmlSize oldWritten;

    if (writer == NULL || writer->out == NULL)
        return -1;

    oldWritten = writer->out->written;
    xmlTextWriterStartElement(writer, name);
    if (content != NULL) {
	xmlTextWriterWriteString(writer, content);
    }
    xmlTextWriterEndElement(writer);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Write a formatted xml element with namespace support.
 *
 * @param writer  the xmlTextWriter
 * @param prefix  namespace prefix
 * @param name  element local name
 * @param namespaceURI  namespace URI
 * @param format  format string (see printf)
 * @param ...  extra parameters for the format
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteFormatElementNS(xmlTextWriter *writer,
                                  const xmlChar * prefix,
                                  const xmlChar * name,
                                  const xmlChar * namespaceURI,
                                  const char *format, ...)
{
    xmlSize rc;
    va_list ap;

    va_start(ap, format);

    rc = xmlTextWriterWriteVFormatElementNS(writer, prefix, name,
                                            namespaceURI, format, ap);

    va_end(ap);
    return rc;
}

/**
 * Write a formatted xml element with namespace support.
 *
 * @param writer  the xmlTextWriter
 * @param prefix  namespace prefix
 * @param name  element local name
 * @param namespaceURI  namespace URI
 * @param format  format string (see printf)
 * @param argptr  pointer to the first member of the variable argument list.
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteVFormatElementNS(xmlTextWriter *writer,
                                   const xmlChar * prefix,
                                   const xmlChar * name,
                                   const xmlChar * namespaceURI,
                                   const char *format, va_list argptr)
{
    xmlSize rc;
    xmlChar *buf;

    if (writer == NULL)
        return -1;

    buf = xmlTextWriterVSprintf(writer, format, argptr);
    if (buf == NULL)
        return -1;

    rc = xmlTextWriterWriteElementNS(writer, prefix, name, namespaceURI,
                                     buf);

    xmlFree(buf);
    return rc;
}

/**
 * Write an xml element with namespace support.
 *
 * @param writer  the xmlTextWriter
 * @param prefix  namespace prefix
 * @param name  element local name
 * @param namespaceURI  namespace URI
 * @param content  element content
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteElementNS(xmlTextWriter *writer,
                            const xmlChar * prefix, const xmlChar * name,
                            const xmlChar * namespaceURI,
                            const xmlChar * content)
{
    xmlSize oldWritten;

    if (writer == NULL || writer->out == NULL ||
        name == NULL || *name == '\0')
        return -1;

    oldWritten = writer->out->written;
    xmlTextWriterStartElementNS(writer, prefix, name, namespaceURI);
    xmlTextWriterWriteString(writer, content);
    xmlTextWriterEndElement(writer);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Start an xml PI.
 *
 * @param writer  the xmlTextWriter
 * @param target  PI target
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterStartPI(xmlTextWriter *writer, const xmlChar * target)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL ||
        target == NULL || *target == '\0')
        return -1;

    if (xmlStrcasecmp(target, (const xmlChar *) "xml") == 0) {
        xmlWriterErr(writer, XML_ERR_ARGUMENT);
        return -1;
    }

    oldWritten = writer->out->written;
    if (writer->nodesNr > 0) {
        p = &writer->nodes[writer->nodesNr-1];
        switch (p->state) {
            case XML_TEXTWRITER_ATTRIBUTE:
                xmlTextWriterEndAttribute(writer);
                /* fallthrough */
            case XML_TEXTWRITER_NAME:
                /* Output namespace declarations */
                xmlTextWriterOutputNSDecl(writer);
                xmlWrite(writer->out, ">", 1);
                p->state = XML_TEXTWRITER_TEXT;
                break;
            case XML_TEXTWRITER_NONE:
            case XML_TEXTWRITER_TEXT:
            case XML_TEXTWRITER_DTD:
                break;
            case XML_TEXTWRITER_PI:
            case XML_TEXTWRITER_PI_TEXT:
                xmlWriterErr(writer, XML_ERR_ARGUMENT);
                return -1;
            default:
                return -1;
        }
    }

    p = xmlWriterPushNode(writer, target, XML_TEXTWRITER_PI);
    if (p == NULL)
        return -1;

    xmlWrite(writer->out, "<?", 2);
    xmlWriteString(writer->out, p->name);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * End the current xml PI.
 *
 * @param writer  the xmlTextWriter
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterEndPI(xmlTextWriter *writer)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL)
        return -1;

    if (writer->nodesNr <= 0) {
        xmlWriterErr(writer, XML_ERR_ARGUMENT);
        return -1;
    }

    p = &writer->nodes[writer->nodesNr-1];

    oldWritten = writer->out->written;
    switch (p->state) {
        case XML_TEXTWRITER_PI:
        case XML_TEXTWRITER_PI_TEXT:
            xmlWrite(writer->out, "?>", 2);
            break;
        default:
            return -1;
    }

    if (writer->indent) {
        xmlWrite(writer->out, "\n", 1);
    }

    xmlWriterPopNode(writer);
    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Write a formatted PI.
 *
 * @param writer  the xmlTextWriter
 * @param target  PI target
 * @param format  format string (see printf)
 * @param ...  extra parameters for the format
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteFormatPI(xmlTextWriter *writer, const xmlChar * target,
                           const char *format, ...)
{
    xmlSize rc;
    va_list ap;

    va_start(ap, format);

    rc = xmlTextWriterWriteVFormatPI(writer, target, format, ap);

    va_end(ap);
    return rc;
}

/**
 * Write a formatted xml PI.
 *
 * @param writer  the xmlTextWriter
 * @param target  PI target
 * @param format  format string (see printf)
 * @param argptr  pointer to the first member of the variable argument list.
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteVFormatPI(xmlTextWriter *writer,
                            const xmlChar * target, const char *format,
                            va_list argptr)
{
    xmlSize rc;
    xmlChar *buf;

    if (writer == NULL)
        return -1;

    buf = xmlTextWriterVSprintf(writer, format, argptr);
    if (buf == NULL)
        return -1;

    rc = xmlTextWriterWritePI(writer, target, buf);

    xmlFree(buf);
    return rc;
}

/**
 * Write an xml PI.
 *
 * @param writer  the xmlTextWriter
 * @param target  PI target
 * @param content  PI content
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWritePI(xmlTextWriter *writer, const xmlChar * target,
                     const xmlChar * content)
{
    xmlSize oldWritten;

    if (writer == NULL || writer->out == NULL)
        return -1;

    oldWritten = writer->out->written;
    xmlTextWriterStartPI(writer, target);
    if (content != 0) {
        xmlTextWriterWriteString(writer, content);
    }
    xmlTextWriterEndPI(writer);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Start an xml CDATA section.
 *
 * @param writer  the xmlTextWriter
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterStartCDATA(xmlTextWriter *writer)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL)
        return -1;

    oldWritten = writer->out->written;
    if (writer->nodesNr > 0) {
        p = &writer->nodes[writer->nodesNr-1];
        switch (p->state) {
            case XML_TEXTWRITER_NONE:
            case XML_TEXTWRITER_TEXT:
            case XML_TEXTWRITER_PI:
            case XML_TEXTWRITER_PI_TEXT:
                break;
            case XML_TEXTWRITER_ATTRIBUTE:
                xmlTextWriterEndAttribute(writer);
                /* fallthrough */
            case XML_TEXTWRITER_NAME:
                /* Output namespace declarations */
                xmlTextWriterOutputNSDecl(writer);
                xmlWrite(writer->out, ">", 1);
                p->state = XML_TEXTWRITER_TEXT;
                break;
            case XML_TEXTWRITER_CDATA:
                xmlWriterErr(writer, XML_ERR_ARGUMENT);
                return -1;
            default:
                return -1;
        }
    }

    p = xmlWriterPushNode(writer, NULL, XML_TEXTWRITER_CDATA);
    if (p == NULL)
        return -1;

    xmlWrite(writer->out, "<![CDATA[", 9);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * End an xml CDATA section.
 *
 * @param writer  the xmlTextWriter
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterEndCDATA(xmlTextWriter *writer)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL)
        return -1;

    if (writer->nodesNr <= 0) {
        xmlWriterErr(writer, XML_ERR_ARGUMENT);
        return -1;
    }

    p = &writer->nodes[writer->nodesNr-1];

    oldWritten = writer->out->written;
    switch (p->state) {
        case XML_TEXTWRITER_CDATA:
            xmlWrite(writer->out, "]]>", 3);
            break;
        default:
            return -1;
    }

    xmlWriterPopNode(writer);
    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Write a formatted xml CDATA.
 *
 * @param writer  the xmlTextWriter
 * @param format  format string (see printf)
 * @param ...  extra parameters for the format
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteFormatCDATA(xmlTextWriter *writer, const char *format,
                              ...)
{
    xmlSize rc;
    va_list ap;

    va_start(ap, format);

    rc = xmlTextWriterWriteVFormatCDATA(writer, format, ap);

    va_end(ap);
    return rc;
}

/**
 * Write a formatted xml CDATA.
 *
 * @param writer  the xmlTextWriter
 * @param format  format string (see printf)
 * @param argptr  pointer to the first member of the variable argument list.
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteVFormatCDATA(xmlTextWriter *writer, const char *format,
                               va_list argptr)
{
    xmlSize rc;
    xmlChar *buf;

    if (writer == NULL)
        return -1;

    buf = xmlTextWriterVSprintf(writer, format, argptr);
    if (buf == NULL)
        return -1;

    rc = xmlTextWriterWriteCDATA(writer, buf);

    xmlFree(buf);
    return rc;
}

/**
 * Write an xml CDATA.
 *
 * @param writer  the xmlTextWriter
 * @param content  CDATA content
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteCDATA(xmlTextWriter *writer, const xmlChar * content)
{
    xmlSize oldWritten;

    if (writer == NULL || writer->out == NULL)
        return -1;

    oldWritten = writer->out->written;
    xmlTextWriterStartCDATA(writer);
    if (content != 0) {
        xmlTextWriterWriteString(writer, content);
    }
    xmlTextWriterEndCDATA(writer);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Start an xml DTD.
 *
 * @param writer  the xmlTextWriter
 * @param name  the name of the DTD
 * @param pubid  the public identifier, which is an alternative to the system identifier
 * @param sysid  the system identifier, which is the URI of the DTD
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterStartDTD(xmlTextWriter *writer,
                      const xmlChar * name,
                      const xmlChar * pubid, const xmlChar * sysid)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL ||
        name == NULL || *name == '\0')
        return -1;

    oldWritten = writer->out->written;
    if (writer->nodesNr > 0) {
        xmlWriterErr(writer, XML_ERR_ARGUMENT);
        return -1;
    }

    p = xmlWriterPushNode(writer, name, XML_TEXTWRITER_DTD);
    if (p == NULL)
        return -1;

    xmlWrite(writer->out, "<!DOCTYPE ", 10);
    xmlWriteString(writer->out, name);

    if (pubid != 0) {
        if (sysid == 0) {
            xmlWriterErr(writer, XML_ERR_ARGUMENT);
            return -1;
        }

        if (writer->indent)
            xmlWrite(writer->out, "\n", 1);
        else
            xmlWrite(writer->out, " ", 1);

        xmlWrite(writer->out, "PUBLIC ", 7);

        xmlWrite(writer->out, &writer->qchar, 1);
        xmlWriteString(writer->out, pubid);
        xmlWrite(writer->out, &writer->qchar, 1);
    }

    if (sysid != 0) {
        if (pubid == 0) {
            if (writer->indent)
                xmlWrite(writer->out, "\n", 1);
            else
                xmlWrite(writer->out, " ", 1);
            xmlWrite(writer->out, "SYSTEM ", 7);
        } else {
            if (writer->indent)
                xmlWrite(writer->out, "\n       ", 8);
            else
                xmlWrite(writer->out, " ", 1);
        }

        xmlWrite(writer->out, &writer->qchar, 1);
        xmlWriteString(writer->out, sysid);
        xmlWrite(writer->out, &writer->qchar, 1);
    }

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * End an xml DTD.
 *
 * @param writer  the xmlTextWriter
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterEndDTD(xmlTextWriter *writer)
{
    int loop;
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL)
        return -1;

    oldWritten = writer->out->written;
    loop = 1;
    while (loop) {
        if (writer->nodesNr <= 0)
            break;
        p = &writer->nodes[writer->nodesNr-1];
        switch (p->state) {
            case XML_TEXTWRITER_DTD_TEXT:
                xmlWrite(writer->out, "]", 1);
                /* fallthrough */
            case XML_TEXTWRITER_DTD:
                xmlWrite(writer->out, ">", 1);

                if (writer->indent) {
                    xmlWrite(writer->out, "\n", 1);
                }

                xmlWriterPopNode(writer);
                break;
            case XML_TEXTWRITER_DTD_ELEM:
            case XML_TEXTWRITER_DTD_ELEM_TEXT:
                xmlTextWriterEndDTDElement(writer);
                break;
            case XML_TEXTWRITER_DTD_ATTL:
            case XML_TEXTWRITER_DTD_ATTL_TEXT:
                xmlTextWriterEndDTDAttlist(writer);
                break;
            case XML_TEXTWRITER_DTD_ENTY:
            case XML_TEXTWRITER_DTD_PENT:
            case XML_TEXTWRITER_DTD_ENTY_TEXT:
                xmlTextWriterEndDTDEntity(writer);
                break;
            case XML_TEXTWRITER_COMMENT:
                xmlTextWriterEndComment(writer);
                break;
            default:
                loop = 0;
                continue;
        }

    }

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Write a DTD with a formatted markup declarations part.
 *
 * @param writer  the xmlTextWriter
 * @param name  the name of the DTD
 * @param pubid  the public identifier, which is an alternative to the system identifier
 * @param sysid  the system identifier, which is the URI of the DTD
 * @param format  format string (see printf)
 * @param ...  extra parameters for the format
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteFormatDTD(xmlTextWriter *writer,
                            const xmlChar * name,
                            const xmlChar * pubid,
                            const xmlChar * sysid, const char *format, ...)
{
    xmlSize rc;
    va_list ap;

    va_start(ap, format);

    rc = xmlTextWriterWriteVFormatDTD(writer, name, pubid, sysid, format,
                                      ap);

    va_end(ap);
    return rc;
}

/**
 * Write a DTD with a formatted markup declarations part.
 *
 * @param writer  the xmlTextWriter
 * @param name  the name of the DTD
 * @param pubid  the public identifier, which is an alternative to the system identifier
 * @param sysid  the system identifier, which is the URI of the DTD
 * @param format  format string (see printf)
 * @param argptr  pointer to the first member of the variable argument list.
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteVFormatDTD(xmlTextWriter *writer,
                             const xmlChar * name,
                             const xmlChar * pubid,
                             const xmlChar * sysid,
                             const char *format, va_list argptr)
{
    xmlSize rc;
    xmlChar *buf;

    if (writer == NULL)
        return -1;

    buf = xmlTextWriterVSprintf(writer, format, argptr);
    if (buf == NULL)
        return -1;

    rc = xmlTextWriterWriteDTD(writer, name, pubid, sysid, buf);

    xmlFree(buf);
    return rc;
}

/**
 * Write a DTD.
 *
 * @param writer  the xmlTextWriter
 * @param name  the name of the DTD
 * @param pubid  the public identifier, which is an alternative to the system identifier
 * @param sysid  the system identifier, which is the URI of the DTD
 * @param subset  string content of the DTD
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteDTD(xmlTextWriter *writer,
                      const xmlChar * name,
                      const xmlChar * pubid,
                      const xmlChar * sysid, const xmlChar * subset)
{
    xmlSize oldWritten;

    if (writer == NULL || writer->out == NULL)
        return -1;

    oldWritten = writer->out->written;
    if (xmlTextWriterStartDTD(writer, name, pubid, sysid) < 0)
        return -1;
    if (subset != 0) {
        xmlTextWriterWriteString(writer, subset);
    }
    xmlTextWriterEndDTD(writer);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Start an xml DTD element.
 *
 * @param writer  the xmlTextWriter
 * @param name  the name of the DTD element
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterStartDTDElement(xmlTextWriter *writer, const xmlChar * name)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL ||
        name == NULL || *name == '\0')
        return -1;

    oldWritten = writer->out->written;
    if (writer->nodesNr > 0) {
        p = &writer->nodes[writer->nodesNr-1];
        switch (p->state) {
            case XML_TEXTWRITER_DTD:
                xmlWrite(writer->out, " [", 2);
                if (writer->indent) {
                    xmlWrite(writer->out, "\n", 1);
                }
                p->state = XML_TEXTWRITER_DTD_TEXT;
                /* fallthrough */
            case XML_TEXTWRITER_DTD_TEXT:
            case XML_TEXTWRITER_NONE:
                break;
            default:
                return -1;
        }
    }

    p = xmlWriterPushNode(writer, name, XML_TEXTWRITER_DTD_ELEM);
    if (p == NULL)
        return -1;

    if (writer->indent) {
        xmlTextWriterWriteIndent(writer);
    }

    xmlWrite(writer->out, "<!ELEMENT ", 10);
    xmlWriteString(writer->out, name);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * End an xml DTD element.
 *
 * @param writer  the xmlTextWriter
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterEndDTDElement(xmlTextWriter *writer)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL)
        return -1;

    oldWritten = writer->out->written;
    if (writer->nodesNr <= 0) {
        xmlWriterErr(writer, XML_ERR_ARGUMENT);
        return -1;
    }

    p = &writer->nodes[writer->nodesNr-1];

    switch (p->state) {
        case XML_TEXTWRITER_DTD_ELEM:
        case XML_TEXTWRITER_DTD_ELEM_TEXT:
            xmlWrite(writer->out, ">", 1);
            break;
        default:
            return -1;
    }

    if (writer->indent) {
        xmlWrite(writer->out, "\n", 1);
    }

    xmlWriterPopNode(writer);
    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Write a formatted DTD element.
 *
 * @param writer  the xmlTextWriter
 * @param name  the name of the DTD element
 * @param format  format string (see printf)
 * @param ...  extra parameters for the format
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteFormatDTDElement(xmlTextWriter *writer,
                                   const xmlChar * name,
                                   const char *format, ...)
{
    xmlSize rc;
    va_list ap;

    va_start(ap, format);

    rc = xmlTextWriterWriteVFormatDTDElement(writer, name, format, ap);

    va_end(ap);
    return rc;
}

/**
 * Write a formatted DTD element.
 *
 * @param writer  the xmlTextWriter
 * @param name  the name of the DTD element
 * @param format  format string (see printf)
 * @param argptr  pointer to the first member of the variable argument list.
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteVFormatDTDElement(xmlTextWriter *writer,
                                    const xmlChar * name,
                                    const char *format, va_list argptr)
{
    xmlSize rc;
    xmlChar *buf;

    if (writer == NULL)
        return -1;

    buf = xmlTextWriterVSprintf(writer, format, argptr);
    if (buf == NULL)
        return -1;

    rc = xmlTextWriterWriteDTDElement(writer, name, buf);

    xmlFree(buf);
    return rc;
}

/**
 * Write a DTD element.
 *
 * @param writer  the xmlTextWriter
 * @param name  the name of the DTD element
 * @param content  content of the element
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteDTDElement(xmlTextWriter *writer,
                             const xmlChar * name, const xmlChar * content)
{
    xmlSize oldWritten;

    if (writer == NULL || writer->out == NULL || content == NULL)
        return -1;

    oldWritten = writer->out->written;
    xmlTextWriterStartDTDElement(writer, name);

    xmlTextWriterWriteString(writer, content);

    xmlTextWriterEndDTDElement(writer);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Start an xml DTD ATTLIST.
 *
 * @param writer  the xmlTextWriter
 * @param name  the name of the DTD ATTLIST
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterStartDTDAttlist(xmlTextWriter *writer, const xmlChar * name)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL ||
        name == NULL || *name == '\0')
        return -1;

    oldWritten = writer->out->written;
    if (writer->nodesNr > 0) {
        p = &writer->nodes[writer->nodesNr-1];
        if (p != 0) {
            switch (p->state) {
                case XML_TEXTWRITER_DTD:
                    xmlWrite(writer->out, " [", 2);
                    if (writer->indent) {
                        xmlWrite(writer->out, "\n", 1);
                    }
                    p->state = XML_TEXTWRITER_DTD_TEXT;
                    /* fallthrough */
                case XML_TEXTWRITER_DTD_TEXT:
                case XML_TEXTWRITER_NONE:
                    break;
                default:
                    return -1;
            }
        }
    }

    p = xmlWriterPushNode(writer, name, XML_TEXTWRITER_DTD_ATTL);
    if (p == NULL)
        return -1;

    if (writer->indent) {
        xmlTextWriterWriteIndent(writer);
    }

    xmlWrite(writer->out, "<!ATTLIST ", 10);
    xmlWriteString(writer->out, name);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * End an xml DTD attribute list.
 *
 * @param writer  the xmlTextWriter
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterEndDTDAttlist(xmlTextWriter *writer)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL)
        return -1;

    oldWritten = writer->out->written;
    if (writer->nodesNr <= 0) {
        xmlWriterErr(writer, XML_ERR_ARGUMENT);
        return -1;
    }

    p = &writer->nodes[writer->nodesNr-1];

    switch (p->state) {
        case XML_TEXTWRITER_DTD_ATTL:
        case XML_TEXTWRITER_DTD_ATTL_TEXT:
            xmlWrite(writer->out, ">", 1);
            break;
        default:
            return -1;
    }

    if (writer->indent) {
        xmlWrite(writer->out, "\n", 1);
    }

    xmlWriterPopNode(writer);
    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Write a formatted DTD ATTLIST.
 *
 * @param writer  the xmlTextWriter
 * @param name  the name of the DTD ATTLIST
 * @param format  format string (see printf)
 * @param ...  extra parameters for the format
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteFormatDTDAttlist(xmlTextWriter *writer,
                                   const xmlChar * name,
                                   const char *format, ...)
{
    xmlSize rc;
    va_list ap;

    va_start(ap, format);

    rc = xmlTextWriterWriteVFormatDTDAttlist(writer, name, format, ap);

    va_end(ap);
    return rc;
}

/**
 * Write a formatted DTD ATTLIST.
 *
 * @param writer  the xmlTextWriter
 * @param name  the name of the DTD ATTLIST
 * @param format  format string (see printf)
 * @param argptr  pointer to the first member of the variable argument list.
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteVFormatDTDAttlist(xmlTextWriter *writer,
                                    const xmlChar * name,
                                    const char *format, va_list argptr)
{
    xmlSize rc;
    xmlChar *buf;

    if (writer == NULL)
        return -1;

    buf = xmlTextWriterVSprintf(writer, format, argptr);
    if (buf == NULL)
        return -1;

    rc = xmlTextWriterWriteDTDAttlist(writer, name, buf);

    xmlFree(buf);
    return rc;
}

/**
 * Write a DTD ATTLIST.
 *
 * @param writer  the xmlTextWriter
 * @param name  the name of the DTD ATTLIST
 * @param content  content of the ATTLIST
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteDTDAttlist(xmlTextWriter *writer,
                             const xmlChar * name, const xmlChar * content)
{
    xmlSize oldWritten;

    if (writer == NULL || writer->out == NULL || content == NULL)
        return -1;

    oldWritten = writer->out->written;
    xmlTextWriterStartDTDAttlist(writer, name);

    xmlTextWriterWriteString(writer, content);

    xmlTextWriterEndDTDAttlist(writer);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Start an xml DTD ATTLIST.
 *
 * @param writer  the xmlTextWriter
 * @param pe  TRUE if this is a parameter entity, FALSE if not
 * @param name  the name of the DTD ATTLIST
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterStartDTDEntity(xmlTextWriter *writer,
                            int pe, const xmlChar * name)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;
    xmlTextWriterState state;

    if (writer == NULL || writer->out == NULL ||
        name == NULL || *name == '\0')
        return -1;

    oldWritten = writer->out->written;
    if (writer->nodesNr > 0) {

        p = &writer->nodes[writer->nodesNr-1];
        switch (p->state) {
            case XML_TEXTWRITER_DTD:
                xmlWrite(writer->out, " [", 2);
                if (writer->indent) {
                    xmlWrite(writer->out, "\n", 1);
                }
                p->state = XML_TEXTWRITER_DTD_TEXT;
                /* fallthrough */
            case XML_TEXTWRITER_DTD_TEXT:
            case XML_TEXTWRITER_NONE:
                break;
            default:
                return -1;
        }
    }

    if (pe != 0)
        state = XML_TEXTWRITER_DTD_PENT;
    else
        state = XML_TEXTWRITER_DTD_ENTY;

    p = xmlWriterPushNode(writer, name, state);
    if (p == NULL)
        return -1;

    if (writer->indent) {
        xmlTextWriterWriteIndent(writer);
    }

    xmlWrite(writer->out, "<!ENTITY ", 9);

    if (pe != 0) {
        xmlWrite(writer->out, "% ", 2);
    }

    xmlWriteString(writer->out, name);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * End an xml DTD entity.
 *
 * @param writer  the xmlTextWriter
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterEndDTDEntity(xmlTextWriter *writer)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL)
        return -1;

    oldWritten = writer->out->written;
    if (writer->nodesNr <= 0) {
        xmlWriterErr(writer, XML_ERR_ARGUMENT);
        return -1;
    }

    p = &writer->nodes[writer->nodesNr-1];

    switch (p->state) {
        case XML_TEXTWRITER_DTD_ENTY_TEXT:
            xmlWrite(writer->out, &writer->qchar, 1);
            /* Falls through. */
        case XML_TEXTWRITER_DTD_ENTY:
        case XML_TEXTWRITER_DTD_PENT:
            xmlWrite(writer->out, ">", 1);
            break;
        default:
            return -1;
    }

    if (writer->indent) {
        xmlWrite(writer->out, "\n", 1);
    }

    xmlWriterPopNode(writer);
    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Write a formatted DTD internal entity.
 *
 * @param writer  the xmlTextWriter
 * @param pe  TRUE if this is a parameter entity, FALSE if not
 * @param name  the name of the DTD entity
 * @param format  format string (see printf)
 * @param ...  extra parameters for the format
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteFormatDTDInternalEntity(xmlTextWriter *writer,
                                          int pe,
                                          const xmlChar * name,
                                          const char *format, ...)
{
    xmlSize rc;
    va_list ap;

    va_start(ap, format);

    rc = xmlTextWriterWriteVFormatDTDInternalEntity(writer, pe, name,
                                                    format, ap);

    va_end(ap);
    return rc;
}

/**
 * Write a formatted DTD internal entity.
 *
 * @param writer  the xmlTextWriter
 * @param pe  TRUE if this is a parameter entity, FALSE if not
 * @param name  the name of the DTD entity
 * @param format  format string (see printf)
 * @param argptr  pointer to the first member of the variable argument list.
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteVFormatDTDInternalEntity(xmlTextWriter *writer,
                                           int pe,
                                           const xmlChar * name,
                                           const char *format,
                                           va_list argptr)
{
    xmlSize rc;
    xmlChar *buf;

    if (writer == NULL)
        return -1;

    buf = xmlTextWriterVSprintf(writer, format, argptr);
    if (buf == NULL)
        return -1;

    rc = xmlTextWriterWriteDTDInternalEntity(writer, pe, name, buf);

    xmlFree(buf);
    return rc;
}

/**
 * Write a DTD entity.
 *
 * @param writer  the xmlTextWriter
 * @param pe  TRUE if this is a parameter entity, FALSE if not
 * @param name  the name of the DTD entity
 * @param pubid  the public identifier, which is an alternative to the system identifier
 * @param sysid  the system identifier, which is the URI of the DTD
 * @param ndataid  the xml notation name.
 * @param content  content of the entity
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteDTDEntity(xmlTextWriter *writer,
                            int pe,
                            const xmlChar * name,
                            const xmlChar * pubid,
                            const xmlChar * sysid,
                            const xmlChar * ndataid,
                            const xmlChar * content)
{
    if ((content == NULL) && (pubid == NULL) && (sysid == NULL))
        return -1;
    if ((pe != 0) && (ndataid != NULL))
        return -1;

    if ((pubid == NULL) && (sysid == NULL))
        return xmlTextWriterWriteDTDInternalEntity(writer, pe, name,
                                                   content);

    return xmlTextWriterWriteDTDExternalEntity(writer, pe, name, pubid,
                                               sysid, ndataid);
}

/**
 * Write a DTD internal entity.
 *
 * @param writer  the xmlTextWriter
 * @param pe  TRUE if this is a parameter entity, FALSE if not
 * @param name  the name of the DTD entity
 * @param content  content of the entity
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteDTDInternalEntity(xmlTextWriter *writer,
                                    int pe,
                                    const xmlChar * name,
                                    const xmlChar * content)
{
    xmlSize oldWritten;

    if (writer == NULL || writer->out == NULL ||
        name == NULL || *name == '\0' || content == NULL)
        return -1;

    oldWritten = writer->out->written;
    xmlTextWriterStartDTDEntity(writer, pe, name);

    xmlTextWriterWriteString(writer, content);

    xmlTextWriterEndDTDEntity(writer);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Write a DTD external entity. The entity must have been started with #xmlTextWriterStartDTDEntity
 *
 * @param writer  the xmlTextWriter
 * @param pe  TRUE if this is a parameter entity, FALSE if not
 * @param name  the name of the DTD entity
 * @param pubid  the public identifier, which is an alternative to the system identifier
 * @param sysid  the system identifier, which is the URI of the DTD
 * @param ndataid  the xml notation name.
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteDTDExternalEntity(xmlTextWriter *writer,
                                    int pe,
                                    const xmlChar * name,
                                    const xmlChar * pubid,
                                    const xmlChar * sysid,
                                    const xmlChar * ndataid)
{
    xmlSize oldWritten;

    if (writer == NULL || writer->out == NULL)
        return -1;
    if (((pubid == NULL) && (sysid == NULL)))
        return -1;
    if ((pe != 0) && (ndataid != NULL))
        return -1;

    oldWritten = writer->out->written;
    xmlTextWriterStartDTDEntity(writer, pe, name);

    xmlTextWriterWriteDTDExternalEntityContents(writer, pubid, sysid,
                                                ndataid);

    xmlTextWriterEndDTDEntity(writer);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Write the contents of a DTD external entity.
 *
 * @param writer  the xmlTextWriter
 * @param pubid  the public identifier, which is an alternative to the system identifier
 * @param sysid  the system identifier, which is the URI of the DTD
 * @param ndataid  the xml notation name.
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteDTDExternalEntityContents(xmlTextWriter *writer,
                                            const xmlChar * pubid,
                                            const xmlChar * sysid,
                                            const xmlChar * ndataid)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL)
        return -1;

    oldWritten = writer->out->written;
    if (writer->nodesNr <= 0) {
        xmlWriterErr(writer, XML_ERR_ARGUMENT);
        return -1;
    }

    p = &writer->nodes[writer->nodesNr-1];

    switch (p->state) {
        case XML_TEXTWRITER_DTD_ENTY:
            break;
        case XML_TEXTWRITER_DTD_PENT:
            if (ndataid != NULL) {
                xmlWriterErr(writer, XML_ERR_ARGUMENT);
                return -1;
            }
            break;
        default:
            xmlWriterErr(writer, XML_ERR_ARGUMENT);
            return -1;
    }

    if (pubid != 0) {
        if (sysid == 0) {
            xmlWriterErr(writer, XML_ERR_ARGUMENT);
            return -1;
        }

        xmlWrite(writer->out, " PUBLIC ", 8);

        xmlWrite(writer->out, &writer->qchar, 1);
        xmlWriteString(writer->out, pubid);
        xmlWrite(writer->out, &writer->qchar, 1);
    }

    if (sysid != 0) {
        if (pubid == 0) {
            xmlWrite(writer->out, " SYSTEM", 7);
        }

        xmlWrite(writer->out, " ", 1);

        xmlWrite(writer->out, &writer->qchar, 1);
        xmlWriteString(writer->out, sysid);
        xmlWrite(writer->out, &writer->qchar, 1);
    }

    if (ndataid != NULL) {
        xmlWrite(writer->out, " NDATA ", 6);

        xmlWriteString(writer->out, ndataid);
    }

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Write a DTD entity.
 *
 * @param writer  the xmlTextWriter
 * @param name  the name of the xml notation
 * @param pubid  the public identifier, which is an alternative to the system identifier
 * @param sysid  the system identifier, which is the URI of the DTD
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterWriteDTDNotation(xmlTextWriter *writer,
                              const xmlChar * name,
                              const xmlChar * pubid, const xmlChar * sysid)
{
    xmlSize oldWritten;
    xmlTextWriterStackEntry *p;

    if (writer == NULL || writer->out == NULL ||
        name == NULL || *name == '\0')
        return -1;

    oldWritten = writer->out->written;
    if (writer->nodesNr <= 0) {
        xmlWriterErr(writer, XML_ERR_ARGUMENT);
        return -1;
    }

    p = &writer->nodes[writer->nodesNr-1];
    switch (p->state) {
        case XML_TEXTWRITER_DTD:
            xmlWrite(writer->out, " [", 2);
            if (writer->indent) {
                xmlWrite(writer->out, "\n", 1);
            }
            p->state = XML_TEXTWRITER_DTD_TEXT;
            /* fallthrough */
        case XML_TEXTWRITER_DTD_TEXT:
            break;
        default:
            return -1;
    }

    if (writer->indent) {
        xmlTextWriterWriteIndent(writer);
    }

    xmlWrite(writer->out, "<!NOTATION ", 11);
    xmlWriteString(writer->out, name);

    if (pubid != 0) {
        xmlWrite(writer->out, " PUBLIC ", 8);
        xmlWrite(writer->out, &writer->qchar, 1);
        xmlWriteString(writer->out, pubid);
        xmlWrite(writer->out, &writer->qchar, 1);
    }

    if (sysid != 0) {
        if (pubid == 0) {
            xmlWrite(writer->out, " SYSTEM", 7);
        }
        xmlWrite(writer->out, " ", 1);
        xmlWrite(writer->out, &writer->qchar, 1);
        xmlWriteString(writer->out, sysid);
        xmlWrite(writer->out, &writer->qchar, 1);
    }

    xmlWrite(writer->out, ">", 1);

    return writer->out->error ? -1 : writer->out->written - oldWritten;
}

/**
 * Flush the output buffer.
 *
 * @param writer  the xmlTextWriter
 * @returns the bytes written (may be 0 because of buffering) or -1 in case of error
 */
xmlSize
xmlTextWriterFlush(xmlTextWriter *writer)
{

    if (writer == NULL)
        return -1;

    if (writer->out == NULL)
        return 0;

    return xmlOutputBufferFlush(writer->out);
}

/**
 * Flushes and closes the output buffer.
 *
 * @since 2.13.0
 *
 * @param writer  the xmlTextWriter
 * @returns an xmlParserErrors code.
 */
int
xmlTextWriterClose(xmlTextWriter *writer)
{
    xmlSize result;

    if (writer == NULL)
        return XML_ERR_ARGUMENT;

    if (writer->out != NULL) {
        result = xmlOutputBufferClose(writer->out);
        if (result < 0)
            xmlWriterErr(writer, -result);
        writer->out = NULL;
    }

    return writer->errNo;
}

/**
 * misc
 */

/**
 * Output the current namespace declarations.
 *
 * @param writer  the xmlTextWriter
 */
static void
xmlTextWriterOutputNSDecl(xmlTextWriterPtr writer)
{
    xmlTextWriterNsStackEntry *np;
    int i;

    for (i = writer->nsstackNr - 1; i >= 0; i--) {
        xmlChar *namespaceURI;
        xmlChar *prefix;
        xmlChar namebuf[50];
        xmlChar *qname;

        np = &writer->nsstack[i];

        namespaceURI = np->uri;
        prefix = np->prefix;

        if (prefix == NULL) {
            qname = BAD_CAST "xmlns";
        } else {
            qname = xmlBuildQName(prefix, BAD_CAST "xmlns",
                                  namebuf, sizeof(namebuf));
            if (qname == NULL) {
                xmlWriterErr(writer, XML_ERR_NO_MEMORY);
                goto next_entry;
            }
        }

        xmlTextWriterWriteAttribute(writer, qname, namespaceURI);
        if (prefix != NULL && qname != namebuf)
            xmlFree(qname);

next_entry:
        xmlFree(namespaceURI);
        xmlFree(prefix);
    }

    writer->nsstackNr = 0;
}

/**
 * Write callback for the xmlOutputBuffer with target xmlBuffer
 *
 * @param context  the xmlBuffer
 * @param str  the data to write
 * @param len  the length of the data
 * @returns -1, 0, 1
 */
static xmlSize
xmlTextWriterWriteDocCallback(void *context, const char *str, xmlSize len)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) context;
    int rc;

    rc = xmlParseChunk(ctxt, str, len, 0);
    if (rc != 0)
        return -rc;

    return len;
}

/**
 * Close callback for the xmlOutputBuffer with target xmlBuffer
 *
 * @param context  the xmlBuffer
 * @returns -1, 0, 1
 */
static int
xmlTextWriterCloseDocCallback(void *context)
{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) context;
    int rc;

    rc = xmlParseChunk(ctxt, NULL, 0, 1);
    if (rc != 0)
        return rc;

    return 0;
}

/**
 * Utility function for formatted output
 *
 * @param writer  the xmlTextWriter
 * @param format  see printf
 * @param argptr  pointer to the first member of the variable argument list.
 * @returns a new xmlChar buffer with the data or NULL on error. This buffer must be freed.
 */
static xmlChar *
xmlTextWriterVSprintf(xmlTextWriter *writer, const char *format,
                      va_list argptr)
{
    xmlChar *buf = NULL;

    if (xmlStrVASPrintf(&buf, XML_MAX_ITEMS, format, argptr) < 0) {
        xmlWriterErr(writer, XML_ERR_NO_MEMORY);
        return NULL;
    }

    return buf;
}

/**
 * Set indentation output. indent = 0 do not indentation. indent > 0 do indentation.
 *
 * @param writer  the xmlTextWriter
 * @param indent  do indentation?
 * @returns -1 on error or 0 otherwise.
 */
int
xmlTextWriterSetIndent(xmlTextWriter *writer, int indent)
{
    if ((writer == NULL) || (indent < 0))
        return -1;

    writer->indent = indent;
    writer->doindent = 1;

    return 0;
}

/**
 * Set string indentation.
 *
 * @param writer  the xmlTextWriter
 * @param str  the xmlChar string
 * @returns -1 on error or 0 otherwise.
 */
int
xmlTextWriterSetIndentString(xmlTextWriter *writer, const xmlChar * str)
{
    if ((writer == NULL) || (!str))
        return -1;

    if (writer->ichar != NULL)
        xmlFree(writer->ichar);
    writer->ichar = xmlStrdup(str);

    if (!writer->ichar) {
        xmlWriterErr(writer, XML_ERR_NO_MEMORY);
        return -1;
    } else {
        return 0;
    }
}

/**
 * Set the character used for quoting attributes.
 *
 * @param writer  the xmlTextWriter
 * @param quotechar  the quote character
 * @returns -1 on error or 0 otherwise.
 */
int
xmlTextWriterSetQuoteChar(xmlTextWriter *writer, xmlChar quotechar)
{
    if ((writer == NULL) || ((quotechar != '\'') && (quotechar != '"')))
        return -1;

    writer->qchar = quotechar;

    return 0;
}

/**
 * Write indent string.
 *
 * @param writer  the xmlTextWriter
 * @returns -1 on error or the number of strings written.
 */
static void
xmlTextWriterWriteIndent(xmlTextWriterPtr writer)
{
    int lksize;
    int i;

    lksize = writer->nodesNr;
    if (lksize > 100)
        lksize = 100;
    for (i = 0; i < (lksize - 1); i++) {
        xmlWriteString(writer->out, writer->ichar);
    }
}

/**
 * Write state dependent strings.
 *
 * @param writer  the xmlTextWriter
 * @param p  the xmlTextWriterStackEntry
 * @returns -1 on error or the number of characters written.
 */
static void
xmlTextWriterHandleStateDependencies(xmlTextWriterPtr writer,
                                     xmlTextWriterStackEntry * p)
{
    char extra[3];
    xmlSize extraLen;

    if (writer == NULL)
        return;

    if (p == NULL)
        return;

    extra[0] = extra[1] = extra[2] = '\0';
    extraLen = 1;
    if (p != 0) {
        switch (p->state) {
            case XML_TEXTWRITER_NAME:
                /* Output namespace declarations */
                xmlTextWriterOutputNSDecl(writer);
                extra[0] = '>';
                p->state = XML_TEXTWRITER_TEXT;
                break;
            case XML_TEXTWRITER_PI:
                extra[0] = ' ';
                p->state = XML_TEXTWRITER_PI_TEXT;
                break;
            case XML_TEXTWRITER_DTD:
                extra[0] = ' ';
                extra[1] = '[';
                extraLen = 2;
                p->state = XML_TEXTWRITER_DTD_TEXT;
                break;
            case XML_TEXTWRITER_DTD_ELEM:
                extra[0] = ' ';
                p->state = XML_TEXTWRITER_DTD_ELEM_TEXT;
                break;
            case XML_TEXTWRITER_DTD_ATTL:
                extra[0] = ' ';
                p->state = XML_TEXTWRITER_DTD_ATTL_TEXT;
                break;
            case XML_TEXTWRITER_DTD_ENTY:
            case XML_TEXTWRITER_DTD_PENT:
                extra[0] = ' ';
                extra[1] = writer->qchar;
                extraLen = 2;
                p->state = XML_TEXTWRITER_DTD_ENTY_TEXT;
                break;
            default:
                break;
        }
    }

    if (*extra != '\0') {
        xmlWrite(writer->out, extra, extraLen);
    }
}

#endif