1: /*
2: * xmlsave.c: Implemetation of the document serializer
3: *
4: * See Copyright for the status of this software.
5: *
6: * daniel@veillard.com
7: */
8:
9: #define IN_LIBXML
10: #include "libxml.h"
11:
12: #include <string.h>
13: #include <libxml/xmlmemory.h>
14: #include <libxml/parserInternals.h>
15: #include <libxml/tree.h>
16: #include <libxml/xmlsave.h>
17:
18: #define MAX_INDENT 60
19:
20: #include <libxml/HTMLtree.h>
21:
22: #include "buf.h"
23: #include "enc.h"
24: #include "save.h"
25:
26: /************************************************************************
27: * *
28: * XHTML detection *
29: * *
30: ************************************************************************/
31: #define XHTML_STRICT_PUBLIC_ID BAD_CAST \
32: "-//W3C//DTD XHTML 1.0 Strict//EN"
33: #define XHTML_STRICT_SYSTEM_ID BAD_CAST \
34: "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
35: #define XHTML_FRAME_PUBLIC_ID BAD_CAST \
36: "-//W3C//DTD XHTML 1.0 Frameset//EN"
37: #define XHTML_FRAME_SYSTEM_ID BAD_CAST \
38: "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd"
39: #define XHTML_TRANS_PUBLIC_ID BAD_CAST \
40: "-//W3C//DTD XHTML 1.0 Transitional//EN"
41: #define XHTML_TRANS_SYSTEM_ID BAD_CAST \
42: "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"
43:
44: #define XHTML_NS_NAME BAD_CAST "http://www.w3.org/1999/xhtml"
45: /**
46: * xmlIsXHTML:
47: * @systemID: the system identifier
48: * @publicID: the public identifier
49: *
50: * Try to find if the document correspond to an XHTML DTD
51: *
52: * Returns 1 if true, 0 if not and -1 in case of error
53: */
54: int
55: xmlIsXHTML(const xmlChar *systemID, const xmlChar *publicID) {
56: if ((systemID == NULL) && (publicID == NULL))
57: return(-1);
58: if (publicID != NULL) {
59: if (xmlStrEqual(publicID, XHTML_STRICT_PUBLIC_ID)) return(1);
60: if (xmlStrEqual(publicID, XHTML_FRAME_PUBLIC_ID)) return(1);
61: if (xmlStrEqual(publicID, XHTML_TRANS_PUBLIC_ID)) return(1);
62: }
63: if (systemID != NULL) {
64: if (xmlStrEqual(systemID, XHTML_STRICT_SYSTEM_ID)) return(1);
65: if (xmlStrEqual(systemID, XHTML_FRAME_SYSTEM_ID)) return(1);
66: if (xmlStrEqual(systemID, XHTML_TRANS_SYSTEM_ID)) return(1);
67: }
68: return(0);
69: }
70:
71: #ifdef LIBXML_OUTPUT_ENABLED
72:
73: #define TODO \
74: xmlGenericError(xmlGenericErrorContext, \
75: "Unimplemented block at %s:%d\n", \
76: __FILE__, __LINE__);
77:
78: struct _xmlSaveCtxt {
79: void *_private;
80: int type;
81: int fd;
82: const xmlChar *filename;
83: const xmlChar *encoding;
84: xmlCharEncodingHandlerPtr handler;
85: xmlOutputBufferPtr buf;
86: xmlDocPtr doc;
87: int options;
88: int level;
89: int format;
90: char indent[MAX_INDENT + 1]; /* array for indenting output */
91: int indent_nr;
92: int indent_size;
93: xmlCharEncodingOutputFunc escape; /* used for element content */
94: xmlCharEncodingOutputFunc escapeAttr;/* used for attribute content */
95: };
96:
97: /************************************************************************
98: * *
99: * Output error handlers *
100: * *
101: ************************************************************************/
102: /**
103: * xmlSaveErrMemory:
104: * @extra: extra informations
105: *
106: * Handle an out of memory condition
107: */
108: static void
109: xmlSaveErrMemory(const char *extra)
110: {
111: __xmlSimpleError(XML_FROM_OUTPUT, XML_ERR_NO_MEMORY, NULL, NULL, extra);
112: }
113:
114: /**
115: * xmlSaveErr:
116: * @code: the error number
117: * @node: the location of the error.
118: * @extra: extra informations
119: *
120: * Handle an out of memory condition
121: */
122: static void
123: xmlSaveErr(int code, xmlNodePtr node, const char *extra)
124: {
125: const char *msg = NULL;
126:
127: switch(code) {
128: case XML_SAVE_NOT_UTF8:
129: msg = "string is not in UTF-8\n";
130: break;
131: case XML_SAVE_CHAR_INVALID:
132: msg = "invalid character value\n";
133: break;
134: case XML_SAVE_UNKNOWN_ENCODING:
135: msg = "unknown encoding %s\n";
136: break;
137: case XML_SAVE_NO_DOCTYPE:
138: msg = "document has no DOCTYPE\n";
139: break;
140: default:
141: msg = "unexpected error number\n";
142: }
143: __xmlSimpleError(XML_FROM_OUTPUT, code, node, msg, extra);
144: }
145:
146: /************************************************************************
147: * *
148: * Special escaping routines *
149: * *
150: ************************************************************************/
151: static unsigned char *
152: xmlSerializeHexCharRef(unsigned char *out, int val) {
153: unsigned char *ptr;
154:
155: *out++ = '&';
156: *out++ = '#';
157: *out++ = 'x';
158: if (val < 0x10) ptr = out;
159: else if (val < 0x100) ptr = out + 1;
160: else if (val < 0x1000) ptr = out + 2;
161: else if (val < 0x10000) ptr = out + 3;
162: else if (val < 0x100000) ptr = out + 4;
163: else ptr = out + 5;
164: out = ptr + 1;
165: while (val > 0) {
166: switch (val & 0xF) {
167: case 0: *ptr-- = '0'; break;
168: case 1: *ptr-- = '1'; break;
169: case 2: *ptr-- = '2'; break;
170: case 3: *ptr-- = '3'; break;
171: case 4: *ptr-- = '4'; break;
172: case 5: *ptr-- = '5'; break;
173: case 6: *ptr-- = '6'; break;
174: case 7: *ptr-- = '7'; break;
175: case 8: *ptr-- = '8'; break;
176: case 9: *ptr-- = '9'; break;
177: case 0xA: *ptr-- = 'A'; break;
178: case 0xB: *ptr-- = 'B'; break;
179: case 0xC: *ptr-- = 'C'; break;
180: case 0xD: *ptr-- = 'D'; break;
181: case 0xE: *ptr-- = 'E'; break;
182: case 0xF: *ptr-- = 'F'; break;
183: default: *ptr-- = '0'; break;
184: }
185: val >>= 4;
186: }
187: *out++ = ';';
188: *out = 0;
189: return(out);
190: }
191:
192: /**
193: * xmlEscapeEntities:
194: * @out: a pointer to an array of bytes to store the result
195: * @outlen: the length of @out
196: * @in: a pointer to an array of unescaped UTF-8 bytes
197: * @inlen: the length of @in
198: *
199: * Take a block of UTF-8 chars in and escape them. Used when there is no
200: * encoding specified.
201: *
202: * Returns 0 if success, or -1 otherwise
203: * The value of @inlen after return is the number of octets consumed
204: * if the return value is positive, else unpredictable.
205: * The value of @outlen after return is the number of octets consumed.
206: */
207: static int
208: xmlEscapeEntities(unsigned char* out, int *outlen,
209: const xmlChar* in, int *inlen) {
210: unsigned char* outstart = out;
211: const unsigned char* base = in;
212: unsigned char* outend = out + *outlen;
213: const unsigned char* inend;
214: int val;
215:
216: inend = in + (*inlen);
217:
218: while ((in < inend) && (out < outend)) {
219: if (*in == '<') {
220: if (outend - out < 4) break;
221: *out++ = '&';
222: *out++ = 'l';
223: *out++ = 't';
224: *out++ = ';';
225: in++;
226: continue;
227: } else if (*in == '>') {
228: if (outend - out < 4) break;
229: *out++ = '&';
230: *out++ = 'g';
231: *out++ = 't';
232: *out++ = ';';
233: in++;
234: continue;
235: } else if (*in == '&') {
236: if (outend - out < 5) break;
237: *out++ = '&';
238: *out++ = 'a';
239: *out++ = 'm';
240: *out++ = 'p';
241: *out++ = ';';
242: in++;
243: continue;
244: } else if (((*in >= 0x20) && (*in < 0x80)) ||
245: (*in == '\n') || (*in == '\t')) {
246: /*
247: * default case, just copy !
248: */
249: *out++ = *in++;
250: continue;
251: } else if (*in >= 0x80) {
252: /*
253: * We assume we have UTF-8 input.
254: */
255: if (outend - out < 11) break;
256:
257: if (*in < 0xC0) {
258: xmlSaveErr(XML_SAVE_NOT_UTF8, NULL, NULL);
259: in++;
260: goto error;
261: } else if (*in < 0xE0) {
262: if (inend - in < 2) break;
263: val = (in[0]) & 0x1F;
264: val <<= 6;
265: val |= (in[1]) & 0x3F;
266: in += 2;
267: } else if (*in < 0xF0) {
268: if (inend - in < 3) break;
269: val = (in[0]) & 0x0F;
270: val <<= 6;
271: val |= (in[1]) & 0x3F;
272: val <<= 6;
273: val |= (in[2]) & 0x3F;
274: in += 3;
275: } else if (*in < 0xF8) {
276: if (inend - in < 4) break;
277: val = (in[0]) & 0x07;
278: val <<= 6;
279: val |= (in[1]) & 0x3F;
280: val <<= 6;
281: val |= (in[2]) & 0x3F;
282: val <<= 6;
283: val |= (in[3]) & 0x3F;
284: in += 4;
285: } else {
286: xmlSaveErr(XML_SAVE_CHAR_INVALID, NULL, NULL);
287: in++;
288: goto error;
289: }
290: if (!IS_CHAR(val)) {
291: xmlSaveErr(XML_SAVE_CHAR_INVALID, NULL, NULL);
292: in++;
293: goto error;
294: }
295:
296: /*
297: * We could do multiple things here. Just save as a char ref
298: */
299: out = xmlSerializeHexCharRef(out, val);
300: } else if (IS_BYTE_CHAR(*in)) {
301: if (outend - out < 6) break;
302: out = xmlSerializeHexCharRef(out, *in++);
303: } else {
304: xmlGenericError(xmlGenericErrorContext,
305: "xmlEscapeEntities : char out of range\n");
306: in++;
307: goto error;
308: }
309: }
310: *outlen = out - outstart;
311: *inlen = in - base;
312: return(0);
313: error:
314: *outlen = out - outstart;
315: *inlen = in - base;
316: return(-1);
317: }
318:
319: /************************************************************************
320: * *
321: * Allocation and deallocation *
322: * *
323: ************************************************************************/
324: /**
325: * xmlSaveCtxtInit:
326: * @ctxt: the saving context
327: *
328: * Initialize a saving context
329: */
330: static void
331: xmlSaveCtxtInit(xmlSaveCtxtPtr ctxt)
332: {
333: int i;
334: int len;
335:
336: if (ctxt == NULL) return;
337: if ((ctxt->encoding == NULL) && (ctxt->escape == NULL))
338: ctxt->escape = xmlEscapeEntities;
339: len = xmlStrlen((xmlChar *)xmlTreeIndentString);
340: if ((xmlTreeIndentString == NULL) || (len == 0)) {
341: memset(&ctxt->indent[0], 0, MAX_INDENT + 1);
342: } else {
343: ctxt->indent_size = len;
344: ctxt->indent_nr = MAX_INDENT / ctxt->indent_size;
345: for (i = 0;i < ctxt->indent_nr;i++)
346: memcpy(&ctxt->indent[i * ctxt->indent_size], xmlTreeIndentString,
347: ctxt->indent_size);
348: ctxt->indent[ctxt->indent_nr * ctxt->indent_size] = 0;
349: }
350:
351: if (xmlSaveNoEmptyTags) {
352: ctxt->options |= XML_SAVE_NO_EMPTY;
353: }
354: }
355:
356: /**
357: * xmlFreeSaveCtxt:
358: *
359: * Free a saving context, destroying the ouptut in any remaining buffer
360: */
361: static void
362: xmlFreeSaveCtxt(xmlSaveCtxtPtr ctxt)
363: {
364: if (ctxt == NULL) return;
365: if (ctxt->encoding != NULL)
366: xmlFree((char *) ctxt->encoding);
367: if (ctxt->buf != NULL)
368: xmlOutputBufferClose(ctxt->buf);
369: xmlFree(ctxt);
370: }
371:
372: /**
373: * xmlNewSaveCtxt:
374: *
375: * Create a new saving context
376: *
377: * Returns the new structure or NULL in case of error
378: */
379: static xmlSaveCtxtPtr
380: xmlNewSaveCtxt(const char *encoding, int options)
381: {
382: xmlSaveCtxtPtr ret;
383:
384: ret = (xmlSaveCtxtPtr) xmlMalloc(sizeof(xmlSaveCtxt));
385: if (ret == NULL) {
386: xmlSaveErrMemory("creating saving context");
387: return ( NULL );
388: }
389: memset(ret, 0, sizeof(xmlSaveCtxt));
390:
391: if (encoding != NULL) {
392: ret->handler = xmlFindCharEncodingHandler(encoding);
393: if (ret->handler == NULL) {
394: xmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding);
395: xmlFreeSaveCtxt(ret);
396: return(NULL);
397: }
398: ret->encoding = xmlStrdup((const xmlChar *)encoding);
399: ret->escape = NULL;
400: }
401: xmlSaveCtxtInit(ret);
402:
403: /*
404: * Use the options
405: */
406:
407: /* Re-check this option as it may already have been set */
408: if ((ret->options & XML_SAVE_NO_EMPTY) && ! (options & XML_SAVE_NO_EMPTY)) {
409: options |= XML_SAVE_NO_EMPTY;
410: }
411:
412: ret->options = options;
413: if (options & XML_SAVE_FORMAT)
414: ret->format = 1;
415: else if (options & XML_SAVE_WSNONSIG)
416: ret->format = 2;
417:
418: return(ret);
419: }
420:
421: /************************************************************************
422: * *
423: * Dumping XML tree content to a simple buffer *
424: * *
425: ************************************************************************/
426: /**
427: * xmlAttrSerializeContent:
428: * @buf: the XML buffer output
429: * @doc: the document
430: * @attr: the attribute pointer
431: *
432: * Serialize the attribute in the buffer
433: */
434: static void
435: xmlAttrSerializeContent(xmlOutputBufferPtr buf, xmlAttrPtr attr)
436: {
437: xmlNodePtr children;
438:
439: children = attr->children;
440: while (children != NULL) {
441: switch (children->type) {
442: case XML_TEXT_NODE:
443: xmlBufAttrSerializeTxtContent(buf->buffer, attr->doc,
444: attr, children->content);
445: break;
446: case XML_ENTITY_REF_NODE:
447: xmlBufAdd(buf->buffer, BAD_CAST "&", 1);
448: xmlBufAdd(buf->buffer, children->name,
449: xmlStrlen(children->name));
450: xmlBufAdd(buf->buffer, BAD_CAST ";", 1);
451: break;
452: default:
453: /* should not happen unless we have a badly built tree */
454: break;
455: }
456: children = children->next;
457: }
458: }
459:
460: /**
461: * xmlBufDumpNotationTable:
462: * @buf: an xmlBufPtr output
463: * @table: A notation table
464: *
465: * This will dump the content of the notation table as an XML DTD definition
466: */
467: void
468: xmlBufDumpNotationTable(xmlBufPtr buf, xmlNotationTablePtr table) {
469: xmlBufferPtr buffer;
470:
471: buffer = xmlBufferCreate();
472: if (buffer == NULL) {
473: /*
474: * TODO set the error in buf
475: */
476: return;
477: }
478: xmlDumpNotationTable(buffer, table);
479: xmlBufMergeBuffer(buf, buffer);
480: }
481:
482: /**
483: * xmlBufDumpElementDecl:
484: * @buf: an xmlBufPtr output
485: * @elem: An element table
486: *
487: * This will dump the content of the element declaration as an XML
488: * DTD definition
489: */
490: void
491: xmlBufDumpElementDecl(xmlBufPtr buf, xmlElementPtr elem) {
492: xmlBufferPtr buffer;
493:
494: buffer = xmlBufferCreate();
495: if (buffer == NULL) {
496: /*
497: * TODO set the error in buf
498: */
499: return;
500: }
501: xmlDumpElementDecl(buffer, elem);
502: xmlBufMergeBuffer(buf, buffer);
503: }
504:
505: /**
506: * xmlBufDumpAttributeDecl:
507: * @buf: an xmlBufPtr output
508: * @attr: An attribute declaration
509: *
510: * This will dump the content of the attribute declaration as an XML
511: * DTD definition
512: */
513: void
514: xmlBufDumpAttributeDecl(xmlBufPtr buf, xmlAttributePtr attr) {
515: xmlBufferPtr buffer;
516:
517: buffer = xmlBufferCreate();
518: if (buffer == NULL) {
519: /*
520: * TODO set the error in buf
521: */
522: return;
523: }
524: xmlDumpAttributeDecl(buffer, attr);
525: xmlBufMergeBuffer(buf, buffer);
526: }
527:
528: /**
529: * xmlBufDumpEntityDecl:
530: * @buf: an xmlBufPtr output
531: * @ent: An entity table
532: *
533: * This will dump the content of the entity table as an XML DTD definition
534: */
535: void
536: xmlBufDumpEntityDecl(xmlBufPtr buf, xmlEntityPtr ent) {
537: xmlBufferPtr buffer;
538:
539: buffer = xmlBufferCreate();
540: if (buffer == NULL) {
541: /*
542: * TODO set the error in buf
543: */
544: return;
545: }
546: xmlDumpEntityDecl(buffer, ent);
547: xmlBufMergeBuffer(buf, buffer);
548: }
549:
550: /************************************************************************
551: * *
552: * Dumping XML tree content to an I/O output buffer *
553: * *
554: ************************************************************************/
555:
556: static int xmlSaveSwitchEncoding(xmlSaveCtxtPtr ctxt, const char *encoding) {
557: xmlOutputBufferPtr buf = ctxt->buf;
558:
559: if ((encoding != NULL) && (buf->encoder == NULL) && (buf->conv == NULL)) {
560: buf->encoder = xmlFindCharEncodingHandler((const char *)encoding);
561: if (buf->encoder == NULL) {
562: xmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL,
563: (const char *)encoding);
564: return(-1);
565: }
566: buf->conv = xmlBufCreate();
567: if (buf->conv == NULL) {
568: xmlCharEncCloseFunc(buf->encoder);
569: xmlSaveErrMemory("creating encoding buffer");
570: return(-1);
571: }
572: /*
573: * initialize the state, e.g. if outputting a BOM
574: */
575: xmlCharEncOutput(buf, 1);
576: }
577: return(0);
578: }
579:
580: static int xmlSaveClearEncoding(xmlSaveCtxtPtr ctxt) {
581: xmlOutputBufferPtr buf = ctxt->buf;
582: xmlOutputBufferFlush(buf);
583: xmlCharEncCloseFunc(buf->encoder);
584: xmlBufFree(buf->conv);
585: buf->encoder = NULL;
586: buf->conv = NULL;
587: return(0);
588: }
589:
590: #ifdef LIBXML_HTML_ENABLED
591: static void
592: xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur);
593: #endif
594: static void xmlNodeListDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur);
595: static void xmlNodeDumpOutputInternal(xmlSaveCtxtPtr ctxt, xmlNodePtr cur);
596: void xmlNsListDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr cur);
597: static int xmlDocContentDumpOutput(xmlSaveCtxtPtr ctxt, xmlDocPtr cur);
598:
599: /**
600: * xmlOutputBufferWriteWSNonSig:
601: * @ctxt: The save context
602: * @extra: Number of extra indents to apply to ctxt->level
603: *
604: * Write out formatting for non-significant whitespace output.
605: */
606: static void
607: xmlOutputBufferWriteWSNonSig(xmlSaveCtxtPtr ctxt, int extra)
608: {
609: int i;
610: if ((ctxt == NULL) || (ctxt->buf == NULL))
611: return;
612: xmlOutputBufferWrite(ctxt->buf, 1, "\n");
613: for (i = 0; i < (ctxt->level + extra); i += ctxt->indent_nr) {
614: xmlOutputBufferWrite(ctxt->buf, ctxt->indent_size *
615: ((ctxt->level + extra - i) > ctxt->indent_nr ?
616: ctxt->indent_nr : (ctxt->level + extra - i)),
617: ctxt->indent);
618: }
619: }
620:
621: /**
622: * xmlNsDumpOutput:
623: * @buf: the XML buffer output
624: * @cur: a namespace
625: * @ctxt: the output save context. Optional.
626: *
627: * Dump a local Namespace definition.
628: * Should be called in the context of attributes dumps.
629: * If @ctxt is supplied, @buf should be its buffer.
630: */
631: static void
632: xmlNsDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr cur, xmlSaveCtxtPtr ctxt) {
633: if ((cur == NULL) || (buf == NULL)) return;
634: if ((cur->type == XML_LOCAL_NAMESPACE) && (cur->href != NULL)) {
635: if (xmlStrEqual(cur->prefix, BAD_CAST "xml"))
636: return;
637:
638: if (ctxt != NULL && ctxt->format == 2)
639: xmlOutputBufferWriteWSNonSig(ctxt, 2);
640: else
641: xmlOutputBufferWrite(buf, 1, " ");
642:
643: /* Within the context of an element attributes */
644: if (cur->prefix != NULL) {
645: xmlOutputBufferWrite(buf, 6, "xmlns:");
646: xmlOutputBufferWriteString(buf, (const char *)cur->prefix);
647: } else
648: xmlOutputBufferWrite(buf, 5, "xmlns");
649: xmlOutputBufferWrite(buf, 1, "=");
650: xmlBufWriteQuotedString(buf->buffer, cur->href);
651: }
652: }
653:
654: /**
655: * xmlNsDumpOutputCtxt
656: * @ctxt: the save context
657: * @cur: a namespace
658: *
659: * Dump a local Namespace definition to a save context.
660: * Should be called in the context of attribute dumps.
661: */
662: static void
663: xmlNsDumpOutputCtxt(xmlSaveCtxtPtr ctxt, xmlNsPtr cur) {
664: xmlNsDumpOutput(ctxt->buf, cur, ctxt);
665: }
666:
667: /**
668: * xmlNsListDumpOutputCtxt
669: * @ctxt: the save context
670: * @cur: the first namespace
671: *
672: * Dump a list of local namespace definitions to a save context.
673: * Should be called in the context of attribute dumps.
674: */
675: static void
676: xmlNsListDumpOutputCtxt(xmlSaveCtxtPtr ctxt, xmlNsPtr cur) {
677: while (cur != NULL) {
678: xmlNsDumpOutput(ctxt->buf, cur, ctxt);
679: cur = cur->next;
680: }
681: }
682:
683: /**
684: * xmlNsListDumpOutput:
685: * @buf: the XML buffer output
686: * @cur: the first namespace
687: *
688: * Dump a list of local Namespace definitions.
689: * Should be called in the context of attributes dumps.
690: */
691: void
692: xmlNsListDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr cur) {
693: while (cur != NULL) {
694: xmlNsDumpOutput(buf, cur, NULL);
695: cur = cur->next;
696: }
697: }
698:
699: /**
700: * xmlDtdDumpOutput:
701: * @buf: the XML buffer output
702: * @dtd: the pointer to the DTD
703: *
704: * Dump the XML document DTD, if any.
705: */
706: static void
707: xmlDtdDumpOutput(xmlSaveCtxtPtr ctxt, xmlDtdPtr dtd) {
708: xmlOutputBufferPtr buf;
709: int format, level;
710: xmlDocPtr doc;
711:
712: if (dtd == NULL) return;
713: if ((ctxt == NULL) || (ctxt->buf == NULL))
714: return;
715: buf = ctxt->buf;
716: xmlOutputBufferWrite(buf, 10, "<!DOCTYPE ");
717: xmlOutputBufferWriteString(buf, (const char *)dtd->name);
718: if (dtd->ExternalID != NULL) {
719: xmlOutputBufferWrite(buf, 8, " PUBLIC ");
720: xmlBufWriteQuotedString(buf->buffer, dtd->ExternalID);
721: xmlOutputBufferWrite(buf, 1, " ");
722: xmlBufWriteQuotedString(buf->buffer, dtd->SystemID);
723: } else if (dtd->SystemID != NULL) {
724: xmlOutputBufferWrite(buf, 8, " SYSTEM ");
725: xmlBufWriteQuotedString(buf->buffer, dtd->SystemID);
726: }
727: if ((dtd->entities == NULL) && (dtd->elements == NULL) &&
728: (dtd->attributes == NULL) && (dtd->notations == NULL) &&
729: (dtd->pentities == NULL)) {
730: xmlOutputBufferWrite(buf, 1, ">");
731: return;
732: }
733: xmlOutputBufferWrite(buf, 3, " [\n");
734: /*
735: * Dump the notations first they are not in the DTD children list
736: * Do this only on a standalone DTD or on the internal subset though.
737: */
738: if ((dtd->notations != NULL) && ((dtd->doc == NULL) ||
739: (dtd->doc->intSubset == dtd))) {
740: xmlBufDumpNotationTable(buf->buffer,
741: (xmlNotationTablePtr) dtd->notations);
742: }
743: format = ctxt->format;
744: level = ctxt->level;
745: doc = ctxt->doc;
746: ctxt->format = 0;
747: ctxt->level = -1;
748: ctxt->doc = dtd->doc;
749: xmlNodeListDumpOutput(ctxt, dtd->children);
750: ctxt->format = format;
751: ctxt->level = level;
752: ctxt->doc = doc;
753: xmlOutputBufferWrite(buf, 2, "]>");
754: }
755:
756: /**
757: * xmlAttrDumpOutput:
758: * @buf: the XML buffer output
759: * @cur: the attribute pointer
760: *
761: * Dump an XML attribute
762: */
763: static void
764: xmlAttrDumpOutput(xmlSaveCtxtPtr ctxt, xmlAttrPtr cur) {
765: xmlOutputBufferPtr buf;
766:
767: if (cur == NULL) return;
768: buf = ctxt->buf;
769: if (buf == NULL) return;
770: if (ctxt->format == 2)
771: xmlOutputBufferWriteWSNonSig(ctxt, 2);
772: else
773: xmlOutputBufferWrite(buf, 1, " ");
774: if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
775: xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
776: xmlOutputBufferWrite(buf, 1, ":");
777: }
778: xmlOutputBufferWriteString(buf, (const char *)cur->name);
779: xmlOutputBufferWrite(buf, 2, "=\"");
780: xmlAttrSerializeContent(buf, cur);
781: xmlOutputBufferWrite(buf, 1, "\"");
782: }
783:
784: /**
785: * xmlAttrListDumpOutput:
786: * @buf: the XML buffer output
787: * @doc: the document
788: * @cur: the first attribute pointer
789: * @encoding: an optional encoding string
790: *
791: * Dump a list of XML attributes
792: */
793: static void
794: xmlAttrListDumpOutput(xmlSaveCtxtPtr ctxt, xmlAttrPtr cur) {
795: if (cur == NULL) return;
796: while (cur != NULL) {
797: xmlAttrDumpOutput(ctxt, cur);
798: cur = cur->next;
799: }
800: }
801:
802:
803:
804: /**
805: * xmlNodeListDumpOutput:
806: * @cur: the first node
807: *
808: * Dump an XML node list, recursive behaviour, children are printed too.
809: */
810: static void
811: xmlNodeListDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur) {
812: xmlOutputBufferPtr buf;
813:
814: if (cur == NULL) return;
815: buf = ctxt->buf;
816: while (cur != NULL) {
817: if ((ctxt->format == 1) && (xmlIndentTreeOutput) &&
818: ((cur->type == XML_ELEMENT_NODE) ||
819: (cur->type == XML_COMMENT_NODE) ||
820: (cur->type == XML_PI_NODE)))
821: xmlOutputBufferWrite(buf, ctxt->indent_size *
822: (ctxt->level > ctxt->indent_nr ?
823: ctxt->indent_nr : ctxt->level),
824: ctxt->indent);
825: xmlNodeDumpOutputInternal(ctxt, cur);
826: if (ctxt->format == 1) {
827: xmlOutputBufferWrite(buf, 1, "\n");
828: }
829: cur = cur->next;
830: }
831: }
832:
833: #ifdef LIBXML_HTML_ENABLED
834: /**
835: * xmlNodeDumpOutputInternal:
836: * @cur: the current node
837: *
838: * Dump an HTML node, recursive behaviour, children are printed too.
839: */
840: static int
841: htmlNodeDumpOutputInternal(xmlSaveCtxtPtr ctxt, xmlNodePtr cur) {
842: const xmlChar *oldenc = NULL;
843: const xmlChar *oldctxtenc = ctxt->encoding;
844: const xmlChar *encoding = ctxt->encoding;
845: xmlOutputBufferPtr buf = ctxt->buf;
846: int switched_encoding = 0;
847: xmlDocPtr doc;
848:
849: xmlInitParser();
850:
851: doc = cur->doc;
852: if (doc != NULL) {
853: oldenc = doc->encoding;
854: if (ctxt->encoding != NULL) {
855: doc->encoding = BAD_CAST ctxt->encoding;
856: } else if (doc->encoding != NULL) {
857: encoding = doc->encoding;
858: }
859: }
860:
861: if ((encoding != NULL) && (doc != NULL))
862: htmlSetMetaEncoding(doc, (const xmlChar *) encoding);
863: if ((encoding == NULL) && (doc != NULL))
864: encoding = htmlGetMetaEncoding(doc);
865: if (encoding == NULL)
866: encoding = BAD_CAST "HTML";
867: if ((encoding != NULL) && (oldctxtenc == NULL) &&
868: (buf->encoder == NULL) && (buf->conv == NULL)) {
869: if (xmlSaveSwitchEncoding(ctxt, (const char*) encoding) < 0) {
870: doc->encoding = oldenc;
871: return(-1);
872: }
873: switched_encoding = 1;
874: }
875: if (ctxt->options & XML_SAVE_FORMAT)
876: htmlNodeDumpFormatOutput(buf, doc, cur,
877: (const char *)encoding, 1);
878: else
879: htmlNodeDumpFormatOutput(buf, doc, cur,
880: (const char *)encoding, 0);
881: /*
882: * Restore the state of the saving context at the end of the document
883: */
884: if ((switched_encoding) && (oldctxtenc == NULL)) {
885: xmlSaveClearEncoding(ctxt);
886: }
887: if (doc != NULL)
888: doc->encoding = oldenc;
889: return(0);
890: }
891: #endif
892:
893: /**
894: * xmlNodeDumpOutputInternal:
895: * @cur: the current node
896: *
897: * Dump an XML node, recursive behaviour, children are printed too.
898: */
899: static void
900: xmlNodeDumpOutputInternal(xmlSaveCtxtPtr ctxt, xmlNodePtr cur) {
901: int format;
902: xmlNodePtr tmp;
903: xmlChar *start, *end;
904: xmlOutputBufferPtr buf;
905:
906: if (cur == NULL) return;
907: buf = ctxt->buf;
908: if (cur->type == XML_XINCLUDE_START)
909: return;
910: if (cur->type == XML_XINCLUDE_END)
911: return;
912: if ((cur->type == XML_DOCUMENT_NODE) ||
913: (cur->type == XML_HTML_DOCUMENT_NODE)) {
914: xmlDocContentDumpOutput(ctxt, (xmlDocPtr) cur);
915: return;
916: }
917: #ifdef LIBXML_HTML_ENABLED
918: if (ctxt->options & XML_SAVE_XHTML) {
919: xhtmlNodeDumpOutput(ctxt, cur);
920: return;
921: }
922: if (((cur->type != XML_NAMESPACE_DECL) && (cur->doc != NULL) &&
923: (cur->doc->type == XML_HTML_DOCUMENT_NODE) &&
924: ((ctxt->options & XML_SAVE_AS_XML) == 0)) ||
925: (ctxt->options & XML_SAVE_AS_HTML)) {
926: htmlNodeDumpOutputInternal(ctxt, cur);
927: return;
928: }
929: #endif
930: if (cur->type == XML_DTD_NODE) {
931: xmlDtdDumpOutput(ctxt, (xmlDtdPtr) cur);
932: return;
933: }
934: if (cur->type == XML_DOCUMENT_FRAG_NODE) {
935: xmlNodeListDumpOutput(ctxt, cur->children);
936: return;
937: }
938: if (cur->type == XML_ELEMENT_DECL) {
939: xmlBufDumpElementDecl(buf->buffer, (xmlElementPtr) cur);
940: return;
941: }
942: if (cur->type == XML_ATTRIBUTE_DECL) {
943: xmlBufDumpAttributeDecl(buf->buffer, (xmlAttributePtr) cur);
944: return;
945: }
946: if (cur->type == XML_ENTITY_DECL) {
947: xmlBufDumpEntityDecl(buf->buffer, (xmlEntityPtr) cur);
948: return;
949: }
950: if (cur->type == XML_TEXT_NODE) {
951: if (cur->content != NULL) {
952: if (cur->name != xmlStringTextNoenc) {
953: xmlOutputBufferWriteEscape(buf, cur->content, ctxt->escape);
954: } else {
955: /*
956: * Disable escaping, needed for XSLT
957: */
958: xmlOutputBufferWriteString(buf, (const char *) cur->content);
959: }
960: }
961:
962: return;
963: }
964: if (cur->type == XML_PI_NODE) {
965: if (cur->content != NULL) {
966: xmlOutputBufferWrite(buf, 2, "<?");
967: xmlOutputBufferWriteString(buf, (const char *)cur->name);
968: if (cur->content != NULL) {
969: if (ctxt->format == 2)
970: xmlOutputBufferWriteWSNonSig(ctxt, 0);
971: else
972: xmlOutputBufferWrite(buf, 1, " ");
973: xmlOutputBufferWriteString(buf, (const char *)cur->content);
974: }
975: xmlOutputBufferWrite(buf, 2, "?>");
976: } else {
977: xmlOutputBufferWrite(buf, 2, "<?");
978: xmlOutputBufferWriteString(buf, (const char *)cur->name);
979: if (ctxt->format == 2)
980: xmlOutputBufferWriteWSNonSig(ctxt, 0);
981: xmlOutputBufferWrite(buf, 2, "?>");
982: }
983: return;
984: }
985: if (cur->type == XML_COMMENT_NODE) {
986: if (cur->content != NULL) {
987: xmlOutputBufferWrite(buf, 4, "<!--");
988: xmlOutputBufferWriteString(buf, (const char *)cur->content);
989: xmlOutputBufferWrite(buf, 3, "-->");
990: }
991: return;
992: }
993: if (cur->type == XML_ENTITY_REF_NODE) {
994: xmlOutputBufferWrite(buf, 1, "&");
995: xmlOutputBufferWriteString(buf, (const char *)cur->name);
996: xmlOutputBufferWrite(buf, 1, ";");
997: return;
998: }
999: if (cur->type == XML_CDATA_SECTION_NODE) {
1000: if (cur->content == NULL || *cur->content == '\0') {
1001: xmlOutputBufferWrite(buf, 12, "<![CDATA[]]>");
1002: } else {
1003: start = end = cur->content;
1004: while (*end != '\0') {
1005: if ((*end == ']') && (*(end + 1) == ']') &&
1006: (*(end + 2) == '>')) {
1007: end = end + 2;
1008: xmlOutputBufferWrite(buf, 9, "<![CDATA[");
1009: xmlOutputBufferWrite(buf, end - start, (const char *)start);
1010: xmlOutputBufferWrite(buf, 3, "]]>");
1011: start = end;
1012: }
1013: end++;
1014: }
1015: if (start != end) {
1016: xmlOutputBufferWrite(buf, 9, "<![CDATA[");
1017: xmlOutputBufferWriteString(buf, (const char *)start);
1018: xmlOutputBufferWrite(buf, 3, "]]>");
1019: }
1020: }
1021: return;
1022: }
1023: if (cur->type == XML_ATTRIBUTE_NODE) {
1024: xmlAttrDumpOutput(ctxt, (xmlAttrPtr) cur);
1025: return;
1026: }
1027: if (cur->type == XML_NAMESPACE_DECL) {
1028: xmlNsDumpOutputCtxt(ctxt, (xmlNsPtr) cur);
1029: return;
1030: }
1031:
1032: format = ctxt->format;
1033: if (format == 1) {
1034: tmp = cur->children;
1035: while (tmp != NULL) {
1036: if ((tmp->type == XML_TEXT_NODE) ||
1037: (tmp->type == XML_CDATA_SECTION_NODE) ||
1038: (tmp->type == XML_ENTITY_REF_NODE)) {
1039: ctxt->format = 0;
1040: break;
1041: }
1042: tmp = tmp->next;
1043: }
1044: }
1045: xmlOutputBufferWrite(buf, 1, "<");
1046: if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
1047: xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
1048: xmlOutputBufferWrite(buf, 1, ":");
1049: }
1050:
1051: xmlOutputBufferWriteString(buf, (const char *)cur->name);
1052: if (cur->nsDef)
1053: xmlNsListDumpOutputCtxt(ctxt, cur->nsDef);
1054: if (cur->properties != NULL)
1055: xmlAttrListDumpOutput(ctxt, cur->properties);
1056:
1057: if (((cur->type == XML_ELEMENT_NODE) || (cur->content == NULL)) &&
1058: (cur->children == NULL) && ((ctxt->options & XML_SAVE_NO_EMPTY) == 0)) {
1059: if (ctxt->format == 2)
1060: xmlOutputBufferWriteWSNonSig(ctxt, 0);
1061: xmlOutputBufferWrite(buf, 2, "/>");
1062: ctxt->format = format;
1063: return;
1064: }
1065: if (ctxt->format == 2)
1066: xmlOutputBufferWriteWSNonSig(ctxt, 1);
1067: xmlOutputBufferWrite(buf, 1, ">");
1068: if ((cur->type != XML_ELEMENT_NODE) && (cur->content != NULL)) {
1069: xmlOutputBufferWriteEscape(buf, cur->content, ctxt->escape);
1070: }
1071: if (cur->children != NULL) {
1072: if (ctxt->format == 1) xmlOutputBufferWrite(buf, 1, "\n");
1073: if (ctxt->level >= 0) ctxt->level++;
1074: xmlNodeListDumpOutput(ctxt, cur->children);
1075: if (ctxt->level > 0) ctxt->level--;
1076: if ((xmlIndentTreeOutput) && (ctxt->format == 1))
1077: xmlOutputBufferWrite(buf, ctxt->indent_size *
1078: (ctxt->level > ctxt->indent_nr ?
1079: ctxt->indent_nr : ctxt->level),
1080: ctxt->indent);
1081: }
1082: xmlOutputBufferWrite(buf, 2, "</");
1083: if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
1084: xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
1085: xmlOutputBufferWrite(buf, 1, ":");
1086: }
1087:
1088: xmlOutputBufferWriteString(buf, (const char *)cur->name);
1089: if (ctxt->format == 2)
1090: xmlOutputBufferWriteWSNonSig(ctxt, 0);
1091: xmlOutputBufferWrite(buf, 1, ">");
1092: ctxt->format = format;
1093: }
1094:
1095: /**
1096: * xmlDocContentDumpOutput:
1097: * @cur: the document
1098: *
1099: * Dump an XML document.
1100: */
1101: static int
1102: xmlDocContentDumpOutput(xmlSaveCtxtPtr ctxt, xmlDocPtr cur) {
1103: #ifdef LIBXML_HTML_ENABLED
1104: xmlDtdPtr dtd;
1105: int is_xhtml = 0;
1106: #endif
1107: const xmlChar *oldenc = cur->encoding;
1108: const xmlChar *oldctxtenc = ctxt->encoding;
1109: const xmlChar *encoding = ctxt->encoding;
1110: xmlCharEncodingOutputFunc oldescape = ctxt->escape;
1111: xmlCharEncodingOutputFunc oldescapeAttr = ctxt->escapeAttr;
1112: xmlOutputBufferPtr buf = ctxt->buf;
1113: xmlCharEncoding enc;
1114: int switched_encoding = 0;
1115:
1116: xmlInitParser();
1117:
1118: if ((cur->type != XML_HTML_DOCUMENT_NODE) &&
1119: (cur->type != XML_DOCUMENT_NODE))
1120: return(-1);
1121:
1122: if (ctxt->encoding != NULL) {
1123: cur->encoding = BAD_CAST ctxt->encoding;
1124: } else if (cur->encoding != NULL) {
1125: encoding = cur->encoding;
1126: } else if (cur->charset != XML_CHAR_ENCODING_UTF8) {
1127: encoding = (const xmlChar *)
1128: xmlGetCharEncodingName((xmlCharEncoding) cur->charset);
1129: }
1130:
1131: if (((cur->type == XML_HTML_DOCUMENT_NODE) &&
1132: ((ctxt->options & XML_SAVE_AS_XML) == 0) &&
1133: ((ctxt->options & XML_SAVE_XHTML) == 0)) ||
1134: (ctxt->options & XML_SAVE_AS_HTML)) {
1135: #ifdef LIBXML_HTML_ENABLED
1136: if (encoding != NULL)
1137: htmlSetMetaEncoding(cur, (const xmlChar *) encoding);
1138: if (encoding == NULL)
1139: encoding = htmlGetMetaEncoding(cur);
1140: if (encoding == NULL)
1141: encoding = BAD_CAST "HTML";
1142: if ((encoding != NULL) && (oldctxtenc == NULL) &&
1143: (buf->encoder == NULL) && (buf->conv == NULL)) {
1144: if (xmlSaveSwitchEncoding(ctxt, (const char*) encoding) < 0) {
1145: cur->encoding = oldenc;
1146: return(-1);
1147: }
1148: }
1149: if (ctxt->options & XML_SAVE_FORMAT)
1150: htmlDocContentDumpFormatOutput(buf, cur,
1151: (const char *)encoding, 1);
1152: else
1153: htmlDocContentDumpFormatOutput(buf, cur,
1154: (const char *)encoding, 0);
1155: if (ctxt->encoding != NULL)
1156: cur->encoding = oldenc;
1157: return(0);
1158: #else
1159: return(-1);
1160: #endif
1161: } else if ((cur->type == XML_DOCUMENT_NODE) ||
1162: (ctxt->options & XML_SAVE_AS_XML) ||
1163: (ctxt->options & XML_SAVE_XHTML)) {
1164: enc = xmlParseCharEncoding((const char*) encoding);
1165: if ((encoding != NULL) && (oldctxtenc == NULL) &&
1166: (buf->encoder == NULL) && (buf->conv == NULL) &&
1167: ((ctxt->options & XML_SAVE_NO_DECL) == 0)) {
1168: if ((enc != XML_CHAR_ENCODING_UTF8) &&
1169: (enc != XML_CHAR_ENCODING_NONE) &&
1170: (enc != XML_CHAR_ENCODING_ASCII)) {
1171: /*
1172: * we need to switch to this encoding but just for this
1173: * document since we output the XMLDecl the conversion
1174: * must be done to not generate not well formed documents.
1175: */
1176: if (xmlSaveSwitchEncoding(ctxt, (const char*) encoding) < 0) {
1177: cur->encoding = oldenc;
1178: return(-1);
1179: }
1180: switched_encoding = 1;
1181: }
1182: if (ctxt->escape == xmlEscapeEntities)
1183: ctxt->escape = NULL;
1184: if (ctxt->escapeAttr == xmlEscapeEntities)
1185: ctxt->escapeAttr = NULL;
1186: }
1187:
1188:
1189: /*
1190: * Save the XML declaration
1191: */
1192: if ((ctxt->options & XML_SAVE_NO_DECL) == 0) {
1193: xmlOutputBufferWrite(buf, 14, "<?xml version=");
1194: if (cur->version != NULL)
1195: xmlBufWriteQuotedString(buf->buffer, cur->version);
1196: else
1197: xmlOutputBufferWrite(buf, 5, "\"1.0\"");
1198: if (encoding != NULL) {
1199: xmlOutputBufferWrite(buf, 10, " encoding=");
1200: xmlBufWriteQuotedString(buf->buffer, (xmlChar *) encoding);
1201: }
1202: switch (cur->standalone) {
1203: case 0:
1204: xmlOutputBufferWrite(buf, 16, " standalone=\"no\"");
1205: break;
1206: case 1:
1207: xmlOutputBufferWrite(buf, 17, " standalone=\"yes\"");
1208: break;
1209: }
1210: xmlOutputBufferWrite(buf, 3, "?>\n");
1211: }
1212:
1213: #ifdef LIBXML_HTML_ENABLED
1214: if (ctxt->options & XML_SAVE_XHTML)
1215: is_xhtml = 1;
1216: if ((ctxt->options & XML_SAVE_NO_XHTML) == 0) {
1217: dtd = xmlGetIntSubset(cur);
1218: if (dtd != NULL) {
1219: is_xhtml = xmlIsXHTML(dtd->SystemID, dtd->ExternalID);
1220: if (is_xhtml < 0) is_xhtml = 0;
1221: }
1222: }
1223: #endif
1224: if (cur->children != NULL) {
1225: xmlNodePtr child = cur->children;
1226:
1227: while (child != NULL) {
1228: ctxt->level = 0;
1229: #ifdef LIBXML_HTML_ENABLED
1230: if (is_xhtml)
1231: xhtmlNodeDumpOutput(ctxt, child);
1232: else
1233: #endif
1234: xmlNodeDumpOutputInternal(ctxt, child);
1235: xmlOutputBufferWrite(buf, 1, "\n");
1236: child = child->next;
1237: }
1238: }
1239: }
1240:
1241: /*
1242: * Restore the state of the saving context at the end of the document
1243: */
1244: if ((switched_encoding) && (oldctxtenc == NULL)) {
1245: xmlSaveClearEncoding(ctxt);
1246: ctxt->escape = oldescape;
1247: ctxt->escapeAttr = oldescapeAttr;
1248: }
1249: cur->encoding = oldenc;
1250: return(0);
1251: }
1252:
1253: #ifdef LIBXML_HTML_ENABLED
1254: /************************************************************************
1255: * *
1256: * Functions specific to XHTML serialization *
1257: * *
1258: ************************************************************************/
1259:
1260: /**
1261: * xhtmlIsEmpty:
1262: * @node: the node
1263: *
1264: * Check if a node is an empty xhtml node
1265: *
1266: * Returns 1 if the node is an empty node, 0 if not and -1 in case of error
1267: */
1268: static int
1269: xhtmlIsEmpty(xmlNodePtr node) {
1270: if (node == NULL)
1271: return(-1);
1272: if (node->type != XML_ELEMENT_NODE)
1273: return(0);
1274: if ((node->ns != NULL) && (!xmlStrEqual(node->ns->href, XHTML_NS_NAME)))
1275: return(0);
1276: if (node->children != NULL)
1277: return(0);
1278: switch (node->name[0]) {
1279: case 'a':
1280: if (xmlStrEqual(node->name, BAD_CAST "area"))
1281: return(1);
1282: return(0);
1283: case 'b':
1284: if (xmlStrEqual(node->name, BAD_CAST "br"))
1285: return(1);
1286: if (xmlStrEqual(node->name, BAD_CAST "base"))
1287: return(1);
1288: if (xmlStrEqual(node->name, BAD_CAST "basefont"))
1289: return(1);
1290: return(0);
1291: case 'c':
1292: if (xmlStrEqual(node->name, BAD_CAST "col"))
1293: return(1);
1294: return(0);
1295: case 'f':
1296: if (xmlStrEqual(node->name, BAD_CAST "frame"))
1297: return(1);
1298: return(0);
1299: case 'h':
1300: if (xmlStrEqual(node->name, BAD_CAST "hr"))
1301: return(1);
1302: return(0);
1303: case 'i':
1304: if (xmlStrEqual(node->name, BAD_CAST "img"))
1305: return(1);
1306: if (xmlStrEqual(node->name, BAD_CAST "input"))
1307: return(1);
1308: if (xmlStrEqual(node->name, BAD_CAST "isindex"))
1309: return(1);
1310: return(0);
1311: case 'l':
1312: if (xmlStrEqual(node->name, BAD_CAST "link"))
1313: return(1);
1314: return(0);
1315: case 'm':
1316: if (xmlStrEqual(node->name, BAD_CAST "meta"))
1317: return(1);
1318: return(0);
1319: case 'p':
1320: if (xmlStrEqual(node->name, BAD_CAST "param"))
1321: return(1);
1322: return(0);
1323: }
1324: return(0);
1325: }
1326:
1327: /**
1328: * xhtmlAttrListDumpOutput:
1329: * @cur: the first attribute pointer
1330: *
1331: * Dump a list of XML attributes
1332: */
1333: static void
1334: xhtmlAttrListDumpOutput(xmlSaveCtxtPtr ctxt, xmlAttrPtr cur) {
1335: xmlAttrPtr xml_lang = NULL;
1336: xmlAttrPtr lang = NULL;
1337: xmlAttrPtr name = NULL;
1338: xmlAttrPtr id = NULL;
1339: xmlNodePtr parent;
1340: xmlOutputBufferPtr buf;
1341:
1342: if (cur == NULL) return;
1343: buf = ctxt->buf;
1344: parent = cur->parent;
1345: while (cur != NULL) {
1346: if ((cur->ns == NULL) && (xmlStrEqual(cur->name, BAD_CAST "id")))
1347: id = cur;
1348: else
1349: if ((cur->ns == NULL) && (xmlStrEqual(cur->name, BAD_CAST "name")))
1350: name = cur;
1351: else
1352: if ((cur->ns == NULL) && (xmlStrEqual(cur->name, BAD_CAST "lang")))
1353: lang = cur;
1354: else
1355: if ((cur->ns != NULL) && (xmlStrEqual(cur->name, BAD_CAST "lang")) &&
1356: (xmlStrEqual(cur->ns->prefix, BAD_CAST "xml")))
1357: xml_lang = cur;
1358: else if ((cur->ns == NULL) &&
1359: ((cur->children == NULL) ||
1360: (cur->children->content == NULL) ||
1361: (cur->children->content[0] == 0)) &&
1362: (htmlIsBooleanAttr(cur->name))) {
1363: if (cur->children != NULL)
1364: xmlFreeNode(cur->children);
1365: cur->children = xmlNewText(cur->name);
1366: if (cur->children != NULL)
1367: cur->children->parent = (xmlNodePtr) cur;
1368: }
1369: xmlAttrDumpOutput(ctxt, cur);
1370: cur = cur->next;
1371: }
1372: /*
1373: * C.8
1374: */
1375: if ((name != NULL) && (id == NULL)) {
1376: if ((parent != NULL) && (parent->name != NULL) &&
1377: ((xmlStrEqual(parent->name, BAD_CAST "a")) ||
1378: (xmlStrEqual(parent->name, BAD_CAST "p")) ||
1379: (xmlStrEqual(parent->name, BAD_CAST "div")) ||
1380: (xmlStrEqual(parent->name, BAD_CAST "img")) ||
1381: (xmlStrEqual(parent->name, BAD_CAST "map")) ||
1382: (xmlStrEqual(parent->name, BAD_CAST "applet")) ||
1383: (xmlStrEqual(parent->name, BAD_CAST "form")) ||
1384: (xmlStrEqual(parent->name, BAD_CAST "frame")) ||
1385: (xmlStrEqual(parent->name, BAD_CAST "iframe")))) {
1386: xmlOutputBufferWrite(buf, 5, " id=\"");
1387: xmlAttrSerializeContent(buf, name);
1388: xmlOutputBufferWrite(buf, 1, "\"");
1389: }
1390: }
1391: /*
1392: * C.7.
1393: */
1394: if ((lang != NULL) && (xml_lang == NULL)) {
1395: xmlOutputBufferWrite(buf, 11, " xml:lang=\"");
1396: xmlAttrSerializeContent(buf, lang);
1397: xmlOutputBufferWrite(buf, 1, "\"");
1398: } else
1399: if ((xml_lang != NULL) && (lang == NULL)) {
1400: xmlOutputBufferWrite(buf, 7, " lang=\"");
1401: xmlAttrSerializeContent(buf, xml_lang);
1402: xmlOutputBufferWrite(buf, 1, "\"");
1403: }
1404: }
1405:
1406: /**
1407: * xhtmlNodeListDumpOutput:
1408: * @buf: the XML buffer output
1409: * @doc: the XHTML document
1410: * @cur: the first node
1411: * @level: the imbrication level for indenting
1412: * @format: is formatting allowed
1413: * @encoding: an optional encoding string
1414: *
1415: * Dump an XML node list, recursive behaviour, children are printed too.
1416: * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
1417: * or xmlKeepBlanksDefault(0) was called
1418: */
1419: static void
1420: xhtmlNodeListDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur) {
1421: xmlOutputBufferPtr buf;
1422:
1423: if (cur == NULL) return;
1424: buf = ctxt->buf;
1425: while (cur != NULL) {
1426: if ((ctxt->format == 1) && (xmlIndentTreeOutput) &&
1427: (cur->type == XML_ELEMENT_NODE))
1428: xmlOutputBufferWrite(buf, ctxt->indent_size *
1429: (ctxt->level > ctxt->indent_nr ?
1430: ctxt->indent_nr : ctxt->level),
1431: ctxt->indent);
1432: xhtmlNodeDumpOutput(ctxt, cur);
1433: if (ctxt->format == 1) {
1434: xmlOutputBufferWrite(buf, 1, "\n");
1435: }
1436: cur = cur->next;
1437: }
1438: }
1439:
1440: /**
1441: * xhtmlNodeDumpOutput:
1442: * @buf: the XML buffer output
1443: * @doc: the XHTML document
1444: * @cur: the current node
1445: * @level: the imbrication level for indenting
1446: * @format: is formatting allowed
1447: * @encoding: an optional encoding string
1448: *
1449: * Dump an XHTML node, recursive behaviour, children are printed too.
1450: */
1451: static void
1452: xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur) {
1453: int format, addmeta = 0;
1454: xmlNodePtr tmp;
1455: xmlChar *start, *end;
1456: xmlOutputBufferPtr buf;
1457:
1458: if (cur == NULL) return;
1459: if ((cur->type == XML_DOCUMENT_NODE) ||
1460: (cur->type == XML_HTML_DOCUMENT_NODE)) {
1461: xmlDocContentDumpOutput(ctxt, (xmlDocPtr) cur);
1462: return;
1463: }
1464: if (cur->type == XML_XINCLUDE_START)
1465: return;
1466: if (cur->type == XML_XINCLUDE_END)
1467: return;
1468: if (cur->type == XML_NAMESPACE_DECL) {
1469: xmlNsDumpOutputCtxt(ctxt, (xmlNsPtr) cur);
1470: return;
1471: }
1472: if (cur->type == XML_DTD_NODE) {
1473: xmlDtdDumpOutput(ctxt, (xmlDtdPtr) cur);
1474: return;
1475: }
1476: if (cur->type == XML_DOCUMENT_FRAG_NODE) {
1477: xhtmlNodeListDumpOutput(ctxt, cur->children);
1478: return;
1479: }
1480: buf = ctxt->buf;
1481: if (cur->type == XML_ELEMENT_DECL) {
1482: xmlBufDumpElementDecl(buf->buffer, (xmlElementPtr) cur);
1483: return;
1484: }
1485: if (cur->type == XML_ATTRIBUTE_DECL) {
1486: xmlBufDumpAttributeDecl(buf->buffer, (xmlAttributePtr) cur);
1487: return;
1488: }
1489: if (cur->type == XML_ENTITY_DECL) {
1490: xmlBufDumpEntityDecl(buf->buffer, (xmlEntityPtr) cur);
1491: return;
1492: }
1493: if (cur->type == XML_TEXT_NODE) {
1494: if (cur->content != NULL) {
1495: if ((cur->name == xmlStringText) ||
1496: (cur->name != xmlStringTextNoenc)) {
1497: xmlOutputBufferWriteEscape(buf, cur->content, ctxt->escape);
1498: } else {
1499: /*
1500: * Disable escaping, needed for XSLT
1501: */
1502: xmlOutputBufferWriteString(buf, (const char *) cur->content);
1503: }
1504: }
1505:
1506: return;
1507: }
1508: if (cur->type == XML_PI_NODE) {
1509: if (cur->content != NULL) {
1510: xmlOutputBufferWrite(buf, 2, "<?");
1511: xmlOutputBufferWriteString(buf, (const char *)cur->name);
1512: if (cur->content != NULL) {
1513: xmlOutputBufferWrite(buf, 1, " ");
1514: xmlOutputBufferWriteString(buf, (const char *)cur->content);
1515: }
1516: xmlOutputBufferWrite(buf, 2, "?>");
1517: } else {
1518: xmlOutputBufferWrite(buf, 2, "<?");
1519: xmlOutputBufferWriteString(buf, (const char *)cur->name);
1520: xmlOutputBufferWrite(buf, 2, "?>");
1521: }
1522: return;
1523: }
1524: if (cur->type == XML_COMMENT_NODE) {
1525: if (cur->content != NULL) {
1526: xmlOutputBufferWrite(buf, 4, "<!--");
1527: xmlOutputBufferWriteString(buf, (const char *)cur->content);
1528: xmlOutputBufferWrite(buf, 3, "-->");
1529: }
1530: return;
1531: }
1532: if (cur->type == XML_ENTITY_REF_NODE) {
1533: xmlOutputBufferWrite(buf, 1, "&");
1534: xmlOutputBufferWriteString(buf, (const char *)cur->name);
1535: xmlOutputBufferWrite(buf, 1, ";");
1536: return;
1537: }
1538: if (cur->type == XML_CDATA_SECTION_NODE) {
1539: if (cur->content == NULL || *cur->content == '\0') {
1540: xmlOutputBufferWrite(buf, 12, "<![CDATA[]]>");
1541: } else {
1542: start = end = cur->content;
1543: while (*end != '\0') {
1544: if (*end == ']' && *(end + 1) == ']' && *(end + 2) == '>') {
1545: end = end + 2;
1546: xmlOutputBufferWrite(buf, 9, "<![CDATA[");
1547: xmlOutputBufferWrite(buf, end - start, (const char *)start);
1548: xmlOutputBufferWrite(buf, 3, "]]>");
1549: start = end;
1550: }
1551: end++;
1552: }
1553: if (start != end) {
1554: xmlOutputBufferWrite(buf, 9, "<![CDATA[");
1555: xmlOutputBufferWriteString(buf, (const char *)start);
1556: xmlOutputBufferWrite(buf, 3, "]]>");
1557: }
1558: }
1559: return;
1560: }
1561: if (cur->type == XML_ATTRIBUTE_NODE) {
1562: xmlAttrDumpOutput(ctxt, (xmlAttrPtr) cur);
1563: return;
1564: }
1565:
1566: format = ctxt->format;
1567: if (format == 1) {
1568: tmp = cur->children;
1569: while (tmp != NULL) {
1570: if ((tmp->type == XML_TEXT_NODE) ||
1571: (tmp->type == XML_ENTITY_REF_NODE)) {
1572: format = 0;
1573: break;
1574: }
1575: tmp = tmp->next;
1576: }
1577: }
1578: xmlOutputBufferWrite(buf, 1, "<");
1579: if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
1580: xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
1581: xmlOutputBufferWrite(buf, 1, ":");
1582: }
1583:
1584: xmlOutputBufferWriteString(buf, (const char *)cur->name);
1585: if (cur->nsDef)
1586: xmlNsListDumpOutputCtxt(ctxt, cur->nsDef);
1587: if ((xmlStrEqual(cur->name, BAD_CAST "html") &&
1588: (cur->ns == NULL) && (cur->nsDef == NULL))) {
1589: /*
1590: * 3.1.1. Strictly Conforming Documents A.3.1.1 3/
1591: */
1592: xmlOutputBufferWriteString(buf,
1593: " xmlns=\"http://www.w3.org/1999/xhtml\"");
1594: }
1595: if (cur->properties != NULL)
1596: xhtmlAttrListDumpOutput(ctxt, cur->properties);
1597:
1598: if ((cur->type == XML_ELEMENT_NODE) &&
1599: (cur->parent != NULL) &&
1600: (cur->parent->parent == (xmlNodePtr) cur->doc) &&
1601: xmlStrEqual(cur->name, BAD_CAST"head") &&
1602: xmlStrEqual(cur->parent->name, BAD_CAST"html")) {
1603:
1604: tmp = cur->children;
1605: while (tmp != NULL) {
1606: if (xmlStrEqual(tmp->name, BAD_CAST"meta")) {
1607: xmlChar *httpequiv;
1608:
1609: httpequiv = xmlGetProp(tmp, BAD_CAST"http-equiv");
1610: if (httpequiv != NULL) {
1611: if (xmlStrcasecmp(httpequiv, BAD_CAST"Content-Type") == 0) {
1612: xmlFree(httpequiv);
1613: break;
1614: }
1615: xmlFree(httpequiv);
1616: }
1617: }
1618: tmp = tmp->next;
1619: }
1620: if (tmp == NULL)
1621: addmeta = 1;
1622: }
1623:
1624: if ((cur->type == XML_ELEMENT_NODE) && (cur->children == NULL)) {
1625: if (((cur->ns == NULL) || (cur->ns->prefix == NULL)) &&
1626: ((xhtmlIsEmpty(cur) == 1) && (addmeta == 0))) {
1627: /*
1628: * C.2. Empty Elements
1629: */
1630: xmlOutputBufferWrite(buf, 3, " />");
1631: } else {
1632: if (addmeta == 1) {
1633: xmlOutputBufferWrite(buf, 1, ">");
1634: if (ctxt->format == 1) {
1635: xmlOutputBufferWrite(buf, 1, "\n");
1636: if (xmlIndentTreeOutput)
1637: xmlOutputBufferWrite(buf, ctxt->indent_size *
1638: (ctxt->level + 1 > ctxt->indent_nr ?
1639: ctxt->indent_nr : ctxt->level + 1), ctxt->indent);
1640: }
1641: xmlOutputBufferWriteString(buf,
1642: "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=");
1643: if (ctxt->encoding) {
1644: xmlOutputBufferWriteString(buf, (const char *)ctxt->encoding);
1645: } else {
1646: xmlOutputBufferWrite(buf, 5, "UTF-8");
1647: }
1648: xmlOutputBufferWrite(buf, 4, "\" />");
1649: if (ctxt->format == 1)
1650: xmlOutputBufferWrite(buf, 1, "\n");
1651: } else {
1652: xmlOutputBufferWrite(buf, 1, ">");
1653: }
1654: /*
1655: * C.3. Element Minimization and Empty Element Content
1656: */
1657: xmlOutputBufferWrite(buf, 2, "</");
1658: if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
1659: xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
1660: xmlOutputBufferWrite(buf, 1, ":");
1661: }
1662: xmlOutputBufferWriteString(buf, (const char *)cur->name);
1663: xmlOutputBufferWrite(buf, 1, ">");
1664: }
1665: return;
1666: }
1667: xmlOutputBufferWrite(buf, 1, ">");
1668: if (addmeta == 1) {
1669: if (ctxt->format == 1) {
1670: xmlOutputBufferWrite(buf, 1, "\n");
1671: if (xmlIndentTreeOutput)
1672: xmlOutputBufferWrite(buf, ctxt->indent_size *
1673: (ctxt->level + 1 > ctxt->indent_nr ?
1674: ctxt->indent_nr : ctxt->level + 1), ctxt->indent);
1675: }
1676: xmlOutputBufferWriteString(buf,
1677: "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=");
1678: if (ctxt->encoding) {
1679: xmlOutputBufferWriteString(buf, (const char *)ctxt->encoding);
1680: } else {
1681: xmlOutputBufferWrite(buf, 5, "UTF-8");
1682: }
1683: xmlOutputBufferWrite(buf, 4, "\" />");
1684: }
1685: if ((cur->type != XML_ELEMENT_NODE) && (cur->content != NULL)) {
1686: xmlOutputBufferWriteEscape(buf, cur->content, ctxt->escape);
1687: }
1688:
1689: #if 0
1690: /*
1691: * This was removed due to problems with HTML processors.
1692: * See bug #345147.
1693: */
1694: /*
1695: * 4.8. Script and Style elements
1696: */
1697: if ((cur->type == XML_ELEMENT_NODE) &&
1698: ((xmlStrEqual(cur->name, BAD_CAST "script")) ||
1699: (xmlStrEqual(cur->name, BAD_CAST "style"))) &&
1700: ((cur->ns == NULL) ||
1701: (xmlStrEqual(cur->ns->href, XHTML_NS_NAME)))) {
1702: xmlNodePtr child = cur->children;
1703:
1704: while (child != NULL) {
1705: if (child->type == XML_TEXT_NODE) {
1706: if ((xmlStrchr(child->content, '<') == NULL) &&
1707: (xmlStrchr(child->content, '&') == NULL) &&
1708: (xmlStrstr(child->content, BAD_CAST "]]>") == NULL)) {
1709: /* Nothing to escape, so just output as is... */
1710: /* FIXME: Should we do something about "--" also? */
1711: int level = ctxt->level;
1712: int indent = ctxt->format;
1713:
1714: ctxt->level = 0;
1715: ctxt->format = 0;
1716: xmlOutputBufferWriteString(buf, (const char *) child->content);
1717: /* (We cannot use xhtmlNodeDumpOutput() here because
1718: * we wish to leave '>' unescaped!) */
1719: ctxt->level = level;
1720: ctxt->format = indent;
1721: } else {
1722: /* We must use a CDATA section. Unfortunately,
1723: * this will break CSS and JavaScript when read by
1724: * a browser in HTML4-compliant mode. :-( */
1725: start = end = child->content;
1726: while (*end != '\0') {
1727: if (*end == ']' &&
1728: *(end + 1) == ']' &&
1729: *(end + 2) == '>') {
1730: end = end + 2;
1731: xmlOutputBufferWrite(buf, 9, "<![CDATA[");
1732: xmlOutputBufferWrite(buf, end - start,
1733: (const char *)start);
1734: xmlOutputBufferWrite(buf, 3, "]]>");
1735: start = end;
1736: }
1737: end++;
1738: }
1739: if (start != end) {
1740: xmlOutputBufferWrite(buf, 9, "<![CDATA[");
1741: xmlOutputBufferWrite(buf, end - start,
1742: (const char *)start);
1743: xmlOutputBufferWrite(buf, 3, "]]>");
1744: }
1745: }
1746: } else {
1747: int level = ctxt->level;
1748: int indent = ctxt->format;
1749:
1750: ctxt->level = 0;
1751: ctxt->format = 0;
1752: xhtmlNodeDumpOutput(ctxt, child);
1753: ctxt->level = level;
1754: ctxt->format = indent;
1755: }
1756: child = child->next;
1757: }
1758: }
1759: #endif
1760:
1761: if (cur->children != NULL) {
1762: int indent = ctxt->format;
1763:
1764: if (format == 1) xmlOutputBufferWrite(buf, 1, "\n");
1765: if (ctxt->level >= 0) ctxt->level++;
1766: ctxt->format = format;
1767: xhtmlNodeListDumpOutput(ctxt, cur->children);
1768: if (ctxt->level > 0) ctxt->level--;
1769: ctxt->format = indent;
1770: if ((xmlIndentTreeOutput) && (format == 1))
1771: xmlOutputBufferWrite(buf, ctxt->indent_size *
1772: (ctxt->level > ctxt->indent_nr ?
1773: ctxt->indent_nr : ctxt->level),
1774: ctxt->indent);
1775: }
1776: xmlOutputBufferWrite(buf, 2, "</");
1777: if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
1778: xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
1779: xmlOutputBufferWrite(buf, 1, ":");
1780: }
1781:
1782: xmlOutputBufferWriteString(buf, (const char *)cur->name);
1783: xmlOutputBufferWrite(buf, 1, ">");
1784: }
1785: #endif
1786:
1787: /************************************************************************
1788: * *
1789: * Public entry points *
1790: * *
1791: ************************************************************************/
1792:
1793: /**
1794: * xmlSaveToFd:
1795: * @fd: a file descriptor number
1796: * @encoding: the encoding name to use or NULL
1797: * @options: a set of xmlSaveOptions
1798: *
1799: * Create a document saving context serializing to a file descriptor
1800: * with the encoding and the options given.
1801: *
1802: * Returns a new serialization context or NULL in case of error.
1803: */
1804: xmlSaveCtxtPtr
1805: xmlSaveToFd(int fd, const char *encoding, int options)
1806: {
1807: xmlSaveCtxtPtr ret;
1808:
1809: ret = xmlNewSaveCtxt(encoding, options);
1810: if (ret == NULL) return(NULL);
1811: ret->buf = xmlOutputBufferCreateFd(fd, ret->handler);
1812: if (ret->buf == NULL) {
1813: xmlFreeSaveCtxt(ret);
1814: return(NULL);
1815: }
1816: return(ret);
1817: }
1818:
1819: /**
1820: * xmlSaveToFilename:
1821: * @filename: a file name or an URL
1822: * @encoding: the encoding name to use or NULL
1823: * @options: a set of xmlSaveOptions
1824: *
1825: * Create a document saving context serializing to a filename or possibly
1826: * to an URL (but this is less reliable) with the encoding and the options
1827: * given.
1828: *
1829: * Returns a new serialization context or NULL in case of error.
1830: */
1831: xmlSaveCtxtPtr
1832: xmlSaveToFilename(const char *filename, const char *encoding, int options)
1833: {
1834: xmlSaveCtxtPtr ret;
1835: int compression = 0; /* TODO handle compression option */
1836:
1837: ret = xmlNewSaveCtxt(encoding, options);
1838: if (ret == NULL) return(NULL);
1839: ret->buf = xmlOutputBufferCreateFilename(filename, ret->handler,
1840: compression);
1841: if (ret->buf == NULL) {
1842: xmlFreeSaveCtxt(ret);
1843: return(NULL);
1844: }
1845: return(ret);
1846: }
1847:
1848: /**
1849: * xmlSaveToBuffer:
1850: * @buffer: a buffer
1851: * @encoding: the encoding name to use or NULL
1852: * @options: a set of xmlSaveOptions
1853: *
1854: * Create a document saving context serializing to a buffer
1855: * with the encoding and the options given
1856: *
1857: * Returns a new serialization context or NULL in case of error.
1858: */
1859:
1860: xmlSaveCtxtPtr
1861: xmlSaveToBuffer(xmlBufferPtr buffer, const char *encoding, int options)
1862: {
1863: xmlSaveCtxtPtr ret;
1864: xmlOutputBufferPtr out_buff;
1865: xmlCharEncodingHandlerPtr handler;
1866:
1867: ret = xmlNewSaveCtxt(encoding, options);
1868: if (ret == NULL) return(NULL);
1869:
1870: if (encoding != NULL) {
1871: handler = xmlFindCharEncodingHandler(encoding);
1872: if (handler == NULL) {
1873: xmlFree(ret);
1874: return(NULL);
1875: }
1876: } else
1877: handler = NULL;
1878: out_buff = xmlOutputBufferCreateBuffer(buffer, handler);
1879: if (out_buff == NULL) {
1880: xmlFree(ret);
1881: if (handler) xmlCharEncCloseFunc(handler);
1882: return(NULL);
1883: }
1884:
1885: ret->buf = out_buff;
1886: return(ret);
1887: }
1888:
1889: /**
1890: * xmlSaveToIO:
1891: * @iowrite: an I/O write function
1892: * @ioclose: an I/O close function
1893: * @ioctx: an I/O handler
1894: * @encoding: the encoding name to use or NULL
1895: * @options: a set of xmlSaveOptions
1896: *
1897: * Create a document saving context serializing to a file descriptor
1898: * with the encoding and the options given
1899: *
1900: * Returns a new serialization context or NULL in case of error.
1901: */
1902: xmlSaveCtxtPtr
1903: xmlSaveToIO(xmlOutputWriteCallback iowrite,
1904: xmlOutputCloseCallback ioclose,
1905: void *ioctx, const char *encoding, int options)
1906: {
1907: xmlSaveCtxtPtr ret;
1908:
1909: ret = xmlNewSaveCtxt(encoding, options);
1910: if (ret == NULL) return(NULL);
1911: ret->buf = xmlOutputBufferCreateIO(iowrite, ioclose, ioctx, ret->handler);
1912: if (ret->buf == NULL) {
1913: xmlFreeSaveCtxt(ret);
1914: return(NULL);
1915: }
1916: return(ret);
1917: }
1918:
1919: /**
1920: * xmlSaveDoc:
1921: * @ctxt: a document saving context
1922: * @doc: a document
1923: *
1924: * Save a full document to a saving context
1925: * TODO: The function is not fully implemented yet as it does not return the
1926: * byte count but 0 instead
1927: *
1928: * Returns the number of byte written or -1 in case of error
1929: */
1930: long
1931: xmlSaveDoc(xmlSaveCtxtPtr ctxt, xmlDocPtr doc)
1932: {
1933: long ret = 0;
1934:
1935: if ((ctxt == NULL) || (doc == NULL)) return(-1);
1936: if (xmlDocContentDumpOutput(ctxt, doc) < 0)
1937: return(-1);
1938: return(ret);
1939: }
1940:
1941: /**
1942: * xmlSaveTree:
1943: * @ctxt: a document saving context
1944: * @node: the top node of the subtree to save
1945: *
1946: * Save a subtree starting at the node parameter to a saving context
1947: * TODO: The function is not fully implemented yet as it does not return the
1948: * byte count but 0 instead
1949: *
1950: * Returns the number of byte written or -1 in case of error
1951: */
1952: long
1953: xmlSaveTree(xmlSaveCtxtPtr ctxt, xmlNodePtr node)
1954: {
1955: long ret = 0;
1956:
1957: if ((ctxt == NULL) || (node == NULL)) return(-1);
1958: xmlNodeDumpOutputInternal(ctxt, node);
1959: return(ret);
1960: }
1961:
1962: /**
1963: * xmlSaveFlush:
1964: * @ctxt: a document saving context
1965: *
1966: * Flush a document saving context, i.e. make sure that all bytes have
1967: * been output.
1968: *
1969: * Returns the number of byte written or -1 in case of error.
1970: */
1971: int
1972: xmlSaveFlush(xmlSaveCtxtPtr ctxt)
1973: {
1974: if (ctxt == NULL) return(-1);
1975: if (ctxt->buf == NULL) return(-1);
1976: return(xmlOutputBufferFlush(ctxt->buf));
1977: }
1978:
1979: /**
1980: * xmlSaveClose:
1981: * @ctxt: a document saving context
1982: *
1983: * Close a document saving context, i.e. make sure that all bytes have
1984: * been output and free the associated data.
1985: *
1986: * Returns the number of byte written or -1 in case of error.
1987: */
1988: int
1989: xmlSaveClose(xmlSaveCtxtPtr ctxt)
1990: {
1991: int ret;
1992:
1993: if (ctxt == NULL) return(-1);
1994: ret = xmlSaveFlush(ctxt);
1995: xmlFreeSaveCtxt(ctxt);
1996: return(ret);
1997: }
1998:
1999: /**
2000: * xmlSaveSetEscape:
2001: * @ctxt: a document saving context
2002: * @escape: the escaping function
2003: *
2004: * Set a custom escaping function to be used for text in element content
2005: *
2006: * Returns 0 if successful or -1 in case of error.
2007: */
2008: int
2009: xmlSaveSetEscape(xmlSaveCtxtPtr ctxt, xmlCharEncodingOutputFunc escape)
2010: {
2011: if (ctxt == NULL) return(-1);
2012: ctxt->escape = escape;
2013: return(0);
2014: }
2015:
2016: /**
2017: * xmlSaveSetAttrEscape:
2018: * @ctxt: a document saving context
2019: * @escape: the escaping function
2020: *
2021: * Set a custom escaping function to be used for text in attribute content
2022: *
2023: * Returns 0 if successful or -1 in case of error.
2024: */
2025: int
2026: xmlSaveSetAttrEscape(xmlSaveCtxtPtr ctxt, xmlCharEncodingOutputFunc escape)
2027: {
2028: if (ctxt == NULL) return(-1);
2029: ctxt->escapeAttr = escape;
2030: return(0);
2031: }
2032:
2033: /************************************************************************
2034: * *
2035: * Public entry points based on buffers *
2036: * *
2037: ************************************************************************/
2038:
2039: /**
2040: * xmlBufAttrSerializeTxtContent:
2041: * @buf: and xmlBufPtr output
2042: * @doc: the document
2043: * @attr: the attribute node
2044: * @string: the text content
2045: *
2046: * Serialize text attribute values to an xmlBufPtr
2047: */
2048: void
2049: xmlBufAttrSerializeTxtContent(xmlBufPtr buf, xmlDocPtr doc,
2050: xmlAttrPtr attr, const xmlChar * string)
2051: {
2052: xmlChar *base, *cur;
2053:
2054: if (string == NULL)
2055: return;
2056: base = cur = (xmlChar *) string;
2057: while (*cur != 0) {
2058: if (*cur == '\n') {
2059: if (base != cur)
2060: xmlBufAdd(buf, base, cur - base);
2061: xmlBufAdd(buf, BAD_CAST " ", 5);
2062: cur++;
2063: base = cur;
2064: } else if (*cur == '\r') {
2065: if (base != cur)
2066: xmlBufAdd(buf, base, cur - base);
2067: xmlBufAdd(buf, BAD_CAST " ", 5);
2068: cur++;
2069: base = cur;
2070: } else if (*cur == '\t') {
2071: if (base != cur)
2072: xmlBufAdd(buf, base, cur - base);
2073: xmlBufAdd(buf, BAD_CAST "	", 4);
2074: cur++;
2075: base = cur;
2076: } else if (*cur == '"') {
2077: if (base != cur)
2078: xmlBufAdd(buf, base, cur - base);
2079: xmlBufAdd(buf, BAD_CAST """, 6);
2080: cur++;
2081: base = cur;
2082: } else if (*cur == '<') {
2083: if (base != cur)
2084: xmlBufAdd(buf, base, cur - base);
2085: xmlBufAdd(buf, BAD_CAST "<", 4);
2086: cur++;
2087: base = cur;
2088: } else if (*cur == '>') {
2089: if (base != cur)
2090: xmlBufAdd(buf, base, cur - base);
2091: xmlBufAdd(buf, BAD_CAST ">", 4);
2092: cur++;
2093: base = cur;
2094: } else if (*cur == '&') {
2095: if (base != cur)
2096: xmlBufAdd(buf, base, cur - base);
2097: xmlBufAdd(buf, BAD_CAST "&", 5);
2098: cur++;
2099: base = cur;
2100: } else if ((*cur >= 0x80) && ((doc == NULL) ||
2101: (doc->encoding == NULL))) {
2102: /*
2103: * We assume we have UTF-8 content.
2104: */
2105: unsigned char tmp[12];
2106: int val = 0, l = 1;
2107:
2108: if (base != cur)
2109: xmlBufAdd(buf, base, cur - base);
2110: if (*cur < 0xC0) {
2111: xmlSaveErr(XML_SAVE_NOT_UTF8, (xmlNodePtr) attr, NULL);
2112: if (doc != NULL)
2113: doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
2114: xmlSerializeHexCharRef(tmp, *cur);
2115: xmlBufAdd(buf, (xmlChar *) tmp, -1);
2116: cur++;
2117: base = cur;
2118: continue;
2119: } else if (*cur < 0xE0) {
2120: val = (cur[0]) & 0x1F;
2121: val <<= 6;
2122: val |= (cur[1]) & 0x3F;
2123: l = 2;
2124: } else if (*cur < 0xF0) {
2125: val = (cur[0]) & 0x0F;
2126: val <<= 6;
2127: val |= (cur[1]) & 0x3F;
2128: val <<= 6;
2129: val |= (cur[2]) & 0x3F;
2130: l = 3;
2131: } else if (*cur < 0xF8) {
2132: val = (cur[0]) & 0x07;
2133: val <<= 6;
2134: val |= (cur[1]) & 0x3F;
2135: val <<= 6;
2136: val |= (cur[2]) & 0x3F;
2137: val <<= 6;
2138: val |= (cur[3]) & 0x3F;
2139: l = 4;
2140: }
2141: if ((l == 1) || (!IS_CHAR(val))) {
2142: xmlSaveErr(XML_SAVE_CHAR_INVALID, (xmlNodePtr) attr, NULL);
2143: if (doc != NULL)
2144: doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
2145:
2146: xmlSerializeHexCharRef(tmp, *cur);
2147: xmlBufAdd(buf, (xmlChar *) tmp, -1);
2148: cur++;
2149: base = cur;
2150: continue;
2151: }
2152: /*
2153: * We could do multiple things here. Just save
2154: * as a char ref
2155: */
2156: xmlSerializeHexCharRef(tmp, val);
2157: xmlBufAdd(buf, (xmlChar *) tmp, -1);
2158: cur += l;
2159: base = cur;
2160: } else {
2161: cur++;
2162: }
2163: }
2164: if (base != cur)
2165: xmlBufAdd(buf, base, cur - base);
2166: }
2167:
2168: /**
2169: * xmlAttrSerializeTxtContent:
2170: * @buf: the XML buffer output
2171: * @doc: the document
2172: * @attr: the attribute node
2173: * @string: the text content
2174: *
2175: * Serialize text attribute values to an xml simple buffer
2176: */
2177: void
2178: xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr doc,
2179: xmlAttrPtr attr, const xmlChar * string)
2180: {
2181: xmlBufPtr buffer;
2182:
2183: if ((buf == NULL) || (string == NULL))
2184: return;
2185: buffer = xmlBufFromBuffer(buf);
2186: if (buffer == NULL)
2187: return;
2188: xmlBufAttrSerializeTxtContent(buffer, doc, attr, string);
2189: xmlBufBackToBuffer(buffer);
2190: }
2191:
2192: /**
2193: * xmlNodeDump:
2194: * @buf: the XML buffer output
2195: * @doc: the document
2196: * @cur: the current node
2197: * @level: the imbrication level for indenting
2198: * @format: is formatting allowed
2199: *
2200: * Dump an XML node, recursive behaviour,children are printed too.
2201: * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
2202: * or xmlKeepBlanksDefault(0) was called
2203: * Since this is using xmlBuffer structures it is limited to 2GB and somehow
2204: * deprecated, use xmlBufNodeDump() instead.
2205: *
2206: * Returns the number of bytes written to the buffer or -1 in case of error
2207: */
2208: int
2209: xmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur, int level,
2210: int format)
2211: {
2212: xmlBufPtr buffer;
2213: int ret;
2214:
2215: if ((buf == NULL) || (cur == NULL))
2216: return(-1);
2217: buffer = xmlBufFromBuffer(buf);
2218: if (buffer == NULL)
2219: return(-1);
2220: ret = xmlBufNodeDump(buffer, doc, cur, level, format);
2221: xmlBufBackToBuffer(buffer);
2222: if (ret > INT_MAX)
2223: return(-1);
2224: return((int) ret);
2225: }
2226:
2227: /**
2228: * xmlBufNodeDump:
2229: * @buf: the XML buffer output
2230: * @doc: the document
2231: * @cur: the current node
2232: * @level: the imbrication level for indenting
2233: * @format: is formatting allowed
2234: *
2235: * Dump an XML node, recursive behaviour,children are printed too.
2236: * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
2237: * or xmlKeepBlanksDefault(0) was called
2238: *
2239: * Returns the number of bytes written to the buffer, in case of error 0
2240: * is returned or @buf stores the error
2241: */
2242:
2243: size_t
2244: xmlBufNodeDump(xmlBufPtr buf, xmlDocPtr doc, xmlNodePtr cur, int level,
2245: int format)
2246: {
2247: size_t use;
2248: int ret;
2249: xmlOutputBufferPtr outbuf;
2250: int oldalloc;
2251:
2252: xmlInitParser();
2253:
2254: if (cur == NULL) {
2255: #ifdef DEBUG_TREE
2256: xmlGenericError(xmlGenericErrorContext,
2257: "xmlNodeDump : node == NULL\n");
2258: #endif
2259: return (-1);
2260: }
2261: if (buf == NULL) {
2262: #ifdef DEBUG_TREE
2263: xmlGenericError(xmlGenericErrorContext,
2264: "xmlNodeDump : buf == NULL\n");
2265: #endif
2266: return (-1);
2267: }
2268: outbuf = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer));
2269: if (outbuf == NULL) {
2270: xmlSaveErrMemory("creating buffer");
2271: return (-1);
2272: }
2273: memset(outbuf, 0, (size_t) sizeof(xmlOutputBuffer));
2274: outbuf->buffer = buf;
2275: outbuf->encoder = NULL;
2276: outbuf->writecallback = NULL;
2277: outbuf->closecallback = NULL;
2278: outbuf->context = NULL;
2279: outbuf->written = 0;
2280:
2281: use = xmlBufUse(buf);
2282: oldalloc = xmlBufGetAllocationScheme(buf);
2283: xmlBufSetAllocationScheme(buf, XML_BUFFER_ALLOC_DOUBLEIT);
2284: xmlNodeDumpOutput(outbuf, doc, cur, level, format, NULL);
2285: xmlBufSetAllocationScheme(buf, oldalloc);
2286: xmlFree(outbuf);
2287: ret = xmlBufUse(buf) - use;
2288: return (ret);
2289: }
2290:
2291: /**
2292: * xmlElemDump:
2293: * @f: the FILE * for the output
2294: * @doc: the document
2295: * @cur: the current node
2296: *
2297: * Dump an XML/HTML node, recursive behaviour, children are printed too.
2298: */
2299: void
2300: xmlElemDump(FILE * f, xmlDocPtr doc, xmlNodePtr cur)
2301: {
2302: xmlOutputBufferPtr outbuf;
2303:
2304: xmlInitParser();
2305:
2306: if (cur == NULL) {
2307: #ifdef DEBUG_TREE
2308: xmlGenericError(xmlGenericErrorContext,
2309: "xmlElemDump : cur == NULL\n");
2310: #endif
2311: return;
2312: }
2313: #ifdef DEBUG_TREE
2314: if (doc == NULL) {
2315: xmlGenericError(xmlGenericErrorContext,
2316: "xmlElemDump : doc == NULL\n");
2317: }
2318: #endif
2319:
2320: outbuf = xmlOutputBufferCreateFile(f, NULL);
2321: if (outbuf == NULL)
2322: return;
2323: if ((doc != NULL) && (doc->type == XML_HTML_DOCUMENT_NODE)) {
2324: #ifdef LIBXML_HTML_ENABLED
2325: htmlNodeDumpOutput(outbuf, doc, cur, NULL);
2326: #else
2327: xmlSaveErr(XML_ERR_INTERNAL_ERROR, cur, "HTML support not compiled in\n");
2328: #endif /* LIBXML_HTML_ENABLED */
2329: } else
2330: xmlNodeDumpOutput(outbuf, doc, cur, 0, 1, NULL);
2331: xmlOutputBufferClose(outbuf);
2332: }
2333:
2334: /************************************************************************
2335: * *
2336: * Saving functions front-ends *
2337: * *
2338: ************************************************************************/
2339:
2340: /**
2341: * xmlNodeDumpOutput:
2342: * @buf: the XML buffer output
2343: * @doc: the document
2344: * @cur: the current node
2345: * @level: the imbrication level for indenting
2346: * @format: is formatting allowed
2347: * @encoding: an optional encoding string
2348: *
2349: * Dump an XML node, recursive behaviour, children are printed too.
2350: * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
2351: * or xmlKeepBlanksDefault(0) was called
2352: */
2353: void
2354: xmlNodeDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur,
2355: int level, int format, const char *encoding)
2356: {
2357: xmlSaveCtxt ctxt;
2358: #ifdef LIBXML_HTML_ENABLED
2359: xmlDtdPtr dtd;
2360: int is_xhtml = 0;
2361: #endif
2362:
2363: xmlInitParser();
2364:
2365: if ((buf == NULL) || (cur == NULL)) return;
2366:
2367: if (encoding == NULL)
2368: encoding = "UTF-8";
2369:
2370: memset(&ctxt, 0, sizeof(ctxt));
2371: ctxt.doc = doc;
2372: ctxt.buf = buf;
2373: ctxt.level = level;
2374: ctxt.format = format ? 1 : 0;
2375: ctxt.encoding = (const xmlChar *) encoding;
2376: xmlSaveCtxtInit(&ctxt);
2377: ctxt.options |= XML_SAVE_AS_XML;
2378:
2379: #ifdef LIBXML_HTML_ENABLED
2380: dtd = xmlGetIntSubset(doc);
2381: if (dtd != NULL) {
2382: is_xhtml = xmlIsXHTML(dtd->SystemID, dtd->ExternalID);
2383: if (is_xhtml < 0)
2384: is_xhtml = 0;
2385: }
2386:
2387: if (is_xhtml)
2388: xhtmlNodeDumpOutput(&ctxt, cur);
2389: else
2390: #endif
2391: xmlNodeDumpOutputInternal(&ctxt, cur);
2392: }
2393:
2394: /**
2395: * xmlDocDumpFormatMemoryEnc:
2396: * @out_doc: Document to generate XML text from
2397: * @doc_txt_ptr: Memory pointer for allocated XML text
2398: * @doc_txt_len: Length of the generated XML text
2399: * @txt_encoding: Character encoding to use when generating XML text
2400: * @format: should formatting spaces been added
2401: *
2402: * Dump the current DOM tree into memory using the character encoding specified
2403: * by the caller. Note it is up to the caller of this function to free the
2404: * allocated memory with xmlFree().
2405: * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
2406: * or xmlKeepBlanksDefault(0) was called
2407: */
2408:
2409: void
2410: xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc, xmlChar **doc_txt_ptr,
2411: int * doc_txt_len, const char * txt_encoding,
2412: int format) {
2413: xmlSaveCtxt ctxt;
2414: int dummy = 0;
2415: xmlOutputBufferPtr out_buff = NULL;
2416: xmlCharEncodingHandlerPtr conv_hdlr = NULL;
2417:
2418: if (doc_txt_len == NULL) {
2419: doc_txt_len = &dummy; /* Continue, caller just won't get length */
2420: }
2421:
2422: if (doc_txt_ptr == NULL) {
2423: *doc_txt_len = 0;
2424: return;
2425: }
2426:
2427: *doc_txt_ptr = NULL;
2428: *doc_txt_len = 0;
2429:
2430: if (out_doc == NULL) {
2431: /* No document, no output */
2432: return;
2433: }
2434:
2435: /*
2436: * Validate the encoding value, if provided.
2437: * This logic is copied from xmlSaveFileEnc.
2438: */
2439:
2440: if (txt_encoding == NULL)
2441: txt_encoding = (const char *) out_doc->encoding;
2442: if (txt_encoding != NULL) {
2443: conv_hdlr = xmlFindCharEncodingHandler(txt_encoding);
2444: if ( conv_hdlr == NULL ) {
2445: xmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, (xmlNodePtr) out_doc,
2446: txt_encoding);
2447: return;
2448: }
2449: }
2450:
2451: if ((out_buff = xmlAllocOutputBuffer(conv_hdlr)) == NULL ) {
2452: xmlSaveErrMemory("creating buffer");
2453: return;
2454: }
2455:
2456: memset(&ctxt, 0, sizeof(ctxt));
2457: ctxt.doc = out_doc;
2458: ctxt.buf = out_buff;
2459: ctxt.level = 0;
2460: ctxt.format = format ? 1 : 0;
2461: ctxt.encoding = (const xmlChar *) txt_encoding;
2462: xmlSaveCtxtInit(&ctxt);
2463: ctxt.options |= XML_SAVE_AS_XML;
2464: xmlDocContentDumpOutput(&ctxt, out_doc);
2465: xmlOutputBufferFlush(out_buff);
2466: if (out_buff->conv != NULL) {
2467: *doc_txt_len = xmlBufUse(out_buff->conv);
2468: *doc_txt_ptr = xmlStrndup(xmlBufContent(out_buff->conv), *doc_txt_len);
2469: } else {
2470: *doc_txt_len = xmlBufUse(out_buff->buffer);
2471: *doc_txt_ptr = xmlStrndup(xmlBufContent(out_buff->buffer),*doc_txt_len);
2472: }
2473: (void)xmlOutputBufferClose(out_buff);
2474:
2475: if ((*doc_txt_ptr == NULL) && (*doc_txt_len > 0)) {
2476: *doc_txt_len = 0;
2477: xmlSaveErrMemory("creating output");
2478: }
2479:
2480: return;
2481: }
2482:
2483: /**
2484: * xmlDocDumpMemory:
2485: * @cur: the document
2486: * @mem: OUT: the memory pointer
2487: * @size: OUT: the memory length
2488: *
2489: * Dump an XML document in memory and return the #xmlChar * and it's size
2490: * in bytes. It's up to the caller to free the memory with xmlFree().
2491: * The resulting byte array is zero terminated, though the last 0 is not
2492: * included in the returned size.
2493: */
2494: void
2495: xmlDocDumpMemory(xmlDocPtr cur, xmlChar**mem, int *size) {
2496: xmlDocDumpFormatMemoryEnc(cur, mem, size, NULL, 0);
2497: }
2498:
2499: /**
2500: * xmlDocDumpFormatMemory:
2501: * @cur: the document
2502: * @mem: OUT: the memory pointer
2503: * @size: OUT: the memory length
2504: * @format: should formatting spaces been added
2505: *
2506: *
2507: * Dump an XML document in memory and return the #xmlChar * and it's size.
2508: * It's up to the caller to free the memory with xmlFree().
2509: * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
2510: * or xmlKeepBlanksDefault(0) was called
2511: */
2512: void
2513: xmlDocDumpFormatMemory(xmlDocPtr cur, xmlChar**mem, int *size, int format) {
2514: xmlDocDumpFormatMemoryEnc(cur, mem, size, NULL, format);
2515: }
2516:
2517: /**
2518: * xmlDocDumpMemoryEnc:
2519: * @out_doc: Document to generate XML text from
2520: * @doc_txt_ptr: Memory pointer for allocated XML text
2521: * @doc_txt_len: Length of the generated XML text
2522: * @txt_encoding: Character encoding to use when generating XML text
2523: *
2524: * Dump the current DOM tree into memory using the character encoding specified
2525: * by the caller. Note it is up to the caller of this function to free the
2526: * allocated memory with xmlFree().
2527: */
2528:
2529: void
2530: xmlDocDumpMemoryEnc(xmlDocPtr out_doc, xmlChar **doc_txt_ptr,
2531: int * doc_txt_len, const char * txt_encoding) {
2532: xmlDocDumpFormatMemoryEnc(out_doc, doc_txt_ptr, doc_txt_len,
2533: txt_encoding, 0);
2534: }
2535:
2536: /**
2537: * xmlDocFormatDump:
2538: * @f: the FILE*
2539: * @cur: the document
2540: * @format: should formatting spaces been added
2541: *
2542: * Dump an XML document to an open FILE.
2543: *
2544: * returns: the number of bytes written or -1 in case of failure.
2545: * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
2546: * or xmlKeepBlanksDefault(0) was called
2547: */
2548: int
2549: xmlDocFormatDump(FILE *f, xmlDocPtr cur, int format) {
2550: xmlSaveCtxt ctxt;
2551: xmlOutputBufferPtr buf;
2552: const char * encoding;
2553: xmlCharEncodingHandlerPtr handler = NULL;
2554: int ret;
2555:
2556: if (cur == NULL) {
2557: #ifdef DEBUG_TREE
2558: xmlGenericError(xmlGenericErrorContext,
2559: "xmlDocDump : document == NULL\n");
2560: #endif
2561: return(-1);
2562: }
2563: encoding = (const char *) cur->encoding;
2564:
2565: if (encoding != NULL) {
2566: handler = xmlFindCharEncodingHandler(encoding);
2567: if (handler == NULL) {
2568: xmlFree((char *) cur->encoding);
2569: cur->encoding = NULL;
2570: encoding = NULL;
2571: }
2572: }
2573: buf = xmlOutputBufferCreateFile(f, handler);
2574: if (buf == NULL) return(-1);
2575: memset(&ctxt, 0, sizeof(ctxt));
2576: ctxt.doc = cur;
2577: ctxt.buf = buf;
2578: ctxt.level = 0;
2579: ctxt.format = format ? 1 : 0;
2580: ctxt.encoding = (const xmlChar *) encoding;
2581: xmlSaveCtxtInit(&ctxt);
2582: ctxt.options |= XML_SAVE_AS_XML;
2583: xmlDocContentDumpOutput(&ctxt, cur);
2584:
2585: ret = xmlOutputBufferClose(buf);
2586: return(ret);
2587: }
2588:
2589: /**
2590: * xmlDocDump:
2591: * @f: the FILE*
2592: * @cur: the document
2593: *
2594: * Dump an XML document to an open FILE.
2595: *
2596: * returns: the number of bytes written or -1 in case of failure.
2597: */
2598: int
2599: xmlDocDump(FILE *f, xmlDocPtr cur) {
2600: return(xmlDocFormatDump (f, cur, 0));
2601: }
2602:
2603: /**
2604: * xmlSaveFileTo:
2605: * @buf: an output I/O buffer
2606: * @cur: the document
2607: * @encoding: the encoding if any assuming the I/O layer handles the trancoding
2608: *
2609: * Dump an XML document to an I/O buffer.
2610: * Warning ! This call xmlOutputBufferClose() on buf which is not available
2611: * after this call.
2612: *
2613: * returns: the number of bytes written or -1 in case of failure.
2614: */
2615: int
2616: xmlSaveFileTo(xmlOutputBufferPtr buf, xmlDocPtr cur, const char *encoding) {
2617: xmlSaveCtxt ctxt;
2618: int ret;
2619:
2620: if (buf == NULL) return(-1);
2621: if (cur == NULL) {
2622: xmlOutputBufferClose(buf);
2623: return(-1);
2624: }
2625: memset(&ctxt, 0, sizeof(ctxt));
2626: ctxt.doc = cur;
2627: ctxt.buf = buf;
2628: ctxt.level = 0;
2629: ctxt.format = 0;
2630: ctxt.encoding = (const xmlChar *) encoding;
2631: xmlSaveCtxtInit(&ctxt);
2632: ctxt.options |= XML_SAVE_AS_XML;
2633: xmlDocContentDumpOutput(&ctxt, cur);
2634: ret = xmlOutputBufferClose(buf);
2635: return(ret);
2636: }
2637:
2638: /**
2639: * xmlSaveFormatFileTo:
2640: * @buf: an output I/O buffer
2641: * @cur: the document
2642: * @encoding: the encoding if any assuming the I/O layer handles the trancoding
2643: * @format: should formatting spaces been added
2644: *
2645: * Dump an XML document to an I/O buffer.
2646: * Warning ! This call xmlOutputBufferClose() on buf which is not available
2647: * after this call.
2648: *
2649: * returns: the number of bytes written or -1 in case of failure.
2650: */
2651: int
2652: xmlSaveFormatFileTo(xmlOutputBufferPtr buf, xmlDocPtr cur,
2653: const char *encoding, int format)
2654: {
2655: xmlSaveCtxt ctxt;
2656: int ret;
2657:
2658: if (buf == NULL) return(-1);
2659: if ((cur == NULL) ||
2660: ((cur->type != XML_DOCUMENT_NODE) &&
2661: (cur->type != XML_HTML_DOCUMENT_NODE))) {
2662: xmlOutputBufferClose(buf);
2663: return(-1);
2664: }
2665: memset(&ctxt, 0, sizeof(ctxt));
2666: ctxt.doc = cur;
2667: ctxt.buf = buf;
2668: ctxt.level = 0;
2669: ctxt.format = format ? 1 : 0;
2670: ctxt.encoding = (const xmlChar *) encoding;
2671: xmlSaveCtxtInit(&ctxt);
2672: ctxt.options |= XML_SAVE_AS_XML;
2673: xmlDocContentDumpOutput(&ctxt, cur);
2674: ret = xmlOutputBufferClose(buf);
2675: return (ret);
2676: }
2677:
2678: /**
2679: * xmlSaveFormatFileEnc:
2680: * @filename: the filename or URL to output
2681: * @cur: the document being saved
2682: * @encoding: the name of the encoding to use or NULL.
2683: * @format: should formatting spaces be added.
2684: *
2685: * Dump an XML document to a file or an URL.
2686: *
2687: * Returns the number of bytes written or -1 in case of error.
2688: * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
2689: * or xmlKeepBlanksDefault(0) was called
2690: */
2691: int
2692: xmlSaveFormatFileEnc( const char * filename, xmlDocPtr cur,
2693: const char * encoding, int format ) {
2694: xmlSaveCtxt ctxt;
2695: xmlOutputBufferPtr buf;
2696: xmlCharEncodingHandlerPtr handler = NULL;
2697: int ret;
2698:
2699: if (cur == NULL)
2700: return(-1);
2701:
2702: if (encoding == NULL)
2703: encoding = (const char *) cur->encoding;
2704:
2705: if (encoding != NULL) {
2706:
2707: handler = xmlFindCharEncodingHandler(encoding);
2708: if (handler == NULL)
2709: return(-1);
2710: }
2711:
2712: #ifdef HAVE_ZLIB_H
2713: if (cur->compression < 0) cur->compression = xmlGetCompressMode();
2714: #endif
2715: /*
2716: * save the content to a temp buffer.
2717: */
2718: buf = xmlOutputBufferCreateFilename(filename, handler, cur->compression);
2719: if (buf == NULL) return(-1);
2720: memset(&ctxt, 0, sizeof(ctxt));
2721: ctxt.doc = cur;
2722: ctxt.buf = buf;
2723: ctxt.level = 0;
2724: ctxt.format = format ? 1 : 0;
2725: ctxt.encoding = (const xmlChar *) encoding;
2726: xmlSaveCtxtInit(&ctxt);
2727: ctxt.options |= XML_SAVE_AS_XML;
2728:
2729: xmlDocContentDumpOutput(&ctxt, cur);
2730:
2731: ret = xmlOutputBufferClose(buf);
2732: return(ret);
2733: }
2734:
2735:
2736: /**
2737: * xmlSaveFileEnc:
2738: * @filename: the filename (or URL)
2739: * @cur: the document
2740: * @encoding: the name of an encoding (or NULL)
2741: *
2742: * Dump an XML document, converting it to the given encoding
2743: *
2744: * returns: the number of bytes written or -1 in case of failure.
2745: */
2746: int
2747: xmlSaveFileEnc(const char *filename, xmlDocPtr cur, const char *encoding) {
2748: return ( xmlSaveFormatFileEnc( filename, cur, encoding, 0 ) );
2749: }
2750:
2751: /**
2752: * xmlSaveFormatFile:
2753: * @filename: the filename (or URL)
2754: * @cur: the document
2755: * @format: should formatting spaces been added
2756: *
2757: * Dump an XML document to a file. Will use compression if
2758: * compiled in and enabled. If @filename is "-" the stdout file is
2759: * used. If @format is set then the document will be indented on output.
2760: * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
2761: * or xmlKeepBlanksDefault(0) was called
2762: *
2763: * returns: the number of bytes written or -1 in case of failure.
2764: */
2765: int
2766: xmlSaveFormatFile(const char *filename, xmlDocPtr cur, int format) {
2767: return ( xmlSaveFormatFileEnc( filename, cur, NULL, format ) );
2768: }
2769:
2770: /**
2771: * xmlSaveFile:
2772: * @filename: the filename (or URL)
2773: * @cur: the document
2774: *
2775: * Dump an XML document to a file. Will use compression if
2776: * compiled in and enabled. If @filename is "-" the stdout file is
2777: * used.
2778: * returns: the number of bytes written or -1 in case of failure.
2779: */
2780: int
2781: xmlSaveFile(const char *filename, xmlDocPtr cur) {
2782: return(xmlSaveFormatFileEnc(filename, cur, NULL, 0));
2783: }
2784:
2785: #endif /* LIBXML_OUTPUT_ENABLED */
2786:
2787: #define bottom_xmlsave
2788: #include "elfgcchack.h"
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to xmlsave.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