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