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