/*
* xmlwriter.c: XML text writer implementation
*
* For license and disclaimer see the license and disclaimer of
* libxml2.
*
* alfred@mickautsch.de
*/
#define IN_LIBXML
#include "libxml.h"
#include <string.h>
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include <libxml/uri.h>
#include <libxml/HTMLtree.h>
#ifdef LIBXML_WRITER_ENABLED
#include <libxml/xmlwriter.h>
#define B64LINELEN 72
#define B64CRLF "\r\n"
/*
* The following VA_COPY was coded following an example in
* the Samba project. It may not be sufficient for some
* esoteric implementations of va_list (i.e. it may need
* something involving a memcpy) but (hopefully) will be
* sufficient for libxml2.
*/
#ifndef VA_COPY
#ifdef HAVE_VA_COPY
#define VA_COPY(dest, src) va_copy(dest, src)
#else
#ifdef HAVE___VA_COPY
#define VA_COPY(dest,src) __va_copy(dest, src)
#else
#define VA_COPY(dest,src) (dest) = (src)
#endif
#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;
xmlLinkPtr elem;
};
struct _xmlTextWriter {
xmlOutputBufferPtr out; /* output buffer */
xmlListPtr nodes; /* element name stack */
xmlListPtr nsstack; /* name spaces stack */
int level;
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;
xmlDocPtr doc;
};
static void xmlFreeTextWriterStackEntry(xmlLinkPtr lk);
static int xmlCmpTextWriterStackEntry(const void *data0,
const void *data1);
static int xmlTextWriterOutputNSDecl(xmlTextWriterPtr writer);
static void xmlFreeTextWriterNsStackEntry(xmlLinkPtr lk);
static int xmlCmpTextWriterNsStackEntry(const void *data0,
const void *data1);
static int xmlTextWriterWriteDocCallback(void *context,
const xmlChar * str, int len);
static int xmlTextWriterCloseDocCallback(void *context);
static xmlChar *xmlTextWriterVSprintf(const char *format, va_list argptr);
static int xmlOutputBufferWriteBase64(xmlOutputBufferPtr out, int len,
const unsigned char *data);
static void xmlTextWriterStartDocumentCallback(void *ctx);
static int xmlTextWriterWriteIndent(xmlTextWriterPtr writer);
static int
xmlTextWriterHandleStateDependencies(xmlTextWriterPtr writer,
xmlTextWriterStackEntry * p);
/**
* xmlWriterErrMsg:
* @ctxt: a writer context
* @error: the error number
* @msg: the error message
*
* Handle a writer error
*/
static void
xmlWriterErrMsg(xmlTextWriterPtr ctxt, xmlParserErrors error,
const char *msg)
{
if (ctxt != NULL) {
__xmlRaiseError(NULL, NULL, NULL, ctxt->ctxt,
NULL, XML_FROM_WRITER, error, XML_ERR_FATAL,
NULL, 0, NULL, NULL, NULL, 0, 0, "%s", msg);
} else {
__xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_WRITER, error,
XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0, "%s", msg);
}
}
/**
* xmlWriterErrMsgInt:
* @ctxt: a writer context
* @error: the error number
* @msg: the error message
* @val: an int
*
* Handle a writer error
*/
static void
xmlWriterErrMsgInt(xmlTextWriterPtr ctxt, xmlParserErrors error,
const char *msg, int val)
{
if (ctxt != NULL) {
__xmlRaiseError(NULL, NULL, NULL, ctxt->ctxt,
NULL, XML_FROM_WRITER, error, XML_ERR_FATAL,
NULL, 0, NULL, NULL, NULL, val, 0, msg, val);
} else {
__xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_WRITER, error,
XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, val, 0, msg, val);
}
}
/**
* xmlNewTextWriter:
* @out: an xmlOutputBufferPtr
*
* Create a new xmlNewTextWriter structure using an xmlOutputBufferPtr
* NOTE: the @out parameter will be deallocated when the writer is closed
* (if the call succeed.)
*
* Returns the new xmlTextWriterPtr or NULL in case of error
*/
xmlTextWriterPtr
xmlNewTextWriter(xmlOutputBufferPtr out)
{
xmlTextWriterPtr ret;
ret = (xmlTextWriterPtr) xmlMalloc(sizeof(xmlTextWriter));
if (ret == NULL) {
xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
"xmlNewTextWriter : out of memory!\n");
return NULL;
}
memset(ret, 0, (size_t) sizeof(xmlTextWriter));
ret->nodes = xmlListCreate((xmlListDeallocator)
xmlFreeTextWriterStackEntry,
(xmlListDataCompare)
xmlCmpTextWriterStackEntry);
if (ret->nodes == NULL) {
xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
"xmlNewTextWriter : out of memory!\n");
xmlFree(ret);
return NULL;
}
ret->nsstack = xmlListCreate((xmlListDeallocator)
xmlFreeTextWriterNsStackEntry,
(xmlListDataCompare)
xmlCmpTextWriterNsStackEntry);
if (ret->nsstack == NULL) {
xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
"xmlNewTextWriter : out of memory!\n");
xmlListDelete(ret->nodes);
xmlFree(ret);
return NULL;
}
ret->out = out;
ret->ichar = xmlStrdup(BAD_CAST " ");
ret->qchar = '"';
if (!ret->ichar) {
xmlListDelete(ret->nodes);
xmlListDelete(ret->nsstack);
xmlFree(ret);
xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
"xmlNewTextWriter : out of memory!\n");
return NULL;
}
ret->doc = xmlNewDoc(NULL);
ret->no_doc_free = 0;
return ret;
}
/**
* xmlNewTextWriterFilename:
* @uri: the URI of the resource for the output
* @compression: compress the output?
*
* Create a new xmlNewTextWriter structure with @uri as output
*
* Returns the new xmlTextWriterPtr or NULL in case of error
*/
xmlTextWriterPtr
xmlNewTextWriterFilename(const char *uri, int compression)
{
xmlTextWriterPtr ret;
xmlOutputBufferPtr out;
out = xmlOutputBufferCreateFilename(uri, NULL, compression);
if (out == NULL) {
xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
"xmlNewTextWriterFilename : out of memory!\n");
return NULL;
}
ret = xmlNewTextWriter(out);
if (ret == NULL) {
xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
"xmlNewTextWriterFilename : out of memory!\n");
xmlOutputBufferClose(out);
return NULL;
}
ret->indent = 0;
ret->doindent = 0;
return ret;
}
/**
* xmlNewTextWriterMemory:
* @buf: xmlBufferPtr
* @compression: compress the output?
*
* Create a new xmlNewTextWriter structure with @buf as output
* TODO: handle compression
*
* Returns the new xmlTextWriterPtr or NULL in case of error
*/
xmlTextWriterPtr
xmlNewTextWriterMemory(xmlBufferPtr buf, int compression ATTRIBUTE_UNUSED)
{
xmlTextWriterPtr ret;
xmlOutputBufferPtr out;
/*::todo handle compression */
out = xmlOutputBufferCreateBuffer(buf, NULL);
if (out == NULL) {
xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
"xmlNewTextWriterMemory : out of memory!\n");
return NULL;
}
ret = xmlNewTextWriter(out);
if (ret == NULL) {
xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
"xmlNewTextWriterMemory : out of memory!\n");
xmlOutputBufferClose(out);
return NULL;
}
return ret;
}
/**
* xmlNewTextWriterPushParser:
* @ctxt: xmlParserCtxtPtr to hold the new XML document tree
* @compression: compress the output?
*
* Create a new xmlNewTextWriter structure with @ctxt as output
* NOTE: the @ctxt context will be freed with the resulting writer
* (if the call succeeds).
* TODO: handle compression
*
* Returns the new xmlTextWriterPtr or NULL in case of error
*/
xmlTextWriterPtr
xmlNewTextWriterPushParser(xmlParserCtxtPtr ctxt,
int compression ATTRIBUTE_UNUSED)
{
xmlTextWriterPtr ret;
xmlOutputBufferPtr out;
if (ctxt == NULL) {
xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
"xmlNewTextWriterPushParser : invalid context!\n");
return NULL;
}
out = xmlOutputBufferCreateIO((xmlOutputWriteCallback)
xmlTextWriterWriteDocCallback,
(xmlOutputCloseCallback)
xmlTextWriterCloseDocCallback,
(void *) ctxt, NULL);
if (out == NULL) {
xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
"xmlNewTextWriterPushParser : error at xmlOutputBufferCreateIO!\n");
return NULL;
}
ret = xmlNewTextWriter(out);
if (ret == NULL) {
xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
"xmlNewTextWriterPushParser : error at xmlNewTextWriter!\n");
xmlOutputBufferClose(out);
return NULL;
}
ret->ctxt = ctxt;
return ret;
}
/**
* xmlNewTextWriterDoc:
* @doc: address of a xmlDocPtr to hold the new XML document tree
* @compression: compress the output?
*
* Create a new xmlNewTextWriter structure with @*doc as output
*
* Returns the new xmlTextWriterPtr or NULL in case of error
*/
xmlTextWriterPtr
xmlNewTextWriterDoc(xmlDocPtr * doc, int compression)
{
xmlTextWriterPtr ret;
xmlSAXHandler saxHandler;
xmlParserCtxtPtr ctxt;
memset(&saxHandler, '\0', sizeof(saxHandler));
xmlSAX2InitDefaultSAXHandler(&saxHandler, 1);
saxHandler.startDocument = xmlTextWriterStartDocumentCallback;
saxHandler.startElement = xmlSAX2StartElement;
saxHandler.endElement = xmlSAX2EndElement;
ctxt = xmlCreatePushParserCtxt(&saxHandler, NULL, NULL, 0, NULL);
if (ctxt == NULL) {
xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
"xmlNewTextWriterDoc : error at xmlCreatePushParserCtxt!\n");
return NULL;
}
/*
* For some reason this seems to completely break if node names
* are interned.
*/
ctxt->dictNames = 0;
ctxt->myDoc = xmlNewDoc(BAD_CAST XML_DEFAULT_VERSION);
if (ctxt->myDoc == NULL) {
xmlFreeParserCtxt(ctxt);
xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
"xmlNewTextWriterDoc : error at xmlNewDoc!\n");
return NULL;
}
ret = xmlNewTextWriterPushParser(ctxt, compression);
if (ret == NULL) {
xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
"xmlNewTextWriterDoc : error at xmlNewTextWriterPushParser!\n");
return NULL;
}
xmlSetDocCompressMode(ctxt->myDoc, compression);
if (doc != NULL) {
*doc = ctxt->myDoc;
ret->no_doc_free = 1;
}
return ret;
}
/**
* xmlNewTextWriterTree:
* @doc: xmlDocPtr
* @node: xmlNodePtr or NULL for doc->children
* @compression: compress the output?
*
* Create a new xmlNewTextWriter structure with @doc as output
* starting at @node
*
* Returns the new xmlTextWriterPtr or NULL in case of error
*/
xmlTextWriterPtr
xmlNewTextWriterTree(xmlDocPtr doc, xmlNodePtr node, int compression)
{
xmlTextWriterPtr ret;
xmlSAXHandler saxHandler;
xmlParserCtxtPtr ctxt;
if (doc == NULL) {
xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
"xmlNewTextWriterTree : invalid document tree!\n");
return NULL;
}
memset(&saxHandler, '\0', sizeof(saxHandler));
xmlSAX2InitDefaultSAXHandler(&saxHandler, 1);
saxHandler.startDocument = xmlTextWriterStartDocumentCallback;
saxHandler.startElement = xmlSAX2StartElement;
saxHandler.endElement = xmlSAX2EndElement;
ctxt = xmlCreatePushParserCtxt(&saxHandler, NULL, NULL, 0, NULL);
if (ctxt == NULL) {
xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
"xmlNewTextWriterDoc : error at xmlCreatePushParserCtxt!\n");
return NULL;
}
/*
* For some reason this seems to completely break if node names
* are interned.
*/
ctxt->dictNames = 0;
ret = xmlNewTextWriterPushParser(ctxt, compression);
if (ret == NULL) {
xmlFreeParserCtxt(ctxt);
xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
"xmlNewTextWriterDoc : error at xmlNewTextWriterPushParser!\n");
return NULL;
}
ctxt->myDoc = doc;
ctxt->node = node;
ret->no_doc_free = 1;
xmlSetDocCompressMode(doc, compression);
return ret;
}
/**
* xmlFreeTextWriter:
* @writer: the xmlTextWriterPtr
*
* Deallocate all the resources associated to the writer
*/
void
xmlFreeTextWriter(xmlTextWriterPtr writer)
{
if (writer == NULL)
return;
if (writer->out != NULL)
xmlOutputBufferClose(writer->out);
if (writer->nodes != NULL)
xmlListDelete(writer->nodes);
if (writer->nsstack != NULL)
xmlListDelete(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->doc != NULL)
xmlFreeDoc(writer->doc);
if (writer->ichar != NULL)
xmlFree(writer->ichar);
xmlFree(writer);
}
/**
* xmlTextWriterStartDocument:
* @writer: the xmlTextWriterPtr
* @version: the xml version ("1.0") or NULL for default ("1.0")
* @encoding: the encoding or NULL for default
* @standalone: "yes" or "no" or NULL for default
*
* Start a new xml document
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterStartDocument(xmlTextWriterPtr writer, const char *version,
const char *encoding, const char *standalone)
{
int count;
int sum;
xmlLinkPtr lk;
xmlCharEncodingHandlerPtr encoder;
if ((writer == NULL) || (writer->out == NULL)) {
xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterStartDocument : invalid writer!\n");
return -1;
}
lk = xmlListFront(writer->nodes);
if ((lk != NULL) && (xmlLinkGetData(lk) != NULL)) {
xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterStartDocument : not allowed in this context!\n");
return -1;
}
encoder = NULL;
if (encoding != NULL) {
encoder = xmlFindCharEncodingHandler(encoding);
if (encoder == NULL) {
xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartDocument : out of memory!\n");
return -1;
}
}
writer->out->encoder = encoder;
if (encoder != NULL) {
if (writer->out->conv == NULL) {
writer->out->conv = xmlBufferCreateSize(4000);
}
xmlCharEncOutFunc(encoder, writer->out->conv, NULL);
if ((writer->doc != NULL) && (writer->doc->encoding == NULL))
writer->doc->encoding = xmlStrdup((xmlChar *)writer->out->encoder->name);
} else
writer->out->conv = NULL;
sum = 0;
count = xmlOutputBufferWriteString(writer->out, "<?xml version=");
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
if (count < 0)
return -1;
sum += count;
if (version != 0)
count = xmlOutputBufferWriteString(writer->out, version);
else
count = xmlOutputBufferWriteString(writer->out, "1.0");
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
if (count < 0)
return -1;
sum += count;
if (writer->out->encoder != 0) {
count = xmlOutputBufferWriteString(writer->out, " encoding=");
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
if (count < 0)
return -1;
sum += count;
count =
xmlOutputBufferWriteString(writer->out,
writer->out->encoder->name);
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
if (count < 0)
return -1;
sum += count;
}
if (standalone != 0) {
count = xmlOutputBufferWriteString(writer->out, " standalone=");
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWriteString(writer->out, standalone);
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
if (count < 0)
return -1;
sum += count;
}
count = xmlOutputBufferWriteString(writer->out, "?>\n");
if (count < 0)
return -1;
sum += count;
return sum;
}
/**
* xmlTextWriterEndDocument:
* @writer: the xmlTextWriterPtr
*
* End an xml document. All open elements are closed, and
* the content is flushed to the output.
*
* Returns the bytes written or -1 in case of error
*/
int
xmlTextWriterEndDocument(xmlTextWriterPtr writer)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL) {
xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterEndDocument : invalid writer!\n");
return -1;
}
sum = 0;
while ((lk = xmlListFront(writer->nodes)) != NULL) {
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p == 0)
break;
switch (p->state) {
case XML_TEXTWRITER_NAME:
case XML_TEXTWRITER_ATTRIBUTE:
case XML_TEXTWRITER_TEXT:
count = xmlTextWriterEndElement(writer);
if (count < 0)
return -1;
sum += count;
break;
case XML_TEXTWRITER_PI:
case XML_TEXTWRITER_PI_TEXT:
count = xmlTextWriterEndPI(writer);
if (count < 0)
return -1;
sum += count;
break;
case XML_TEXTWRITER_CDATA:
count = xmlTextWriterEndCDATA(writer);
if (count < 0)
return -1;
sum += count;
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:
count = xmlTextWriterEndDTD(writer);
if (count < 0)
return -1;
sum += count;
break;
case XML_TEXTWRITER_COMMENT:
count = xmlTextWriterEndComment(writer);
if (count < 0)
return -1;
sum += count;
break;
default:
break;
}
}
if (!writer->indent) {
count = xmlOutputBufferWriteString(writer->out, "\n");
if (count < 0)
return -1;
sum += count;
}
sum += xmlTextWriterFlush(writer);
return sum;
}
/**
* xmlTextWriterStartComment:
* @writer: the xmlTextWriterPtr
*
* Start an xml comment.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterStartComment(xmlTextWriterPtr writer)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL) {
xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterStartComment : invalid writer!\n");
return -1;
}
sum = 0;
lk = xmlListFront(writer->nodes);
if (lk != 0) {
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p != 0) {
switch (p->state) {
case XML_TEXTWRITER_TEXT:
case XML_TEXTWRITER_NONE:
break;
case XML_TEXTWRITER_NAME:
/* Output namespace declarations */
count = xmlTextWriterOutputNSDecl(writer);
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWriteString(writer->out, ">");
if (count < 0)
return -1;
sum += count;
if (writer->indent) {
count =
xmlOutputBufferWriteString(writer->out, "\n");
if (count < 0)
return -1;
sum += count;
}
p->state = XML_TEXTWRITER_TEXT;
break;
default:
return -1;
}
}
}
p = (xmlTextWriterStackEntry *)
xmlMalloc(sizeof(xmlTextWriterStackEntry));
if (p == 0) {
xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartElement : out of memory!\n");
return -1;
}
p->name = NULL;
p->state = XML_TEXTWRITER_COMMENT;
xmlListPushFront(writer->nodes, p);
if (writer->indent) {
count = xmlTextWriterWriteIndent(writer);
if (count < 0)
return -1;
sum += count;
}
count = xmlOutputBufferWriteString(writer->out, "<!--");
if (count < 0)
return -1;
sum += count;
return sum;
}
/**
* xmlTextWriterEndComment:
* @writer: the xmlTextWriterPtr
*
* End the current xml coment.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterEndComment(xmlTextWriterPtr writer)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL) {
xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterEndComment : invalid writer!\n");
return -1;
}
lk = xmlListFront(writer->nodes);
if (lk == 0) {
xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterEndComment : not allowed in this context!\n");
return -1;
}
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p == 0)
return -1;
sum = 0;
switch (p->state) {
case XML_TEXTWRITER_COMMENT:
count = xmlOutputBufferWriteString(writer->out, "-->");
if (count < 0)
return -1;
sum += count;
break;
default:
return -1;
}
if (writer->indent) {
count = xmlOutputBufferWriteString(writer->out, "\n");
if (count < 0)
return -1;
sum += count;
}
xmlListPopFront(writer->nodes);
return sum;
}
/**
* xmlTextWriterWriteFormatComment:
* @writer: the xmlTextWriterPtr
* @format: format string (see printf)
* @...: extra parameters for the format
*
* Write an xml comment.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int XMLCDECL
xmlTextWriterWriteFormatComment(xmlTextWriterPtr writer,
const char *format, ...)
{
int rc;
va_list ap;
va_start(ap, format);
rc = xmlTextWriterWriteVFormatComment(writer, format, ap);
va_end(ap);
return rc;
}
/**
* xmlTextWriterWriteVFormatComment:
* @writer: the xmlTextWriterPtr
* @format: format string (see printf)
* @argptr: pointer to the first member of the variable argument list.
*
* Write an xml comment.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteVFormatComment(xmlTextWriterPtr writer,
const char *format, va_list argptr)
{
int rc;
xmlChar *buf;
if (writer == NULL) {
xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterWriteVFormatComment : invalid writer!\n");
return -1;
}
buf = xmlTextWriterVSprintf(format, argptr);
if (buf == 0)
return 0;
rc = xmlTextWriterWriteComment(writer, buf);
xmlFree(buf);
return rc;
}
/**
* xmlTextWriterWriteComment:
* @writer: the xmlTextWriterPtr
* @content: comment string
*
* Write an xml comment.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteComment(xmlTextWriterPtr writer, const xmlChar * content)
{
int count;
int sum;
sum = 0;
count = xmlTextWriterStartComment(writer);
if (count < 0)
return -1;
sum += count;
count = xmlTextWriterWriteString(writer, content);
if (count < 0)
return -1;
sum += count;
count = xmlTextWriterEndComment(writer);
if (count < 0)
return -1;
sum += count;
return sum;
}
/**
* xmlTextWriterStartElement:
* @writer: the xmlTextWriterPtr
* @name: element name
*
* Start an xml element.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterStartElement(xmlTextWriterPtr writer, const xmlChar * name)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if ((writer == NULL) || (name == NULL) || (*name == '\0'))
return -1;
sum = 0;
lk = xmlListFront(writer->nodes);
if (lk != 0) {
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p != 0) {
switch (p->state) {
case XML_TEXTWRITER_PI:
case XML_TEXTWRITER_PI_TEXT:
return -1;
case XML_TEXTWRITER_NONE:
break;
case XML_TEXTWRITER_ATTRIBUTE:
count = xmlTextWriterEndAttribute(writer);
if (count < 0)
return -1;
sum += count;
/* fallthrough */
case XML_TEXTWRITER_NAME:
/* Output namespace declarations */
count = xmlTextWriterOutputNSDecl(writer);
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWriteString(writer->out, ">");
if (count < 0)
return -1;
sum += count;
if (writer->indent)
count =
xmlOutputBufferWriteString(writer->out, "\n");
p->state = XML_TEXTWRITER_TEXT;
break;
default:
break;
}
}
}
p = (xmlTextWriterStackEntry *)
xmlMalloc(sizeof(xmlTextWriterStackEntry));
if (p == 0) {
xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartElement : out of memory!\n");
return -1;
}
p->name = xmlStrdup(name);
if (p->name == 0) {
xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartElement : out of memory!\n");
xmlFree(p);
return -1;
}
p->state = XML_TEXTWRITER_NAME;
xmlListPushFront(writer->nodes, p);
if (writer->indent) {
count = xmlTextWriterWriteIndent(writer);
sum += count;
}
count = xmlOutputBufferWriteString(writer->out, "<");
if (count < 0)
return -1;
sum += count;
count =
xmlOutputBufferWriteString(writer->out, (const char *) p->name);
if (count < 0)
return -1;
sum += count;
return sum;
}
/**
* xmlTextWriterStartElementNS:
* @writer: the xmlTextWriterPtr
* @prefix: namespace prefix or NULL
* @name: element local name
* @namespaceURI: namespace URI or NULL
*
* Start an xml element with namespace support.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterStartElementNS(xmlTextWriterPtr writer,
const xmlChar * prefix, const xmlChar * name,
const xmlChar * namespaceURI)
{
int count;
int sum;
xmlChar *buf;
if ((writer == NULL) || (name == NULL) || (*name == '\0'))
return -1;
buf = NULL;
if (prefix != 0) {
buf = xmlStrdup(prefix);
buf = xmlStrcat(buf, BAD_CAST ":");
}
buf = xmlStrcat(buf, name);
sum = 0;
count = xmlTextWriterStartElement(writer, buf);
xmlFree(buf);
if (count < 0)
return -1;
sum += count;
if (namespaceURI != 0) {
xmlTextWriterNsStackEntry *p = (xmlTextWriterNsStackEntry *)
xmlMalloc(sizeof(xmlTextWriterNsStackEntry));
if (p == 0) {
xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartElementNS : out of memory!\n");
return -1;
}
buf = xmlStrdup(BAD_CAST "xmlns");
if (prefix != 0) {
buf = xmlStrcat(buf, BAD_CAST ":");
buf = xmlStrcat(buf, prefix);
}
p->prefix = buf;
p->uri = xmlStrdup(namespaceURI);
if (p->uri == 0) {
xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartElementNS : out of memory!\n");
xmlFree(p);
return -1;
}
p->elem = xmlListFront(writer->nodes);
xmlListPushFront(writer->nsstack, p);
}
return sum;
}
/**
* xmlTextWriterEndElement:
* @writer: the xmlTextWriterPtr
*
* End the current xml element.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterEndElement(xmlTextWriterPtr writer)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL)
return -1;
lk = xmlListFront(writer->nodes);
if (lk == 0) {
xmlListDelete(writer->nsstack);
writer->nsstack = NULL;
return -1;
}
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p == 0) {
xmlListDelete(writer->nsstack);
writer->nsstack = NULL;
return -1;
}
sum = 0;
switch (p->state) {
case XML_TEXTWRITER_ATTRIBUTE:
count = xmlTextWriterEndAttribute(writer);
if (count < 0) {
xmlListDelete(writer->nsstack);
writer->nsstack = NULL;
return -1;
}
sum += count;
/* fallthrough */
case XML_TEXTWRITER_NAME:
/* Output namespace declarations */
count = xmlTextWriterOutputNSDecl(writer);
if (count < 0)
return -1;
sum += count;
if (writer->indent) /* next element needs indent */
writer->doindent = 1;
count = xmlOutputBufferWriteString(writer->out, "/>");
if (count < 0)
return -1;
sum += count;
break;
case XML_TEXTWRITER_TEXT:
if ((writer->indent) && (writer->doindent)) {
count = xmlTextWriterWriteIndent(writer);
sum += count;
writer->doindent = 1;
} else
writer->doindent = 1;
count = xmlOutputBufferWriteString(writer->out, "</");
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWriteString(writer->out,
(const char *) p->name);
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWriteString(writer->out, ">");
if (count < 0)
return -1;
sum += count;
break;
default:
return -1;
}
if (writer->indent) {
count = xmlOutputBufferWriteString(writer->out, "\n");
sum += count;
}
xmlListPopFront(writer->nodes);
return sum;
}
/**
* xmlTextWriterFullEndElement:
* @writer: the xmlTextWriterPtr
*
* End the current xml element. Writes an end tag even if the element is empty
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterFullEndElement(xmlTextWriterPtr writer)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL)
return -1;
lk = xmlListFront(writer->nodes);
if (lk == 0)
return -1;
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p == 0)
return -1;
sum = 0;
switch (p->state) {
case XML_TEXTWRITER_ATTRIBUTE:
count = xmlTextWriterEndAttribute(writer);
if (count < 0)
return -1;
sum += count;
/* fallthrough */
case XML_TEXTWRITER_NAME:
/* Output namespace declarations */
count = xmlTextWriterOutputNSDecl(writer);
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWriteString(writer->out, ">");
if (count < 0)
return -1;
sum += count;
if (writer->indent)
writer->doindent = 0;
/* fallthrough */
case XML_TEXTWRITER_TEXT:
if ((writer->indent) && (writer->doindent)) {
count = xmlTextWriterWriteIndent(writer);
sum += count;
writer->doindent = 1;
} else
writer->doindent = 1;
count = xmlOutputBufferWriteString(writer->out, "</");
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWriteString(writer->out,
(const char *) p->name);
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWriteString(writer->out, ">");
if (count < 0)
return -1;
sum += count;
break;
default:
return -1;
}
if (writer->indent) {
count = xmlOutputBufferWriteString(writer->out, "\n");
sum += count;
}
xmlListPopFront(writer->nodes);
return sum;
}
/**
* xmlTextWriterWriteFormatRaw:
* @writer: the xmlTextWriterPtr
* @format: format string (see printf)
* @...: extra parameters for the format
*
* Write a formatted raw xml text.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int XMLCDECL
xmlTextWriterWriteFormatRaw(xmlTextWriterPtr writer, const char *format,
...)
{
int rc;
va_list ap;
va_start(ap, format);
rc = xmlTextWriterWriteVFormatRaw(writer, format, ap);
va_end(ap);
return rc;
}
/**
* xmlTextWriterWriteVFormatRaw:
* @writer: the xmlTextWriterPtr
* @format: format string (see printf)
* @argptr: pointer to the first member of the variable argument list.
*
* Write a formatted raw xml text.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteVFormatRaw(xmlTextWriterPtr writer, const char *format,
va_list argptr)
{
int rc;
xmlChar *buf;
if (writer == NULL)
return -1;
buf = xmlTextWriterVSprintf(format, argptr);
if (buf == 0)
return 0;
rc = xmlTextWriterWriteRaw(writer, buf);
xmlFree(buf);
return rc;
}
/**
* xmlTextWriterWriteRawLen:
* @writer: the xmlTextWriterPtr
* @content: text string
* @len: length of the text string
*
* Write an xml text.
* TODO: what about entities and special chars??
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteRawLen(xmlTextWriterPtr writer, const xmlChar * content,
int len)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL) {
xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterWriteRawLen : invalid writer!\n");
return -1;
}
if ((content == NULL) || (len < 0)) {
xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterWriteRawLen : invalid content!\n");
return -1;
}
sum = 0;
lk = xmlListFront(writer->nodes);
if (lk != 0) {
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
count = xmlTextWriterHandleStateDependencies(writer, p);
if (count < 0)
return -1;
sum += count;
}
if (writer->indent)
writer->doindent = 0;
if (content != NULL) {
count =
xmlOutputBufferWrite(writer->out, len, (const char *) content);
if (count < 0)
return -1;
sum += count;
}
return sum;
}
/**
* xmlTextWriterWriteRaw:
* @writer: the xmlTextWriterPtr
* @content: text string
*
* Write a raw xml text.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteRaw(xmlTextWriterPtr writer, const xmlChar * content)
{
return xmlTextWriterWriteRawLen(writer, content, xmlStrlen(content));
}
/**
* xmlTextWriterWriteFormatString:
* @writer: the xmlTextWriterPtr
* @format: format string (see printf)
* @...: extra parameters for the format
*
* Write a formatted xml text.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int XMLCDECL
xmlTextWriterWriteFormatString(xmlTextWriterPtr writer, const char *format,
...)
{
int 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;
}
/**
* xmlTextWriterWriteVFormatString:
* @writer: the xmlTextWriterPtr
* @format: format string (see printf)
* @argptr: pointer to the first member of the variable argument list.
*
* Write a formatted xml text.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteVFormatString(xmlTextWriterPtr writer,
const char *format, va_list argptr)
{
int rc;
xmlChar *buf;
if ((writer == NULL) || (format == NULL))
return -1;
buf = xmlTextWriterVSprintf(format, argptr);
if (buf == 0)
return 0;
rc = xmlTextWriterWriteString(writer, buf);
xmlFree(buf);
return rc;
}
/**
* xmlTextWriterWriteString:
* @writer: the xmlTextWriterPtr
* @content: text string
*
* Write an xml text.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteString(xmlTextWriterPtr writer, const xmlChar * content)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
xmlChar *buf;
if ((writer == NULL) || (content == NULL))
return -1;
sum = 0;
buf = (xmlChar *) content;
lk = xmlListFront(writer->nodes);
if (lk != 0) {
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p != 0) {
switch (p->state) {
case XML_TEXTWRITER_NAME:
case XML_TEXTWRITER_TEXT:
#if 0
buf = NULL;
xmlOutputBufferWriteEscape(writer->out, content, NULL);
#endif
buf = xmlEncodeSpecialChars(NULL, content);
break;
case XML_TEXTWRITER_ATTRIBUTE:
buf = NULL;
xmlAttrSerializeTxtContent(writer->out->buffer, writer->doc,
NULL, content);
break;
default:
break;
}
}
}
if (buf != NULL) {
count = xmlTextWriterWriteRaw(writer, buf);
if (count < 0)
return -1;
sum += count;
if (buf != content) /* buf was allocated by us, so free it */
xmlFree(buf);
}
return sum;
}
/**
* xmlOutputBufferWriteBase64:
* @out: the xmlOutputBufferPtr
* @data: binary data
* @len: the number of bytes to encode
*
* Write base64 encoded data to an xmlOutputBuffer.
* Adapted from John Walker's base64.c (http://www.fourmilab.ch/).
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
static int
xmlOutputBufferWriteBase64(xmlOutputBufferPtr out, int len,
const unsigned char *data)
{
static 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','+','/'};
int i;
int linelen;
int count;
int sum;
if ((out == NULL) || (len < 0) || (data == NULL))
return(-1);
linelen = 0;
sum = 0;
i = 0;
while (1) {
unsigned char igroup[3];
unsigned char ogroup[4];
int c;
int 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) {
count = xmlOutputBufferWrite(out, 2, B64CRLF);
if (count == -1)
return -1;
sum += count;
linelen = 0;
}
count = xmlOutputBufferWrite(out, 4, (const char *) ogroup);
if (count == -1)
return -1;
sum += count;
linelen += 4;
}
if (i >= len)
break;
}
return sum;
}
/**
* xmlTextWriterWriteBase64:
* @writer: the xmlTextWriterPtr
* @data: binary data
* @start: the position within the data of the first byte to encode
* @len: the number of bytes to encode
*
* Write an base64 encoded xml text.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteBase64(xmlTextWriterPtr writer, const char *data,
int start, int len)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if ((writer == NULL) || (data == NULL) || (start < 0) || (len < 0))
return -1;
sum = 0;
lk = xmlListFront(writer->nodes);
if (lk != 0) {
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p != 0) {
count = xmlTextWriterHandleStateDependencies(writer, p);
if (count < 0)
return -1;
sum += count;
}
}
if (writer->indent)
writer->doindent = 0;
count =
xmlOutputBufferWriteBase64(writer->out, len,
(unsigned char *) data + start);
if (count < 0)
return -1;
sum += count;
return sum;
}
/**
* xmlOutputBufferWriteBinHex:
* @out: the xmlOutputBufferPtr
* @data: binary data
* @len: the number of bytes to encode
*
* Write hqx encoded data to an xmlOutputBuffer.
* ::todo
*
* Returns the bytes written (may be 0 because of buffering)
* or -1 in case of error
*/
static int
xmlOutputBufferWriteBinHex(xmlOutputBufferPtr out,
int len, const unsigned char *data)
{
int count;
int sum;
static char hex[16] =
{'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
int i;
if ((out == NULL) || (data == NULL) || (len < 0)) {
return -1;
}
sum = 0;
for (i = 0; i < len; i++) {
count =
xmlOutputBufferWrite(out, 1,
(const char *) &hex[data[i] >> 4]);
if (count == -1)
return -1;
sum += count;
count =
xmlOutputBufferWrite(out, 1,
(const char *) &hex[data[i] & 0xF]);
if (count == -1)
return -1;
sum += count;
}
return sum;
}
/**
* xmlTextWriterWriteBinHex:
* @writer: the xmlTextWriterPtr
* @data: binary data
* @start: the position within the data of the first byte to encode
* @len: the number of bytes to encode
*
* Write a BinHex encoded xml text.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteBinHex(xmlTextWriterPtr writer, const char *data,
int start, int len)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if ((writer == NULL) || (data == NULL) || (start < 0) || (len < 0))
return -1;
sum = 0;
lk = xmlListFront(writer->nodes);
if (lk != 0) {
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p != 0) {
count = xmlTextWriterHandleStateDependencies(writer, p);
if (count < 0)
return -1;
sum += count;
}
}
if (writer->indent)
writer->doindent = 0;
count =
xmlOutputBufferWriteBinHex(writer->out, len,
(unsigned char *) data + start);
if (count < 0)
return -1;
sum += count;
return sum;
}
/**
* xmlTextWriterStartAttribute:
* @writer: the xmlTextWriterPtr
* @name: element name
*
* Start an xml attribute.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterStartAttribute(xmlTextWriterPtr writer, const xmlChar * name)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if ((writer == NULL) || (name == NULL) || (*name == '\0'))
return -1;
sum = 0;
lk = xmlListFront(writer->nodes);
if (lk == 0)
return -1;
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p == 0)
return -1;
switch (p->state) {
case XML_TEXTWRITER_ATTRIBUTE:
count = xmlTextWriterEndAttribute(writer);
if (count < 0)
return -1;
sum += count;
/* fallthrough */
case XML_TEXTWRITER_NAME:
count = xmlOutputBufferWriteString(writer->out, " ");
if (count < 0)
return -1;
sum += count;
count =
xmlOutputBufferWriteString(writer->out,
(const char *) name);
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWriteString(writer->out, "=");
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
if (count < 0)
return -1;
sum += count;
p->state = XML_TEXTWRITER_ATTRIBUTE;
break;
default:
return -1;
}
return sum;
}
/**
* xmlTextWriterStartAttributeNS:
* @writer: the xmlTextWriterPtr
* @prefix: namespace prefix or NULL
* @name: element local name
* @namespaceURI: namespace URI or NULL
*
* Start an xml attribute with namespace support.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterStartAttributeNS(xmlTextWriterPtr writer,
const xmlChar * prefix, const xmlChar * name,
const xmlChar * namespaceURI)
{
int count;
int sum;
xmlChar *buf;
xmlTextWriterNsStackEntry *p;
if ((writer == NULL) || (name == NULL) || (*name == '\0'))
return -1;
/* Handle namespace first in case of error */
if (namespaceURI != 0) {
xmlTextWriterNsStackEntry nsentry, *curns;
buf = xmlStrdup(BAD_CAST "xmlns");
if (prefix != 0) {
buf = xmlStrcat(buf, BAD_CAST ":");
buf = xmlStrcat(buf, prefix);
}
nsentry.prefix = buf;
nsentry.uri = (xmlChar *)namespaceURI;
nsentry.elem = xmlListFront(writer->nodes);
curns = (xmlTextWriterNsStackEntry *)xmlListSearch(writer->nsstack,
(void *)&nsentry);
if ((curns != NULL)) {
xmlFree(buf);
if (xmlStrcmp(curns->uri, namespaceURI) == 0) {
/* Namespace already defined on element skip */
buf = NULL;
} else {
/* Prefix mismatch so error out */
return -1;
}
}
/* Do not add namespace decl to list - it is already there */
if (buf != NULL) {
p = (xmlTextWriterNsStackEntry *)
xmlMalloc(sizeof(xmlTextWriterNsStackEntry));
if (p == 0) {
xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartAttributeNS : out of memory!\n");
return -1;
}
p->prefix = buf;
p->uri = xmlStrdup(namespaceURI);
if (p->uri == 0) {
xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartAttributeNS : out of memory!\n");
xmlFree(p);
return -1;
}
p->elem = xmlListFront(writer->nodes);
xmlListPushFront(writer->nsstack, p);
}
}
buf = NULL;
if (prefix != 0) {
buf = xmlStrdup(prefix);
buf = xmlStrcat(buf, BAD_CAST ":");
}
buf = xmlStrcat(buf, name);
sum = 0;
count = xmlTextWriterStartAttribute(writer, buf);
xmlFree(buf);
if (count < 0)
return -1;
sum += count;
return sum;
}
/**
* xmlTextWriterEndAttribute:
* @writer: the xmlTextWriterPtr
*
* End the current xml element.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterEndAttribute(xmlTextWriterPtr writer)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL)
return -1;
lk = xmlListFront(writer->nodes);
if (lk == 0) {
return -1;
}
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p == 0) {
return -1;
}
sum = 0;
switch (p->state) {
case XML_TEXTWRITER_ATTRIBUTE:
p->state = XML_TEXTWRITER_NAME;
count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
if (count < 0) {
return -1;
}
sum += count;
break;
default:
return -1;
}
return sum;
}
/**
* xmlTextWriterWriteFormatAttribute:
* @writer: the xmlTextWriterPtr
* @name: attribute name
* @format: format string (see printf)
* @...: extra parameters for the format
*
* Write a formatted xml attribute.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int XMLCDECL
xmlTextWriterWriteFormatAttribute(xmlTextWriterPtr writer,
const xmlChar * name, const char *format,
...)
{
int rc;
va_list ap;
va_start(ap, format);
rc = xmlTextWriterWriteVFormatAttribute(writer, name, format, ap);
va_end(ap);
return rc;
}
/**
* xmlTextWriterWriteVFormatAttribute:
* @writer: the xmlTextWriterPtr
* @name: attribute name
* @format: format string (see printf)
* @argptr: pointer to the first member of the variable argument list.
*
* Write a formatted xml attribute.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteVFormatAttribute(xmlTextWriterPtr writer,
const xmlChar * name,
const char *format, va_list argptr)
{
int rc;
xmlChar *buf;
if (writer == NULL)
return -1;
buf = xmlTextWriterVSprintf(format, argptr);
if (buf == 0)
return 0;
rc = xmlTextWriterWriteAttribute(writer, name, buf);
xmlFree(buf);
return rc;
}
/**
* xmlTextWriterWriteAttribute:
* @writer: the xmlTextWriterPtr
* @name: attribute name
* @content: attribute content
*
* Write an xml attribute.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteAttribute(xmlTextWriterPtr writer, const xmlChar * name,
const xmlChar * content)
{
int count;
int sum;
sum = 0;
count = xmlTextWriterStartAttribute(writer, name);
if (count < 0)
return -1;
sum += count;
count = xmlTextWriterWriteString(writer, content);
if (count < 0)
return -1;
sum += count;
count = xmlTextWriterEndAttribute(writer);
if (count < 0)
return -1;
sum += count;
return sum;
}
/**
* xmlTextWriterWriteFormatAttributeNS:
* @writer: the xmlTextWriterPtr
* @prefix: namespace prefix
* @name: attribute local name
* @namespaceURI: namespace URI
* @format: format string (see printf)
* @...: extra parameters for the format
*
* Write a formatted xml attribute.with namespace support
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int XMLCDECL
xmlTextWriterWriteFormatAttributeNS(xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI,
const char *format, ...)
{
int rc;
va_list ap;
va_start(ap, format);
rc = xmlTextWriterWriteVFormatAttributeNS(writer, prefix, name,
namespaceURI, format, ap);
va_end(ap);
return rc;
}
/**
* xmlTextWriterWriteVFormatAttributeNS:
* @writer: the xmlTextWriterPtr
* @prefix: namespace prefix
* @name: attribute local name
* @namespaceURI: namespace URI
* @format: format string (see printf)
* @argptr: pointer to the first member of the variable argument list.
*
* Write a formatted xml attribute.with namespace support
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteVFormatAttributeNS(xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI,
const char *format, va_list argptr)
{
int rc;
xmlChar *buf;
if (writer == NULL)
return -1;
buf = xmlTextWriterVSprintf(format, argptr);
if (buf == 0)
return 0;
rc = xmlTextWriterWriteAttributeNS(writer, prefix, name, namespaceURI,
buf);
xmlFree(buf);
return rc;
}
/**
* xmlTextWriterWriteAttributeNS:
* @writer: the xmlTextWriterPtr
* @prefix: namespace prefix
* @name: attribute local name
* @namespaceURI: namespace URI
* @content: attribute content
*
* Write an xml attribute.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteAttributeNS(xmlTextWriterPtr writer,
const xmlChar * prefix, const xmlChar * name,
const xmlChar * namespaceURI,
const xmlChar * content)
{
int count;
int sum;
if ((writer == NULL) || (name == NULL) || (*name == '\0'))
return -1;
sum = 0;
count = xmlTextWriterStartAttributeNS(writer, prefix, name, namespaceURI);
if (count < 0)
return -1;
sum += count;
count = xmlTextWriterWriteString(writer, content);
if (count < 0)
return -1;
sum += count;
count = xmlTextWriterEndAttribute(writer);
if (count < 0)
return -1;
sum += count;
return sum;
}
/**
* xmlTextWriterWriteFormatElement:
* @writer: the xmlTextWriterPtr
* @name: element name
* @format: format string (see printf)
* @...: extra parameters for the format
*
* Write a formatted xml element.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int XMLCDECL
xmlTextWriterWriteFormatElement(xmlTextWriterPtr writer,
const xmlChar * name, const char *format,
...)
{
int rc;
va_list ap;
va_start(ap, format);
rc = xmlTextWriterWriteVFormatElement(writer, name, format, ap);
va_end(ap);
return rc;
}
/**
* xmlTextWriterWriteVFormatElement:
* @writer: the xmlTextWriterPtr
* @name: element name
* @format: format string (see printf)
* @argptr: pointer to the first member of the variable argument list.
*
* Write a formatted xml element.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteVFormatElement(xmlTextWriterPtr writer,
const xmlChar * name, const char *format,
va_list argptr)
{
int rc;
xmlChar *buf;
if (writer == NULL)
return -1;
buf = xmlTextWriterVSprintf(format, argptr);
if (buf == 0)
return 0;
rc = xmlTextWriterWriteElement(writer, name, buf);
xmlFree(buf);
return rc;
}
/**
* xmlTextWriterWriteElement:
* @writer: the xmlTextWriterPtr
* @name: element name
* @content: element content
*
* Write an xml element.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteElement(xmlTextWriterPtr writer, const xmlChar * name,
const xmlChar * content)
{
int count;
int sum;
sum = 0;
count = xmlTextWriterStartElement(writer, name);
if (count == -1)
return -1;
sum += count;
count = xmlTextWriterWriteString(writer, content);
if (count == -1)
return -1;
sum += count;
count = xmlTextWriterEndElement(writer);
if (count == -1)
return -1;
sum += count;
return sum;
}
/**
* xmlTextWriterWriteFormatElementNS:
* @writer: the xmlTextWriterPtr
* @prefix: namespace prefix
* @name: element local name
* @namespaceURI: namespace URI
* @format: format string (see printf)
* @...: extra parameters for the format
*
* Write a formatted xml element with namespace support.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int XMLCDECL
xmlTextWriterWriteFormatElementNS(xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI,
const char *format, ...)
{
int rc;
va_list ap;
va_start(ap, format);
rc = xmlTextWriterWriteVFormatElementNS(writer, prefix, name,
namespaceURI, format, ap);
va_end(ap);
return rc;
}
/**
* xmlTextWriterWriteVFormatElementNS:
* @writer: the xmlTextWriterPtr
* @prefix: namespace prefix
* @name: element local name
* @namespaceURI: namespace URI
* @format: format string (see printf)
* @argptr: pointer to the first member of the variable argument list.
*
* Write a formatted xml element with namespace support.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteVFormatElementNS(xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI,
const char *format, va_list argptr)
{
int rc;
xmlChar *buf;
if (writer == NULL)
return -1;
buf = xmlTextWriterVSprintf(format, argptr);
if (buf == 0)
return 0;
rc = xmlTextWriterWriteElementNS(writer, prefix, name, namespaceURI,
buf);
xmlFree(buf);
return rc;
}
/**
* xmlTextWriterWriteElementNS:
* @writer: the xmlTextWriterPtr
* @prefix: namespace prefix
* @name: element local name
* @namespaceURI: namespace URI
* @content: element content
*
* Write an xml element with namespace support.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteElementNS(xmlTextWriterPtr writer,
const xmlChar * prefix, const xmlChar * name,
const xmlChar * namespaceURI,
const xmlChar * content)
{
int count;
int sum;
if ((writer == NULL) || (name == NULL) || (*name == '\0'))
return -1;
sum = 0;
count =
xmlTextWriterStartElementNS(writer, prefix, name, namespaceURI);
if (count < 0)
return -1;
sum += count;
count = xmlTextWriterWriteString(writer, content);
if (count == -1)
return -1;
sum += count;
count = xmlTextWriterEndElement(writer);
if (count == -1)
return -1;
sum += count;
return sum;
}
/**
* xmlTextWriterStartPI:
* @writer: the xmlTextWriterPtr
* @target: PI target
*
* Start an xml PI.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterStartPI(xmlTextWriterPtr writer, const xmlChar * target)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if ((writer == NULL) || (target == NULL) || (*target == '\0'))
return -1;
if (xmlStrcasecmp(target, (const xmlChar *) "xml") == 0) {
xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterStartPI : target name [Xx][Mm][Ll] is reserved for xml standardization!\n");
return -1;
}
sum = 0;
lk = xmlListFront(writer->nodes);
if (lk != 0) {
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p != 0) {
switch (p->state) {
case XML_TEXTWRITER_ATTRIBUTE:
count = xmlTextWriterEndAttribute(writer);
if (count < 0)
return -1;
sum += count;
/* fallthrough */
case XML_TEXTWRITER_NAME:
/* Output namespace declarations */
count = xmlTextWriterOutputNSDecl(writer);
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWriteString(writer->out, ">");
if (count < 0)
return -1;
sum += count;
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:
xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterStartPI : nested PI!\n");
return -1;
default:
return -1;
}
}
}
p = (xmlTextWriterStackEntry *)
xmlMalloc(sizeof(xmlTextWriterStackEntry));
if (p == 0) {
xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartPI : out of memory!\n");
return -1;
}
p->name = xmlStrdup(target);
if (p->name == 0) {
xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartPI : out of memory!\n");
xmlFree(p);
return -1;
}
p->state = XML_TEXTWRITER_PI;
xmlListPushFront(writer->nodes, p);
count = xmlOutputBufferWriteString(writer->out, "<?");
if (count < 0)
return -1;
sum += count;
count =
xmlOutputBufferWriteString(writer->out, (const char *) p->name);
if (count < 0)
return -1;
sum += count;
return sum;
}
/**
* xmlTextWriterEndPI:
* @writer: the xmlTextWriterPtr
*
* End the current xml PI.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterEndPI(xmlTextWriterPtr writer)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL)
return -1;
lk = xmlListFront(writer->nodes);
if (lk == 0)
return 0;
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p == 0)
return 0;
sum = 0;
switch (p->state) {
case XML_TEXTWRITER_PI:
case XML_TEXTWRITER_PI_TEXT:
count = xmlOutputBufferWriteString(writer->out, "?>");
if (count < 0)
return -1;
sum += count;
break;
default:
return -1;
}
if (writer->indent) {
count = xmlOutputBufferWriteString(writer->out, "\n");
if (count < 0)
return -1;
sum += count;
}
xmlListPopFront(writer->nodes);
return sum;
}
/**
* xmlTextWriterWriteFormatPI:
* @writer: the xmlTextWriterPtr
* @target: PI target
* @format: format string (see printf)
* @...: extra parameters for the format
*
* Write a formatted PI.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int XMLCDECL
xmlTextWriterWriteFormatPI(xmlTextWriterPtr writer, const xmlChar * target,
const char *format, ...)
{
int rc;
va_list ap;
va_start(ap, format);
rc = xmlTextWriterWriteVFormatPI(writer, target, format, ap);
va_end(ap);
return rc;
}
/**
* xmlTextWriterWriteVFormatPI:
* @writer: the xmlTextWriterPtr
* @target: PI target
* @format: format string (see printf)
* @argptr: pointer to the first member of the variable argument list.
*
* Write a formatted xml PI.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteVFormatPI(xmlTextWriterPtr writer,
const xmlChar * target, const char *format,
va_list argptr)
{
int rc;
xmlChar *buf;
if (writer == NULL)
return -1;
buf = xmlTextWriterVSprintf(format, argptr);
if (buf == 0)
return 0;
rc = xmlTextWriterWritePI(writer, target, buf);
xmlFree(buf);
return rc;
}
/**
* xmlTextWriterWritePI:
* @writer: the xmlTextWriterPtr
* @target: PI target
* @content: PI content
*
* Write an xml PI.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWritePI(xmlTextWriterPtr writer, const xmlChar * target,
const xmlChar * content)
{
int count;
int sum;
sum = 0;
count = xmlTextWriterStartPI(writer, target);
if (count == -1)
return -1;
sum += count;
if (content != 0) {
count = xmlTextWriterWriteString(writer, content);
if (count == -1)
return -1;
sum += count;
}
count = xmlTextWriterEndPI(writer);
if (count == -1)
return -1;
sum += count;
return sum;
}
/**
* xmlTextWriterStartCDATA:
* @writer: the xmlTextWriterPtr
*
* Start an xml CDATA section.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterStartCDATA(xmlTextWriterPtr writer)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL)
return -1;
sum = 0;
lk = xmlListFront(writer->nodes);
if (lk != 0) {
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p != 0) {
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:
count = xmlTextWriterEndAttribute(writer);
if (count < 0)
return -1;
sum += count;
/* fallthrough */
case XML_TEXTWRITER_NAME:
/* Output namespace declarations */
count = xmlTextWriterOutputNSDecl(writer);
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWriteString(writer->out, ">");
if (count < 0)
return -1;
sum += count;
p->state = XML_TEXTWRITER_TEXT;
break;
case XML_TEXTWRITER_CDATA:
xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterStartCDATA : CDATA not allowed in this context!\n");
return -1;
default:
return -1;
}
}
}
p = (xmlTextWriterStackEntry *)
xmlMalloc(sizeof(xmlTextWriterStackEntry));
if (p == 0) {
xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartCDATA : out of memory!\n");
return -1;
}
p->name = NULL;
p->state = XML_TEXTWRITER_CDATA;
xmlListPushFront(writer->nodes, p);
count = xmlOutputBufferWriteString(writer->out, "<![CDATA[");
if (count < 0)
return -1;
sum += count;
return sum;
}
/**
* xmlTextWriterEndCDATA:
* @writer: the xmlTextWriterPtr
*
* End an xml CDATA section.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterEndCDATA(xmlTextWriterPtr writer)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL)
return -1;
lk = xmlListFront(writer->nodes);
if (lk == 0)
return -1;
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p == 0)
return -1;
sum = 0;
switch (p->state) {
case XML_TEXTWRITER_CDATA:
count = xmlOutputBufferWriteString(writer->out, "]]>");
if (count < 0)
return -1;
sum += count;
break;
default:
return -1;
}
xmlListPopFront(writer->nodes);
return sum;
}
/**
* xmlTextWriterWriteFormatCDATA:
* @writer: the xmlTextWriterPtr
* @format: format string (see printf)
* @...: extra parameters for the format
*
* Write a formatted xml CDATA.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int XMLCDECL
xmlTextWriterWriteFormatCDATA(xmlTextWriterPtr writer, const char *format,
...)
{
int rc;
va_list ap;
va_start(ap, format);
rc = xmlTextWriterWriteVFormatCDATA(writer, format, ap);
va_end(ap);
return rc;
}
/**
* xmlTextWriterWriteVFormatCDATA:
* @writer: the xmlTextWriterPtr
* @format: format string (see printf)
* @argptr: pointer to the first member of the variable argument list.
*
* Write a formatted xml CDATA.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteVFormatCDATA(xmlTextWriterPtr writer, const char *format,
va_list argptr)
{
int rc;
xmlChar *buf;
if (writer == NULL)
return -1;
buf = xmlTextWriterVSprintf(format, argptr);
if (buf == 0)
return 0;
rc = xmlTextWriterWriteCDATA(writer, buf);
xmlFree(buf);
return rc;
}
/**
* xmlTextWriterWriteCDATA:
* @writer: the xmlTextWriterPtr
* @content: CDATA content
*
* Write an xml CDATA.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteCDATA(xmlTextWriterPtr writer, const xmlChar * content)
{
int count;
int sum;
sum = 0;
count = xmlTextWriterStartCDATA(writer);
if (count == -1)
return -1;
sum += count;
if (content != 0) {
count = xmlTextWriterWriteString(writer, content);
if (count == -1)
return -1;
sum += count;
}
count = xmlTextWriterEndCDATA(writer);
if (count == -1)
return -1;
sum += count;
return sum;
}
/**
* xmlTextWriterStartDTD:
* @writer: the xmlTextWriterPtr
* @name: the name of the DTD
* @pubid: the public identifier, which is an alternative to the system identifier
* @sysid: the system identifier, which is the URI of the DTD
*
* Start an xml DTD.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterStartDTD(xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * pubid, const xmlChar * sysid)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL || name == NULL || *name == '\0')
return -1;
sum = 0;
lk = xmlListFront(writer->nodes);
if ((lk != NULL) && (xmlLinkGetData(lk) != NULL)) {
xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterStartDTD : DTD allowed only in prolog!\n");
return -1;
}
p = (xmlTextWriterStackEntry *)
xmlMalloc(sizeof(xmlTextWriterStackEntry));
if (p == 0) {
xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartDTD : out of memory!\n");
return -1;
}
p->name = xmlStrdup(name);
if (p->name == 0) {
xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartDTD : out of memory!\n");
xmlFree(p);
return -1;
}
p->state = XML_TEXTWRITER_DTD;
xmlListPushFront(writer->nodes, p);
count = xmlOutputBufferWriteString(writer->out, "<!DOCTYPE ");
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWriteString(writer->out, (const char *) name);
if (count < 0)
return -1;
sum += count;
if (pubid != 0) {
if (sysid == 0) {
xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterStartDTD : system identifier needed!\n");
return -1;
}
if (writer->indent)
count = xmlOutputBufferWrite(writer->out, 1, "\n");
else
count = xmlOutputBufferWrite(writer->out, 1, " ");
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWriteString(writer->out, "PUBLIC ");
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
if (count < 0)
return -1;
sum += count;
count =
xmlOutputBufferWriteString(writer->out, (const char *) pubid);
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
if (count < 0)
return -1;
sum += count;
}
if (sysid != 0) {
if (pubid == 0) {
if (writer->indent)
count = xmlOutputBufferWrite(writer->out, 1, "\n");
else
count = xmlOutputBufferWrite(writer->out, 1, " ");
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWriteString(writer->out, "SYSTEM ");
if (count < 0)
return -1;
sum += count;
} else {
if (writer->indent)
count = xmlOutputBufferWriteString(writer->out, "\n ");
else
count = xmlOutputBufferWrite(writer->out, 1, " ");
if (count < 0)
return -1;
sum += count;
}
count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
if (count < 0)
return -1;
sum += count;
count =
xmlOutputBufferWriteString(writer->out, (const char *) sysid);
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
if (count < 0)
return -1;
sum += count;
}
return sum;
}
/**
* xmlTextWriterEndDTD:
* @writer: the xmlTextWriterPtr
*
* End an xml DTD.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterEndDTD(xmlTextWriterPtr writer)
{
int loop;
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL)
return -1;
sum = 0;
loop = 1;
while (loop) {
lk = xmlListFront(writer->nodes);
if (lk == NULL)
break;
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p == 0)
break;
switch (p->state) {
case XML_TEXTWRITER_DTD_TEXT:
count = xmlOutputBufferWriteString(writer->out, "]");
if (count < 0)
return -1;
sum += count;
/* fallthrough */
case XML_TEXTWRITER_DTD:
count = xmlOutputBufferWriteString(writer->out, ">");
if (writer->indent) {
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWriteString(writer->out, "\n");
}
xmlListPopFront(writer->nodes);
break;
case XML_TEXTWRITER_DTD_ELEM:
case XML_TEXTWRITER_DTD_ELEM_TEXT:
count = xmlTextWriterEndDTDElement(writer);
break;
case XML_TEXTWRITER_DTD_ATTL:
case XML_TEXTWRITER_DTD_ATTL_TEXT:
count = xmlTextWriterEndDTDAttlist(writer);
break;
case XML_TEXTWRITER_DTD_ENTY:
case XML_TEXTWRITER_DTD_PENT:
case XML_TEXTWRITER_DTD_ENTY_TEXT:
count = xmlTextWriterEndDTDEntity(writer);
break;
case XML_TEXTWRITER_COMMENT:
count = xmlTextWriterEndComment(writer);
break;
default:
loop = 0;
continue;
}
if (count < 0)
return -1;
sum += count;
}
return sum;
}
/**
* xmlTextWriterWriteFormatDTD:
* @writer: the xmlTextWriterPtr
* @name: the name of the DTD
* @pubid: the public identifier, which is an alternative to the system identifier
* @sysid: the system identifier, which is the URI of the DTD
* @format: format string (see printf)
* @...: extra parameters for the format
*
* Write a DTD with a formatted markup declarations part.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int XMLCDECL
xmlTextWriterWriteFormatDTD(xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid, const char *format, ...)
{
int rc;
va_list ap;
va_start(ap, format);
rc = xmlTextWriterWriteVFormatDTD(writer, name, pubid, sysid, format,
ap);
va_end(ap);
return rc;
}
/**
* xmlTextWriterWriteVFormatDTD:
* @writer: the xmlTextWriterPtr
* @name: the name of the DTD
* @pubid: the public identifier, which is an alternative to the system identifier
* @sysid: the system identifier, which is the URI of the DTD
* @format: format string (see printf)
* @argptr: pointer to the first member of the variable argument list.
*
* Write a DTD with a formatted markup declarations part.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteVFormatDTD(xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid,
const char *format, va_list argptr)
{
int rc;
xmlChar *buf;
if (writer == NULL)
return -1;
buf = xmlTextWriterVSprintf(format, argptr);
if (buf == 0)
return 0;
rc = xmlTextWriterWriteDTD(writer, name, pubid, sysid, buf);
xmlFree(buf);
return rc;
}
/**
* xmlTextWriterWriteDTD:
* @writer: the xmlTextWriterPtr
* @name: the name of the DTD
* @pubid: the public identifier, which is an alternative to the system identifier
* @sysid: the system identifier, which is the URI of the DTD
* @subset: string content of the DTD
*
* Write a DTD.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteDTD(xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid, const xmlChar * subset)
{
int count;
int sum;
sum = 0;
count = xmlTextWriterStartDTD(writer, name, pubid, sysid);
if (count == -1)
return -1;
sum += count;
if (subset != 0) {
count = xmlTextWriterWriteString(writer, subset);
if (count == -1)
return -1;
sum += count;
}
count = xmlTextWriterEndDTD(writer);
if (count == -1)
return -1;
sum += count;
return sum;
}
/**
* xmlTextWriterStartDTDElement:
* @writer: the xmlTextWriterPtr
* @name: the name of the DTD element
*
* Start an xml DTD element.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterStartDTDElement(xmlTextWriterPtr writer, const xmlChar * name)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL || name == NULL || *name == '\0')
return -1;
sum = 0;
lk = xmlListFront(writer->nodes);
if (lk == 0) {
return -1;
}
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p != 0) {
switch (p->state) {
case XML_TEXTWRITER_DTD:
count = xmlOutputBufferWriteString(writer->out, " [");
if (count < 0)
return -1;
sum += count;
if (writer->indent) {
count = xmlOutputBufferWriteString(writer->out, "\n");
if (count < 0)
return -1;
sum += count;
}
p->state = XML_TEXTWRITER_DTD_TEXT;
/* fallthrough */
case XML_TEXTWRITER_DTD_TEXT:
case XML_TEXTWRITER_NONE:
break;
default:
return -1;
}
}
p = (xmlTextWriterStackEntry *)
xmlMalloc(sizeof(xmlTextWriterStackEntry));
if (p == 0) {
xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartDTDElement : out of memory!\n");
return -1;
}
p->name = xmlStrdup(name);
if (p->name == 0) {
xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartDTDElement : out of memory!\n");
xmlFree(p);
return -1;
}
p->state = XML_TEXTWRITER_DTD_ELEM;
xmlListPushFront(writer->nodes, p);
if (writer->indent) {
count = xmlTextWriterWriteIndent(writer);
if (count < 0)
return -1;
sum += count;
}
count = xmlOutputBufferWriteString(writer->out, "<!ELEMENT ");
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWriteString(writer->out, (const char *) name);
if (count < 0)
return -1;
sum += count;
return sum;
}
/**
* xmlTextWriterEndDTDElement:
* @writer: the xmlTextWriterPtr
*
* End an xml DTD element.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterEndDTDElement(xmlTextWriterPtr writer)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL)
return -1;
sum = 0;
lk = xmlListFront(writer->nodes);
if (lk == 0)
return -1;
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p == 0)
return -1;
switch (p->state) {
case XML_TEXTWRITER_DTD_ELEM:
case XML_TEXTWRITER_DTD_ELEM_TEXT:
count = xmlOutputBufferWriteString(writer->out, ">");
if (count < 0)
return -1;
sum += count;
break;
default:
return -1;
}
if (writer->indent) {
count = xmlOutputBufferWriteString(writer->out, "\n");
if (count < 0)
return -1;
sum += count;
}
xmlListPopFront(writer->nodes);
return sum;
}
/**
* xmlTextWriterWriteFormatDTDElement:
* @writer: the xmlTextWriterPtr
* @name: the name of the DTD element
* @format: format string (see printf)
* @...: extra parameters for the format
*
* Write a formatted DTD element.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int XMLCDECL
xmlTextWriterWriteFormatDTDElement(xmlTextWriterPtr writer,
const xmlChar * name,
const char *format, ...)
{
int rc;
va_list ap;
va_start(ap, format);
rc = xmlTextWriterWriteVFormatDTDElement(writer, name, format, ap);
va_end(ap);
return rc;
}
/**
* xmlTextWriterWriteVFormatDTDElement:
* @writer: the xmlTextWriterPtr
* @name: the name of the DTD element
* @format: format string (see printf)
* @argptr: pointer to the first member of the variable argument list.
*
* Write a formatted DTD element.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteVFormatDTDElement(xmlTextWriterPtr writer,
const xmlChar * name,
const char *format, va_list argptr)
{
int rc;
xmlChar *buf;
if (writer == NULL)
return -1;
buf = xmlTextWriterVSprintf(format, argptr);
if (buf == 0)
return 0;
rc = xmlTextWriterWriteDTDElement(writer, name, buf);
xmlFree(buf);
return rc;
}
/**
* xmlTextWriterWriteDTDElement:
* @writer: the xmlTextWriterPtr
* @name: the name of the DTD element
* @content: content of the element
*
* Write a DTD element.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteDTDElement(xmlTextWriterPtr writer,
const xmlChar * name, const xmlChar * content)
{
int count;
int sum;
if (content == NULL)
return -1;
sum = 0;
count = xmlTextWriterStartDTDElement(writer, name);
if (count == -1)
return -1;
sum += count;
count = xmlTextWriterWriteString(writer, content);
if (count == -1)
return -1;
sum += count;
count = xmlTextWriterEndDTDElement(writer);
if (count == -1)
return -1;
sum += count;
return sum;
}
/**
* xmlTextWriterStartDTDAttlist:
* @writer: the xmlTextWriterPtr
* @name: the name of the DTD ATTLIST
*
* Start an xml DTD ATTLIST.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterStartDTDAttlist(xmlTextWriterPtr writer, const xmlChar * name)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL || name == NULL || *name == '\0')
return -1;
sum = 0;
lk = xmlListFront(writer->nodes);
if (lk == 0) {
return -1;
}
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p != 0) {
switch (p->state) {
case XML_TEXTWRITER_DTD:
count = xmlOutputBufferWriteString(writer->out, " [");
if (count < 0)
return -1;
sum += count;
if (writer->indent) {
count = xmlOutputBufferWriteString(writer->out, "\n");
if (count < 0)
return -1;
sum += count;
}
p->state = XML_TEXTWRITER_DTD_TEXT;
/* fallthrough */
case XML_TEXTWRITER_DTD_TEXT:
case XML_TEXTWRITER_NONE:
break;
default:
return -1;
}
}
p = (xmlTextWriterStackEntry *)
xmlMalloc(sizeof(xmlTextWriterStackEntry));
if (p == 0) {
xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartDTDAttlist : out of memory!\n");
return -1;
}
p->name = xmlStrdup(name);
if (p->name == 0) {
xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartDTDAttlist : out of memory!\n");
xmlFree(p);
return -1;
}
p->state = XML_TEXTWRITER_DTD_ATTL;
xmlListPushFront(writer->nodes, p);
if (writer->indent) {
count = xmlTextWriterWriteIndent(writer);
if (count < 0)
return -1;
sum += count;
}
count = xmlOutputBufferWriteString(writer->out, "<!ATTLIST ");
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWriteString(writer->out, (const char *) name);
if (count < 0)
return -1;
sum += count;
return sum;
}
/**
* xmlTextWriterEndDTDAttlist:
* @writer: the xmlTextWriterPtr
*
* End an xml DTD attribute list.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterEndDTDAttlist(xmlTextWriterPtr writer)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL)
return -1;
sum = 0;
lk = xmlListFront(writer->nodes);
if (lk == 0)
return -1;
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p == 0)
return -1;
switch (p->state) {
case XML_TEXTWRITER_DTD_ATTL:
case XML_TEXTWRITER_DTD_ATTL_TEXT:
count = xmlOutputBufferWriteString(writer->out, ">");
if (count < 0)
return -1;
sum += count;
break;
default:
return -1;
}
if (writer->indent) {
count = xmlOutputBufferWriteString(writer->out, "\n");
if (count < 0)
return -1;
sum += count;
}
xmlListPopFront(writer->nodes);
return sum;
}
/**
* xmlTextWriterWriteFormatDTDAttlist:
* @writer: the xmlTextWriterPtr
* @name: the name of the DTD ATTLIST
* @format: format string (see printf)
* @...: extra parameters for the format
*
* Write a formatted DTD ATTLIST.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int XMLCDECL
xmlTextWriterWriteFormatDTDAttlist(xmlTextWriterPtr writer,
const xmlChar * name,
const char *format, ...)
{
int rc;
va_list ap;
va_start(ap, format);
rc = xmlTextWriterWriteVFormatDTDAttlist(writer, name, format, ap);
va_end(ap);
return rc;
}
/**
* xmlTextWriterWriteVFormatDTDAttlist:
* @writer: the xmlTextWriterPtr
* @name: the name of the DTD ATTLIST
* @format: format string (see printf)
* @argptr: pointer to the first member of the variable argument list.
*
* Write a formatted DTD ATTLIST.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteVFormatDTDAttlist(xmlTextWriterPtr writer,
const xmlChar * name,
const char *format, va_list argptr)
{
int rc;
xmlChar *buf;
if (writer == NULL)
return -1;
buf = xmlTextWriterVSprintf(format, argptr);
if (buf == 0)
return 0;
rc = xmlTextWriterWriteDTDAttlist(writer, name, buf);
xmlFree(buf);
return rc;
}
/**
* xmlTextWriterWriteDTDAttlist:
* @writer: the xmlTextWriterPtr
* @name: the name of the DTD ATTLIST
* @content: content of the ATTLIST
*
* Write a DTD ATTLIST.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteDTDAttlist(xmlTextWriterPtr writer,
const xmlChar * name, const xmlChar * content)
{
int count;
int sum;
if (content == NULL)
return -1;
sum = 0;
count = xmlTextWriterStartDTDAttlist(writer, name);
if (count == -1)
return -1;
sum += count;
count = xmlTextWriterWriteString(writer, content);
if (count == -1)
return -1;
sum += count;
count = xmlTextWriterEndDTDAttlist(writer);
if (count == -1)
return -1;
sum += count;
return sum;
}
/**
* xmlTextWriterStartDTDEntity:
* @writer: the xmlTextWriterPtr
* @pe: TRUE if this is a parameter entity, FALSE if not
* @name: the name of the DTD ATTLIST
*
* Start an xml DTD ATTLIST.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterStartDTDEntity(xmlTextWriterPtr writer,
int pe, const xmlChar * name)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL || name == NULL || *name == '\0')
return -1;
sum = 0;
lk = xmlListFront(writer->nodes);
if (lk != 0) {
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p != 0) {
switch (p->state) {
case XML_TEXTWRITER_DTD:
count = xmlOutputBufferWriteString(writer->out, " [");
if (count < 0)
return -1;
sum += count;
if (writer->indent) {
count =
xmlOutputBufferWriteString(writer->out, "\n");
if (count < 0)
return -1;
sum += count;
}
p->state = XML_TEXTWRITER_DTD_TEXT;
/* fallthrough */
case XML_TEXTWRITER_DTD_TEXT:
case XML_TEXTWRITER_NONE:
break;
default:
return -1;
}
}
}
p = (xmlTextWriterStackEntry *)
xmlMalloc(sizeof(xmlTextWriterStackEntry));
if (p == 0) {
xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartDTDElement : out of memory!\n");
return -1;
}
p->name = xmlStrdup(name);
if (p->name == 0) {
xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
"xmlTextWriterStartDTDElement : out of memory!\n");
xmlFree(p);
return -1;
}
if (pe != 0)
p->state = XML_TEXTWRITER_DTD_PENT;
else
p->state = XML_TEXTWRITER_DTD_ENTY;
xmlListPushFront(writer->nodes, p);
if (writer->indent) {
count = xmlTextWriterWriteIndent(writer);
if (count < 0)
return -1;
sum += count;
}
count = xmlOutputBufferWriteString(writer->out, "<!ENTITY ");
if (count < 0)
return -1;
sum += count;
if (pe != 0) {
count = xmlOutputBufferWriteString(writer->out, "% ");
if (count < 0)
return -1;
sum += count;
}
count = xmlOutputBufferWriteString(writer->out, (const char *) name);
if (count < 0)
return -1;
sum += count;
return sum;
}
/**
* xmlTextWriterEndDTDEntity:
* @writer: the xmlTextWriterPtr
*
* End an xml DTD entity.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterEndDTDEntity(xmlTextWriterPtr writer)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL)
return -1;
sum = 0;
lk = xmlListFront(writer->nodes);
if (lk == 0)
return -1;
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p == 0)
return -1;
switch (p->state) {
case XML_TEXTWRITER_DTD_ENTY_TEXT:
count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
if (count < 0)
return -1;
sum += count;
case XML_TEXTWRITER_DTD_ENTY:
case XML_TEXTWRITER_DTD_PENT:
count = xmlOutputBufferWriteString(writer->out, ">");
if (count < 0)
return -1;
sum += count;
break;
default:
return -1;
}
if (writer->indent) {
count = xmlOutputBufferWriteString(writer->out, "\n");
if (count < 0)
return -1;
sum += count;
}
xmlListPopFront(writer->nodes);
return sum;
}
/**
* xmlTextWriterWriteFormatDTDInternalEntity:
* @writer: the xmlTextWriterPtr
* @pe: TRUE if this is a parameter entity, FALSE if not
* @name: the name of the DTD entity
* @format: format string (see printf)
* @...: extra parameters for the format
*
* Write a formatted DTD internal entity.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int XMLCDECL
xmlTextWriterWriteFormatDTDInternalEntity(xmlTextWriterPtr writer,
int pe,
const xmlChar * name,
const char *format, ...)
{
int rc;
va_list ap;
va_start(ap, format);
rc = xmlTextWriterWriteVFormatDTDInternalEntity(writer, pe, name,
format, ap);
va_end(ap);
return rc;
}
/**
* xmlTextWriterWriteVFormatDTDInternalEntity:
* @writer: the xmlTextWriterPtr
* @pe: TRUE if this is a parameter entity, FALSE if not
* @name: the name of the DTD entity
* @format: format string (see printf)
* @argptr: pointer to the first member of the variable argument list.
*
* Write a formatted DTD internal entity.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteVFormatDTDInternalEntity(xmlTextWriterPtr writer,
int pe,
const xmlChar * name,
const char *format,
va_list argptr)
{
int rc;
xmlChar *buf;
if (writer == NULL)
return -1;
buf = xmlTextWriterVSprintf(format, argptr);
if (buf == 0)
return 0;
rc = xmlTextWriterWriteDTDInternalEntity(writer, pe, name, buf);
xmlFree(buf);
return rc;
}
/**
* xmlTextWriterWriteDTDEntity:
* @writer: the xmlTextWriterPtr
* @pe: TRUE if this is a parameter entity, FALSE if not
* @name: the name of the DTD entity
* @pubid: the public identifier, which is an alternative to the system identifier
* @sysid: the system identifier, which is the URI of the DTD
* @ndataid: the xml notation name.
* @content: content of the entity
*
* Write a DTD entity.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteDTDEntity(xmlTextWriterPtr 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);
}
/**
* xmlTextWriterWriteDTDInternalEntity:
* @writer: the xmlTextWriterPtr
* @pe: TRUE if this is a parameter entity, FALSE if not
* @name: the name of the DTD entity
* @content: content of the entity
*
* Write a DTD internal entity.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteDTDInternalEntity(xmlTextWriterPtr writer,
int pe,
const xmlChar * name,
const xmlChar * content)
{
int count;
int sum;
if ((name == NULL) || (*name == '\0') || (content == NULL))
return -1;
sum = 0;
count = xmlTextWriterStartDTDEntity(writer, pe, name);
if (count == -1)
return -1;
sum += count;
count = xmlTextWriterWriteString(writer, content);
if (count == -1)
return -1;
sum += count;
count = xmlTextWriterEndDTDEntity(writer);
if (count == -1)
return -1;
sum += count;
return sum;
}
/**
* xmlTextWriterWriteDTDExternalEntity:
* @writer: the xmlTextWriterPtr
* @pe: TRUE if this is a parameter entity, FALSE if not
* @name: the name of the DTD entity
* @pubid: the public identifier, which is an alternative to the system identifier
* @sysid: the system identifier, which is the URI of the DTD
* @ndataid: the xml notation name.
*
* Write a DTD external entity. The entity must have been started with xmlTextWriterStartDTDEntity
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteDTDExternalEntity(xmlTextWriterPtr writer,
int pe,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid,
const xmlChar * ndataid)
{
int count;
int sum;
if (((pubid == NULL) && (sysid == NULL)))
return -1;
if ((pe != 0) && (ndataid != NULL))
return -1;
sum = 0;
count = xmlTextWriterStartDTDEntity(writer, pe, name);
if (count == -1)
return -1;
sum += count;
count =
xmlTextWriterWriteDTDExternalEntityContents(writer, pubid, sysid,
ndataid);
if (count < 0)
return -1;
sum += count;
count = xmlTextWriterEndDTDEntity(writer);
if (count == -1)
return -1;
sum += count;
return sum;
}
/**
* xmlTextWriterWriteDTDExternalEntityContents:
* @writer: the xmlTextWriterPtr
* @pubid: the public identifier, which is an alternative to the system identifier
* @sysid: the system identifier, which is the URI of the DTD
* @ndataid: the xml notation name.
*
* Write the contents of a DTD external entity.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteDTDExternalEntityContents(xmlTextWriterPtr writer,
const xmlChar * pubid,
const xmlChar * sysid,
const xmlChar * ndataid)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL) {
xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterWriteDTDExternalEntityContents: xmlTextWriterPtr invalid!\n");
return -1;
}
sum = 0;
lk = xmlListFront(writer->nodes);
if (lk == 0) {
xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterWriteDTDExternalEntityContents: you must call xmlTextWriterStartDTDEntity before the call to this function!\n");
return -1;
}
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p == 0)
return -1;
switch (p->state) {
case XML_TEXTWRITER_DTD_ENTY:
break;
case XML_TEXTWRITER_DTD_PENT:
if (ndataid != NULL) {
xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterWriteDTDExternalEntityContents: notation not allowed with parameter entities!\n");
return -1;
}
break;
default:
xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterWriteDTDExternalEntityContents: you must call xmlTextWriterStartDTDEntity before the call to this function!\n");
return -1;
}
if (pubid != 0) {
if (sysid == 0) {
xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterWriteDTDExternalEntityContents: system identifier needed!\n");
return -1;
}
count = xmlOutputBufferWriteString(writer->out, " PUBLIC ");
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
if (count < 0)
return -1;
sum += count;
count =
xmlOutputBufferWriteString(writer->out, (const char *) pubid);
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
if (count < 0)
return -1;
sum += count;
}
if (sysid != 0) {
if (pubid == 0) {
count = xmlOutputBufferWriteString(writer->out, " SYSTEM");
if (count < 0)
return -1;
sum += count;
}
count = xmlOutputBufferWriteString(writer->out, " ");
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
if (count < 0)
return -1;
sum += count;
count =
xmlOutputBufferWriteString(writer->out, (const char *) sysid);
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
if (count < 0)
return -1;
sum += count;
}
if (ndataid != NULL) {
count = xmlOutputBufferWriteString(writer->out, " NDATA ");
if (count < 0)
return -1;
sum += count;
count =
xmlOutputBufferWriteString(writer->out,
(const char *) ndataid);
if (count < 0)
return -1;
sum += count;
}
return sum;
}
/**
* xmlTextWriterWriteDTDNotation:
* @writer: the xmlTextWriterPtr
* @name: the name of the xml notation
* @pubid: the public identifier, which is an alternative to the system identifier
* @sysid: the system identifier, which is the URI of the DTD
*
* Write a DTD entity.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterWriteDTDNotation(xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * pubid, const xmlChar * sysid)
{
int count;
int sum;
xmlLinkPtr lk;
xmlTextWriterStackEntry *p;
if (writer == NULL || name == NULL || *name == '\0')
return -1;
sum = 0;
lk = xmlListFront(writer->nodes);
if (lk == 0) {
return -1;
}
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p != 0) {
switch (p->state) {
case XML_TEXTWRITER_DTD:
count = xmlOutputBufferWriteString(writer->out, " [");
if (count < 0)
return -1;
sum += count;
if (writer->indent) {
count = xmlOutputBufferWriteString(writer->out, "\n");
if (count < 0)
return -1;
sum += count;
}
p->state = XML_TEXTWRITER_DTD_TEXT;
/* fallthrough */
case XML_TEXTWRITER_DTD_TEXT:
break;
default:
return -1;
}
}
if (writer->indent) {
count = xmlTextWriterWriteIndent(writer);
if (count < 0)
return -1;
sum += count;
}
count = xmlOutputBufferWriteString(writer->out, "<!NOTATION ");
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWriteString(writer->out, (const char *) name);
if (count < 0)
return -1;
sum += count;
if (pubid != 0) {
count = xmlOutputBufferWriteString(writer->out, " PUBLIC ");
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
if (count < 0)
return -1;
sum += count;
count =
xmlOutputBufferWriteString(writer->out, (const char *) pubid);
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
if (count < 0)
return -1;
sum += count;
}
if (sysid != 0) {
if (pubid == 0) {
count = xmlOutputBufferWriteString(writer->out, " SYSTEM");
if (count < 0)
return -1;
sum += count;
}
count = xmlOutputBufferWriteString(writer->out, " ");
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
if (count < 0)
return -1;
sum += count;
count =
xmlOutputBufferWriteString(writer->out, (const char *) sysid);
if (count < 0)
return -1;
sum += count;
count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
if (count < 0)
return -1;
sum += count;
}
count = xmlOutputBufferWriteString(writer->out, ">");
if (count < 0)
return -1;
sum += count;
return sum;
}
/**
* xmlTextWriterFlush:
* @writer: the xmlTextWriterPtr
*
* Flush the output buffer.
*
* Returns the bytes written (may be 0 because of buffering) or -1 in case of error
*/
int
xmlTextWriterFlush(xmlTextWriterPtr writer)
{
int count;
if (writer == NULL)
return -1;
if (writer->out == NULL)
count = 0;
else
count = xmlOutputBufferFlush(writer->out);
return count;
}
/**
* misc
*/
/**
* xmlFreeTextWriterStackEntry:
* @lk: the xmlLinkPtr
*
* Free callback for the xmlList.
*/
static void
xmlFreeTextWriterStackEntry(xmlLinkPtr lk)
{
xmlTextWriterStackEntry *p;
p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
if (p == 0)
return;
if (p->name != 0)
xmlFree(p->name);
xmlFree(p);
}
/**
* xmlCmpTextWriterStackEntry:
* @data0: the first data
* @data1: the second data
*
* Compare callback for the xmlList.
*
* Returns -1, 0, 1
*/
static int
xmlCmpTextWriterStackEntry(const void *data0, const void *data1)
{
xmlTextWriterStackEntry *p0;
xmlTextWriterStackEntry *p1;
if (data0 == data1)
return 0;
if (data0 == 0)
return -1;
if (data1 == 0)
return 1;
p0 = (xmlTextWriterStackEntry *) data0;
p1 = (xmlTextWriterStackEntry *) data1;
return xmlStrcmp(p0->name, p1->name);
}
/**
* misc
*/
/**
* xmlTextWriterOutputNSDecl:
* @writer: the xmlTextWriterPtr
*
* Output the current namespace declarations.
*/
static int
xmlTextWriterOutputNSDecl(xmlTextWriterPtr writer)
{
xmlLinkPtr lk;
xmlTextWriterNsStackEntry *np;
int count;
int sum;
sum = 0;
while (!xmlListEmpty(writer->nsstack)) {
xmlChar *namespaceURI = NULL;
xmlChar *prefix = NULL;
lk = xmlListFront(writer->nsstack);
np = (xmlTextWriterNsStackEntry *) xmlLinkGetData(lk);
if (np != 0) {
namespaceURI = xmlStrdup(np->uri);
prefix = xmlStrdup(np->prefix);
}
xmlListPopFront(writer->nsstack);
if (np != 0) {
count = xmlTextWriterWriteAttribute(writer, prefix, namespaceURI);
xmlFree(namespaceURI);
xmlFree(prefix);
if (count < 0) {
xmlListDelete(writer->nsstack);
writer->nsstack = NULL;
return -1;
}
sum += count;
}
}
return sum;
}
/**
* xmlFreeTextWriterNsStackEntry:
* @lk: the xmlLinkPtr
*
* Free callback for the xmlList.
*/
static void
xmlFreeTextWriterNsStackEntry(xmlLinkPtr lk)
{
xmlTextWriterNsStackEntry *p;
p = (xmlTextWriterNsStackEntry *) xmlLinkGetData(lk);
if (p == 0)
return;
if (p->prefix != 0)
xmlFree(p->prefix);
if (p->uri != 0)
xmlFree(p->uri);
xmlFree(p);
}
/**
* xmlCmpTextWriterNsStackEntry:
* @data0: the first data
* @data1: the second data
*
* Compare callback for the xmlList.
*
* Returns -1, 0, 1
*/
static int
xmlCmpTextWriterNsStackEntry(const void *data0, const void *data1)
{
xmlTextWriterNsStackEntry *p0;
xmlTextWriterNsStackEntry *p1;
int rc;
if (data0 == data1)
return 0;
if (data0 == 0)
return -1;
if (data1 == 0)
return 1;
p0 = (xmlTextWriterNsStackEntry *) data0;
p1 = (xmlTextWriterNsStackEntry *) data1;
rc = xmlStrcmp(p0->prefix, p1->prefix);
if ((rc != 0) || (p0->elem != p1->elem))
rc = -1;
return rc;
}
/**
* xmlTextWriterWriteDocCallback:
* @context: the xmlBufferPtr
* @str: the data to write
* @len: the length of the data
*
* Write callback for the xmlOutputBuffer with target xmlBuffer
*
* Returns -1, 0, 1
*/
static int
xmlTextWriterWriteDocCallback(void *context, const xmlChar * str, int len)
{
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) context;
int rc;
if ((rc = xmlParseChunk(ctxt, (const char *) str, len, 0)) != 0) {
xmlWriterErrMsgInt(NULL, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterWriteDocCallback : XML error %d !\n",
rc);
return -1;
}
return len;
}
/**
* xmlTextWriterCloseDocCallback:
* @context: the xmlBufferPtr
*
* Close callback for the xmlOutputBuffer with target xmlBuffer
*
* Returns -1, 0, 1
*/
static int
xmlTextWriterCloseDocCallback(void *context)
{
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) context;
int rc;
if ((rc = xmlParseChunk(ctxt, NULL, 0, 1)) != 0) {
xmlWriterErrMsgInt(NULL, XML_ERR_INTERNAL_ERROR,
"xmlTextWriterWriteDocCallback : XML error %d !\n",
rc);
return -1;
}
return 0;
}
/**
* xmlTextWriterVSprintf:
* @format: see printf
* @argptr: pointer to the first member of the variable argument list.
*
* Utility function for formatted output
*
* Returns a new xmlChar buffer with the data or NULL on error. This buffer must be freed.
*/
static xmlChar *
xmlTextWriterVSprintf(const char *format, va_list argptr)
{
int size;
int count;
xmlChar *buf;
va_list locarg;
size = BUFSIZ;
buf = (xmlChar *) xmlMalloc(size);
if (buf == NULL) {
xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
"xmlTextWriterVSprintf : out of memory!\n");
return NULL;
}
VA_COPY(locarg, argptr);
while (((count = vsnprintf((char *) buf, size, format, locarg)) < 0)
|| (count == size - 1) || (count == size) || (count > size)) {
va_end(locarg);
xmlFree(buf);
size += BUFSIZ;
buf = (xmlChar *) xmlMalloc(size);
if (buf == NULL) {
xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
"xmlTextWriterVSprintf : out of memory!\n");
return NULL;
}
VA_COPY(locarg, argptr);
}
va_end(locarg);
return buf;
}
/**
* xmlTextWriterStartDocumentCallback:
* @ctx: the user data (XML parser context)
*
* called at the start of document processing.
*/
static void
xmlTextWriterStartDocumentCallback(void *ctx)
{
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
xmlDocPtr doc;
if (ctxt->html) {
#ifdef LIBXML_HTML_ENABLED
if (ctxt->myDoc == NULL)
ctxt->myDoc = htmlNewDocNoDtD(NULL, NULL);
if (ctxt->myDoc == NULL) {
if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
ctxt->sax->error(ctxt->userData,
"SAX.startDocument(): out of memory\n");
ctxt->errNo = XML_ERR_NO_MEMORY;
ctxt->instate = XML_PARSER_EOF;
ctxt->disableSAX = 1;
return;
}
#else
xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
"libxml2 built without HTML support\n");
ctxt->errNo = XML_ERR_INTERNAL_ERROR;
ctxt->instate = XML_PARSER_EOF;
ctxt->disableSAX = 1;
return;
#endif
} else {
doc = ctxt->myDoc;
if (doc == NULL)
doc = ctxt->myDoc = xmlNewDoc(ctxt->version);
if (doc != NULL) {
if (doc->children == NULL) {
if (ctxt->encoding != NULL)
doc->encoding = xmlStrdup(ctxt->encoding);
else
doc->encoding = NULL;
doc->standalone = ctxt->standalone;
}
} else {
if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
ctxt->sax->error(ctxt->userData,
"SAX.startDocument(): out of memory\n");
ctxt->errNo = XML_ERR_NO_MEMORY;
ctxt->instate = XML_PARSER_EOF;
ctxt->disableSAX = 1;
return;
}
}
if ((ctxt->myDoc != NULL) && (ctxt->myDoc->URL == NULL) &&
(ctxt->input != NULL) && (ctxt->input->filename != NULL)) {
ctxt->myDoc->URL =
xmlCanonicPath((const xmlChar *) ctxt->input->filename);
if (ctxt->myDoc->URL == NULL)
ctxt->myDoc->URL =
xmlStrdup((const xmlChar *) ctxt->input->filename);
}
}
/**
* xmlTextWriterSetIndent:
* @writer: the xmlTextWriterPtr
* @indent: do indentation?
*
* Set indentation output. indent = 0 do not indentation. indent > 0 do indentation.
*
* Returns -1 on error or 0 otherwise.
*/
int
xmlTextWriterSetIndent(xmlTextWriterPtr writer, int indent)
{
if ((writer == NULL) || (indent < 0))
return -1;
writer->indent = indent;
writer->doindent = 1;
return 0;
}
/**
* xmlTextWriterSetIndentString:
* @writer: the xmlTextWriterPtr
* @str: the xmlChar string
*
* Set string indentation.
*
* Returns -1 on error or 0 otherwise.
*/
int
xmlTextWriterSetIndentString(xmlTextWriterPtr writer, const xmlChar * str)
{
if ((writer == NULL) || (!str))
return -1;
if (writer->ichar != NULL)
xmlFree(writer->ichar);
writer->ichar = xmlStrdup(str);
if (!writer->ichar)
return -1;
else
return 0;
}
/**
* xmlTextWriterWriteIndent:
* @writer: the xmlTextWriterPtr
*
* Write indent string.
*
* Returns -1 on error or the number of strings written.
*/
static int
xmlTextWriterWriteIndent(xmlTextWriterPtr writer)
{
int lksize;
int i;
int ret;
lksize = xmlListSize(writer->nodes);
if (lksize < 1)
return (-1); /* list is empty */
for (i = 0; i < (lksize - 1); i++) {
ret = xmlOutputBufferWriteString(writer->out,
(const char *) writer->ichar);
if (ret == -1)
return (-1);
}
return (lksize - 1);
}
/**
* xmlTextWriterHandleStateDependencies:
* @writer: the xmlTextWriterPtr
* @p: the xmlTextWriterStackEntry
*
* Write state dependent strings.
*
* Returns -1 on error or the number of characters written.
*/
static int
xmlTextWriterHandleStateDependencies(xmlTextWriterPtr writer,
xmlTextWriterStackEntry * p)
{
int count;
int sum;
char extra[3];
if (writer == NULL)
return -1;
if (p == NULL)
return 0;
sum = 0;
extra[0] = extra[1] = extra[2] = '\0';
if (p != 0) {
sum = 0;
switch (p->state) {
case XML_TEXTWRITER_NAME:
/* Output namespace declarations */
count = xmlTextWriterOutputNSDecl(writer);
if (count < 0)
return -1;
sum += count;
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] = '[';
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;
p->state = XML_TEXTWRITER_DTD_ENTY_TEXT;
break;
default:
break;
}
}
if (*extra != '\0') {
count = xmlOutputBufferWriteString(writer->out, extra);
if (count < 0)
return -1;
sum += count;
}
return sum;
}
#define bottom_xmlwriter
#include "elfgcchack.h"
#endif