xmlwriter.c revision 7e26fb4b109b50ecf6752fe3d6f74d349432fac7 
1
2/*
3 * xmlwriter.c: XML text writer implementation
4 *
5 * For license and disclaimer see the license and disclaimer of
6 * libxml2.
7 *
8 * alfred@mickautsch.de
9 */
10
11#define IN_LIBXML
12#include "libxml.h"
13#include <string.h>
14
15#include <libxml/xmlmemory.h>
16#include <libxml/parser.h>
17#include <libxml/uri.h>
18#include <libxml/HTMLtree.h>
19
20#ifdef LIBXML_WRITER_ENABLED
21
22#include <libxml/xmlwriter.h>
23
24#define B64LINELEN 72
25#define B64CRLF "\r\n"
26
27/*
28 * The following VA_COPY was coded following an example in
29 * the Samba project.  It may not be sufficient for some
30 * esoteric implementations of va_list (i.e. it may need
31 * something involving a memcpy) but (hopefully) will be
32 * sufficient for libxml2.
33 */
34#ifndef VA_COPY
35  #ifdef HAVE_VA_COPY
36    #define VA_COPY(dest, src) va_copy(dest, src)
37  #else
38    #ifdef HAVE___VA_COPY
39      #define VA_COPY(dest,src) __va_copy(dest, src)
40    #else
41      #define VA_COPY(dest,src) (dest) = (src)
42    #endif
43  #endif
44#endif
45
46/*
47 * Types are kept private
48 */
49typedef enum {
50    XML_TEXTWRITER_NONE = 0,
51    XML_TEXTWRITER_NAME,
52    XML_TEXTWRITER_ATTRIBUTE,
53    XML_TEXTWRITER_TEXT,
54    XML_TEXTWRITER_PI,
55    XML_TEXTWRITER_PI_TEXT,
56    XML_TEXTWRITER_CDATA,
57    XML_TEXTWRITER_DTD,
58    XML_TEXTWRITER_DTD_TEXT,
59    XML_TEXTWRITER_DTD_ELEM,
60    XML_TEXTWRITER_DTD_ELEM_TEXT,
61    XML_TEXTWRITER_DTD_ATTL,
62    XML_TEXTWRITER_DTD_ATTL_TEXT,
63    XML_TEXTWRITER_DTD_ENTY,    /* entity */
64    XML_TEXTWRITER_DTD_ENTY_TEXT,
65    XML_TEXTWRITER_DTD_PENT,    /* parameter entity */
66    XML_TEXTWRITER_COMMENT
67} xmlTextWriterState;
68
69typedef struct _xmlTextWriterStackEntry xmlTextWriterStackEntry;
70
71struct _xmlTextWriterStackEntry {
72    xmlChar *name;
73    xmlTextWriterState state;
74};
75
76typedef struct _xmlTextWriterNsStackEntry xmlTextWriterNsStackEntry;
77struct _xmlTextWriterNsStackEntry {
78    xmlChar *prefix;
79    xmlChar *uri;
80    xmlLinkPtr elem;
81};
82
83struct _xmlTextWriter {
84    xmlOutputBufferPtr out;     /* output buffer */
85    xmlListPtr nodes;           /* element name stack */
86    xmlListPtr nsstack;         /* name spaces stack */
87    int level;
88    int indent;                 /* enable indent */
89    int doindent;               /* internal indent flag */
90    xmlChar *ichar;             /* indent character */
91    char qchar;                 /* character used for quoting attribute values */
92    xmlParserCtxtPtr ctxt;
93    int no_doc_free;
94    xmlDocPtr doc;
95};
96
97static void xmlFreeTextWriterStackEntry(xmlLinkPtr lk);
98static int xmlCmpTextWriterStackEntry(const void *data0,
99                                      const void *data1);
100static int xmlTextWriterOutputNSDecl(xmlTextWriterPtr writer);
101static void xmlFreeTextWriterNsStackEntry(xmlLinkPtr lk);
102static int xmlCmpTextWriterNsStackEntry(const void *data0,
103                                        const void *data1);
104static int xmlTextWriterWriteDocCallback(void *context,
105                                         const xmlChar * str, int len);
106static int xmlTextWriterCloseDocCallback(void *context);
107
108static xmlChar *xmlTextWriterVSprintf(const char *format, va_list argptr);
109static int xmlOutputBufferWriteBase64(xmlOutputBufferPtr out, int len,
110                                      const unsigned char *data);
111static void xmlTextWriterStartDocumentCallback(void *ctx);
112static int xmlTextWriterWriteIndent(xmlTextWriterPtr writer);
113static int
114  xmlTextWriterHandleStateDependencies(xmlTextWriterPtr writer,
115                                       xmlTextWriterStackEntry * p);
116
117/**
118 * xmlWriterErrMsg:
119 * @ctxt:  a writer context
120 * @error:  the error number
121 * @msg:  the error message
122 *
123 * Handle a writer error
124 */
125static void
126xmlWriterErrMsg(xmlTextWriterPtr ctxt, xmlParserErrors error,
127               const char *msg)
128{
129    if (ctxt != NULL) {
130	__xmlRaiseError(NULL, NULL, NULL, ctxt->ctxt,
131	            NULL, XML_FROM_WRITER, error, XML_ERR_FATAL,
132		    NULL, 0, NULL, NULL, NULL, 0, 0, msg);
133    } else {
134	__xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_WRITER, error,
135                    XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0, msg);
136    }
137}
138
139/**
140 * xmlWriterErrMsgInt:
141 * @ctxt:  a writer context
142 * @error:  the error number
143 * @msg:  the error message
144 * @val:  an int
145 *
146 * Handle a writer error
147 */
148static void
149xmlWriterErrMsgInt(xmlTextWriterPtr ctxt, xmlParserErrors error,
150               const char *msg, int val)
151{
152    if (ctxt != NULL) {
153	__xmlRaiseError(NULL, NULL, NULL, ctxt->ctxt,
154	            NULL, XML_FROM_WRITER, error, XML_ERR_FATAL,
155		    NULL, 0, NULL, NULL, NULL, val, 0, msg, val);
156    } else {
157	__xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_WRITER, error,
158                    XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, val, 0, msg, val);
159    }
160}
161
162/**
163 * xmlNewTextWriter:
164 * @out:  an xmlOutputBufferPtr
165 *
166 * Create a new xmlNewTextWriter structure using an xmlOutputBufferPtr
167 * NOTE: the @out parameter will be deallocated when the writer is closed
168 *       (if the call succeed.)
169 *
170 * Returns the new xmlTextWriterPtr or NULL in case of error
171 */
172xmlTextWriterPtr
173xmlNewTextWriter(xmlOutputBufferPtr out)
174{
175    xmlTextWriterPtr ret;
176
177    ret = (xmlTextWriterPtr) xmlMalloc(sizeof(xmlTextWriter));
178    if (ret == NULL) {
179        xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
180                        "xmlNewTextWriter : out of memory!\n");
181        return NULL;
182    }
183    memset(ret, 0, (size_t) sizeof(xmlTextWriter));
184
185    ret->nodes = xmlListCreate((xmlListDeallocator)
186                               xmlFreeTextWriterStackEntry,
187                               (xmlListDataCompare)
188                               xmlCmpTextWriterStackEntry);
189    if (ret->nodes == NULL) {
190        xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
191                        "xmlNewTextWriter : out of memory!\n");
192        xmlFree(ret);
193        return NULL;
194    }
195
196    ret->nsstack = xmlListCreate((xmlListDeallocator)
197                                 xmlFreeTextWriterNsStackEntry,
198                                 (xmlListDataCompare)
199                                 xmlCmpTextWriterNsStackEntry);
200    if (ret->nsstack == NULL) {
201        xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
202                        "xmlNewTextWriter : out of memory!\n");
203        xmlListDelete(ret->nodes);
204        xmlFree(ret);
205        return NULL;
206    }
207
208    ret->out = out;
209    ret->ichar = xmlStrdup(BAD_CAST " ");
210    ret->qchar = '"';
211
212    if (!ret->ichar) {
213        xmlListDelete(ret->nodes);
214        xmlListDelete(ret->nsstack);
215        xmlFree(ret);
216        xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
217                        "xmlNewTextWriter : out of memory!\n");
218        return NULL;
219    }
220
221    ret->doc = xmlNewDoc(NULL);
222
223    ret->no_doc_free = 0;
224
225    return ret;
226}
227
228/**
229 * xmlNewTextWriterFilename:
230 * @uri:  the URI of the resource for the output
231 * @compression:  compress the output?
232 *
233 * Create a new xmlNewTextWriter structure with @uri as output
234 *
235 * Returns the new xmlTextWriterPtr or NULL in case of error
236 */
237xmlTextWriterPtr
238xmlNewTextWriterFilename(const char *uri, int compression)
239{
240    xmlTextWriterPtr ret;
241    xmlOutputBufferPtr out;
242
243    out = xmlOutputBufferCreateFilename(uri, NULL, compression);
244    if (out == NULL) {
245        xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
246                        "xmlNewTextWriterFilename : out of memory!\n");
247        return NULL;
248    }
249
250    ret = xmlNewTextWriter(out);
251    if (ret == NULL) {
252        xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
253                        "xmlNewTextWriterFilename : out of memory!\n");
254        xmlOutputBufferClose(out);
255        return NULL;
256    }
257
258    ret->indent = 0;
259    ret->doindent = 0;
260    return ret;
261}
262
263/**
264 * xmlNewTextWriterMemory:
265 * @buf:  xmlBufferPtr
266 * @compression:  compress the output?
267 *
268 * Create a new xmlNewTextWriter structure with @buf as output
269 * TODO: handle compression
270 *
271 * Returns the new xmlTextWriterPtr or NULL in case of error
272 */
273xmlTextWriterPtr
274xmlNewTextWriterMemory(xmlBufferPtr buf, int compression ATTRIBUTE_UNUSED)
275{
276    xmlTextWriterPtr ret;
277    xmlOutputBufferPtr out;
278
279/*::todo handle compression */
280    out = xmlOutputBufferCreateBuffer(buf, NULL);
281
282    if (out == NULL) {
283        xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
284                        "xmlNewTextWriterMemory : out of memory!\n");
285        return NULL;
286    }
287
288    ret = xmlNewTextWriter(out);
289    if (ret == NULL) {
290        xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
291                        "xmlNewTextWriterMemory : out of memory!\n");
292        xmlOutputBufferClose(out);
293        return NULL;
294    }
295
296    return ret;
297}
298
299/**
300 * xmlNewTextWriterPushParser:
301 * @ctxt: xmlParserCtxtPtr to hold the new XML document tree
302 * @compression:  compress the output?
303 *
304 * Create a new xmlNewTextWriter structure with @ctxt as output
305 * NOTE: the @ctxt context will be freed with the resulting writer
306 *       (if the call succeeds).
307 * TODO: handle compression
308 *
309 * Returns the new xmlTextWriterPtr or NULL in case of error
310 */
311xmlTextWriterPtr
312xmlNewTextWriterPushParser(xmlParserCtxtPtr ctxt,
313                           int compression ATTRIBUTE_UNUSED)
314{
315    xmlTextWriterPtr ret;
316    xmlOutputBufferPtr out;
317
318    if (ctxt == NULL) {
319        xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
320                        "xmlNewTextWriterPushParser : invalid context!\n");
321        return NULL;
322    }
323
324    out = xmlOutputBufferCreateIO((xmlOutputWriteCallback)
325                                  xmlTextWriterWriteDocCallback,
326                                  (xmlOutputCloseCallback)
327                                  xmlTextWriterCloseDocCallback,
328                                  (void *) ctxt, NULL);
329    if (out == NULL) {
330        xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
331                        "xmlNewTextWriterPushParser : error at xmlOutputBufferCreateIO!\n");
332        return NULL;
333    }
334
335    ret = xmlNewTextWriter(out);
336    if (ret == NULL) {
337        xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
338                        "xmlNewTextWriterPushParser : error at xmlNewTextWriter!\n");
339        xmlOutputBufferClose(out);
340        return NULL;
341    }
342
343    ret->ctxt = ctxt;
344
345    return ret;
346}
347
348/**
349 * xmlNewTextWriterDoc:
350 * @doc: address of a xmlDocPtr to hold the new XML document tree
351 * @compression:  compress the output?
352 *
353 * Create a new xmlNewTextWriter structure with @*doc as output
354 *
355 * Returns the new xmlTextWriterPtr or NULL in case of error
356 */
357xmlTextWriterPtr
358xmlNewTextWriterDoc(xmlDocPtr * doc, int compression)
359{
360    xmlTextWriterPtr ret;
361    xmlSAXHandler saxHandler;
362    xmlParserCtxtPtr ctxt;
363
364    memset(&saxHandler, '\0', sizeof(saxHandler));
365    xmlSAX2InitDefaultSAXHandler(&saxHandler, 1);
366    saxHandler.startDocument = xmlTextWriterStartDocumentCallback;
367    saxHandler.startElement = xmlSAX2StartElement;
368    saxHandler.endElement = xmlSAX2EndElement;
369
370    ctxt = xmlCreatePushParserCtxt(&saxHandler, NULL, NULL, 0, NULL);
371    if (ctxt == NULL) {
372        xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
373                        "xmlNewTextWriterDoc : error at xmlCreatePushParserCtxt!\n");
374        return NULL;
375    }
376    /*
377     * For some reason this seems to completely break if node names
378     * are interned.
379     */
380    ctxt->dictNames = 0;
381
382    ctxt->myDoc = xmlNewDoc(BAD_CAST XML_DEFAULT_VERSION);
383    if (ctxt->myDoc == NULL) {
384        xmlFreeParserCtxt(ctxt);
385        xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
386                        "xmlNewTextWriterDoc : error at xmlNewDoc!\n");
387        return NULL;
388    }
389
390    ret = xmlNewTextWriterPushParser(ctxt, compression);
391    if (ret == NULL) {
392        xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
393                        "xmlNewTextWriterDoc : error at xmlNewTextWriterPushParser!\n");
394        return NULL;
395    }
396
397    xmlSetDocCompressMode(ctxt->myDoc, compression);
398
399    if (doc != NULL) {
400        *doc = ctxt->myDoc;
401	ret->no_doc_free = 1;
402    }
403
404    return ret;
405}
406
407/**
408 * xmlNewTextWriterTree:
409 * @doc: xmlDocPtr
410 * @node: xmlNodePtr or NULL for doc->children
411 * @compression:  compress the output?
412 *
413 * Create a new xmlNewTextWriter structure with @doc as output
414 * starting at @node
415 *
416 * Returns the new xmlTextWriterPtr or NULL in case of error
417 */
418xmlTextWriterPtr
419xmlNewTextWriterTree(xmlDocPtr doc, xmlNodePtr node, int compression)
420{
421    xmlTextWriterPtr ret;
422    xmlSAXHandler saxHandler;
423    xmlParserCtxtPtr ctxt;
424
425    if (doc == NULL) {
426        xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
427                        "xmlNewTextWriterTree : invalid document tree!\n");
428        return NULL;
429    }
430
431    memset(&saxHandler, '\0', sizeof(saxHandler));
432    xmlSAX2InitDefaultSAXHandler(&saxHandler, 1);
433    saxHandler.startDocument = xmlTextWriterStartDocumentCallback;
434    saxHandler.startElement = xmlSAX2StartElement;
435    saxHandler.endElement = xmlSAX2EndElement;
436
437    ctxt = xmlCreatePushParserCtxt(&saxHandler, NULL, NULL, 0, NULL);
438    if (ctxt == NULL) {
439        xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
440                        "xmlNewTextWriterDoc : error at xmlCreatePushParserCtxt!\n");
441        return NULL;
442    }
443    /*
444     * For some reason this seems to completely break if node names
445     * are interned.
446     */
447    ctxt->dictNames = 0;
448
449    ret = xmlNewTextWriterPushParser(ctxt, compression);
450    if (ret == NULL) {
451        xmlFreeParserCtxt(ctxt);
452        xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
453                        "xmlNewTextWriterDoc : error at xmlNewTextWriterPushParser!\n");
454        return NULL;
455    }
456
457    ctxt->myDoc = doc;
458    ctxt->node = node;
459    ret->no_doc_free = 1;
460
461    xmlSetDocCompressMode(doc, compression);
462
463    return ret;
464}
465
466/**
467 * xmlFreeTextWriter:
468 * @writer:  the xmlTextWriterPtr
469 *
470 * Deallocate all the resources associated to the writer
471 */
472void
473xmlFreeTextWriter(xmlTextWriterPtr writer)
474{
475    if (writer == NULL)
476        return;
477
478    if (writer->out != NULL)
479        xmlOutputBufferClose(writer->out);
480
481    if (writer->nodes != NULL)
482        xmlListDelete(writer->nodes);
483
484    if (writer->nsstack != NULL)
485        xmlListDelete(writer->nsstack);
486
487    if (writer->ctxt != NULL) {
488        if ((writer->ctxt->myDoc != NULL) && (writer->no_doc_free == 0)) {
489	    xmlFreeDoc(writer->ctxt->myDoc);
490	    writer->ctxt->myDoc = NULL;
491	}
492        xmlFreeParserCtxt(writer->ctxt);
493    }
494
495    if (writer->doc != NULL)
496        xmlFreeDoc(writer->doc);
497
498    if (writer->ichar != NULL)
499        xmlFree(writer->ichar);
500    xmlFree(writer);
501}
502
503/**
504 * xmlTextWriterStartDocument:
505 * @writer:  the xmlTextWriterPtr
506 * @version:  the xml version ("1.0") or NULL for default ("1.0")
507 * @encoding:  the encoding or NULL for default
508 * @standalone: "yes" or "no" or NULL for default
509 *
510 * Start a new xml document
511 *
512 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
513 */
514int
515xmlTextWriterStartDocument(xmlTextWriterPtr writer, const char *version,
516                           const char *encoding, const char *standalone)
517{
518    int count;
519    int sum;
520    xmlLinkPtr lk;
521    xmlCharEncodingHandlerPtr encoder;
522
523    if ((writer == NULL) || (writer->out == NULL)) {
524        xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
525                        "xmlTextWriterStartDocument : invalid writer!\n");
526        return -1;
527    }
528
529    lk = xmlListFront(writer->nodes);
530    if ((lk != NULL) && (xmlLinkGetData(lk) != NULL)) {
531        xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
532                        "xmlTextWriterStartDocument : not allowed in this context!\n");
533        return -1;
534    }
535
536    encoder = NULL;
537    if (encoding != NULL) {
538        encoder = xmlFindCharEncodingHandler(encoding);
539        if (encoder == NULL) {
540            xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
541                            "xmlTextWriterStartDocument : out of memory!\n");
542            return -1;
543        }
544    }
545
546    writer->out->encoder = encoder;
547    if (encoder != NULL) {
548	if (writer->out->conv == NULL) {
549	    writer->out->conv = xmlBufferCreateSize(4000);
550	}
551        xmlCharEncOutFunc(encoder, writer->out->conv, NULL);
552        if ((writer->doc != NULL) && (writer->doc->encoding == NULL))
553            writer->doc->encoding = xmlStrdup((xmlChar *)writer->out->encoder->name);
554    } else
555        writer->out->conv = NULL;
556
557    sum = 0;
558    count = xmlOutputBufferWriteString(writer->out, "<?xml version=");
559    if (count < 0)
560        return -1;
561    sum += count;
562    count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
563    if (count < 0)
564        return -1;
565    sum += count;
566    if (version != 0)
567        count = xmlOutputBufferWriteString(writer->out, version);
568    else
569        count = xmlOutputBufferWriteString(writer->out, "1.0");
570    if (count < 0)
571        return -1;
572    sum += count;
573    count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
574    if (count < 0)
575        return -1;
576    sum += count;
577    if (writer->out->encoder != 0) {
578        count = xmlOutputBufferWriteString(writer->out, " encoding=");
579        if (count < 0)
580            return -1;
581        sum += count;
582        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
583        if (count < 0)
584            return -1;
585        sum += count;
586        count =
587            xmlOutputBufferWriteString(writer->out,
588                                       writer->out->encoder->name);
589        if (count < 0)
590            return -1;
591        sum += count;
592        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
593        if (count < 0)
594            return -1;
595        sum += count;
596    }
597
598    if (standalone != 0) {
599        count = xmlOutputBufferWriteString(writer->out, " standalone=");
600        if (count < 0)
601            return -1;
602        sum += count;
603        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
604        if (count < 0)
605            return -1;
606        sum += count;
607        count = xmlOutputBufferWriteString(writer->out, standalone);
608        if (count < 0)
609            return -1;
610        sum += count;
611        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
612        if (count < 0)
613            return -1;
614        sum += count;
615    }
616
617    count = xmlOutputBufferWriteString(writer->out, "?>\n");
618    if (count < 0)
619        return -1;
620    sum += count;
621
622    return sum;
623}
624
625/**
626 * xmlTextWriterEndDocument:
627 * @writer:  the xmlTextWriterPtr
628 *
629 * End an xml document. All open elements are closed
630 *
631 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
632 */
633int
634xmlTextWriterEndDocument(xmlTextWriterPtr writer)
635{
636    int count;
637    int sum;
638    xmlLinkPtr lk;
639    xmlTextWriterStackEntry *p;
640
641    if (writer == NULL) {
642        xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
643                        "xmlTextWriterEndDocument : invalid writer!\n");
644        return -1;
645    }
646
647    sum = 0;
648    while ((lk = xmlListFront(writer->nodes)) != NULL) {
649        p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
650        if (p == 0)
651            break;
652        switch (p->state) {
653            case XML_TEXTWRITER_NAME:
654            case XML_TEXTWRITER_ATTRIBUTE:
655            case XML_TEXTWRITER_TEXT:
656                count = xmlTextWriterEndElement(writer);
657                if (count < 0)
658                    return -1;
659                sum += count;
660                break;
661            case XML_TEXTWRITER_PI:
662            case XML_TEXTWRITER_PI_TEXT:
663                count = xmlTextWriterEndPI(writer);
664                if (count < 0)
665                    return -1;
666                sum += count;
667                break;
668            case XML_TEXTWRITER_CDATA:
669                count = xmlTextWriterEndCDATA(writer);
670                if (count < 0)
671                    return -1;
672                sum += count;
673                break;
674            case XML_TEXTWRITER_DTD:
675            case XML_TEXTWRITER_DTD_TEXT:
676            case XML_TEXTWRITER_DTD_ELEM:
677            case XML_TEXTWRITER_DTD_ELEM_TEXT:
678            case XML_TEXTWRITER_DTD_ATTL:
679            case XML_TEXTWRITER_DTD_ATTL_TEXT:
680            case XML_TEXTWRITER_DTD_ENTY:
681            case XML_TEXTWRITER_DTD_ENTY_TEXT:
682            case XML_TEXTWRITER_DTD_PENT:
683                count = xmlTextWriterEndDTD(writer);
684                if (count < 0)
685                    return -1;
686                sum += count;
687                break;
688            case XML_TEXTWRITER_COMMENT:
689                count = xmlTextWriterEndComment(writer);
690                if (count < 0)
691                    return -1;
692                sum += count;
693                break;
694            default:
695                break;
696        }
697    }
698
699    if (!writer->indent) {
700        count = xmlOutputBufferWriteString(writer->out, "\n");
701        if (count < 0)
702            return -1;
703        sum += count;
704    }
705    return sum;
706}
707
708/**
709 * xmlTextWriterStartComment:
710 * @writer:  the xmlTextWriterPtr
711 *
712 * Start an xml comment.
713 *
714 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
715 */
716int
717xmlTextWriterStartComment(xmlTextWriterPtr writer)
718{
719    int count;
720    int sum;
721    xmlLinkPtr lk;
722    xmlTextWriterStackEntry *p;
723
724    if (writer == NULL) {
725        xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
726                        "xmlTextWriterStartComment : invalid writer!\n");
727        return -1;
728    }
729
730    sum = 0;
731    lk = xmlListFront(writer->nodes);
732    if (lk != 0) {
733        p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
734        if (p != 0) {
735            switch (p->state) {
736                case XML_TEXTWRITER_TEXT:
737                case XML_TEXTWRITER_NONE:
738                    break;
739                case XML_TEXTWRITER_NAME:
740                    /* Output namespace declarations */
741                    count = xmlTextWriterOutputNSDecl(writer);
742                    if (count < 0)
743                        return -1;
744                    sum += count;
745                    count = xmlOutputBufferWriteString(writer->out, ">");
746                    if (count < 0)
747                        return -1;
748                    sum += count;
749                    if (writer->indent) {
750                        count =
751                            xmlOutputBufferWriteString(writer->out, "\n");
752                        if (count < 0)
753                            return -1;
754                        sum += count;
755                    }
756                    p->state = XML_TEXTWRITER_TEXT;
757                    break;
758                default:
759                    return -1;
760            }
761        }
762    }
763
764    p = (xmlTextWriterStackEntry *)
765        xmlMalloc(sizeof(xmlTextWriterStackEntry));
766    if (p == 0) {
767        xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
768                        "xmlTextWriterStartElement : out of memory!\n");
769        return -1;
770    }
771
772    p->name = NULL;
773    p->state = XML_TEXTWRITER_COMMENT;
774
775    xmlListPushFront(writer->nodes, p);
776
777    if (writer->indent) {
778        count = xmlTextWriterWriteIndent(writer);
779        if (count < 0)
780            return -1;
781        sum += count;
782    }
783
784    count = xmlOutputBufferWriteString(writer->out, "<!--");
785    if (count < 0)
786        return -1;
787    sum += count;
788
789    return sum;
790}
791
792/**
793 * xmlTextWriterEndComment:
794 * @writer:  the xmlTextWriterPtr
795 *
796 * End the current xml coment.
797 *
798 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
799 */
800int
801xmlTextWriterEndComment(xmlTextWriterPtr writer)
802{
803    int count;
804    int sum;
805    xmlLinkPtr lk;
806    xmlTextWriterStackEntry *p;
807
808    if (writer == NULL) {
809        xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
810                        "xmlTextWriterEndComment : invalid writer!\n");
811        return -1;
812    }
813
814    lk = xmlListFront(writer->nodes);
815    if (lk == 0) {
816        xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
817                        "xmlTextWriterEndComment : not allowed in this context!\n");
818        return -1;
819    }
820
821    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
822    if (p == 0)
823        return -1;
824
825    sum = 0;
826    switch (p->state) {
827        case XML_TEXTWRITER_COMMENT:
828            count = xmlOutputBufferWriteString(writer->out, "-->");
829            if (count < 0)
830                return -1;
831            sum += count;
832            break;
833        default:
834            return -1;
835    }
836
837    if (writer->indent) {
838        count = xmlOutputBufferWriteString(writer->out, "\n");
839        if (count < 0)
840            return -1;
841        sum += count;
842    }
843
844    xmlListPopFront(writer->nodes);
845    return sum;
846}
847
848/**
849 * xmlTextWriterWriteFormatComment:
850 * @writer:  the xmlTextWriterPtr
851 * @format:  format string (see printf)
852 * @...:  extra parameters for the format
853 *
854 * Write an xml comment.
855 *
856 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
857 */
858int XMLCDECL
859xmlTextWriterWriteFormatComment(xmlTextWriterPtr writer,
860                                const char *format, ...)
861{
862    int rc;
863    va_list ap;
864
865    va_start(ap, format);
866
867    rc = xmlTextWriterWriteVFormatComment(writer, format, ap);
868
869    va_end(ap);
870    return rc;
871}
872
873/**
874 * xmlTextWriterWriteVFormatComment:
875 * @writer:  the xmlTextWriterPtr
876 * @format:  format string (see printf)
877 * @argptr:  pointer to the first member of the variable argument list.
878 *
879 * Write an xml comment.
880 *
881 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
882 */
883int
884xmlTextWriterWriteVFormatComment(xmlTextWriterPtr writer,
885                                 const char *format, va_list argptr)
886{
887    int rc;
888    xmlChar *buf;
889
890    if (writer == NULL) {
891        xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
892                        "xmlTextWriterWriteVFormatComment : invalid writer!\n");
893        return -1;
894    }
895
896    buf = xmlTextWriterVSprintf(format, argptr);
897    if (buf == 0)
898        return 0;
899
900    rc = xmlTextWriterWriteComment(writer, buf);
901
902    xmlFree(buf);
903    return rc;
904}
905
906/**
907 * xmlTextWriterWriteComment:
908 * @writer:  the xmlTextWriterPtr
909 * @content:  comment string
910 *
911 * Write an xml comment.
912 *
913 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
914 */
915int
916xmlTextWriterWriteComment(xmlTextWriterPtr writer, const xmlChar * content)
917{
918    int count;
919    int sum;
920
921    sum = 0;
922    count = xmlTextWriterStartComment(writer);
923    if (count < 0)
924        return -1;
925    sum += count;
926    count = xmlTextWriterWriteString(writer, content);
927    if (count < 0)
928        return -1;
929    sum += count;
930    count = xmlTextWriterEndComment(writer);
931    if (count < 0)
932        return -1;
933    sum += count;
934
935    return sum;
936}
937
938/**
939 * xmlTextWriterStartElement:
940 * @writer:  the xmlTextWriterPtr
941 * @name:  element name
942 *
943 * Start an xml element.
944 *
945 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
946 */
947int
948xmlTextWriterStartElement(xmlTextWriterPtr writer, const xmlChar * name)
949{
950    int count;
951    int sum;
952    xmlLinkPtr lk;
953    xmlTextWriterStackEntry *p;
954
955    if ((writer == NULL) || (name == NULL) || (*name == '\0'))
956        return -1;
957
958    sum = 0;
959    lk = xmlListFront(writer->nodes);
960    if (lk != 0) {
961        p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
962        if (p != 0) {
963            switch (p->state) {
964                case XML_TEXTWRITER_PI:
965                case XML_TEXTWRITER_PI_TEXT:
966                    return -1;
967                case XML_TEXTWRITER_NONE:
968                    break;
969				case XML_TEXTWRITER_ATTRIBUTE:
970					count = xmlTextWriterEndAttribute(writer);
971					if (count < 0)
972						return -1;
973					sum += count;
974					/* fallthrough */
975                case XML_TEXTWRITER_NAME:
976                    /* Output namespace declarations */
977                    count = xmlTextWriterOutputNSDecl(writer);
978                    if (count < 0)
979                        return -1;
980                    sum += count;
981                    count = xmlOutputBufferWriteString(writer->out, ">");
982                    if (count < 0)
983                        return -1;
984                    sum += count;
985                    if (writer->indent)
986                        count =
987                            xmlOutputBufferWriteString(writer->out, "\n");
988                    p->state = XML_TEXTWRITER_TEXT;
989                    break;
990                default:
991                    break;
992            }
993        }
994    }
995
996    p = (xmlTextWriterStackEntry *)
997        xmlMalloc(sizeof(xmlTextWriterStackEntry));
998    if (p == 0) {
999        xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
1000                        "xmlTextWriterStartElement : out of memory!\n");
1001        return -1;
1002    }
1003
1004    p->name = xmlStrdup(name);
1005    if (p->name == 0) {
1006        xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
1007                        "xmlTextWriterStartElement : out of memory!\n");
1008        xmlFree(p);
1009        return -1;
1010    }
1011    p->state = XML_TEXTWRITER_NAME;
1012
1013    xmlListPushFront(writer->nodes, p);
1014
1015    if (writer->indent) {
1016        count = xmlTextWriterWriteIndent(writer);
1017        sum += count;
1018    }
1019
1020    count = xmlOutputBufferWriteString(writer->out, "<");
1021    if (count < 0)
1022        return -1;
1023    sum += count;
1024    count =
1025        xmlOutputBufferWriteString(writer->out, (const char *) p->name);
1026    if (count < 0)
1027        return -1;
1028    sum += count;
1029
1030    return sum;
1031}
1032
1033/**
1034 * xmlTextWriterStartElementNS:
1035 * @writer:  the xmlTextWriterPtr
1036 * @prefix:  namespace prefix or NULL
1037 * @name:  element local name
1038 * @namespaceURI:  namespace URI or NULL
1039 *
1040 * Start an xml element with namespace support.
1041 *
1042 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1043 */
1044int
1045xmlTextWriterStartElementNS(xmlTextWriterPtr writer,
1046                            const xmlChar * prefix, const xmlChar * name,
1047                            const xmlChar * namespaceURI)
1048{
1049    int count;
1050    int sum;
1051    xmlChar *buf;
1052
1053    if ((writer == NULL) || (name == NULL) || (*name == '\0'))
1054        return -1;
1055
1056    buf = NULL;
1057    if (prefix != 0) {
1058        buf = xmlStrdup(prefix);
1059        buf = xmlStrcat(buf, BAD_CAST ":");
1060    }
1061    buf = xmlStrcat(buf, name);
1062
1063    sum = 0;
1064    count = xmlTextWriterStartElement(writer, buf);
1065    xmlFree(buf);
1066    if (count < 0)
1067        return -1;
1068    sum += count;
1069
1070    if (namespaceURI != 0) {
1071        xmlTextWriterNsStackEntry *p = (xmlTextWriterNsStackEntry *)
1072        xmlMalloc(sizeof(xmlTextWriterNsStackEntry));
1073        if (p == 0) {
1074            xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
1075                            "xmlTextWriterStartElementNS : out of memory!\n");
1076            return -1;
1077        }
1078
1079        buf = xmlStrdup(BAD_CAST "xmlns");
1080        if (prefix != 0) {
1081            buf = xmlStrcat(buf, BAD_CAST ":");
1082            buf = xmlStrcat(buf, prefix);
1083        }
1084
1085        p->prefix = buf;
1086        p->uri = xmlStrdup(namespaceURI);
1087        if (p->uri == 0) {
1088            xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
1089                            "xmlTextWriterStartElementNS : out of memory!\n");
1090            xmlFree(p);
1091            return -1;
1092        }
1093        p->elem = xmlListFront(writer->nodes);
1094
1095        xmlListPushFront(writer->nsstack, p);
1096    }
1097
1098    return sum;
1099}
1100
1101/**
1102 * xmlTextWriterEndElement:
1103 * @writer:  the xmlTextWriterPtr
1104 *
1105 * End the current xml element.
1106 *
1107 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1108 */
1109int
1110xmlTextWriterEndElement(xmlTextWriterPtr writer)
1111{
1112    int count;
1113    int sum;
1114    xmlLinkPtr lk;
1115    xmlTextWriterStackEntry *p;
1116
1117    if (writer == NULL)
1118        return -1;
1119
1120    lk = xmlListFront(writer->nodes);
1121    if (lk == 0) {
1122        xmlListDelete(writer->nsstack);
1123        writer->nsstack = NULL;
1124        return -1;
1125    }
1126
1127    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
1128    if (p == 0) {
1129        xmlListDelete(writer->nsstack);
1130        writer->nsstack = NULL;
1131        return -1;
1132    }
1133
1134    sum = 0;
1135    switch (p->state) {
1136        case XML_TEXTWRITER_ATTRIBUTE:
1137            count = xmlTextWriterEndAttribute(writer);
1138            if (count < 0) {
1139                xmlListDelete(writer->nsstack);
1140                writer->nsstack = NULL;
1141                return -1;
1142            }
1143            sum += count;
1144            /* fallthrough */
1145        case XML_TEXTWRITER_NAME:
1146            /* Output namespace declarations */
1147            count = xmlTextWriterOutputNSDecl(writer);
1148            if (count < 0)
1149                return -1;
1150            sum += count;
1151
1152            if (writer->indent) /* next element needs indent */
1153                writer->doindent = 1;
1154            count = xmlOutputBufferWriteString(writer->out, "/>");
1155            if (count < 0)
1156                return -1;
1157            sum += count;
1158            break;
1159        case XML_TEXTWRITER_TEXT:
1160            if ((writer->indent) && (writer->doindent)) {
1161                count = xmlTextWriterWriteIndent(writer);
1162                sum += count;
1163                writer->doindent = 1;
1164            } else
1165                writer->doindent = 1;
1166            count = xmlOutputBufferWriteString(writer->out, "</");
1167            if (count < 0)
1168                return -1;
1169            sum += count;
1170            count = xmlOutputBufferWriteString(writer->out,
1171                                               (const char *) p->name);
1172            if (count < 0)
1173                return -1;
1174            sum += count;
1175            count = xmlOutputBufferWriteString(writer->out, ">");
1176            if (count < 0)
1177                return -1;
1178            sum += count;
1179            break;
1180        default:
1181            return -1;
1182    }
1183
1184    if (writer->indent) {
1185        count = xmlOutputBufferWriteString(writer->out, "\n");
1186        sum += count;
1187    }
1188
1189    xmlListPopFront(writer->nodes);
1190    return sum;
1191}
1192
1193/**
1194 * xmlTextWriterFullEndElement:
1195 * @writer:  the xmlTextWriterPtr
1196 *
1197 * End the current xml element. Writes an end tag even if the element is empty
1198 *
1199 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1200 */
1201int
1202xmlTextWriterFullEndElement(xmlTextWriterPtr writer)
1203{
1204    int count;
1205    int sum;
1206    xmlLinkPtr lk;
1207    xmlTextWriterStackEntry *p;
1208
1209    if (writer == NULL)
1210        return -1;
1211
1212    lk = xmlListFront(writer->nodes);
1213    if (lk == 0)
1214        return -1;
1215
1216    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
1217    if (p == 0)
1218        return -1;
1219
1220    sum = 0;
1221    switch (p->state) {
1222        case XML_TEXTWRITER_ATTRIBUTE:
1223            count = xmlTextWriterEndAttribute(writer);
1224            if (count < 0)
1225                return -1;
1226            sum += count;
1227            /* fallthrough */
1228        case XML_TEXTWRITER_NAME:
1229            /* Output namespace declarations */
1230            count = xmlTextWriterOutputNSDecl(writer);
1231            if (count < 0)
1232                return -1;
1233            sum += count;
1234
1235            count = xmlOutputBufferWriteString(writer->out, ">");
1236            if (count < 0)
1237                return -1;
1238            sum += count;
1239            /* fallthrough */
1240        case XML_TEXTWRITER_TEXT:
1241            count = xmlOutputBufferWriteString(writer->out, "</");
1242            if (count < 0)
1243                return -1;
1244            sum += count;
1245            count = xmlOutputBufferWriteString(writer->out,
1246                                               (const char *) p->name);
1247            if (count < 0)
1248                return -1;
1249            sum += count;
1250            count = xmlOutputBufferWriteString(writer->out, ">");
1251            if (count < 0)
1252                return -1;
1253            sum += count;
1254            break;
1255        default:
1256            return -1;
1257    }
1258
1259    if (writer->indent) {
1260        count = xmlOutputBufferWriteString(writer->out, "\n");
1261        sum += count;
1262    }
1263
1264    xmlListPopFront(writer->nodes);
1265    return sum;
1266}
1267
1268/**
1269 * xmlTextWriterWriteFormatRaw:
1270 * @writer:  the xmlTextWriterPtr
1271 * @format:  format string (see printf)
1272 * @...:  extra parameters for the format
1273 *
1274 * Write a formatted raw xml text.
1275 *
1276 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1277 */
1278int XMLCDECL
1279xmlTextWriterWriteFormatRaw(xmlTextWriterPtr writer, const char *format,
1280                            ...)
1281{
1282    int rc;
1283    va_list ap;
1284
1285    va_start(ap, format);
1286
1287    rc = xmlTextWriterWriteVFormatRaw(writer, format, ap);
1288
1289    va_end(ap);
1290    return rc;
1291}
1292
1293/**
1294 * xmlTextWriterWriteVFormatRaw:
1295 * @writer:  the xmlTextWriterPtr
1296 * @format:  format string (see printf)
1297 * @argptr:  pointer to the first member of the variable argument list.
1298 *
1299 * Write a formatted raw xml text.
1300 *
1301 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1302 */
1303int
1304xmlTextWriterWriteVFormatRaw(xmlTextWriterPtr writer, const char *format,
1305                             va_list argptr)
1306{
1307    int rc;
1308    xmlChar *buf;
1309
1310    if (writer == NULL)
1311        return -1;
1312
1313    buf = xmlTextWriterVSprintf(format, argptr);
1314    if (buf == 0)
1315        return 0;
1316
1317    rc = xmlTextWriterWriteRaw(writer, buf);
1318
1319    xmlFree(buf);
1320    return rc;
1321}
1322
1323/**
1324 * xmlTextWriterWriteRawLen:
1325 * @writer:  the xmlTextWriterPtr
1326 * @content:  text string
1327 * @len:  length of the text string
1328 *
1329 * Write an xml text.
1330 * TODO: what about entities and special chars??
1331 *
1332 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1333 */
1334int
1335xmlTextWriterWriteRawLen(xmlTextWriterPtr writer, const xmlChar * content,
1336                         int len)
1337{
1338    int count;
1339    int sum;
1340    xmlLinkPtr lk;
1341    xmlTextWriterStackEntry *p;
1342
1343    if (writer == NULL) {
1344        xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
1345                        "xmlTextWriterWriteRawLen : invalid writer!\n");
1346        return -1;
1347    }
1348
1349    if ((content == NULL) || (len < 0)) {
1350        xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
1351                        "xmlTextWriterWriteRawLen : invalid content!\n");
1352        return -1;
1353    }
1354
1355    sum = 0;
1356    lk = xmlListFront(writer->nodes);
1357    if (lk != 0) {
1358        p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
1359        count = xmlTextWriterHandleStateDependencies(writer, p);
1360        if (count < 0)
1361            return -1;
1362        sum += count;
1363    }
1364
1365    if (writer->indent)
1366        writer->doindent = 0;
1367
1368    if (content != NULL) {
1369        count =
1370            xmlOutputBufferWrite(writer->out, len, (const char *) content);
1371        if (count < 0)
1372            return -1;
1373        sum += count;
1374    }
1375
1376    return sum;
1377}
1378
1379/**
1380 * xmlTextWriterWriteRaw:
1381 * @writer:  the xmlTextWriterPtr
1382 * @content:  text string
1383 *
1384 * Write a raw xml text.
1385 *
1386 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1387 */
1388int
1389xmlTextWriterWriteRaw(xmlTextWriterPtr writer, const xmlChar * content)
1390{
1391    return xmlTextWriterWriteRawLen(writer, content, xmlStrlen(content));
1392}
1393
1394/**
1395 * xmlTextWriterWriteFormatString:
1396 * @writer:  the xmlTextWriterPtr
1397 * @format:  format string (see printf)
1398 * @...:  extra parameters for the format
1399 *
1400 * Write a formatted xml text.
1401 *
1402 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1403 */
1404int XMLCDECL
1405xmlTextWriterWriteFormatString(xmlTextWriterPtr writer, const char *format,
1406                               ...)
1407{
1408    int rc;
1409    va_list ap;
1410
1411    if ((writer == NULL) || (format == NULL))
1412        return -1;
1413
1414    va_start(ap, format);
1415
1416    rc = xmlTextWriterWriteVFormatString(writer, format, ap);
1417
1418    va_end(ap);
1419    return rc;
1420}
1421
1422/**
1423 * xmlTextWriterWriteVFormatString:
1424 * @writer:  the xmlTextWriterPtr
1425 * @format:  format string (see printf)
1426 * @argptr:  pointer to the first member of the variable argument list.
1427 *
1428 * Write a formatted xml text.
1429 *
1430 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1431 */
1432int
1433xmlTextWriterWriteVFormatString(xmlTextWriterPtr writer,
1434                                const char *format, va_list argptr)
1435{
1436    int rc;
1437    xmlChar *buf;
1438
1439    if ((writer == NULL) || (format == NULL))
1440        return -1;
1441
1442    buf = xmlTextWriterVSprintf(format, argptr);
1443    if (buf == 0)
1444        return 0;
1445
1446    rc = xmlTextWriterWriteString(writer, buf);
1447
1448    xmlFree(buf);
1449    return rc;
1450}
1451
1452/**
1453 * xmlTextWriterWriteString:
1454 * @writer:  the xmlTextWriterPtr
1455 * @content:  text string
1456 *
1457 * Write an xml text.
1458 *
1459 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1460 */
1461int
1462xmlTextWriterWriteString(xmlTextWriterPtr writer, const xmlChar * content)
1463{
1464    int count;
1465    int sum;
1466    xmlLinkPtr lk;
1467    xmlTextWriterStackEntry *p;
1468    xmlChar *buf;
1469
1470    if ((writer == NULL) || (content == NULL))
1471        return -1;
1472
1473    sum = 0;
1474    buf = (xmlChar *) content;
1475    lk = xmlListFront(writer->nodes);
1476    if (lk != 0) {
1477        p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
1478        if (p != 0) {
1479            switch (p->state) {
1480                case XML_TEXTWRITER_NAME:
1481                case XML_TEXTWRITER_TEXT:
1482#if 0
1483                    buf = NULL;
1484		    xmlOutputBufferWriteEscape(writer->out, content, NULL);
1485#endif
1486                    buf = xmlEncodeSpecialChars(NULL, content);
1487                    break;
1488                case XML_TEXTWRITER_ATTRIBUTE:
1489                    buf = NULL;
1490                    xmlAttrSerializeTxtContent(writer->out->buffer, writer->doc,
1491                                               NULL, content);
1492                    break;
1493		default:
1494		    break;
1495            }
1496        }
1497    }
1498
1499    if (buf != NULL) {
1500        count = xmlTextWriterWriteRaw(writer, buf);
1501        if (count < 0)
1502            return -1;
1503        sum += count;
1504
1505        if (buf != content)     /* buf was allocated by us, so free it */
1506            xmlFree(buf);
1507    }
1508
1509    return sum;
1510}
1511
1512/**
1513 * xmlOutputBufferWriteBase64:
1514 * @out: the xmlOutputBufferPtr
1515 * @data:   binary data
1516 * @len:  the number of bytes to encode
1517 *
1518 * Write base64 encoded data to an xmlOutputBuffer.
1519 * Adapted from John Walker's base64.c (http://www.fourmilab.ch/).
1520 *
1521 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1522 */
1523static int
1524xmlOutputBufferWriteBase64(xmlOutputBufferPtr out, int len,
1525                           const unsigned char *data)
1526{
1527    static unsigned char dtable[64] =
1528            {'A','B','C','D','E','F','G','H','I','J','K','L','M',
1529	     'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
1530	     'a','b','c','d','e','f','g','h','i','j','k','l','m',
1531	     'n','o','p','q','r','s','t','u','v','w','x','y','z',
1532	     '0','1','2','3','4','5','6','7','8','9','+','/'};
1533
1534    int i;
1535    int linelen;
1536    int count;
1537    int sum;
1538
1539    if ((out == NULL) || (len < 0) || (data == NULL))
1540        return(-1);
1541
1542    linelen = 0;
1543    sum = 0;
1544
1545    i = 0;
1546    while (1) {
1547        unsigned char igroup[3];
1548        unsigned char ogroup[4];
1549        int c;
1550        int n;
1551
1552        igroup[0] = igroup[1] = igroup[2] = 0;
1553        for (n = 0; n < 3 && i < len; n++, i++) {
1554            c = data[i];
1555            igroup[n] = (unsigned char) c;
1556        }
1557
1558        if (n > 0) {
1559            ogroup[0] = dtable[igroup[0] >> 2];
1560            ogroup[1] = dtable[((igroup[0] & 3) << 4) | (igroup[1] >> 4)];
1561            ogroup[2] =
1562                dtable[((igroup[1] & 0xF) << 2) | (igroup[2] >> 6)];
1563            ogroup[3] = dtable[igroup[2] & 0x3F];
1564
1565            if (n < 3) {
1566                ogroup[3] = '=';
1567                if (n < 2) {
1568                    ogroup[2] = '=';
1569                }
1570            }
1571
1572            if (linelen >= B64LINELEN) {
1573                count = xmlOutputBufferWrite(out, 2, B64CRLF);
1574                if (count == -1)
1575                    return -1;
1576                sum += count;
1577                linelen = 0;
1578            }
1579            count = xmlOutputBufferWrite(out, 4, (const char *) ogroup);
1580            if (count == -1)
1581                return -1;
1582            sum += count;
1583
1584            linelen += 4;
1585        }
1586
1587        if (i >= len)
1588            break;
1589    }
1590
1591    return sum;
1592}
1593
1594/**
1595 * xmlTextWriterWriteBase64:
1596 * @writer: the xmlTextWriterPtr
1597 * @data:   binary data
1598 * @start:  the position within the data of the first byte to encode
1599 * @len:  the number of bytes to encode
1600 *
1601 * Write an base64 encoded xml text.
1602 *
1603 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1604 */
1605int
1606xmlTextWriterWriteBase64(xmlTextWriterPtr writer, const char *data,
1607                         int start, int len)
1608{
1609    int count;
1610    int sum;
1611    xmlLinkPtr lk;
1612    xmlTextWriterStackEntry *p;
1613
1614    if ((writer == NULL) || (data == NULL) || (start < 0) || (len < 0))
1615        return -1;
1616
1617    sum = 0;
1618    lk = xmlListFront(writer->nodes);
1619    if (lk != 0) {
1620        p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
1621        if (p != 0) {
1622            count = xmlTextWriterHandleStateDependencies(writer, p);
1623            if (count < 0)
1624                return -1;
1625            sum += count;
1626        }
1627    }
1628
1629    if (writer->indent)
1630        writer->doindent = 0;
1631
1632    count =
1633        xmlOutputBufferWriteBase64(writer->out, len,
1634                                   (unsigned char *) data + start);
1635    if (count < 0)
1636        return -1;
1637    sum += count;
1638
1639    return sum;
1640}
1641
1642/**
1643 * xmlOutputBufferWriteBinHex:
1644 * @out: the xmlOutputBufferPtr
1645 * @data:   binary data
1646 * @len:  the number of bytes to encode
1647 *
1648 * Write hqx encoded data to an xmlOutputBuffer.
1649 * ::todo
1650 *
1651 * Returns the bytes written (may be 0 because of buffering)
1652 * or -1 in case of error
1653 */
1654static int
1655xmlOutputBufferWriteBinHex(xmlOutputBufferPtr out,
1656                           int len, const unsigned char *data)
1657{
1658    int count;
1659    int sum;
1660    static char hex[16] =
1661    	{'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
1662    int i;
1663
1664    if ((out == NULL) || (data == NULL) || (len < 0)) {
1665        return -1;
1666    }
1667
1668    sum = 0;
1669    for (i = 0; i < len; i++) {
1670        count =
1671            xmlOutputBufferWrite(out, 1,
1672                                 (const char *) &hex[data[i] >> 4]);
1673        if (count == -1)
1674            return -1;
1675        sum += count;
1676        count =
1677            xmlOutputBufferWrite(out, 1,
1678                                 (const char *) &hex[data[i] & 0xF]);
1679        if (count == -1)
1680            return -1;
1681        sum += count;
1682    }
1683
1684    return sum;
1685}
1686
1687/**
1688 * xmlTextWriterWriteBinHex:
1689 * @writer: the xmlTextWriterPtr
1690 * @data:   binary data
1691 * @start:  the position within the data of the first byte to encode
1692 * @len:  the number of bytes to encode
1693 *
1694 * Write a BinHex encoded xml text.
1695 *
1696 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1697 */
1698int
1699xmlTextWriterWriteBinHex(xmlTextWriterPtr writer, const char *data,
1700                         int start, int len)
1701{
1702    int count;
1703    int sum;
1704    xmlLinkPtr lk;
1705    xmlTextWriterStackEntry *p;
1706
1707    if ((writer == NULL) || (data == NULL) || (start < 0) || (len < 0))
1708        return -1;
1709
1710    sum = 0;
1711    lk = xmlListFront(writer->nodes);
1712    if (lk != 0) {
1713        p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
1714        if (p != 0) {
1715            count = xmlTextWriterHandleStateDependencies(writer, p);
1716            if (count < 0)
1717                return -1;
1718            sum += count;
1719        }
1720    }
1721
1722    if (writer->indent)
1723        writer->doindent = 0;
1724
1725    count =
1726        xmlOutputBufferWriteBinHex(writer->out, len,
1727                                   (unsigned char *) data + start);
1728    if (count < 0)
1729        return -1;
1730    sum += count;
1731
1732    return sum;
1733}
1734
1735/**
1736 * xmlTextWriterStartAttribute:
1737 * @writer:  the xmlTextWriterPtr
1738 * @name:  element name
1739 *
1740 * Start an xml attribute.
1741 *
1742 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1743 */
1744int
1745xmlTextWriterStartAttribute(xmlTextWriterPtr writer, const xmlChar * name)
1746{
1747    int count;
1748    int sum;
1749    xmlLinkPtr lk;
1750    xmlTextWriterStackEntry *p;
1751
1752    if ((writer == NULL) || (name == NULL) || (*name == '\0'))
1753        return -1;
1754
1755    sum = 0;
1756    lk = xmlListFront(writer->nodes);
1757    if (lk == 0)
1758        return -1;
1759
1760    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
1761    if (p == 0)
1762        return -1;
1763
1764    switch (p->state) {
1765        case XML_TEXTWRITER_ATTRIBUTE:
1766            count = xmlTextWriterEndAttribute(writer);
1767            if (count < 0)
1768                return -1;
1769            sum += count;
1770            /* fallthrough */
1771        case XML_TEXTWRITER_NAME:
1772            count = xmlOutputBufferWriteString(writer->out, " ");
1773            if (count < 0)
1774                return -1;
1775            sum += count;
1776            count =
1777                xmlOutputBufferWriteString(writer->out,
1778                                           (const char *) name);
1779            if (count < 0)
1780                return -1;
1781            sum += count;
1782            count = xmlOutputBufferWriteString(writer->out, "=");
1783            if (count < 0)
1784                return -1;
1785            sum += count;
1786            count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
1787            if (count < 0)
1788                return -1;
1789            sum += count;
1790            p->state = XML_TEXTWRITER_ATTRIBUTE;
1791            break;
1792        default:
1793            return -1;
1794    }
1795
1796    return sum;
1797}
1798
1799/**
1800 * xmlTextWriterStartAttributeNS:
1801 * @writer:  the xmlTextWriterPtr
1802 * @prefix:  namespace prefix or NULL
1803 * @name:  element local name
1804 * @namespaceURI:  namespace URI or NULL
1805 *
1806 * Start an xml attribute with namespace support.
1807 *
1808 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1809 */
1810int
1811xmlTextWriterStartAttributeNS(xmlTextWriterPtr writer,
1812                              const xmlChar * prefix, const xmlChar * name,
1813                              const xmlChar * namespaceURI)
1814{
1815    int count;
1816    int sum;
1817    xmlChar *buf;
1818    xmlTextWriterNsStackEntry *p;
1819
1820    if ((writer == NULL) || (name == NULL) || (*name == '\0'))
1821        return -1;
1822
1823    /* Handle namespace first in case of error */
1824    if (namespaceURI != 0) {
1825        xmlTextWriterNsStackEntry nsentry, *curns;
1826
1827        buf = xmlStrdup(BAD_CAST "xmlns");
1828        if (prefix != 0) {
1829            buf = xmlStrcat(buf, BAD_CAST ":");
1830            buf = xmlStrcat(buf, prefix);
1831        }
1832
1833        nsentry.prefix = buf;
1834        nsentry.uri = (xmlChar *)namespaceURI;
1835        nsentry.elem = xmlListFront(writer->nodes);
1836
1837        curns = (xmlTextWriterNsStackEntry *)xmlListSearch(writer->nsstack,
1838                                                           (void *)&nsentry);
1839        if ((curns != NULL)) {
1840            xmlFree(buf);
1841            if (xmlStrcmp(curns->uri, namespaceURI) == 0) {
1842                /* Namespace already defined on element skip */
1843                buf = NULL;
1844            } else {
1845                /* Prefix mismatch so error out */
1846                return -1;
1847            }
1848        }
1849
1850        /* Do not add namespace decl to list - it is already there */
1851        if (buf != NULL) {
1852            p = (xmlTextWriterNsStackEntry *)
1853                xmlMalloc(sizeof(xmlTextWriterNsStackEntry));
1854            if (p == 0) {
1855                xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
1856								        "xmlTextWriterStartAttributeNS : out of memory!\n");
1857                return -1;
1858            }
1859
1860            p->prefix = buf;
1861            p->uri = xmlStrdup(namespaceURI);
1862            if (p->uri == 0) {
1863                xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
1864                        "xmlTextWriterStartAttributeNS : out of memory!\n");
1865                xmlFree(p);
1866                return -1;
1867            }
1868            p->elem = xmlListFront(writer->nodes);
1869
1870            xmlListPushFront(writer->nsstack, p);
1871        }
1872    }
1873
1874    buf = NULL;
1875    if (prefix != 0) {
1876        buf = xmlStrdup(prefix);
1877        buf = xmlStrcat(buf, BAD_CAST ":");
1878    }
1879    buf = xmlStrcat(buf, name);
1880
1881    sum = 0;
1882    count = xmlTextWriterStartAttribute(writer, buf);
1883    xmlFree(buf);
1884    if (count < 0)
1885        return -1;
1886    sum += count;
1887
1888    return sum;
1889}
1890
1891/**
1892 * xmlTextWriterEndAttribute:
1893 * @writer:  the xmlTextWriterPtr
1894 *
1895 * End the current xml element.
1896 *
1897 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1898 */
1899int
1900xmlTextWriterEndAttribute(xmlTextWriterPtr writer)
1901{
1902    int count;
1903    int sum;
1904    xmlLinkPtr lk;
1905    xmlTextWriterStackEntry *p;
1906
1907    if (writer == NULL)
1908        return -1;
1909
1910    lk = xmlListFront(writer->nodes);
1911    if (lk == 0) {
1912        return -1;
1913    }
1914
1915    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
1916    if (p == 0) {
1917        return -1;
1918    }
1919
1920    sum = 0;
1921    switch (p->state) {
1922        case XML_TEXTWRITER_ATTRIBUTE:
1923            p->state = XML_TEXTWRITER_NAME;
1924
1925            count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
1926            if (count < 0) {
1927                return -1;
1928            }
1929            sum += count;
1930            break;
1931        default:
1932            return -1;
1933    }
1934
1935    return sum;
1936}
1937
1938/**
1939 * xmlTextWriterWriteFormatAttribute:
1940 * @writer:  the xmlTextWriterPtr
1941 * @name:  attribute name
1942 * @format:  format string (see printf)
1943 * @...:  extra parameters for the format
1944 *
1945 * Write a formatted xml attribute.
1946 *
1947 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1948 */
1949int XMLCDECL
1950xmlTextWriterWriteFormatAttribute(xmlTextWriterPtr writer,
1951                                  const xmlChar * name, const char *format,
1952                                  ...)
1953{
1954    int rc;
1955    va_list ap;
1956
1957    va_start(ap, format);
1958
1959    rc = xmlTextWriterWriteVFormatAttribute(writer, name, format, ap);
1960
1961    va_end(ap);
1962    return rc;
1963}
1964
1965/**
1966 * xmlTextWriterWriteVFormatAttribute:
1967 * @writer:  the xmlTextWriterPtr
1968 * @name:  attribute name
1969 * @format:  format string (see printf)
1970 * @argptr:  pointer to the first member of the variable argument list.
1971 *
1972 * Write a formatted xml attribute.
1973 *
1974 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
1975 */
1976int
1977xmlTextWriterWriteVFormatAttribute(xmlTextWriterPtr writer,
1978                                   const xmlChar * name,
1979                                   const char *format, va_list argptr)
1980{
1981    int rc;
1982    xmlChar *buf;
1983
1984    if (writer == NULL)
1985        return -1;
1986
1987    buf = xmlTextWriterVSprintf(format, argptr);
1988    if (buf == 0)
1989        return 0;
1990
1991    rc = xmlTextWriterWriteAttribute(writer, name, buf);
1992
1993    xmlFree(buf);
1994    return rc;
1995}
1996
1997/**
1998 * xmlTextWriterWriteAttribute:
1999 * @writer:  the xmlTextWriterPtr
2000 * @name:  attribute name
2001 * @content:  attribute content
2002 *
2003 * Write an xml attribute.
2004 *
2005 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2006 */
2007int
2008xmlTextWriterWriteAttribute(xmlTextWriterPtr writer, const xmlChar * name,
2009                            const xmlChar * content)
2010{
2011    int count;
2012    int sum;
2013
2014    sum = 0;
2015    count = xmlTextWriterStartAttribute(writer, name);
2016    if (count < 0)
2017        return -1;
2018    sum += count;
2019    count = xmlTextWriterWriteString(writer, content);
2020    if (count < 0)
2021        return -1;
2022    sum += count;
2023    count = xmlTextWriterEndAttribute(writer);
2024    if (count < 0)
2025        return -1;
2026    sum += count;
2027
2028    return sum;
2029}
2030
2031/**
2032 * xmlTextWriterWriteFormatAttributeNS:
2033 * @writer:  the xmlTextWriterPtr
2034 * @prefix:  namespace prefix
2035 * @name:  attribute local name
2036 * @namespaceURI:  namespace URI
2037 * @format:  format string (see printf)
2038 * @...:  extra parameters for the format
2039 *
2040 * Write a formatted xml attribute.with namespace support
2041 *
2042 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2043 */
2044int XMLCDECL
2045xmlTextWriterWriteFormatAttributeNS(xmlTextWriterPtr writer,
2046                                    const xmlChar * prefix,
2047                                    const xmlChar * name,
2048                                    const xmlChar * namespaceURI,
2049                                    const char *format, ...)
2050{
2051    int rc;
2052    va_list ap;
2053
2054    va_start(ap, format);
2055
2056    rc = xmlTextWriterWriteVFormatAttributeNS(writer, prefix, name,
2057                                              namespaceURI, format, ap);
2058
2059    va_end(ap);
2060    return rc;
2061}
2062
2063/**
2064 * xmlTextWriterWriteVFormatAttributeNS:
2065 * @writer:  the xmlTextWriterPtr
2066 * @prefix:  namespace prefix
2067 * @name:  attribute local name
2068 * @namespaceURI:  namespace URI
2069 * @format:  format string (see printf)
2070 * @argptr:  pointer to the first member of the variable argument list.
2071 *
2072 * Write a formatted xml attribute.with namespace support
2073 *
2074 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2075 */
2076int
2077xmlTextWriterWriteVFormatAttributeNS(xmlTextWriterPtr writer,
2078                                     const xmlChar * prefix,
2079                                     const xmlChar * name,
2080                                     const xmlChar * namespaceURI,
2081                                     const char *format, va_list argptr)
2082{
2083    int rc;
2084    xmlChar *buf;
2085
2086    if (writer == NULL)
2087        return -1;
2088
2089    buf = xmlTextWriterVSprintf(format, argptr);
2090    if (buf == 0)
2091        return 0;
2092
2093    rc = xmlTextWriterWriteAttributeNS(writer, prefix, name, namespaceURI,
2094                                       buf);
2095
2096    xmlFree(buf);
2097    return rc;
2098}
2099
2100/**
2101 * xmlTextWriterWriteAttributeNS:
2102 * @writer:  the xmlTextWriterPtr
2103 * @prefix:  namespace prefix
2104 * @name:  attribute local name
2105 * @namespaceURI:  namespace URI
2106 * @content:  attribute content
2107 *
2108 * Write an xml attribute.
2109 *
2110 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2111 */
2112int
2113xmlTextWriterWriteAttributeNS(xmlTextWriterPtr writer,
2114                              const xmlChar * prefix, const xmlChar * name,
2115                              const xmlChar * namespaceURI,
2116                              const xmlChar * content)
2117{
2118    int count;
2119    int sum;
2120
2121    if ((writer == NULL) || (name == NULL) || (*name == '\0'))
2122        return -1;
2123
2124    sum = 0;
2125    count = xmlTextWriterStartAttributeNS(writer, prefix, name, namespaceURI);
2126    if (count < 0)
2127        return -1;
2128    sum += count;
2129    count = xmlTextWriterWriteString(writer, content);
2130    if (count < 0)
2131        return -1;
2132    sum += count;
2133    count = xmlTextWriterEndAttribute(writer);
2134    if (count < 0)
2135        return -1;
2136    sum += count;
2137
2138    return sum;
2139}
2140
2141/**
2142 * xmlTextWriterWriteFormatElement:
2143 * @writer:  the xmlTextWriterPtr
2144 * @name:  element name
2145 * @format:  format string (see printf)
2146 * @...:  extra parameters for the format
2147 *
2148 * Write a formatted xml element.
2149 *
2150 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2151 */
2152int XMLCDECL
2153xmlTextWriterWriteFormatElement(xmlTextWriterPtr writer,
2154                                const xmlChar * name, const char *format,
2155                                ...)
2156{
2157    int rc;
2158    va_list ap;
2159
2160    va_start(ap, format);
2161
2162    rc = xmlTextWriterWriteVFormatElement(writer, name, format, ap);
2163
2164    va_end(ap);
2165    return rc;
2166}
2167
2168/**
2169 * xmlTextWriterWriteVFormatElement:
2170 * @writer:  the xmlTextWriterPtr
2171 * @name:  element name
2172 * @format:  format string (see printf)
2173 * @argptr:  pointer to the first member of the variable argument list.
2174 *
2175 * Write a formatted xml element.
2176 *
2177 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2178 */
2179int
2180xmlTextWriterWriteVFormatElement(xmlTextWriterPtr writer,
2181                                 const xmlChar * name, const char *format,
2182                                 va_list argptr)
2183{
2184    int rc;
2185    xmlChar *buf;
2186
2187    if (writer == NULL)
2188        return -1;
2189
2190    buf = xmlTextWriterVSprintf(format, argptr);
2191    if (buf == 0)
2192        return 0;
2193
2194    rc = xmlTextWriterWriteElement(writer, name, buf);
2195
2196    xmlFree(buf);
2197    return rc;
2198}
2199
2200/**
2201 * xmlTextWriterWriteElement:
2202 * @writer:  the xmlTextWriterPtr
2203 * @name:  element name
2204 * @content:  element content
2205 *
2206 * Write an xml element.
2207 *
2208 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2209 */
2210int
2211xmlTextWriterWriteElement(xmlTextWriterPtr writer, const xmlChar * name,
2212                          const xmlChar * content)
2213{
2214    int count;
2215    int sum;
2216
2217    sum = 0;
2218    count = xmlTextWriterStartElement(writer, name);
2219    if (count == -1)
2220        return -1;
2221    sum += count;
2222    count = xmlTextWriterWriteString(writer, content);
2223    if (count == -1)
2224        return -1;
2225    sum += count;
2226    count = xmlTextWriterEndElement(writer);
2227    if (count == -1)
2228        return -1;
2229    sum += count;
2230
2231    return sum;
2232}
2233
2234/**
2235 * xmlTextWriterWriteFormatElementNS:
2236 * @writer:  the xmlTextWriterPtr
2237 * @prefix:  namespace prefix
2238 * @name:  element local name
2239 * @namespaceURI:  namespace URI
2240 * @format:  format string (see printf)
2241 * @...:  extra parameters for the format
2242 *
2243 * Write a formatted xml element with namespace support.
2244 *
2245 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2246 */
2247int XMLCDECL
2248xmlTextWriterWriteFormatElementNS(xmlTextWriterPtr writer,
2249                                  const xmlChar * prefix,
2250                                  const xmlChar * name,
2251                                  const xmlChar * namespaceURI,
2252                                  const char *format, ...)
2253{
2254    int rc;
2255    va_list ap;
2256
2257    va_start(ap, format);
2258
2259    rc = xmlTextWriterWriteVFormatElementNS(writer, prefix, name,
2260                                            namespaceURI, format, ap);
2261
2262    va_end(ap);
2263    return rc;
2264}
2265
2266/**
2267 * xmlTextWriterWriteVFormatElementNS:
2268 * @writer:  the xmlTextWriterPtr
2269 * @prefix:  namespace prefix
2270 * @name:  element local name
2271 * @namespaceURI:  namespace URI
2272 * @format:  format string (see printf)
2273 * @argptr:  pointer to the first member of the variable argument list.
2274 *
2275 * Write a formatted xml element with namespace support.
2276 *
2277 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2278 */
2279int
2280xmlTextWriterWriteVFormatElementNS(xmlTextWriterPtr writer,
2281                                   const xmlChar * prefix,
2282                                   const xmlChar * name,
2283                                   const xmlChar * namespaceURI,
2284                                   const char *format, va_list argptr)
2285{
2286    int rc;
2287    xmlChar *buf;
2288
2289    if (writer == NULL)
2290        return -1;
2291
2292    buf = xmlTextWriterVSprintf(format, argptr);
2293    if (buf == 0)
2294        return 0;
2295
2296    rc = xmlTextWriterWriteElementNS(writer, prefix, name, namespaceURI,
2297                                     buf);
2298
2299    xmlFree(buf);
2300    return rc;
2301}
2302
2303/**
2304 * xmlTextWriterWriteElementNS:
2305 * @writer:  the xmlTextWriterPtr
2306 * @prefix:  namespace prefix
2307 * @name:  element local name
2308 * @namespaceURI:  namespace URI
2309 * @content:  element content
2310 *
2311 * Write an xml element with namespace support.
2312 *
2313 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2314 */
2315int
2316xmlTextWriterWriteElementNS(xmlTextWriterPtr writer,
2317                            const xmlChar * prefix, const xmlChar * name,
2318                            const xmlChar * namespaceURI,
2319                            const xmlChar * content)
2320{
2321    int count;
2322    int sum;
2323
2324    if ((writer == NULL) || (name == NULL) || (*name == '\0'))
2325        return -1;
2326
2327    sum = 0;
2328    count =
2329        xmlTextWriterStartElementNS(writer, prefix, name, namespaceURI);
2330    if (count < 0)
2331        return -1;
2332    sum += count;
2333    count = xmlTextWriterWriteString(writer, content);
2334    if (count == -1)
2335        return -1;
2336    sum += count;
2337    count = xmlTextWriterEndElement(writer);
2338    if (count == -1)
2339        return -1;
2340    sum += count;
2341
2342    return sum;
2343}
2344
2345/**
2346 * xmlTextWriterStartPI:
2347 * @writer:  the xmlTextWriterPtr
2348 * @target:  PI target
2349 *
2350 * Start an xml PI.
2351 *
2352 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2353 */
2354int
2355xmlTextWriterStartPI(xmlTextWriterPtr writer, const xmlChar * target)
2356{
2357    int count;
2358    int sum;
2359    xmlLinkPtr lk;
2360    xmlTextWriterStackEntry *p;
2361
2362    if ((writer == NULL) || (target == NULL) || (*target == '\0'))
2363        return -1;
2364
2365    if (xmlStrcasecmp(target, (const xmlChar *) "xml") == 0) {
2366        xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
2367                        "xmlTextWriterStartPI : target name [Xx][Mm][Ll] is reserved for xml standardization!\n");
2368        return -1;
2369    }
2370
2371    sum = 0;
2372    lk = xmlListFront(writer->nodes);
2373    if (lk != 0) {
2374        p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
2375        if (p != 0) {
2376            switch (p->state) {
2377                case XML_TEXTWRITER_ATTRIBUTE:
2378                    count = xmlTextWriterEndAttribute(writer);
2379                    if (count < 0)
2380                        return -1;
2381                    sum += count;
2382                    /* fallthrough */
2383                case XML_TEXTWRITER_NAME:
2384                    /* Output namespace declarations */
2385                    count = xmlTextWriterOutputNSDecl(writer);
2386                    if (count < 0)
2387                        return -1;
2388                    sum += count;
2389                    count = xmlOutputBufferWriteString(writer->out, ">");
2390                    if (count < 0)
2391                        return -1;
2392                    sum += count;
2393                    p->state = XML_TEXTWRITER_TEXT;
2394                    break;
2395                case XML_TEXTWRITER_NONE:
2396                case XML_TEXTWRITER_TEXT:
2397                case XML_TEXTWRITER_DTD:
2398                    break;
2399                case XML_TEXTWRITER_PI:
2400                case XML_TEXTWRITER_PI_TEXT:
2401                    xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
2402                                    "xmlTextWriterStartPI : nested PI!\n");
2403                    return -1;
2404                default:
2405                    return -1;
2406            }
2407        }
2408    }
2409
2410    p = (xmlTextWriterStackEntry *)
2411        xmlMalloc(sizeof(xmlTextWriterStackEntry));
2412    if (p == 0) {
2413        xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
2414                        "xmlTextWriterStartPI : out of memory!\n");
2415        return -1;
2416    }
2417
2418    p->name = xmlStrdup(target);
2419    if (p->name == 0) {
2420        xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
2421                        "xmlTextWriterStartPI : out of memory!\n");
2422        xmlFree(p);
2423        return -1;
2424    }
2425    p->state = XML_TEXTWRITER_PI;
2426
2427    xmlListPushFront(writer->nodes, p);
2428
2429    count = xmlOutputBufferWriteString(writer->out, "<?");
2430    if (count < 0)
2431        return -1;
2432    sum += count;
2433    count =
2434        xmlOutputBufferWriteString(writer->out, (const char *) p->name);
2435    if (count < 0)
2436        return -1;
2437    sum += count;
2438
2439    return sum;
2440}
2441
2442/**
2443 * xmlTextWriterEndPI:
2444 * @writer:  the xmlTextWriterPtr
2445 *
2446 * End the current xml PI.
2447 *
2448 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2449 */
2450int
2451xmlTextWriterEndPI(xmlTextWriterPtr writer)
2452{
2453    int count;
2454    int sum;
2455    xmlLinkPtr lk;
2456    xmlTextWriterStackEntry *p;
2457
2458    if (writer == NULL)
2459        return -1;
2460
2461    lk = xmlListFront(writer->nodes);
2462    if (lk == 0)
2463        return 0;
2464
2465    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
2466    if (p == 0)
2467        return 0;
2468
2469    sum = 0;
2470    switch (p->state) {
2471        case XML_TEXTWRITER_PI:
2472        case XML_TEXTWRITER_PI_TEXT:
2473            count = xmlOutputBufferWriteString(writer->out, "?>");
2474            if (count < 0)
2475                return -1;
2476            sum += count;
2477            break;
2478        default:
2479            return -1;
2480    }
2481
2482    if (writer->indent) {
2483        count = xmlOutputBufferWriteString(writer->out, "\n");
2484      	if (count < 0)
2485       	return -1;
2486        sum += count;
2487    }
2488
2489    xmlListPopFront(writer->nodes);
2490    return sum;
2491}
2492
2493/**
2494 * xmlTextWriterWriteFormatPI:
2495 * @writer:  the xmlTextWriterPtr
2496 * @target:  PI target
2497 * @format:  format string (see printf)
2498 * @...:  extra parameters for the format
2499 *
2500 * Write a formatted PI.
2501 *
2502 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2503 */
2504int XMLCDECL
2505xmlTextWriterWriteFormatPI(xmlTextWriterPtr writer, const xmlChar * target,
2506                           const char *format, ...)
2507{
2508    int rc;
2509    va_list ap;
2510
2511    va_start(ap, format);
2512
2513    rc = xmlTextWriterWriteVFormatPI(writer, target, format, ap);
2514
2515    va_end(ap);
2516    return rc;
2517}
2518
2519/**
2520 * xmlTextWriterWriteVFormatPI:
2521 * @writer:  the xmlTextWriterPtr
2522 * @target:  PI target
2523 * @format:  format string (see printf)
2524 * @argptr:  pointer to the first member of the variable argument list.
2525 *
2526 * Write a formatted xml PI.
2527 *
2528 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2529 */
2530int
2531xmlTextWriterWriteVFormatPI(xmlTextWriterPtr writer,
2532                            const xmlChar * target, const char *format,
2533                            va_list argptr)
2534{
2535    int rc;
2536    xmlChar *buf;
2537
2538    if (writer == NULL)
2539        return -1;
2540
2541    buf = xmlTextWriterVSprintf(format, argptr);
2542    if (buf == 0)
2543        return 0;
2544
2545    rc = xmlTextWriterWritePI(writer, target, buf);
2546
2547    xmlFree(buf);
2548    return rc;
2549}
2550
2551/**
2552 * xmlTextWriterWritePI:
2553 * @writer:  the xmlTextWriterPtr
2554 * @target:  PI target
2555 * @content:  PI content
2556 *
2557 * Write an xml PI.
2558 *
2559 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2560 */
2561int
2562xmlTextWriterWritePI(xmlTextWriterPtr writer, const xmlChar * target,
2563                     const xmlChar * content)
2564{
2565    int count;
2566    int sum;
2567
2568    sum = 0;
2569    count = xmlTextWriterStartPI(writer, target);
2570    if (count == -1)
2571        return -1;
2572    sum += count;
2573    if (content != 0) {
2574        count = xmlTextWriterWriteString(writer, content);
2575        if (count == -1)
2576            return -1;
2577        sum += count;
2578    }
2579    count = xmlTextWriterEndPI(writer);
2580    if (count == -1)
2581        return -1;
2582    sum += count;
2583
2584    return sum;
2585}
2586
2587/**
2588 * xmlTextWriterStartCDATA:
2589 * @writer:  the xmlTextWriterPtr
2590 *
2591 * Start an xml CDATA section.
2592 *
2593 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2594 */
2595int
2596xmlTextWriterStartCDATA(xmlTextWriterPtr writer)
2597{
2598    int count;
2599    int sum;
2600    xmlLinkPtr lk;
2601    xmlTextWriterStackEntry *p;
2602
2603    if (writer == NULL)
2604        return -1;
2605
2606    sum = 0;
2607    lk = xmlListFront(writer->nodes);
2608    if (lk != 0) {
2609        p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
2610        if (p != 0) {
2611            switch (p->state) {
2612                case XML_TEXTWRITER_NONE:
2613                case XML_TEXTWRITER_PI:
2614                case XML_TEXTWRITER_PI_TEXT:
2615                    break;
2616                case XML_TEXTWRITER_ATTRIBUTE:
2617                    count = xmlTextWriterEndAttribute(writer);
2618                    if (count < 0)
2619                        return -1;
2620                    sum += count;
2621                    /* fallthrough */
2622                case XML_TEXTWRITER_NAME:
2623                    /* Output namespace declarations */
2624                    count = xmlTextWriterOutputNSDecl(writer);
2625                    if (count < 0)
2626                        return -1;
2627                    sum += count;
2628                    count = xmlOutputBufferWriteString(writer->out, ">");
2629                    if (count < 0)
2630                        return -1;
2631                    sum += count;
2632                    p->state = XML_TEXTWRITER_TEXT;
2633                    break;
2634                case XML_TEXTWRITER_CDATA:
2635                    xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
2636                                    "xmlTextWriterStartCDATA : CDATA not allowed in this context!\n");
2637                    return -1;
2638                default:
2639                    return -1;
2640            }
2641        }
2642    }
2643
2644    p = (xmlTextWriterStackEntry *)
2645        xmlMalloc(sizeof(xmlTextWriterStackEntry));
2646    if (p == 0) {
2647        xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
2648                        "xmlTextWriterStartCDATA : out of memory!\n");
2649        return -1;
2650    }
2651
2652    p->name = NULL;
2653    p->state = XML_TEXTWRITER_CDATA;
2654
2655    xmlListPushFront(writer->nodes, p);
2656
2657    count = xmlOutputBufferWriteString(writer->out, "<![CDATA[");
2658    if (count < 0)
2659        return -1;
2660    sum += count;
2661
2662    return sum;
2663}
2664
2665/**
2666 * xmlTextWriterEndCDATA:
2667 * @writer:  the xmlTextWriterPtr
2668 *
2669 * End an xml CDATA section.
2670 *
2671 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2672 */
2673int
2674xmlTextWriterEndCDATA(xmlTextWriterPtr writer)
2675{
2676    int count;
2677    int sum;
2678    xmlLinkPtr lk;
2679    xmlTextWriterStackEntry *p;
2680
2681    if (writer == NULL)
2682        return -1;
2683
2684    lk = xmlListFront(writer->nodes);
2685    if (lk == 0)
2686        return -1;
2687
2688    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
2689    if (p == 0)
2690        return -1;
2691
2692    sum = 0;
2693    switch (p->state) {
2694        case XML_TEXTWRITER_CDATA:
2695            count = xmlOutputBufferWriteString(writer->out, "]]>");
2696            if (count < 0)
2697                return -1;
2698            sum += count;
2699            break;
2700        default:
2701            return -1;
2702    }
2703
2704    xmlListPopFront(writer->nodes);
2705    return sum;
2706}
2707
2708/**
2709 * xmlTextWriterWriteFormatCDATA:
2710 * @writer:  the xmlTextWriterPtr
2711 * @format:  format string (see printf)
2712 * @...:  extra parameters for the format
2713 *
2714 * Write a formatted xml CDATA.
2715 *
2716 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2717 */
2718int XMLCDECL
2719xmlTextWriterWriteFormatCDATA(xmlTextWriterPtr writer, const char *format,
2720                              ...)
2721{
2722    int rc;
2723    va_list ap;
2724
2725    va_start(ap, format);
2726
2727    rc = xmlTextWriterWriteVFormatCDATA(writer, format, ap);
2728
2729    va_end(ap);
2730    return rc;
2731}
2732
2733/**
2734 * xmlTextWriterWriteVFormatCDATA:
2735 * @writer:  the xmlTextWriterPtr
2736 * @format:  format string (see printf)
2737 * @argptr:  pointer to the first member of the variable argument list.
2738 *
2739 * Write a formatted xml CDATA.
2740 *
2741 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2742 */
2743int
2744xmlTextWriterWriteVFormatCDATA(xmlTextWriterPtr writer, const char *format,
2745                               va_list argptr)
2746{
2747    int rc;
2748    xmlChar *buf;
2749
2750    if (writer == NULL)
2751        return -1;
2752
2753    buf = xmlTextWriterVSprintf(format, argptr);
2754    if (buf == 0)
2755        return 0;
2756
2757    rc = xmlTextWriterWriteCDATA(writer, buf);
2758
2759    xmlFree(buf);
2760    return rc;
2761}
2762
2763/**
2764 * xmlTextWriterWriteCDATA:
2765 * @writer:  the xmlTextWriterPtr
2766 * @content:  CDATA content
2767 *
2768 * Write an xml CDATA.
2769 *
2770 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2771 */
2772int
2773xmlTextWriterWriteCDATA(xmlTextWriterPtr writer, const xmlChar * content)
2774{
2775    int count;
2776    int sum;
2777
2778    sum = 0;
2779    count = xmlTextWriterStartCDATA(writer);
2780    if (count == -1)
2781        return -1;
2782    sum += count;
2783    if (content != 0) {
2784        count = xmlTextWriterWriteString(writer, content);
2785        if (count == -1)
2786            return -1;
2787        sum += count;
2788    }
2789    count = xmlTextWriterEndCDATA(writer);
2790    if (count == -1)
2791        return -1;
2792    sum += count;
2793
2794    return sum;
2795}
2796
2797/**
2798 * xmlTextWriterStartDTD:
2799 * @writer:  the xmlTextWriterPtr
2800 * @name:  the name of the DTD
2801 * @pubid:  the public identifier, which is an alternative to the system identifier
2802 * @sysid:  the system identifier, which is the URI of the DTD
2803 *
2804 * Start an xml DTD.
2805 *
2806 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2807 */
2808int
2809xmlTextWriterStartDTD(xmlTextWriterPtr writer,
2810                      const xmlChar * name,
2811                      const xmlChar * pubid, const xmlChar * sysid)
2812{
2813    int count;
2814    int sum;
2815    xmlLinkPtr lk;
2816    xmlTextWriterStackEntry *p;
2817
2818    if (writer == NULL || name == NULL || *name == '\0')
2819        return -1;
2820
2821    sum = 0;
2822    lk = xmlListFront(writer->nodes);
2823    if ((lk != NULL) && (xmlLinkGetData(lk) != NULL)) {
2824        xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
2825                        "xmlTextWriterStartDTD : DTD allowed only in prolog!\n");
2826        return -1;
2827    }
2828
2829    p = (xmlTextWriterStackEntry *)
2830        xmlMalloc(sizeof(xmlTextWriterStackEntry));
2831    if (p == 0) {
2832        xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
2833                        "xmlTextWriterStartDTD : out of memory!\n");
2834        return -1;
2835    }
2836
2837    p->name = xmlStrdup(name);
2838    if (p->name == 0) {
2839        xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
2840                        "xmlTextWriterStartDTD : out of memory!\n");
2841        xmlFree(p);
2842        return -1;
2843    }
2844    p->state = XML_TEXTWRITER_DTD;
2845
2846    xmlListPushFront(writer->nodes, p);
2847
2848    count = xmlOutputBufferWriteString(writer->out, "<!DOCTYPE ");
2849    if (count < 0)
2850        return -1;
2851    sum += count;
2852    count = xmlOutputBufferWriteString(writer->out, (const char *) name);
2853    if (count < 0)
2854        return -1;
2855    sum += count;
2856
2857    if (pubid != 0) {
2858        if (sysid == 0) {
2859            xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
2860                            "xmlTextWriterStartDTD : system identifier needed!\n");
2861            return -1;
2862        }
2863
2864        if (writer->indent)
2865            count = xmlOutputBufferWrite(writer->out, 1, "\n");
2866        else
2867            count = xmlOutputBufferWrite(writer->out, 1, " ");
2868        if (count < 0)
2869            return -1;
2870        sum += count;
2871
2872        count = xmlOutputBufferWriteString(writer->out, "PUBLIC ");
2873        if (count < 0)
2874            return -1;
2875        sum += count;
2876
2877        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
2878        if (count < 0)
2879            return -1;
2880        sum += count;
2881
2882        count =
2883            xmlOutputBufferWriteString(writer->out, (const char *) pubid);
2884        if (count < 0)
2885            return -1;
2886        sum += count;
2887
2888        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
2889        if (count < 0)
2890            return -1;
2891        sum += count;
2892    }
2893
2894    if (sysid != 0) {
2895        if (pubid == 0) {
2896            if (writer->indent)
2897                count = xmlOutputBufferWrite(writer->out, 1, "\n");
2898            else
2899                count = xmlOutputBufferWrite(writer->out, 1, " ");
2900            if (count < 0)
2901                return -1;
2902            sum += count;
2903            count = xmlOutputBufferWriteString(writer->out, "SYSTEM ");
2904            if (count < 0)
2905                return -1;
2906            sum += count;
2907        } else {
2908			if (writer->indent)
2909            count = xmlOutputBufferWriteString(writer->out, "\n       ");
2910            else
2911                count = xmlOutputBufferWrite(writer->out, 1, " ");
2912            if (count < 0)
2913                return -1;
2914            sum += count;
2915        }
2916
2917        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
2918        if (count < 0)
2919            return -1;
2920        sum += count;
2921
2922        count =
2923            xmlOutputBufferWriteString(writer->out, (const char *) sysid);
2924        if (count < 0)
2925            return -1;
2926        sum += count;
2927
2928        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
2929        if (count < 0)
2930            return -1;
2931        sum += count;
2932    }
2933
2934    return sum;
2935}
2936
2937/**
2938 * xmlTextWriterEndDTD:
2939 * @writer:  the xmlTextWriterPtr
2940 *
2941 * End an xml DTD.
2942 *
2943 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
2944 */
2945int
2946xmlTextWriterEndDTD(xmlTextWriterPtr writer)
2947{
2948    int loop;
2949    int count;
2950    int sum;
2951    xmlLinkPtr lk;
2952    xmlTextWriterStackEntry *p;
2953
2954    if (writer == NULL)
2955        return -1;
2956
2957    sum = 0;
2958    loop = 1;
2959    while (loop) {
2960        lk = xmlListFront(writer->nodes);
2961        if (lk == NULL)
2962            break;
2963        p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
2964        if (p == 0)
2965            break;
2966        switch (p->state) {
2967            case XML_TEXTWRITER_DTD_TEXT:
2968                count = xmlOutputBufferWriteString(writer->out, "]");
2969                if (count < 0)
2970                    return -1;
2971                sum += count;
2972                /* fallthrough */
2973            case XML_TEXTWRITER_DTD:
2974                count = xmlOutputBufferWriteString(writer->out, ">");
2975
2976                if (writer->indent) {
2977                    if (count < 0)
2978                        return -1;
2979                    sum += count;
2980                    count = xmlOutputBufferWriteString(writer->out, "\n");
2981                }
2982
2983                xmlListPopFront(writer->nodes);
2984                break;
2985            case XML_TEXTWRITER_DTD_ELEM:
2986            case XML_TEXTWRITER_DTD_ELEM_TEXT:
2987                count = xmlTextWriterEndDTDElement(writer);
2988                break;
2989            case XML_TEXTWRITER_DTD_ATTL:
2990            case XML_TEXTWRITER_DTD_ATTL_TEXT:
2991                count = xmlTextWriterEndDTDAttlist(writer);
2992                break;
2993            case XML_TEXTWRITER_DTD_ENTY:
2994            case XML_TEXTWRITER_DTD_PENT:
2995            case XML_TEXTWRITER_DTD_ENTY_TEXT:
2996                count = xmlTextWriterEndDTDEntity(writer);
2997                break;
2998            case XML_TEXTWRITER_COMMENT:
2999                count = xmlTextWriterEndComment(writer);
3000                break;
3001            default:
3002                loop = 0;
3003                continue;
3004        }
3005
3006        if (count < 0)
3007            return -1;
3008        sum += count;
3009    }
3010
3011    return sum;
3012}
3013
3014/**
3015 * xmlTextWriterWriteFormatDTD:
3016 * @writer:  the xmlTextWriterPtr
3017 * @name:  the name of the DTD
3018 * @pubid:  the public identifier, which is an alternative to the system identifier
3019 * @sysid:  the system identifier, which is the URI of the DTD
3020 * @format:  format string (see printf)
3021 * @...:  extra parameters for the format
3022 *
3023 * Write a DTD with a formatted markup declarations part.
3024 *
3025 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3026 */
3027int XMLCDECL
3028xmlTextWriterWriteFormatDTD(xmlTextWriterPtr writer,
3029                            const xmlChar * name,
3030                            const xmlChar * pubid,
3031                            const xmlChar * sysid, const char *format, ...)
3032{
3033    int rc;
3034    va_list ap;
3035
3036    va_start(ap, format);
3037
3038    rc = xmlTextWriterWriteVFormatDTD(writer, name, pubid, sysid, format,
3039                                      ap);
3040
3041    va_end(ap);
3042    return rc;
3043}
3044
3045/**
3046 * xmlTextWriterWriteVFormatDTD:
3047 * @writer:  the xmlTextWriterPtr
3048 * @name:  the name of the DTD
3049 * @pubid:  the public identifier, which is an alternative to the system identifier
3050 * @sysid:  the system identifier, which is the URI of the DTD
3051 * @format:  format string (see printf)
3052 * @argptr:  pointer to the first member of the variable argument list.
3053 *
3054 * Write a DTD with a formatted markup declarations part.
3055 *
3056 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3057 */
3058int
3059xmlTextWriterWriteVFormatDTD(xmlTextWriterPtr writer,
3060                             const xmlChar * name,
3061                             const xmlChar * pubid,
3062                             const xmlChar * sysid,
3063                             const char *format, va_list argptr)
3064{
3065    int rc;
3066    xmlChar *buf;
3067
3068    if (writer == NULL)
3069        return -1;
3070
3071    buf = xmlTextWriterVSprintf(format, argptr);
3072    if (buf == 0)
3073        return 0;
3074
3075    rc = xmlTextWriterWriteDTD(writer, name, pubid, sysid, buf);
3076
3077    xmlFree(buf);
3078    return rc;
3079}
3080
3081/**
3082 * xmlTextWriterWriteDTD:
3083 * @writer:  the xmlTextWriterPtr
3084 * @name:  the name of the DTD
3085 * @pubid:  the public identifier, which is an alternative to the system identifier
3086 * @sysid:  the system identifier, which is the URI of the DTD
3087 * @subset:  string content of the DTD
3088 *
3089 * Write a DTD.
3090 *
3091 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3092 */
3093int
3094xmlTextWriterWriteDTD(xmlTextWriterPtr writer,
3095                      const xmlChar * name,
3096                      const xmlChar * pubid,
3097                      const xmlChar * sysid, const xmlChar * subset)
3098{
3099    int count;
3100    int sum;
3101
3102    sum = 0;
3103    count = xmlTextWriterStartDTD(writer, name, pubid, sysid);
3104    if (count == -1)
3105        return -1;
3106    sum += count;
3107    if (subset != 0) {
3108        count = xmlTextWriterWriteString(writer, subset);
3109        if (count == -1)
3110            return -1;
3111        sum += count;
3112    }
3113    count = xmlTextWriterEndDTD(writer);
3114    if (count == -1)
3115        return -1;
3116    sum += count;
3117
3118    return sum;
3119}
3120
3121/**
3122 * xmlTextWriterStartDTDElement:
3123 * @writer:  the xmlTextWriterPtr
3124 * @name:  the name of the DTD element
3125 *
3126 * Start an xml DTD element.
3127 *
3128 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3129 */
3130int
3131xmlTextWriterStartDTDElement(xmlTextWriterPtr writer, const xmlChar * name)
3132{
3133    int count;
3134    int sum;
3135    xmlLinkPtr lk;
3136    xmlTextWriterStackEntry *p;
3137
3138    if (writer == NULL || name == NULL || *name == '\0')
3139        return -1;
3140
3141    sum = 0;
3142    lk = xmlListFront(writer->nodes);
3143    if (lk == 0) {
3144        return -1;
3145    }
3146
3147    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
3148    if (p != 0) {
3149        switch (p->state) {
3150            case XML_TEXTWRITER_DTD:
3151                count = xmlOutputBufferWriteString(writer->out, " [");
3152                if (count < 0)
3153                    return -1;
3154                sum += count;
3155                if (writer->indent) {
3156                    count = xmlOutputBufferWriteString(writer->out, "\n");
3157                    if (count < 0)
3158                        return -1;
3159                    sum += count;
3160                }
3161                p->state = XML_TEXTWRITER_DTD_TEXT;
3162                /* fallthrough */
3163            case XML_TEXTWRITER_DTD_TEXT:
3164            case XML_TEXTWRITER_NONE:
3165                break;
3166            default:
3167                return -1;
3168        }
3169    }
3170
3171    p = (xmlTextWriterStackEntry *)
3172        xmlMalloc(sizeof(xmlTextWriterStackEntry));
3173    if (p == 0) {
3174        xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
3175                        "xmlTextWriterStartDTDElement : out of memory!\n");
3176        return -1;
3177    }
3178
3179    p->name = xmlStrdup(name);
3180    if (p->name == 0) {
3181        xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
3182                        "xmlTextWriterStartDTDElement : out of memory!\n");
3183        xmlFree(p);
3184        return -1;
3185    }
3186    p->state = XML_TEXTWRITER_DTD_ELEM;
3187
3188    xmlListPushFront(writer->nodes, p);
3189
3190    if (writer->indent) {
3191        count = xmlTextWriterWriteIndent(writer);
3192        if (count < 0)
3193            return -1;
3194        sum += count;
3195    }
3196
3197    count = xmlOutputBufferWriteString(writer->out, "<!ELEMENT ");
3198    if (count < 0)
3199        return -1;
3200    sum += count;
3201    count = xmlOutputBufferWriteString(writer->out, (const char *) name);
3202    if (count < 0)
3203        return -1;
3204    sum += count;
3205
3206    return sum;
3207}
3208
3209/**
3210 * xmlTextWriterEndDTDElement:
3211 * @writer:  the xmlTextWriterPtr
3212 *
3213 * End an xml DTD element.
3214 *
3215 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3216 */
3217int
3218xmlTextWriterEndDTDElement(xmlTextWriterPtr writer)
3219{
3220    int count;
3221    int sum;
3222    xmlLinkPtr lk;
3223    xmlTextWriterStackEntry *p;
3224
3225    if (writer == NULL)
3226        return -1;
3227
3228    sum = 0;
3229    lk = xmlListFront(writer->nodes);
3230    if (lk == 0)
3231        return -1;
3232
3233    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
3234    if (p == 0)
3235        return -1;
3236
3237    switch (p->state) {
3238        case XML_TEXTWRITER_DTD_ELEM:
3239        case XML_TEXTWRITER_DTD_ELEM_TEXT:
3240            count = xmlOutputBufferWriteString(writer->out, ">");
3241            if (count < 0)
3242                return -1;
3243            sum += count;
3244            break;
3245        default:
3246            return -1;
3247    }
3248
3249    if (writer->indent) {
3250        count = xmlOutputBufferWriteString(writer->out, "\n");
3251        if (count < 0)
3252            return -1;
3253        sum += count;
3254    }
3255
3256    xmlListPopFront(writer->nodes);
3257    return sum;
3258}
3259
3260/**
3261 * xmlTextWriterWriteFormatDTDElement:
3262 * @writer:  the xmlTextWriterPtr
3263 * @name:  the name of the DTD element
3264 * @format:  format string (see printf)
3265 * @...:  extra parameters for the format
3266 *
3267 * Write a formatted DTD element.
3268 *
3269 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3270 */
3271int XMLCDECL
3272xmlTextWriterWriteFormatDTDElement(xmlTextWriterPtr writer,
3273                                   const xmlChar * name,
3274                                   const char *format, ...)
3275{
3276    int rc;
3277    va_list ap;
3278
3279    va_start(ap, format);
3280
3281    rc = xmlTextWriterWriteVFormatDTDElement(writer, name, format, ap);
3282
3283    va_end(ap);
3284    return rc;
3285}
3286
3287/**
3288 * xmlTextWriterWriteVFormatDTDElement:
3289 * @writer:  the xmlTextWriterPtr
3290 * @name:  the name of the DTD element
3291 * @format:  format string (see printf)
3292 * @argptr:  pointer to the first member of the variable argument list.
3293 *
3294 * Write a formatted DTD element.
3295 *
3296 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3297 */
3298int
3299xmlTextWriterWriteVFormatDTDElement(xmlTextWriterPtr writer,
3300                                    const xmlChar * name,
3301                                    const char *format, va_list argptr)
3302{
3303    int rc;
3304    xmlChar *buf;
3305
3306    if (writer == NULL)
3307        return -1;
3308
3309    buf = xmlTextWriterVSprintf(format, argptr);
3310    if (buf == 0)
3311        return 0;
3312
3313    rc = xmlTextWriterWriteDTDElement(writer, name, buf);
3314
3315    xmlFree(buf);
3316    return rc;
3317}
3318
3319/**
3320 * xmlTextWriterWriteDTDElement:
3321 * @writer:  the xmlTextWriterPtr
3322 * @name:  the name of the DTD element
3323 * @content:  content of the element
3324 *
3325 * Write a DTD element.
3326 *
3327 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3328 */
3329int
3330xmlTextWriterWriteDTDElement(xmlTextWriterPtr writer,
3331                             const xmlChar * name, const xmlChar * content)
3332{
3333    int count;
3334    int sum;
3335
3336    if (content == NULL)
3337        return -1;
3338
3339    sum = 0;
3340    count = xmlTextWriterStartDTDElement(writer, name);
3341    if (count == -1)
3342        return -1;
3343    sum += count;
3344
3345    count = xmlTextWriterWriteString(writer, content);
3346    if (count == -1)
3347        return -1;
3348    sum += count;
3349
3350    count = xmlTextWriterEndDTDElement(writer);
3351    if (count == -1)
3352        return -1;
3353    sum += count;
3354
3355    return sum;
3356}
3357
3358/**
3359 * xmlTextWriterStartDTDAttlist:
3360 * @writer:  the xmlTextWriterPtr
3361 * @name:  the name of the DTD ATTLIST
3362 *
3363 * Start an xml DTD ATTLIST.
3364 *
3365 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3366 */
3367int
3368xmlTextWriterStartDTDAttlist(xmlTextWriterPtr writer, const xmlChar * name)
3369{
3370    int count;
3371    int sum;
3372    xmlLinkPtr lk;
3373    xmlTextWriterStackEntry *p;
3374
3375    if (writer == NULL || name == NULL || *name == '\0')
3376        return -1;
3377
3378    sum = 0;
3379    lk = xmlListFront(writer->nodes);
3380    if (lk == 0) {
3381        return -1;
3382    }
3383
3384    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
3385    if (p != 0) {
3386        switch (p->state) {
3387            case XML_TEXTWRITER_DTD:
3388                count = xmlOutputBufferWriteString(writer->out, " [");
3389                if (count < 0)
3390                    return -1;
3391                sum += count;
3392                if (writer->indent) {
3393                    count = xmlOutputBufferWriteString(writer->out, "\n");
3394                    if (count < 0)
3395                        return -1;
3396                    sum += count;
3397                }
3398                p->state = XML_TEXTWRITER_DTD_TEXT;
3399                /* fallthrough */
3400            case XML_TEXTWRITER_DTD_TEXT:
3401            case XML_TEXTWRITER_NONE:
3402                break;
3403            default:
3404                return -1;
3405        }
3406    }
3407
3408    p = (xmlTextWriterStackEntry *)
3409        xmlMalloc(sizeof(xmlTextWriterStackEntry));
3410    if (p == 0) {
3411        xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
3412                        "xmlTextWriterStartDTDAttlist : out of memory!\n");
3413        return -1;
3414    }
3415
3416    p->name = xmlStrdup(name);
3417    if (p->name == 0) {
3418        xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
3419                        "xmlTextWriterStartDTDAttlist : out of memory!\n");
3420        xmlFree(p);
3421        return -1;
3422    }
3423    p->state = XML_TEXTWRITER_DTD_ATTL;
3424
3425    xmlListPushFront(writer->nodes, p);
3426
3427    if (writer->indent) {
3428        count = xmlTextWriterWriteIndent(writer);
3429        if (count < 0)
3430            return -1;
3431        sum += count;
3432    }
3433
3434    count = xmlOutputBufferWriteString(writer->out, "<!ATTLIST ");
3435    if (count < 0)
3436        return -1;
3437    sum += count;
3438    count = xmlOutputBufferWriteString(writer->out, (const char *) name);
3439    if (count < 0)
3440        return -1;
3441    sum += count;
3442
3443    return sum;
3444}
3445
3446/**
3447 * xmlTextWriterEndDTDAttlist:
3448 * @writer:  the xmlTextWriterPtr
3449 *
3450 * End an xml DTD attribute list.
3451 *
3452 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3453 */
3454int
3455xmlTextWriterEndDTDAttlist(xmlTextWriterPtr writer)
3456{
3457    int count;
3458    int sum;
3459    xmlLinkPtr lk;
3460    xmlTextWriterStackEntry *p;
3461
3462    if (writer == NULL)
3463        return -1;
3464
3465    sum = 0;
3466    lk = xmlListFront(writer->nodes);
3467    if (lk == 0)
3468        return -1;
3469
3470    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
3471    if (p == 0)
3472        return -1;
3473
3474    switch (p->state) {
3475        case XML_TEXTWRITER_DTD_ATTL:
3476        case XML_TEXTWRITER_DTD_ATTL_TEXT:
3477            count = xmlOutputBufferWriteString(writer->out, ">");
3478            if (count < 0)
3479                return -1;
3480            sum += count;
3481            break;
3482        default:
3483            return -1;
3484    }
3485
3486    if (writer->indent) {
3487        count = xmlOutputBufferWriteString(writer->out, "\n");
3488        if (count < 0)
3489            return -1;
3490        sum += count;
3491    }
3492
3493    xmlListPopFront(writer->nodes);
3494    return sum;
3495}
3496
3497/**
3498 * xmlTextWriterWriteFormatDTDAttlist:
3499 * @writer:  the xmlTextWriterPtr
3500 * @name:  the name of the DTD ATTLIST
3501 * @format:  format string (see printf)
3502 * @...:  extra parameters for the format
3503 *
3504 * Write a formatted DTD ATTLIST.
3505 *
3506 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3507 */
3508int XMLCDECL
3509xmlTextWriterWriteFormatDTDAttlist(xmlTextWriterPtr writer,
3510                                   const xmlChar * name,
3511                                   const char *format, ...)
3512{
3513    int rc;
3514    va_list ap;
3515
3516    va_start(ap, format);
3517
3518    rc = xmlTextWriterWriteVFormatDTDAttlist(writer, name, format, ap);
3519
3520    va_end(ap);
3521    return rc;
3522}
3523
3524/**
3525 * xmlTextWriterWriteVFormatDTDAttlist:
3526 * @writer:  the xmlTextWriterPtr
3527 * @name:  the name of the DTD ATTLIST
3528 * @format:  format string (see printf)
3529 * @argptr:  pointer to the first member of the variable argument list.
3530 *
3531 * Write a formatted DTD ATTLIST.
3532 *
3533 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3534 */
3535int
3536xmlTextWriterWriteVFormatDTDAttlist(xmlTextWriterPtr writer,
3537                                    const xmlChar * name,
3538                                    const char *format, va_list argptr)
3539{
3540    int rc;
3541    xmlChar *buf;
3542
3543    if (writer == NULL)
3544        return -1;
3545
3546    buf = xmlTextWriterVSprintf(format, argptr);
3547    if (buf == 0)
3548        return 0;
3549
3550    rc = xmlTextWriterWriteDTDAttlist(writer, name, buf);
3551
3552    xmlFree(buf);
3553    return rc;
3554}
3555
3556/**
3557 * xmlTextWriterWriteDTDAttlist:
3558 * @writer:  the xmlTextWriterPtr
3559 * @name:  the name of the DTD ATTLIST
3560 * @content:  content of the ATTLIST
3561 *
3562 * Write a DTD ATTLIST.
3563 *
3564 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3565 */
3566int
3567xmlTextWriterWriteDTDAttlist(xmlTextWriterPtr writer,
3568                             const xmlChar * name, const xmlChar * content)
3569{
3570    int count;
3571    int sum;
3572
3573    if (content == NULL)
3574        return -1;
3575
3576    sum = 0;
3577    count = xmlTextWriterStartDTDAttlist(writer, name);
3578    if (count == -1)
3579        return -1;
3580    sum += count;
3581
3582    count = xmlTextWriterWriteString(writer, content);
3583    if (count == -1)
3584        return -1;
3585    sum += count;
3586
3587    count = xmlTextWriterEndDTDAttlist(writer);
3588    if (count == -1)
3589        return -1;
3590    sum += count;
3591
3592    return sum;
3593}
3594
3595/**
3596 * xmlTextWriterStartDTDEntity:
3597 * @writer:  the xmlTextWriterPtr
3598 * @pe:  TRUE if this is a parameter entity, FALSE if not
3599 * @name:  the name of the DTD ATTLIST
3600 *
3601 * Start an xml DTD ATTLIST.
3602 *
3603 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3604 */
3605int
3606xmlTextWriterStartDTDEntity(xmlTextWriterPtr writer,
3607                            int pe, const xmlChar * name)
3608{
3609    int count;
3610    int sum;
3611    xmlLinkPtr lk;
3612    xmlTextWriterStackEntry *p;
3613
3614    if (writer == NULL || name == NULL || *name == '\0')
3615        return -1;
3616
3617    sum = 0;
3618    lk = xmlListFront(writer->nodes);
3619    if (lk != 0) {
3620
3621        p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
3622        if (p != 0) {
3623            switch (p->state) {
3624                case XML_TEXTWRITER_DTD:
3625                    count = xmlOutputBufferWriteString(writer->out, " [");
3626                    if (count < 0)
3627                        return -1;
3628                    sum += count;
3629                    if (writer->indent) {
3630                        count =
3631                            xmlOutputBufferWriteString(writer->out, "\n");
3632                        if (count < 0)
3633                            return -1;
3634                        sum += count;
3635                    }
3636                    p->state = XML_TEXTWRITER_DTD_TEXT;
3637                    /* fallthrough */
3638                case XML_TEXTWRITER_DTD_TEXT:
3639                case XML_TEXTWRITER_NONE:
3640                    break;
3641                default:
3642                    return -1;
3643            }
3644        }
3645    }
3646
3647    p = (xmlTextWriterStackEntry *)
3648        xmlMalloc(sizeof(xmlTextWriterStackEntry));
3649    if (p == 0) {
3650        xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
3651                        "xmlTextWriterStartDTDElement : out of memory!\n");
3652        return -1;
3653    }
3654
3655    p->name = xmlStrdup(name);
3656    if (p->name == 0) {
3657        xmlWriterErrMsg(writer, XML_ERR_NO_MEMORY,
3658                        "xmlTextWriterStartDTDElement : out of memory!\n");
3659        xmlFree(p);
3660        return -1;
3661    }
3662
3663    if (pe != 0)
3664        p->state = XML_TEXTWRITER_DTD_PENT;
3665    else
3666        p->state = XML_TEXTWRITER_DTD_ENTY;
3667
3668    xmlListPushFront(writer->nodes, p);
3669
3670    if (writer->indent) {
3671        count = xmlTextWriterWriteIndent(writer);
3672        if (count < 0)
3673            return -1;
3674        sum += count;
3675    }
3676
3677    count = xmlOutputBufferWriteString(writer->out, "<!ENTITY ");
3678    if (count < 0)
3679        return -1;
3680    sum += count;
3681
3682    if (pe != 0) {
3683        count = xmlOutputBufferWriteString(writer->out, "% ");
3684        if (count < 0)
3685            return -1;
3686        sum += count;
3687    }
3688
3689    count = xmlOutputBufferWriteString(writer->out, (const char *) name);
3690    if (count < 0)
3691        return -1;
3692    sum += count;
3693
3694    return sum;
3695}
3696
3697/**
3698 * xmlTextWriterEndDTDEntity:
3699 * @writer:  the xmlTextWriterPtr
3700 *
3701 * End an xml DTD entity.
3702 *
3703 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3704 */
3705int
3706xmlTextWriterEndDTDEntity(xmlTextWriterPtr writer)
3707{
3708    int count;
3709    int sum;
3710    xmlLinkPtr lk;
3711    xmlTextWriterStackEntry *p;
3712
3713    if (writer == NULL)
3714        return -1;
3715
3716    sum = 0;
3717    lk = xmlListFront(writer->nodes);
3718    if (lk == 0)
3719        return -1;
3720
3721    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
3722    if (p == 0)
3723        return -1;
3724
3725    switch (p->state) {
3726        case XML_TEXTWRITER_DTD_ENTY_TEXT:
3727            count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
3728            if (count < 0)
3729                return -1;
3730            sum += count;
3731        case XML_TEXTWRITER_DTD_ENTY:
3732        case XML_TEXTWRITER_DTD_PENT:
3733            count = xmlOutputBufferWriteString(writer->out, ">");
3734            if (count < 0)
3735                return -1;
3736            sum += count;
3737            break;
3738        default:
3739            return -1;
3740    }
3741
3742    if (writer->indent) {
3743        count = xmlOutputBufferWriteString(writer->out, "\n");
3744        if (count < 0)
3745            return -1;
3746        sum += count;
3747    }
3748
3749    xmlListPopFront(writer->nodes);
3750    return sum;
3751}
3752
3753/**
3754 * xmlTextWriterWriteFormatDTDInternalEntity:
3755 * @writer:  the xmlTextWriterPtr
3756 * @pe:  TRUE if this is a parameter entity, FALSE if not
3757 * @name:  the name of the DTD entity
3758 * @format:  format string (see printf)
3759 * @...:  extra parameters for the format
3760 *
3761 * Write a formatted DTD internal entity.
3762 *
3763 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3764 */
3765int XMLCDECL
3766xmlTextWriterWriteFormatDTDInternalEntity(xmlTextWriterPtr writer,
3767                                          int pe,
3768                                          const xmlChar * name,
3769                                          const char *format, ...)
3770{
3771    int rc;
3772    va_list ap;
3773
3774    va_start(ap, format);
3775
3776    rc = xmlTextWriterWriteVFormatDTDInternalEntity(writer, pe, name,
3777                                                    format, ap);
3778
3779    va_end(ap);
3780    return rc;
3781}
3782
3783/**
3784 * xmlTextWriterWriteVFormatDTDInternalEntity:
3785 * @writer:  the xmlTextWriterPtr
3786 * @pe:  TRUE if this is a parameter entity, FALSE if not
3787 * @name:  the name of the DTD entity
3788 * @format:  format string (see printf)
3789 * @argptr:  pointer to the first member of the variable argument list.
3790 *
3791 * Write a formatted DTD internal entity.
3792 *
3793 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3794 */
3795int
3796xmlTextWriterWriteVFormatDTDInternalEntity(xmlTextWriterPtr writer,
3797                                           int pe,
3798                                           const xmlChar * name,
3799                                           const char *format,
3800                                           va_list argptr)
3801{
3802    int rc;
3803    xmlChar *buf;
3804
3805    if (writer == NULL)
3806        return -1;
3807
3808    buf = xmlTextWriterVSprintf(format, argptr);
3809    if (buf == 0)
3810        return 0;
3811
3812    rc = xmlTextWriterWriteDTDInternalEntity(writer, pe, name, buf);
3813
3814    xmlFree(buf);
3815    return rc;
3816}
3817
3818/**
3819 * xmlTextWriterWriteDTDEntity:
3820 * @writer:  the xmlTextWriterPtr
3821 * @pe:  TRUE if this is a parameter entity, FALSE if not
3822 * @name:  the name of the DTD entity
3823 * @pubid:  the public identifier, which is an alternative to the system identifier
3824 * @sysid:  the system identifier, which is the URI of the DTD
3825 * @ndataid:  the xml notation name.
3826 * @content:  content of the entity
3827 *
3828 * Write a DTD entity.
3829 *
3830 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3831 */
3832int
3833xmlTextWriterWriteDTDEntity(xmlTextWriterPtr writer,
3834                            int pe,
3835                            const xmlChar * name,
3836                            const xmlChar * pubid,
3837                            const xmlChar * sysid,
3838                            const xmlChar * ndataid,
3839                            const xmlChar * content)
3840{
3841    if ((content == NULL) && (pubid == NULL) && (sysid == NULL))
3842        return -1;
3843    if ((pe != 0) && (ndataid != NULL))
3844        return -1;
3845
3846    if ((pubid == NULL) && (sysid == NULL))
3847        return xmlTextWriterWriteDTDInternalEntity(writer, pe, name,
3848                                                   content);
3849
3850    return xmlTextWriterWriteDTDExternalEntity(writer, pe, name, pubid,
3851                                               sysid, ndataid);
3852}
3853
3854/**
3855 * xmlTextWriterWriteDTDInternalEntity:
3856 * @writer:  the xmlTextWriterPtr
3857 * @pe:  TRUE if this is a parameter entity, FALSE if not
3858 * @name:  the name of the DTD entity
3859 * @content:  content of the entity
3860 *
3861 * Write a DTD internal entity.
3862 *
3863 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3864 */
3865int
3866xmlTextWriterWriteDTDInternalEntity(xmlTextWriterPtr writer,
3867                                    int pe,
3868                                    const xmlChar * name,
3869                                    const xmlChar * content)
3870{
3871    int count;
3872    int sum;
3873
3874    if ((name == NULL) || (*name == '\0') || (content == NULL))
3875        return -1;
3876
3877    sum = 0;
3878    count = xmlTextWriterStartDTDEntity(writer, pe, name);
3879    if (count == -1)
3880        return -1;
3881    sum += count;
3882
3883    count = xmlTextWriterWriteString(writer, content);
3884    if (count == -1)
3885        return -1;
3886    sum += count;
3887
3888    count = xmlTextWriterEndDTDEntity(writer);
3889    if (count == -1)
3890        return -1;
3891    sum += count;
3892
3893    return sum;
3894}
3895
3896/**
3897 * xmlTextWriterWriteDTDExternalEntity:
3898 * @writer:  the xmlTextWriterPtr
3899 * @pe:  TRUE if this is a parameter entity, FALSE if not
3900 * @name:  the name of the DTD entity
3901 * @pubid:  the public identifier, which is an alternative to the system identifier
3902 * @sysid:  the system identifier, which is the URI of the DTD
3903 * @ndataid:  the xml notation name.
3904 *
3905 * Write a DTD external entity. The entity must have been started with xmlTextWriterStartDTDEntity
3906 *
3907 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3908 */
3909int
3910xmlTextWriterWriteDTDExternalEntity(xmlTextWriterPtr writer,
3911                                    int pe,
3912                                    const xmlChar * name,
3913                                    const xmlChar * pubid,
3914                                    const xmlChar * sysid,
3915                                    const xmlChar * ndataid)
3916{
3917    int count;
3918    int sum;
3919
3920    if (((pubid == NULL) && (sysid == NULL)))
3921        return -1;
3922    if ((pe != 0) && (ndataid != NULL))
3923        return -1;
3924
3925    sum = 0;
3926    count = xmlTextWriterStartDTDEntity(writer, pe, name);
3927    if (count == -1)
3928        return -1;
3929    sum += count;
3930
3931    count =
3932        xmlTextWriterWriteDTDExternalEntityContents(writer, pubid, sysid,
3933                                                    ndataid);
3934    if (count < 0)
3935        return -1;
3936    sum += count;
3937
3938    count = xmlTextWriterEndDTDEntity(writer);
3939    if (count == -1)
3940        return -1;
3941    sum += count;
3942
3943    return sum;
3944}
3945
3946/**
3947 * xmlTextWriterWriteDTDExternalEntityContents:
3948 * @writer:  the xmlTextWriterPtr
3949 * @pubid:  the public identifier, which is an alternative to the system identifier
3950 * @sysid:  the system identifier, which is the URI of the DTD
3951 * @ndataid:  the xml notation name.
3952 *
3953 * Write the contents of a DTD external entity.
3954 *
3955 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
3956 */
3957int
3958xmlTextWriterWriteDTDExternalEntityContents(xmlTextWriterPtr writer,
3959                                            const xmlChar * pubid,
3960                                            const xmlChar * sysid,
3961                                            const xmlChar * ndataid)
3962{
3963    int count;
3964    int sum;
3965    xmlLinkPtr lk;
3966    xmlTextWriterStackEntry *p;
3967
3968    if (writer == NULL) {
3969        xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
3970                        "xmlTextWriterWriteDTDExternalEntityContents: xmlTextWriterPtr invalid!\n");
3971        return -1;
3972    }
3973
3974    sum = 0;
3975    lk = xmlListFront(writer->nodes);
3976    if (lk == 0) {
3977        xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
3978                        "xmlTextWriterWriteDTDExternalEntityContents: you must call xmlTextWriterStartDTDEntity before the call to this function!\n");
3979        return -1;
3980    }
3981
3982    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
3983    if (p == 0)
3984        return -1;
3985
3986    switch (p->state) {
3987        case XML_TEXTWRITER_DTD_ENTY:
3988            break;
3989        case XML_TEXTWRITER_DTD_PENT:
3990            if (ndataid != NULL) {
3991                xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
3992                                "xmlTextWriterWriteDTDExternalEntityContents: notation not allowed with parameter entities!\n");
3993                return -1;
3994            }
3995            break;
3996        default:
3997            xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
3998                            "xmlTextWriterWriteDTDExternalEntityContents: you must call xmlTextWriterStartDTDEntity before the call to this function!\n");
3999            return -1;
4000    }
4001
4002    if (pubid != 0) {
4003        if (sysid == 0) {
4004            xmlWriterErrMsg(writer, XML_ERR_INTERNAL_ERROR,
4005                            "xmlTextWriterWriteDTDExternalEntityContents: system identifier needed!\n");
4006            return -1;
4007        }
4008
4009        count = xmlOutputBufferWriteString(writer->out, " PUBLIC ");
4010        if (count < 0)
4011            return -1;
4012        sum += count;
4013
4014        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
4015        if (count < 0)
4016            return -1;
4017        sum += count;
4018
4019        count =
4020            xmlOutputBufferWriteString(writer->out, (const char *) pubid);
4021        if (count < 0)
4022            return -1;
4023        sum += count;
4024
4025        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
4026        if (count < 0)
4027            return -1;
4028        sum += count;
4029    }
4030
4031    if (sysid != 0) {
4032        if (pubid == 0) {
4033            count = xmlOutputBufferWriteString(writer->out, " SYSTEM");
4034            if (count < 0)
4035                return -1;
4036            sum += count;
4037        }
4038
4039        count = xmlOutputBufferWriteString(writer->out, " ");
4040        if (count < 0)
4041            return -1;
4042        sum += count;
4043
4044        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
4045        if (count < 0)
4046            return -1;
4047        sum += count;
4048
4049        count =
4050            xmlOutputBufferWriteString(writer->out, (const char *) sysid);
4051        if (count < 0)
4052            return -1;
4053        sum += count;
4054
4055        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
4056        if (count < 0)
4057            return -1;
4058        sum += count;
4059    }
4060
4061    if (ndataid != NULL) {
4062        count = xmlOutputBufferWriteString(writer->out, " NDATA ");
4063        if (count < 0)
4064            return -1;
4065        sum += count;
4066
4067        count =
4068            xmlOutputBufferWriteString(writer->out,
4069                                       (const char *) ndataid);
4070        if (count < 0)
4071            return -1;
4072        sum += count;
4073    }
4074
4075    return sum;
4076}
4077
4078/**
4079 * xmlTextWriterWriteDTDNotation:
4080 * @writer:  the xmlTextWriterPtr
4081 * @name:  the name of the xml notation
4082 * @pubid:  the public identifier, which is an alternative to the system identifier
4083 * @sysid:  the system identifier, which is the URI of the DTD
4084 *
4085 * Write a DTD entity.
4086 *
4087 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
4088 */
4089int
4090xmlTextWriterWriteDTDNotation(xmlTextWriterPtr writer,
4091                              const xmlChar * name,
4092                              const xmlChar * pubid, const xmlChar * sysid)
4093{
4094    int count;
4095    int sum;
4096    xmlLinkPtr lk;
4097    xmlTextWriterStackEntry *p;
4098
4099    if (writer == NULL || name == NULL || *name == '\0')
4100        return -1;
4101
4102    sum = 0;
4103    lk = xmlListFront(writer->nodes);
4104    if (lk == 0) {
4105        return -1;
4106    }
4107
4108    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
4109    if (p != 0) {
4110        switch (p->state) {
4111            case XML_TEXTWRITER_DTD:
4112                count = xmlOutputBufferWriteString(writer->out, " [");
4113                if (count < 0)
4114                    return -1;
4115                sum += count;
4116                if (writer->indent) {
4117                    count = xmlOutputBufferWriteString(writer->out, "\n");
4118                    if (count < 0)
4119                        return -1;
4120                    sum += count;
4121                }
4122                p->state = XML_TEXTWRITER_DTD_TEXT;
4123                /* fallthrough */
4124            case XML_TEXTWRITER_DTD_TEXT:
4125                break;
4126            default:
4127                return -1;
4128        }
4129    }
4130
4131    if (writer->indent) {
4132        count = xmlTextWriterWriteIndent(writer);
4133        if (count < 0)
4134            return -1;
4135        sum += count;
4136    }
4137
4138    count = xmlOutputBufferWriteString(writer->out, "<!NOTATION ");
4139    if (count < 0)
4140        return -1;
4141    sum += count;
4142    count = xmlOutputBufferWriteString(writer->out, (const char *) name);
4143    if (count < 0)
4144        return -1;
4145    sum += count;
4146
4147    if (pubid != 0) {
4148        count = xmlOutputBufferWriteString(writer->out, " PUBLIC ");
4149        if (count < 0)
4150            return -1;
4151        sum += count;
4152        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
4153        if (count < 0)
4154            return -1;
4155        sum += count;
4156        count =
4157            xmlOutputBufferWriteString(writer->out, (const char *) pubid);
4158        if (count < 0)
4159            return -1;
4160        sum += count;
4161        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
4162        if (count < 0)
4163            return -1;
4164        sum += count;
4165    }
4166
4167    if (sysid != 0) {
4168        if (pubid == 0) {
4169            count = xmlOutputBufferWriteString(writer->out, " SYSTEM");
4170            if (count < 0)
4171                return -1;
4172            sum += count;
4173        }
4174        count = xmlOutputBufferWriteString(writer->out, " ");
4175        if (count < 0)
4176            return -1;
4177        sum += count;
4178        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
4179        if (count < 0)
4180            return -1;
4181        sum += count;
4182        count =
4183            xmlOutputBufferWriteString(writer->out, (const char *) sysid);
4184        if (count < 0)
4185            return -1;
4186        sum += count;
4187        count = xmlOutputBufferWrite(writer->out, 1, &writer->qchar);
4188        if (count < 0)
4189            return -1;
4190        sum += count;
4191    }
4192
4193    count = xmlOutputBufferWriteString(writer->out, ">");
4194    if (count < 0)
4195        return -1;
4196    sum += count;
4197
4198    return sum;
4199}
4200
4201/**
4202 * xmlTextWriterFlush:
4203 * @writer:  the xmlTextWriterPtr
4204 *
4205 * Flush the output buffer.
4206 *
4207 * Returns the bytes written (may be 0 because of buffering) or -1 in case of error
4208 */
4209int
4210xmlTextWriterFlush(xmlTextWriterPtr writer)
4211{
4212    int count;
4213
4214    if (writer == NULL)
4215        return -1;
4216
4217    if (writer->out == NULL)
4218        count = 0;
4219    else
4220        count = xmlOutputBufferFlush(writer->out);
4221
4222    return count;
4223}
4224
4225/**
4226 * misc
4227 */
4228
4229/**
4230 * xmlFreeTextWriterStackEntry:
4231 * @lk:  the xmlLinkPtr
4232 *
4233 * Free callback for the xmlList.
4234 */
4235static void
4236xmlFreeTextWriterStackEntry(xmlLinkPtr lk)
4237{
4238    xmlTextWriterStackEntry *p;
4239
4240    p = (xmlTextWriterStackEntry *) xmlLinkGetData(lk);
4241    if (p == 0)
4242        return;
4243
4244    if (p->name != 0)
4245        xmlFree(p->name);
4246    xmlFree(p);
4247}
4248
4249/**
4250 * xmlCmpTextWriterStackEntry:
4251 * @data0:  the first data
4252 * @data1:  the second data
4253 *
4254 * Compare callback for the xmlList.
4255 *
4256 * Returns -1, 0, 1
4257 */
4258static int
4259xmlCmpTextWriterStackEntry(const void *data0, const void *data1)
4260{
4261    xmlTextWriterStackEntry *p0;
4262    xmlTextWriterStackEntry *p1;
4263
4264    if (data0 == data1)
4265        return 0;
4266
4267    if (data0 == 0)
4268        return -1;
4269
4270    if (data1 == 0)
4271        return 1;
4272
4273    p0 = (xmlTextWriterStackEntry *) data0;
4274    p1 = (xmlTextWriterStackEntry *) data1;
4275
4276    return xmlStrcmp(p0->name, p1->name);
4277}
4278
4279/**
4280 * misc
4281 */
4282
4283/**
4284 * xmlTextWriterOutputNSDecl:
4285 * @writer:  the xmlTextWriterPtr
4286 *
4287 * Output the current namespace declarations.
4288 */
4289static int
4290xmlTextWriterOutputNSDecl(xmlTextWriterPtr writer)
4291{
4292    xmlLinkPtr lk;
4293    xmlTextWriterNsStackEntry *np;
4294    int count;
4295    int sum;
4296
4297    sum = 0;
4298    while (!xmlListEmpty(writer->nsstack)) {
4299        xmlChar *namespaceURI = NULL;
4300        xmlChar *prefix = NULL;
4301
4302        lk = xmlListFront(writer->nsstack);
4303        np = (xmlTextWriterNsStackEntry *) xmlLinkGetData(lk);
4304
4305        if (np != 0) {
4306            namespaceURI = xmlStrdup(np->uri);
4307            prefix = xmlStrdup(np->prefix);
4308        }
4309
4310        xmlListPopFront(writer->nsstack);
4311
4312        if (np != 0) {
4313            count = xmlTextWriterWriteAttribute(writer, prefix, namespaceURI);
4314            xmlFree(namespaceURI);
4315            xmlFree(prefix);
4316
4317            if (count < 0) {
4318                xmlListDelete(writer->nsstack);
4319                writer->nsstack = NULL;
4320                return -1;
4321            }
4322            sum += count;
4323        }
4324    }
4325    return sum;
4326}
4327
4328/**
4329 * xmlFreeTextWriterNsStackEntry:
4330 * @lk:  the xmlLinkPtr
4331 *
4332 * Free callback for the xmlList.
4333 */
4334static void
4335xmlFreeTextWriterNsStackEntry(xmlLinkPtr lk)
4336{
4337    xmlTextWriterNsStackEntry *p;
4338
4339    p = (xmlTextWriterNsStackEntry *) xmlLinkGetData(lk);
4340    if (p == 0)
4341        return;
4342
4343    if (p->prefix != 0)
4344        xmlFree(p->prefix);
4345    if (p->uri != 0)
4346        xmlFree(p->uri);
4347
4348    xmlFree(p);
4349}
4350
4351/**
4352 * xmlCmpTextWriterNsStackEntry:
4353 * @data0:  the first data
4354 * @data1:  the second data
4355 *
4356 * Compare callback for the xmlList.
4357 *
4358 * Returns -1, 0, 1
4359 */
4360static int
4361xmlCmpTextWriterNsStackEntry(const void *data0, const void *data1)
4362{
4363    xmlTextWriterNsStackEntry *p0;
4364    xmlTextWriterNsStackEntry *p1;
4365    int rc;
4366
4367    if (data0 == data1)
4368        return 0;
4369
4370    if (data0 == 0)
4371        return -1;
4372
4373    if (data1 == 0)
4374        return 1;
4375
4376    p0 = (xmlTextWriterNsStackEntry *) data0;
4377    p1 = (xmlTextWriterNsStackEntry *) data1;
4378
4379    rc = xmlStrcmp(p0->prefix, p1->prefix);
4380
4381    if ((rc != 0) || (p0->elem != p1->elem))
4382        rc = -1;
4383
4384    return rc;
4385}
4386
4387/**
4388 * xmlTextWriterWriteDocCallback:
4389 * @context:  the xmlBufferPtr
4390 * @str:  the data to write
4391 * @len:  the length of the data
4392 *
4393 * Write callback for the xmlOutputBuffer with target xmlBuffer
4394 *
4395 * Returns -1, 0, 1
4396 */
4397static int
4398xmlTextWriterWriteDocCallback(void *context, const xmlChar * str, int len)
4399{
4400    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) context;
4401    int rc;
4402
4403    if ((rc = xmlParseChunk(ctxt, (const char *) str, len, 0)) != 0) {
4404        xmlWriterErrMsgInt(NULL, XML_ERR_INTERNAL_ERROR,
4405                        "xmlTextWriterWriteDocCallback : XML error %d !\n",
4406                        rc);
4407        return -1;
4408    }
4409
4410    return len;
4411}
4412
4413/**
4414 * xmlTextWriterCloseDocCallback:
4415 * @context:  the xmlBufferPtr
4416 *
4417 * Close callback for the xmlOutputBuffer with target xmlBuffer
4418 *
4419 * Returns -1, 0, 1
4420 */
4421static int
4422xmlTextWriterCloseDocCallback(void *context)
4423{
4424    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) context;
4425    int rc;
4426
4427    if ((rc = xmlParseChunk(ctxt, NULL, 0, 1)) != 0) {
4428        xmlWriterErrMsgInt(NULL, XML_ERR_INTERNAL_ERROR,
4429                        "xmlTextWriterWriteDocCallback : XML error %d !\n",
4430                        rc);
4431        return -1;
4432    }
4433
4434    return 0;
4435}
4436
4437/**
4438 * xmlTextWriterVSprintf:
4439 * @format:  see printf
4440 * @argptr:  pointer to the first member of the variable argument list.
4441 *
4442 * Utility function for formatted output
4443 *
4444 * Returns a new xmlChar buffer with the data or NULL on error. This buffer must be freed.
4445 */
4446static xmlChar *
4447xmlTextWriterVSprintf(const char *format, va_list argptr)
4448{
4449    int size;
4450    int count;
4451    xmlChar *buf;
4452    va_list locarg;
4453
4454    size = BUFSIZ;
4455    buf = (xmlChar *) xmlMalloc(size);
4456    if (buf == NULL) {
4457        xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
4458                        "xmlTextWriterVSprintf : out of memory!\n");
4459        return NULL;
4460    }
4461
4462    VA_COPY(locarg, argptr);
4463    while (((count = vsnprintf((char *) buf, size, format, locarg)) < 0)
4464           || (count == size - 1) || (count == size) || (count > size)) {
4465	va_end(locarg);
4466        xmlFree(buf);
4467        size += BUFSIZ;
4468        buf = (xmlChar *) xmlMalloc(size);
4469        if (buf == NULL) {
4470            xmlWriterErrMsg(NULL, XML_ERR_NO_MEMORY,
4471                            "xmlTextWriterVSprintf : out of memory!\n");
4472            return NULL;
4473        }
4474	VA_COPY(locarg, argptr);
4475    }
4476    va_end(locarg);
4477
4478    return buf;
4479}
4480
4481/**
4482 * xmlTextWriterStartDocumentCallback:
4483 * @ctx: the user data (XML parser context)
4484 *
4485 * called at the start of document processing.
4486 */
4487static void
4488xmlTextWriterStartDocumentCallback(void *ctx)
4489{
4490    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
4491    xmlDocPtr doc;
4492
4493    if (ctxt->html) {
4494#ifdef LIBXML_HTML_ENABLED
4495        if (ctxt->myDoc == NULL)
4496            ctxt->myDoc = htmlNewDocNoDtD(NULL, NULL);
4497        if (ctxt->myDoc == NULL) {
4498            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
4499                ctxt->sax->error(ctxt->userData,
4500                                 "SAX.startDocument(): out of memory\n");
4501            ctxt->errNo = XML_ERR_NO_MEMORY;
4502            ctxt->instate = XML_PARSER_EOF;
4503            ctxt->disableSAX = 1;
4504            return;
4505        }
4506#else
4507        xmlWriterErrMsg(NULL, XML_ERR_INTERNAL_ERROR,
4508                        "libxml2 built without HTML support\n");
4509        ctxt->errNo = XML_ERR_INTERNAL_ERROR;
4510        ctxt->instate = XML_PARSER_EOF;
4511        ctxt->disableSAX = 1;
4512        return;
4513#endif
4514    } else {
4515        doc = ctxt->myDoc;
4516        if (doc == NULL)
4517            doc = ctxt->myDoc = xmlNewDoc(ctxt->version);
4518        if (doc != NULL) {
4519            if (doc->children == NULL) {
4520                if (ctxt->encoding != NULL)
4521                    doc->encoding = xmlStrdup(ctxt->encoding);
4522                else
4523                    doc->encoding = NULL;
4524                doc->standalone = ctxt->standalone;
4525            }
4526        } else {
4527            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
4528                ctxt->sax->error(ctxt->userData,
4529                                 "SAX.startDocument(): out of memory\n");
4530            ctxt->errNo = XML_ERR_NO_MEMORY;
4531            ctxt->instate = XML_PARSER_EOF;
4532            ctxt->disableSAX = 1;
4533            return;
4534        }
4535    }
4536    if ((ctxt->myDoc != NULL) && (ctxt->myDoc->URL == NULL) &&
4537        (ctxt->input != NULL) && (ctxt->input->filename != NULL)) {
4538        ctxt->myDoc->URL =
4539            xmlCanonicPath((const xmlChar *) ctxt->input->filename);
4540        if (ctxt->myDoc->URL == NULL)
4541            ctxt->myDoc->URL =
4542                xmlStrdup((const xmlChar *) ctxt->input->filename);
4543    }
4544}
4545
4546/**
4547 * xmlTextWriterSetIndent:
4548 * @writer:  the xmlTextWriterPtr
4549 * @indent:  do indentation?
4550 *
4551 * Set indentation output. indent = 0 do not indentation. indent > 0 do indentation.
4552 *
4553 * Returns -1 on error or 0 otherwise.
4554 */
4555int
4556xmlTextWriterSetIndent(xmlTextWriterPtr writer, int indent)
4557{
4558    if ((writer == NULL) || (indent < 0))
4559        return -1;
4560
4561    writer->indent = indent;
4562    writer->doindent = 1;
4563
4564    return 0;
4565}
4566
4567/**
4568 * xmlTextWriterSetIndentString:
4569 * @writer:  the xmlTextWriterPtr
4570 * @str:  the xmlChar string
4571 *
4572 * Set string indentation.
4573 *
4574 * Returns -1 on error or 0 otherwise.
4575 */
4576int
4577xmlTextWriterSetIndentString(xmlTextWriterPtr writer, const xmlChar * str)
4578{
4579    if ((writer == NULL) || (!str))
4580        return -1;
4581
4582    if (writer->ichar != NULL)
4583        xmlFree(writer->ichar);
4584    writer->ichar = xmlStrdup(str);
4585
4586    if (!writer->ichar)
4587        return -1;
4588    else
4589        return 0;
4590}
4591
4592/**
4593 * xmlTextWriterWriteIndent:
4594 * @writer:  the xmlTextWriterPtr
4595 *
4596 * Write indent string.
4597 *
4598 * Returns -1 on error or the number of strings written.
4599 */
4600static int
4601xmlTextWriterWriteIndent(xmlTextWriterPtr writer)
4602{
4603    int lksize;
4604    int i;
4605    int ret;
4606
4607    lksize = xmlListSize(writer->nodes);
4608    if (lksize < 1)
4609        return (-1);            /* list is empty */
4610    for (i = 0; i < (lksize - 1); i++) {
4611        ret = xmlOutputBufferWriteString(writer->out,
4612                                         (const char *) writer->ichar);
4613        if (ret == -1)
4614            return (-1);
4615    }
4616
4617    return (lksize - 1);
4618}
4619
4620/**
4621 * xmlTextWriterHandleStateDependencies:
4622 * @writer:  the xmlTextWriterPtr
4623 * @p:  the xmlTextWriterStackEntry
4624 *
4625 * Write state dependent strings.
4626 *
4627 * Returns -1 on error or the number of characters written.
4628 */
4629static int
4630xmlTextWriterHandleStateDependencies(xmlTextWriterPtr writer,
4631                                     xmlTextWriterStackEntry * p)
4632{
4633    int count;
4634    int sum;
4635    char extra[3];
4636
4637    if (writer == NULL)
4638        return -1;
4639
4640    if (p == NULL)
4641        return 0;
4642
4643    sum = 0;
4644    extra[0] = extra[1] = extra[2] = '\0';
4645    if (p != 0) {
4646        sum = 0;
4647        switch (p->state) {
4648            case XML_TEXTWRITER_NAME:
4649                /* Output namespace declarations */
4650                count = xmlTextWriterOutputNSDecl(writer);
4651                if (count < 0)
4652                    return -1;
4653                sum += count;
4654                extra[0] = '>';
4655                p->state = XML_TEXTWRITER_TEXT;
4656                break;
4657            case XML_TEXTWRITER_PI:
4658                extra[0] = ' ';
4659                p->state = XML_TEXTWRITER_PI_TEXT;
4660                break;
4661            case XML_TEXTWRITER_DTD:
4662                extra[0] = ' ';
4663                extra[1] = '[';
4664                p->state = XML_TEXTWRITER_DTD_TEXT;
4665                break;
4666            case XML_TEXTWRITER_DTD_ELEM:
4667                extra[0] = ' ';
4668                p->state = XML_TEXTWRITER_DTD_ELEM_TEXT;
4669                break;
4670            case XML_TEXTWRITER_DTD_ATTL:
4671                extra[0] = ' ';
4672                p->state = XML_TEXTWRITER_DTD_ATTL_TEXT;
4673                break;
4674            case XML_TEXTWRITER_DTD_ENTY:
4675            case XML_TEXTWRITER_DTD_PENT:
4676                extra[0] = ' ';
4677                extra[1] = writer->qchar;
4678                p->state = XML_TEXTWRITER_DTD_ENTY_TEXT;
4679                break;
4680            default:
4681                break;
4682        }
4683    }
4684
4685    if (*extra != '\0') {
4686        count = xmlOutputBufferWriteString(writer->out, extra);
4687        if (count < 0)
4688            return -1;
4689        sum += count;
4690    }
4691
4692    return sum;
4693}
4694
4695#define bottom_xmlwriter
4696#include "elfgcchack.h"
4697#endif
4698