?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dnsmasq: stay close as possible to master branch
[tomato.git] / release / src-rt-6.x.4708 / router / libxml2 / xmlsave.c
blob774404b884ad8596cf6ee9142ed5a93a1cbf7e7d
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 "&#10;", 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 "&#13;", 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 "&#9;", 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 "&quot;", 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 "&lt;", 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 "&gt;", 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 "&amp;", 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"
Tomato firmware and modifications.