projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[LIBXML2] Update to version 2.9.9. CORE-15854
[reactos.git] / sdk / lib / 3rdparty / libxml2 / xmlsave.c
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 }
1127
1128 if (((cur->type == XML_HTML_DOCUMENT_NODE) &&
1129 ((ctxt->options & XML_SAVE_AS_XML) == 0) &&
1130 ((ctxt->options & XML_SAVE_XHTML) == 0)) ||
1131 (ctxt->options & XML_SAVE_AS_HTML)) {
1132 #ifdef LIBXML_HTML_ENABLED
1133 if (encoding != NULL)
1134 htmlSetMetaEncoding(cur, (const xmlChar *) encoding);
1135 if (encoding == NULL)
1136 encoding = htmlGetMetaEncoding(cur);
1137 if (encoding == NULL)
1138 encoding = BAD_CAST "HTML";
1139 if ((encoding != NULL) && (oldctxtenc == NULL) &&
1140 (buf->encoder == NULL) && (buf->conv == NULL)) {
1141 if (xmlSaveSwitchEncoding(ctxt, (const char*) encoding) < 0) {
1142 cur->encoding = oldenc;
1143 return(-1);
1144 }
1145 }
1146 if (ctxt->options & XML_SAVE_FORMAT)
1147 htmlDocContentDumpFormatOutput(buf, cur,
1148 (const char *)encoding, 1);
1149 else
1150 htmlDocContentDumpFormatOutput(buf, cur,
1151 (const char *)encoding, 0);
1152 if (ctxt->encoding != NULL)
1153 cur->encoding = oldenc;
1154 return(0);
1155 #else
1156 return(-1);
1157 #endif
1158 } else if ((cur->type == XML_DOCUMENT_NODE) ||
1159 (ctxt->options & XML_SAVE_AS_XML) ||
1160 (ctxt->options & XML_SAVE_XHTML)) {
1161 enc = xmlParseCharEncoding((const char*) encoding);
1162 if ((encoding != NULL) && (oldctxtenc == NULL) &&
1163 (buf->encoder == NULL) && (buf->conv == NULL) &&
1164 ((ctxt->options & XML_SAVE_NO_DECL) == 0)) {
1165 if ((enc != XML_CHAR_ENCODING_UTF8) &&
1166 (enc != XML_CHAR_ENCODING_NONE) &&
1167 (enc != XML_CHAR_ENCODING_ASCII)) {
1168 /*
1169 * we need to switch to this encoding but just for this
1170 * document since we output the XMLDecl the conversion
1171 * must be done to not generate not well formed documents.
1172 */
1173 if (xmlSaveSwitchEncoding(ctxt, (const char*) encoding) < 0) {
1174 cur->encoding = oldenc;
1175 return(-1);
1176 }
1177 switched_encoding = 1;
1178 }
1179 if (ctxt->escape == xmlEscapeEntities)
1180 ctxt->escape = NULL;
1181 if (ctxt->escapeAttr == xmlEscapeEntities)
1182 ctxt->escapeAttr = NULL;
1183 }
1184
1185
1186 /*
1187 * Save the XML declaration
1188 */
1189 if ((ctxt->options & XML_SAVE_NO_DECL) == 0) {
1190 xmlOutputBufferWrite(buf, 14, "<?xml version=");
1191 if (cur->version != NULL)
1192 xmlBufWriteQuotedString(buf->buffer, cur->version);
1193 else
1194 xmlOutputBufferWrite(buf, 5, "\"1.0\"");
1195 if (encoding != NULL) {
1196 xmlOutputBufferWrite(buf, 10, " encoding=");
1197 xmlBufWriteQuotedString(buf->buffer, (xmlChar *) encoding);
1198 }
1199 switch (cur->standalone) {
1200 case 0:
1201 xmlOutputBufferWrite(buf, 16, " standalone=\"no\"");
1202 break;
1203 case 1:
1204 xmlOutputBufferWrite(buf, 17, " standalone=\"yes\"");
1205 break;
1206 }
1207 xmlOutputBufferWrite(buf, 3, "?>\n");
1208 }
1209
1210 #ifdef LIBXML_HTML_ENABLED
1211 if (ctxt->options & XML_SAVE_XHTML)
1212 is_xhtml = 1;
1213 if ((ctxt->options & XML_SAVE_NO_XHTML) == 0) {
1214 dtd = xmlGetIntSubset(cur);
1215 if (dtd != NULL) {
1216 is_xhtml = xmlIsXHTML(dtd->SystemID, dtd->ExternalID);
1217 if (is_xhtml < 0) is_xhtml = 0;
1218 }
1219 }
1220 #endif
1221 if (cur->children != NULL) {
1222 xmlNodePtr child = cur->children;
1223
1224 while (child != NULL) {
1225 ctxt->level = 0;
1226 #ifdef LIBXML_HTML_ENABLED
1227 if (is_xhtml)
1228 xhtmlNodeDumpOutput(ctxt, child);
1229 else
1230 #endif
1231 xmlNodeDumpOutputInternal(ctxt, child);
1232 xmlOutputBufferWrite(buf, 1, "\n");
1233 child = child->next;
1234 }
1235 }
1236 }
1237
1238 /*
1239 * Restore the state of the saving context at the end of the document
1240 */
1241 if ((switched_encoding) && (oldctxtenc == NULL)) {
1242 xmlSaveClearEncoding(ctxt);
1243 ctxt->escape = oldescape;
1244 ctxt->escapeAttr = oldescapeAttr;
1245 }
1246 cur->encoding = oldenc;
1247 return(0);
1248 }
1249
1250 #ifdef LIBXML_HTML_ENABLED
1251 /************************************************************************
1252 * *
1253 * Functions specific to XHTML serialization *
1254 * *
1255 ************************************************************************/
1256
1257 /**
1258 * xhtmlIsEmpty:
1259 * @node: the node
1260 *
1261 * Check if a node is an empty xhtml node
1262 *
1263 * Returns 1 if the node is an empty node, 0 if not and -1 in case of error
1264 */
1265 static int
1266 xhtmlIsEmpty(xmlNodePtr node) {
1267 if (node == NULL)
1268 return(-1);
1269 if (node->type != XML_ELEMENT_NODE)
1270 return(0);
1271 if ((node->ns != NULL) && (!xmlStrEqual(node->ns->href, XHTML_NS_NAME)))
1272 return(0);
1273 if (node->children != NULL)
1274 return(0);
1275 switch (node->name[0]) {
1276 case 'a':
1277 if (xmlStrEqual(node->name, BAD_CAST "area"))
1278 return(1);
1279 return(0);
1280 case 'b':
1281 if (xmlStrEqual(node->name, BAD_CAST "br"))
1282 return(1);
1283 if (xmlStrEqual(node->name, BAD_CAST "base"))
1284 return(1);
1285 if (xmlStrEqual(node->name, BAD_CAST "basefont"))
1286 return(1);
1287 return(0);
1288 case 'c':
1289 if (xmlStrEqual(node->name, BAD_CAST "col"))
1290 return(1);
1291 return(0);
1292 case 'f':
1293 if (xmlStrEqual(node->name, BAD_CAST "frame"))
1294 return(1);
1295 return(0);
1296 case 'h':
1297 if (xmlStrEqual(node->name, BAD_CAST "hr"))
1298 return(1);
1299 return(0);
1300 case 'i':
1301 if (xmlStrEqual(node->name, BAD_CAST "img"))
1302 return(1);
1303 if (xmlStrEqual(node->name, BAD_CAST "input"))
1304 return(1);
1305 if (xmlStrEqual(node->name, BAD_CAST "isindex"))
1306 return(1);
1307 return(0);
1308 case 'l':
1309 if (xmlStrEqual(node->name, BAD_CAST "link"))
1310 return(1);
1311 return(0);
1312 case 'm':
1313 if (xmlStrEqual(node->name, BAD_CAST "meta"))
1314 return(1);
1315 return(0);
1316 case 'p':
1317 if (xmlStrEqual(node->name, BAD_CAST "param"))
1318 return(1);
1319 return(0);
1320 }
1321 return(0);
1322 }
1323
1324 /**
1325 * xhtmlAttrListDumpOutput:
1326 * @cur: the first attribute pointer
1327 *
1328 * Dump a list of XML attributes
1329 */
1330 static void
1331 xhtmlAttrListDumpOutput(xmlSaveCtxtPtr ctxt, xmlAttrPtr cur) {
1332 xmlAttrPtr xml_lang = NULL;
1333 xmlAttrPtr lang = NULL;
1334 xmlAttrPtr name = NULL;
1335 xmlAttrPtr id = NULL;
1336 xmlNodePtr parent;
1337 xmlOutputBufferPtr buf;
1338
1339 if (cur == NULL) return;
1340 buf = ctxt->buf;
1341 parent = cur->parent;
1342 while (cur != NULL) {
1343 if ((cur->ns == NULL) && (xmlStrEqual(cur->name, BAD_CAST "id")))
1344 id = cur;
1345 else
1346 if ((cur->ns == NULL) && (xmlStrEqual(cur->name, BAD_CAST "name")))
1347 name = cur;
1348 else
1349 if ((cur->ns == NULL) && (xmlStrEqual(cur->name, BAD_CAST "lang")))
1350 lang = cur;
1351 else
1352 if ((cur->ns != NULL) && (xmlStrEqual(cur->name, BAD_CAST "lang")) &&
1353 (xmlStrEqual(cur->ns->prefix, BAD_CAST "xml")))
1354 xml_lang = cur;
1355 else if ((cur->ns == NULL) &&
1356 ((cur->children == NULL) ||
1357 (cur->children->content == NULL) ||
1358 (cur->children->content[0] == 0)) &&
1359 (htmlIsBooleanAttr(cur->name))) {
1360 if (cur->children != NULL)
1361 xmlFreeNode(cur->children);
1362 cur->children = xmlNewText(cur->name);
1363 if (cur->children != NULL)
1364 cur->children->parent = (xmlNodePtr) cur;
1365 }
1366 xmlAttrDumpOutput(ctxt, cur);
1367 cur = cur->next;
1368 }
1369 /*
1370 * C.8
1371 */
1372 if ((name != NULL) && (id == NULL)) {
1373 if ((parent != NULL) && (parent->name != NULL) &&
1374 ((xmlStrEqual(parent->name, BAD_CAST "a")) ||
1375 (xmlStrEqual(parent->name, BAD_CAST "p")) ||
1376 (xmlStrEqual(parent->name, BAD_CAST "div")) ||
1377 (xmlStrEqual(parent->name, BAD_CAST "img")) ||
1378 (xmlStrEqual(parent->name, BAD_CAST "map")) ||
1379 (xmlStrEqual(parent->name, BAD_CAST "applet")) ||
1380 (xmlStrEqual(parent->name, BAD_CAST "form")) ||
1381 (xmlStrEqual(parent->name, BAD_CAST "frame")) ||
1382 (xmlStrEqual(parent->name, BAD_CAST "iframe")))) {
1383 xmlOutputBufferWrite(buf, 5, " id=\"");
1384 xmlAttrSerializeContent(buf, name);
1385 xmlOutputBufferWrite(buf, 1, "\"");
1386 }
1387 }
1388 /*
1389 * C.7.
1390 */
1391 if ((lang != NULL) && (xml_lang == NULL)) {
1392 xmlOutputBufferWrite(buf, 11, " xml:lang=\"");
1393 xmlAttrSerializeContent(buf, lang);
1394 xmlOutputBufferWrite(buf, 1, "\"");
1395 } else
1396 if ((xml_lang != NULL) && (lang == NULL)) {
1397 xmlOutputBufferWrite(buf, 7, " lang=\"");
1398 xmlAttrSerializeContent(buf, xml_lang);
1399 xmlOutputBufferWrite(buf, 1, "\"");
1400 }
1401 }
1402
1403 /**
1404 * xhtmlNodeListDumpOutput:
1405 * @buf: the XML buffer output
1406 * @doc: the XHTML document
1407 * @cur: the first node
1408 * @level: the imbrication level for indenting
1409 * @format: is formatting allowed
1410 * @encoding: an optional encoding string
1411 *
1412 * Dump an XML node list, recursive behaviour, children are printed too.
1413 * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
1414 * or xmlKeepBlanksDefault(0) was called
1415 */
1416 static void
1417 xhtmlNodeListDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur) {
1418 xmlOutputBufferPtr buf;
1419
1420 if (cur == NULL) return;
1421 buf = ctxt->buf;
1422 while (cur != NULL) {
1423 if ((ctxt->format == 1) && (xmlIndentTreeOutput) &&
1424 (cur->type == XML_ELEMENT_NODE))
1425 xmlOutputBufferWrite(buf, ctxt->indent_size *
1426 (ctxt->level > ctxt->indent_nr ?
1427 ctxt->indent_nr : ctxt->level),
1428 ctxt->indent);
1429 xhtmlNodeDumpOutput(ctxt, cur);
1430 if (ctxt->format == 1) {
1431 xmlOutputBufferWrite(buf, 1, "\n");
1432 }
1433 cur = cur->next;
1434 }
1435 }
1436
1437 /**
1438 * xhtmlNodeDumpOutput:
1439 * @buf: the XML buffer output
1440 * @doc: the XHTML document
1441 * @cur: the current node
1442 * @level: the imbrication level for indenting
1443 * @format: is formatting allowed
1444 * @encoding: an optional encoding string
1445 *
1446 * Dump an XHTML node, recursive behaviour, children are printed too.
1447 */
1448 static void
1449 xhtmlNodeDumpOutput(xmlSaveCtxtPtr ctxt, xmlNodePtr cur) {
1450 int format, addmeta = 0;
1451 xmlNodePtr tmp;
1452 xmlChar *start, *end;
1453 xmlOutputBufferPtr buf;
1454
1455 if (cur == NULL) return;
1456 if ((cur->type == XML_DOCUMENT_NODE) ||
1457 (cur->type == XML_HTML_DOCUMENT_NODE)) {
1458 xmlDocContentDumpOutput(ctxt, (xmlDocPtr) cur);
1459 return;
1460 }
1461 if (cur->type == XML_XINCLUDE_START)
1462 return;
1463 if (cur->type == XML_XINCLUDE_END)
1464 return;
1465 if (cur->type == XML_NAMESPACE_DECL) {
1466 xmlNsDumpOutputCtxt(ctxt, (xmlNsPtr) cur);
1467 return;
1468 }
1469 if (cur->type == XML_DTD_NODE) {
1470 xmlDtdDumpOutput(ctxt, (xmlDtdPtr) cur);
1471 return;
1472 }
1473 if (cur->type == XML_DOCUMENT_FRAG_NODE) {
1474 xhtmlNodeListDumpOutput(ctxt, cur->children);
1475 return;
1476 }
1477 buf = ctxt->buf;
1478 if (cur->type == XML_ELEMENT_DECL) {
1479 xmlBufDumpElementDecl(buf->buffer, (xmlElementPtr) cur);
1480 return;
1481 }
1482 if (cur->type == XML_ATTRIBUTE_DECL) {
1483 xmlBufDumpAttributeDecl(buf->buffer, (xmlAttributePtr) cur);
1484 return;
1485 }
1486 if (cur->type == XML_ENTITY_DECL) {
1487 xmlBufDumpEntityDecl(buf->buffer, (xmlEntityPtr) cur);
1488 return;
1489 }
1490 if (cur->type == XML_TEXT_NODE) {
1491 if (cur->content != NULL) {
1492 if ((cur->name == xmlStringText) ||
1493 (cur->name != xmlStringTextNoenc)) {
1494 xmlOutputBufferWriteEscape(buf, cur->content, ctxt->escape);
1495 } else {
1496 /*
1497 * Disable escaping, needed for XSLT
1498 */
1499 xmlOutputBufferWriteString(buf, (const char *) cur->content);
1500 }
1501 }
1502
1503 return;
1504 }
1505 if (cur->type == XML_PI_NODE) {
1506 if (cur->content != NULL) {
1507 xmlOutputBufferWrite(buf, 2, "<?");
1508 xmlOutputBufferWriteString(buf, (const char *)cur->name);
1509 if (cur->content != NULL) {
1510 xmlOutputBufferWrite(buf, 1, " ");
1511 xmlOutputBufferWriteString(buf, (const char *)cur->content);
1512 }
1513 xmlOutputBufferWrite(buf, 2, "?>");
1514 } else {
1515 xmlOutputBufferWrite(buf, 2, "<?");
1516 xmlOutputBufferWriteString(buf, (const char *)cur->name);
1517 xmlOutputBufferWrite(buf, 2, "?>");
1518 }
1519 return;
1520 }
1521 if (cur->type == XML_COMMENT_NODE) {
1522 if (cur->content != NULL) {
1523 xmlOutputBufferWrite(buf, 4, "<!--");
1524 xmlOutputBufferWriteString(buf, (const char *)cur->content);
1525 xmlOutputBufferWrite(buf, 3, "-->");
1526 }
1527 return;
1528 }
1529 if (cur->type == XML_ENTITY_REF_NODE) {
1530 xmlOutputBufferWrite(buf, 1, "&");
1531 xmlOutputBufferWriteString(buf, (const char *)cur->name);
1532 xmlOutputBufferWrite(buf, 1, ";");
1533 return;
1534 }
1535 if (cur->type == XML_CDATA_SECTION_NODE) {
1536 if (cur->content == NULL || *cur->content == '\0') {
1537 xmlOutputBufferWrite(buf, 12, "<![CDATA[]]>");
1538 } else {
1539 start = end = cur->content;
1540 while (*end != '\0') {
1541 if (*end == ']' && *(end + 1) == ']' && *(end + 2) == '>') {
1542 end = end + 2;
1543 xmlOutputBufferWrite(buf, 9, "<![CDATA[");
1544 xmlOutputBufferWrite(buf, end - start, (const char *)start);
1545 xmlOutputBufferWrite(buf, 3, "]]>");
1546 start = end;
1547 }
1548 end++;
1549 }
1550 if (start != end) {
1551 xmlOutputBufferWrite(buf, 9, "<![CDATA[");
1552 xmlOutputBufferWriteString(buf, (const char *)start);
1553 xmlOutputBufferWrite(buf, 3, "]]>");
1554 }
1555 }
1556 return;
1557 }
1558 if (cur->type == XML_ATTRIBUTE_NODE) {
1559 xmlAttrDumpOutput(ctxt, (xmlAttrPtr) cur);
1560 return;
1561 }
1562
1563 format = ctxt->format;
1564 if (format == 1) {
1565 tmp = cur->children;
1566 while (tmp != NULL) {
1567 if ((tmp->type == XML_TEXT_NODE) ||
1568 (tmp->type == XML_ENTITY_REF_NODE)) {
1569 format = 0;
1570 break;
1571 }
1572 tmp = tmp->next;
1573 }
1574 }
1575 xmlOutputBufferWrite(buf, 1, "<");
1576 if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
1577 xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
1578 xmlOutputBufferWrite(buf, 1, ":");
1579 }
1580
1581 xmlOutputBufferWriteString(buf, (const char *)cur->name);
1582 if (cur->nsDef)
1583 xmlNsListDumpOutputCtxt(ctxt, cur->nsDef);
1584 if ((xmlStrEqual(cur->name, BAD_CAST "html") &&
1585 (cur->ns == NULL) && (cur->nsDef == NULL))) {
1586 /*
1587 * 3.1.1. Strictly Conforming Documents A.3.1.1 3/
1588 */
1589 xmlOutputBufferWriteString(buf,
1590 " xmlns=\"http://www.w3.org/1999/xhtml\"");
1591 }
1592 if (cur->properties != NULL)
1593 xhtmlAttrListDumpOutput(ctxt, cur->properties);
1594
1595 if ((cur->type == XML_ELEMENT_NODE) &&
1596 (cur->parent != NULL) &&
1597 (cur->parent->parent == (xmlNodePtr) cur->doc) &&
1598 xmlStrEqual(cur->name, BAD_CAST"head") &&
1599 xmlStrEqual(cur->parent->name, BAD_CAST"html")) {
1600
1601 tmp = cur->children;
1602 while (tmp != NULL) {
1603 if (xmlStrEqual(tmp->name, BAD_CAST"meta")) {
1604 xmlChar *httpequiv;
1605
1606 httpequiv = xmlGetProp(tmp, BAD_CAST"http-equiv");
1607 if (httpequiv != NULL) {
1608 if (xmlStrcasecmp(httpequiv, BAD_CAST"Content-Type") == 0) {
1609 xmlFree(httpequiv);
1610 break;
1611 }
1612 xmlFree(httpequiv);
1613 }
1614 }
1615 tmp = tmp->next;
1616 }
1617 if (tmp == NULL)
1618 addmeta = 1;
1619 }
1620
1621 if ((cur->type == XML_ELEMENT_NODE) && (cur->children == NULL)) {
1622 if (((cur->ns == NULL) || (cur->ns->prefix == NULL)) &&
1623 ((xhtmlIsEmpty(cur) == 1) && (addmeta == 0))) {
1624 /*
1625 * C.2. Empty Elements
1626 */
1627 xmlOutputBufferWrite(buf, 3, " />");
1628 } else {
1629 if (addmeta == 1) {
1630 xmlOutputBufferWrite(buf, 1, ">");
1631 if (ctxt->format == 1) {
1632 xmlOutputBufferWrite(buf, 1, "\n");
1633 if (xmlIndentTreeOutput)
1634 xmlOutputBufferWrite(buf, ctxt->indent_size *
1635 (ctxt->level + 1 > ctxt->indent_nr ?
1636 ctxt->indent_nr : ctxt->level + 1), ctxt->indent);
1637 }
1638 xmlOutputBufferWriteString(buf,
1639 "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=");
1640 if (ctxt->encoding) {
1641 xmlOutputBufferWriteString(buf, (const char *)ctxt->encoding);
1642 } else {
1643 xmlOutputBufferWrite(buf, 5, "UTF-8");
1644 }
1645 xmlOutputBufferWrite(buf, 4, "\" />");
1646 if (ctxt->format == 1)
1647 xmlOutputBufferWrite(buf, 1, "\n");
1648 } else {
1649 xmlOutputBufferWrite(buf, 1, ">");
1650 }
1651 /*
1652 * C.3. Element Minimization and Empty Element Content
1653 */
1654 xmlOutputBufferWrite(buf, 2, "</");
1655 if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
1656 xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
1657 xmlOutputBufferWrite(buf, 1, ":");
1658 }
1659 xmlOutputBufferWriteString(buf, (const char *)cur->name);
1660 xmlOutputBufferWrite(buf, 1, ">");
1661 }
1662 return;
1663 }
1664 xmlOutputBufferWrite(buf, 1, ">");
1665 if (addmeta == 1) {
1666 if (ctxt->format == 1) {
1667 xmlOutputBufferWrite(buf, 1, "\n");
1668 if (xmlIndentTreeOutput)
1669 xmlOutputBufferWrite(buf, ctxt->indent_size *
1670 (ctxt->level + 1 > ctxt->indent_nr ?
1671 ctxt->indent_nr : ctxt->level + 1), ctxt->indent);
1672 }
1673 xmlOutputBufferWriteString(buf,
1674 "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=");
1675 if (ctxt->encoding) {
1676 xmlOutputBufferWriteString(buf, (const char *)ctxt->encoding);
1677 } else {
1678 xmlOutputBufferWrite(buf, 5, "UTF-8");
1679 }
1680 xmlOutputBufferWrite(buf, 4, "\" />");
1681 }
1682 if ((cur->type != XML_ELEMENT_NODE) && (cur->content != NULL)) {
1683 xmlOutputBufferWriteEscape(buf, cur->content, ctxt->escape);
1684 }
1685
1686 #if 0
1687 /*
1688 * This was removed due to problems with HTML processors.
1689 * See bug #345147.
1690 */
1691 /*
1692 * 4.8. Script and Style elements
1693 */
1694 if ((cur->type == XML_ELEMENT_NODE) &&
1695 ((xmlStrEqual(cur->name, BAD_CAST "script")) ||
1696 (xmlStrEqual(cur->name, BAD_CAST "style"))) &&
1697 ((cur->ns == NULL) ||
1698 (xmlStrEqual(cur->ns->href, XHTML_NS_NAME)))) {
1699 xmlNodePtr child = cur->children;
1700
1701 while (child != NULL) {
1702 if (child->type == XML_TEXT_NODE) {
1703 if ((xmlStrchr(child->content, '<') == NULL) &&
1704 (xmlStrchr(child->content, '&') == NULL) &&
1705 (xmlStrstr(child->content, BAD_CAST "]]>") == NULL)) {
1706 /* Nothing to escape, so just output as is... */
1707 /* FIXME: Should we do something about "--" also? */
1708 int level = ctxt->level;
1709 int indent = ctxt->format;
1710
1711 ctxt->level = 0;
1712 ctxt->format = 0;
1713 xmlOutputBufferWriteString(buf, (const char *) child->content);
1714 /* (We cannot use xhtmlNodeDumpOutput() here because
1715 * we wish to leave '>' unescaped!) */
1716 ctxt->level = level;
1717 ctxt->format = indent;
1718 } else {
1719 /* We must use a CDATA section. Unfortunately,
1720 * this will break CSS and JavaScript when read by
1721 * a browser in HTML4-compliant mode. :-( */
1722 start = end = child->content;
1723 while (*end != '\0') {
1724 if (*end == ']' &&
1725 *(end + 1) == ']' &&
1726 *(end + 2) == '>') {
1727 end = end + 2;
1728 xmlOutputBufferWrite(buf, 9, "<![CDATA[");
1729 xmlOutputBufferWrite(buf, end - start,
1730 (const char *)start);
1731 xmlOutputBufferWrite(buf, 3, "]]>");
1732 start = end;
1733 }
1734 end++;
1735 }
1736 if (start != end) {
1737 xmlOutputBufferWrite(buf, 9, "<![CDATA[");
1738 xmlOutputBufferWrite(buf, end - start,
1739 (const char *)start);
1740 xmlOutputBufferWrite(buf, 3, "]]>");
1741 }
1742 }
1743 } else {
1744 int level = ctxt->level;
1745 int indent = ctxt->format;
1746
1747 ctxt->level = 0;
1748 ctxt->format = 0;
1749 xhtmlNodeDumpOutput(ctxt, child);
1750 ctxt->level = level;
1751 ctxt->format = indent;
1752 }
1753 child = child->next;
1754 }
1755 }
1756 #endif
1757
1758 if (cur->children != NULL) {
1759 int indent = ctxt->format;
1760
1761 if (format == 1) xmlOutputBufferWrite(buf, 1, "\n");
1762 if (ctxt->level >= 0) ctxt->level++;
1763 ctxt->format = format;
1764 xhtmlNodeListDumpOutput(ctxt, cur->children);
1765 if (ctxt->level > 0) ctxt->level--;
1766 ctxt->format = indent;
1767 if ((xmlIndentTreeOutput) && (format == 1))
1768 xmlOutputBufferWrite(buf, ctxt->indent_size *
1769 (ctxt->level > ctxt->indent_nr ?
1770 ctxt->indent_nr : ctxt->level),
1771 ctxt->indent);
1772 }
1773 xmlOutputBufferWrite(buf, 2, "</");
1774 if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
1775 xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
1776 xmlOutputBufferWrite(buf, 1, ":");
1777 }
1778
1779 xmlOutputBufferWriteString(buf, (const char *)cur->name);
1780 xmlOutputBufferWrite(buf, 1, ">");
1781 }
1782 #endif
1783
1784 /************************************************************************
1785 * *
1786 * Public entry points *
1787 * *
1788 ************************************************************************/
1789
1790 /**
1791 * xmlSaveToFd:
1792 * @fd: a file descriptor number
1793 * @encoding: the encoding name to use or NULL
1794 * @options: a set of xmlSaveOptions
1795 *
1796 * Create a document saving context serializing to a file descriptor
1797 * with the encoding and the options given.
1798 *
1799 * Returns a new serialization context or NULL in case of error.
1800 */
1801 xmlSaveCtxtPtr
1802 xmlSaveToFd(int fd, const char *encoding, int options)
1803 {
1804 xmlSaveCtxtPtr ret;
1805
1806 ret = xmlNewSaveCtxt(encoding, options);
1807 if (ret == NULL) return(NULL);
1808 ret->buf = xmlOutputBufferCreateFd(fd, ret->handler);
1809 if (ret->buf == NULL) {
1810 xmlFreeSaveCtxt(ret);
1811 return(NULL);
1812 }
1813 return(ret);
1814 }
1815
1816 /**
1817 * xmlSaveToFilename:
1818 * @filename: a file name or an URL
1819 * @encoding: the encoding name to use or NULL
1820 * @options: a set of xmlSaveOptions
1821 *
1822 * Create a document saving context serializing to a filename or possibly
1823 * to an URL (but this is less reliable) with the encoding and the options
1824 * given.
1825 *
1826 * Returns a new serialization context or NULL in case of error.
1827 */
1828 xmlSaveCtxtPtr
1829 xmlSaveToFilename(const char *filename, const char *encoding, int options)
1830 {
1831 xmlSaveCtxtPtr ret;
1832 int compression = 0; /* TODO handle compression option */
1833
1834 ret = xmlNewSaveCtxt(encoding, options);
1835 if (ret == NULL) return(NULL);
1836 ret->buf = xmlOutputBufferCreateFilename(filename, ret->handler,
1837 compression);
1838 if (ret->buf == NULL) {
1839 xmlFreeSaveCtxt(ret);
1840 return(NULL);
1841 }
1842 return(ret);
1843 }
1844
1845 /**
1846 * xmlSaveToBuffer:
1847 * @buffer: a buffer
1848 * @encoding: the encoding name to use or NULL
1849 * @options: a set of xmlSaveOptions
1850 *
1851 * Create a document saving context serializing to a buffer
1852 * with the encoding and the options given
1853 *
1854 * Returns a new serialization context or NULL in case of error.
1855 */
1856
1857 xmlSaveCtxtPtr
1858 xmlSaveToBuffer(xmlBufferPtr buffer, const char *encoding, int options)
1859 {
1860 xmlSaveCtxtPtr ret;
1861 xmlOutputBufferPtr out_buff;
1862 xmlCharEncodingHandlerPtr handler;
1863
1864 ret = xmlNewSaveCtxt(encoding, options);
1865 if (ret == NULL) return(NULL);
1866
1867 if (encoding != NULL) {
1868 handler = xmlFindCharEncodingHandler(encoding);
1869 if (handler == NULL) {
1870 xmlFree(ret);
1871 return(NULL);
1872 }
1873 } else
1874 handler = NULL;
1875 out_buff = xmlOutputBufferCreateBuffer(buffer, handler);
1876 if (out_buff == NULL) {
1877 xmlFree(ret);
1878 if (handler) xmlCharEncCloseFunc(handler);
1879 return(NULL);
1880 }
1881
1882 ret->buf = out_buff;
1883 return(ret);
1884 }
1885
1886 /**
1887 * xmlSaveToIO:
1888 * @iowrite: an I/O write function
1889 * @ioclose: an I/O close function
1890 * @ioctx: an I/O handler
1891 * @encoding: the encoding name to use or NULL
1892 * @options: a set of xmlSaveOptions
1893 *
1894 * Create a document saving context serializing to a file descriptor
1895 * with the encoding and the options given
1896 *
1897 * Returns a new serialization context or NULL in case of error.
1898 */
1899 xmlSaveCtxtPtr
1900 xmlSaveToIO(xmlOutputWriteCallback iowrite,
1901 xmlOutputCloseCallback ioclose,
1902 void *ioctx, const char *encoding, int options)
1903 {
1904 xmlSaveCtxtPtr ret;
1905
1906 ret = xmlNewSaveCtxt(encoding, options);
1907 if (ret == NULL) return(NULL);
1908 ret->buf = xmlOutputBufferCreateIO(iowrite, ioclose, ioctx, ret->handler);
1909 if (ret->buf == NULL) {
1910 xmlFreeSaveCtxt(ret);
1911 return(NULL);
1912 }
1913 return(ret);
1914 }
1915
1916 /**
1917 * xmlSaveDoc:
1918 * @ctxt: a document saving context
1919 * @doc: a document
1920 *
1921 * Save a full document to a saving context
1922 * TODO: The function is not fully implemented yet as it does not return the
1923 * byte count but 0 instead
1924 *
1925 * Returns the number of byte written or -1 in case of error
1926 */
1927 long
1928 xmlSaveDoc(xmlSaveCtxtPtr ctxt, xmlDocPtr doc)
1929 {
1930 long ret = 0;
1931
1932 if ((ctxt == NULL) || (doc == NULL)) return(-1);
1933 if (xmlDocContentDumpOutput(ctxt, doc) < 0)
1934 return(-1);
1935 return(ret);
1936 }
1937
1938 /**
1939 * xmlSaveTree:
1940 * @ctxt: a document saving context
1941 * @node: the top node of the subtree to save
1942 *
1943 * Save a subtree starting at the node parameter to a saving context
1944 * TODO: The function is not fully implemented yet as it does not return the
1945 * byte count but 0 instead
1946 *
1947 * Returns the number of byte written or -1 in case of error
1948 */
1949 long
1950 xmlSaveTree(xmlSaveCtxtPtr ctxt, xmlNodePtr node)
1951 {
1952 long ret = 0;
1953
1954 if ((ctxt == NULL) || (node == NULL)) return(-1);
1955 xmlNodeDumpOutputInternal(ctxt, node);
1956 return(ret);
1957 }
1958
1959 /**
1960 * xmlSaveFlush:
1961 * @ctxt: a document saving context
1962 *
1963 * Flush a document saving context, i.e. make sure that all bytes have
1964 * been output.
1965 *
1966 * Returns the number of byte written or -1 in case of error.
1967 */
1968 int
1969 xmlSaveFlush(xmlSaveCtxtPtr ctxt)
1970 {
1971 if (ctxt == NULL) return(-1);
1972 if (ctxt->buf == NULL) return(-1);
1973 return(xmlOutputBufferFlush(ctxt->buf));
1974 }
1975
1976 /**
1977 * xmlSaveClose:
1978 * @ctxt: a document saving context
1979 *
1980 * Close a document saving context, i.e. make sure that all bytes have
1981 * been output and free the associated data.
1982 *
1983 * Returns the number of byte written or -1 in case of error.
1984 */
1985 int
1986 xmlSaveClose(xmlSaveCtxtPtr ctxt)
1987 {
1988 int ret;
1989
1990 if (ctxt == NULL) return(-1);
1991 ret = xmlSaveFlush(ctxt);
1992 xmlFreeSaveCtxt(ctxt);
1993 return(ret);
1994 }
1995
1996 /**
1997 * xmlSaveSetEscape:
1998 * @ctxt: a document saving context
1999 * @escape: the escaping function
2000 *
2001 * Set a custom escaping function to be used for text in element content
2002 *
2003 * Returns 0 if successful or -1 in case of error.
2004 */
2005 int
2006 xmlSaveSetEscape(xmlSaveCtxtPtr ctxt, xmlCharEncodingOutputFunc escape)
2007 {
2008 if (ctxt == NULL) return(-1);
2009 ctxt->escape = escape;
2010 return(0);
2011 }
2012
2013 /**
2014 * xmlSaveSetAttrEscape:
2015 * @ctxt: a document saving context
2016 * @escape: the escaping function
2017 *
2018 * Set a custom escaping function to be used for text in attribute content
2019 *
2020 * Returns 0 if successful or -1 in case of error.
2021 */
2022 int
2023 xmlSaveSetAttrEscape(xmlSaveCtxtPtr ctxt, xmlCharEncodingOutputFunc escape)
2024 {
2025 if (ctxt == NULL) return(-1);
2026 ctxt->escapeAttr = escape;
2027 return(0);
2028 }
2029
2030 /************************************************************************
2031 * *
2032 * Public entry points based on buffers *
2033 * *
2034 ************************************************************************/
2035
2036 /**
2037 * xmlBufAttrSerializeTxtContent:
2038 * @buf: and xmlBufPtr output
2039 * @doc: the document
2040 * @attr: the attribute node
2041 * @string: the text content
2042 *
2043 * Serialize text attribute values to an xmlBufPtr
2044 */
2045 void
2046 xmlBufAttrSerializeTxtContent(xmlBufPtr buf, xmlDocPtr doc,
2047 xmlAttrPtr attr, const xmlChar * string)
2048 {
2049 xmlChar *base, *cur;
2050
2051 if (string == NULL)
2052 return;
2053 base = cur = (xmlChar *) string;
2054 while (*cur != 0) {
2055 if (*cur == '\n') {
2056 if (base != cur)
2057 xmlBufAdd(buf, base, cur - base);
2058 xmlBufAdd(buf, BAD_CAST "&#10;", 5);
2059 cur++;
2060 base = cur;
2061 } else if (*cur == '\r') {
2062 if (base != cur)
2063 xmlBufAdd(buf, base, cur - base);
2064 xmlBufAdd(buf, BAD_CAST "&#13;", 5);
2065 cur++;
2066 base = cur;
2067 } else if (*cur == '\t') {
2068 if (base != cur)
2069 xmlBufAdd(buf, base, cur - base);
2070 xmlBufAdd(buf, BAD_CAST "&#9;", 4);
2071 cur++;
2072 base = cur;
2073 } else if (*cur == '"') {
2074 if (base != cur)
2075 xmlBufAdd(buf, base, cur - base);
2076 xmlBufAdd(buf, BAD_CAST "&quot;", 6);
2077 cur++;
2078 base = cur;
2079 } else if (*cur == '<') {
2080 if (base != cur)
2081 xmlBufAdd(buf, base, cur - base);
2082 xmlBufAdd(buf, BAD_CAST "&lt;", 4);
2083 cur++;
2084 base = cur;
2085 } else if (*cur == '>') {
2086 if (base != cur)
2087 xmlBufAdd(buf, base, cur - base);
2088 xmlBufAdd(buf, BAD_CAST "&gt;", 4);
2089 cur++;
2090 base = cur;
2091 } else if (*cur == '&') {
2092 if (base != cur)
2093 xmlBufAdd(buf, base, cur - base);
2094 xmlBufAdd(buf, BAD_CAST "&amp;", 5);
2095 cur++;
2096 base = cur;
2097 } else if ((*cur >= 0x80) && (cur[1] != 0) &&
2098 ((doc == NULL) || (doc->encoding == NULL))) {
2099 /*
2100 * We assume we have UTF-8 content.
2101 */
2102 unsigned char tmp[12];
2103 int val = 0, l = 1;
2104
2105 if (base != cur)
2106 xmlBufAdd(buf, base, cur - base);
2107 if (*cur < 0xC0) {
2108 xmlSaveErr(XML_SAVE_NOT_UTF8, (xmlNodePtr) attr, NULL);
2109 xmlSerializeHexCharRef(tmp, *cur);
2110 xmlBufAdd(buf, (xmlChar *) tmp, -1);
2111 cur++;
2112 base = cur;
2113 continue;
2114 } else if (*cur < 0xE0) {
2115 val = (cur[0]) & 0x1F;
2116 val <<= 6;
2117 val |= (cur[1]) & 0x3F;
2118 l = 2;
2119 } else if ((*cur < 0xF0) && (cur [2] != 0)) {
2120 val = (cur[0]) & 0x0F;
2121 val <<= 6;
2122 val |= (cur[1]) & 0x3F;
2123 val <<= 6;
2124 val |= (cur[2]) & 0x3F;
2125 l = 3;
2126 } else if ((*cur < 0xF8) && (cur [2] != 0) && (cur[3] != 0)) {
2127 val = (cur[0]) & 0x07;
2128 val <<= 6;
2129 val |= (cur[1]) & 0x3F;
2130 val <<= 6;
2131 val |= (cur[2]) & 0x3F;
2132 val <<= 6;
2133 val |= (cur[3]) & 0x3F;
2134 l = 4;
2135 }
2136 if ((l == 1) || (!IS_CHAR(val))) {
2137 xmlSaveErr(XML_SAVE_CHAR_INVALID, (xmlNodePtr) attr, NULL);
2138 xmlSerializeHexCharRef(tmp, *cur);
2139 xmlBufAdd(buf, (xmlChar *) tmp, -1);
2140 cur++;
2141 base = cur;
2142 continue;
2143 }
2144 /*
2145 * We could do multiple things here. Just save
2146 * as a char ref
2147 */
2148 xmlSerializeHexCharRef(tmp, val);
2149 xmlBufAdd(buf, (xmlChar *) tmp, -1);
2150 cur += l;
2151 base = cur;
2152 } else {
2153 cur++;
2154 }
2155 }
2156 if (base != cur)
2157 xmlBufAdd(buf, base, cur - base);
2158 }
2159
2160 /**
2161 * xmlAttrSerializeTxtContent:
2162 * @buf: the XML buffer output
2163 * @doc: the document
2164 * @attr: the attribute node
2165 * @string: the text content
2166 *
2167 * Serialize text attribute values to an xml simple buffer
2168 */
2169 void
2170 xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr doc,
2171 xmlAttrPtr attr, const xmlChar * string)
2172 {
2173 xmlBufPtr buffer;
2174
2175 if ((buf == NULL) || (string == NULL))
2176 return;
2177 buffer = xmlBufFromBuffer(buf);
2178 if (buffer == NULL)
2179 return;
2180 xmlBufAttrSerializeTxtContent(buffer, doc, attr, string);
2181 xmlBufBackToBuffer(buffer);
2182 }
2183
2184 /**
2185 * xmlNodeDump:
2186 * @buf: the XML buffer output
2187 * @doc: the document
2188 * @cur: the current node
2189 * @level: the imbrication level for indenting
2190 * @format: is formatting allowed
2191 *
2192 * Dump an XML node, recursive behaviour,children are printed too.
2193 * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
2194 * or xmlKeepBlanksDefault(0) was called
2195 * Since this is using xmlBuffer structures it is limited to 2GB and somehow
2196 * deprecated, use xmlBufNodeDump() instead.
2197 *
2198 * Returns the number of bytes written to the buffer or -1 in case of error
2199 */
2200 int
2201 xmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur, int level,
2202 int format)
2203 {
2204 xmlBufPtr buffer;
2205 int ret;
2206
2207 if ((buf == NULL) || (cur == NULL))
2208 return(-1);
2209 buffer = xmlBufFromBuffer(buf);
2210 if (buffer == NULL)
2211 return(-1);
2212 ret = xmlBufNodeDump(buffer, doc, cur, level, format);
2213 xmlBufBackToBuffer(buffer);
2214 if (ret > INT_MAX)
2215 return(-1);
2216 return((int) ret);
2217 }
2218
2219 /**
2220 * xmlBufNodeDump:
2221 * @buf: the XML buffer output
2222 * @doc: the document
2223 * @cur: the current node
2224 * @level: the imbrication level for indenting
2225 * @format: is formatting allowed
2226 *
2227 * Dump an XML node, recursive behaviour,children are printed too.
2228 * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
2229 * or xmlKeepBlanksDefault(0) was called
2230 *
2231 * Returns the number of bytes written to the buffer, in case of error 0
2232 * is returned or @buf stores the error
2233 */
2234
2235 size_t
2236 xmlBufNodeDump(xmlBufPtr buf, xmlDocPtr doc, xmlNodePtr cur, int level,
2237 int format)
2238 {
2239 size_t use;
2240 int ret;
2241 xmlOutputBufferPtr outbuf;
2242 int oldalloc;
2243
2244 xmlInitParser();
2245
2246 if (cur == NULL) {
2247 #ifdef DEBUG_TREE
2248 xmlGenericError(xmlGenericErrorContext,
2249 "xmlNodeDump : node == NULL\n");
2250 #endif
2251 return (-1);
2252 }
2253 if (buf == NULL) {
2254 #ifdef DEBUG_TREE
2255 xmlGenericError(xmlGenericErrorContext,
2256 "xmlNodeDump : buf == NULL\n");
2257 #endif
2258 return (-1);
2259 }
2260 outbuf = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer));
2261 if (outbuf == NULL) {
2262 xmlSaveErrMemory("creating buffer");
2263 return (-1);
2264 }
2265 memset(outbuf, 0, (size_t) sizeof(xmlOutputBuffer));
2266 outbuf->buffer = buf;
2267 outbuf->encoder = NULL;
2268 outbuf->writecallback = NULL;
2269 outbuf->closecallback = NULL;
2270 outbuf->context = NULL;
2271 outbuf->written = 0;
2272
2273 use = xmlBufUse(buf);
2274 oldalloc = xmlBufGetAllocationScheme(buf);
2275 xmlBufSetAllocationScheme(buf, XML_BUFFER_ALLOC_DOUBLEIT);
2276 xmlNodeDumpOutput(outbuf, doc, cur, level, format, NULL);
2277 xmlBufSetAllocationScheme(buf, oldalloc);
2278 xmlFree(outbuf);
2279 ret = xmlBufUse(buf) - use;
2280 return (ret);
2281 }
2282
2283 /**
2284 * xmlElemDump:
2285 * @f: the FILE * for the output
2286 * @doc: the document
2287 * @cur: the current node
2288 *
2289 * Dump an XML/HTML node, recursive behaviour, children are printed too.
2290 */
2291 void
2292 xmlElemDump(FILE * f, xmlDocPtr doc, xmlNodePtr cur)
2293 {
2294 xmlOutputBufferPtr outbuf;
2295
2296 xmlInitParser();
2297
2298 if (cur == NULL) {
2299 #ifdef DEBUG_TREE
2300 xmlGenericError(xmlGenericErrorContext,
2301 "xmlElemDump : cur == NULL\n");
2302 #endif
2303 return;
2304 }
2305 #ifdef DEBUG_TREE
2306 if (doc == NULL) {
2307 xmlGenericError(xmlGenericErrorContext,
2308 "xmlElemDump : doc == NULL\n");
2309 }
2310 #endif
2311
2312 outbuf = xmlOutputBufferCreateFile(f, NULL);
2313 if (outbuf == NULL)
2314 return;
2315 if ((doc != NULL) && (doc->type == XML_HTML_DOCUMENT_NODE)) {
2316 #ifdef LIBXML_HTML_ENABLED
2317 htmlNodeDumpOutput(outbuf, doc, cur, NULL);
2318 #else
2319 xmlSaveErr(XML_ERR_INTERNAL_ERROR, cur, "HTML support not compiled in\n");
2320 #endif /* LIBXML_HTML_ENABLED */
2321 } else
2322 xmlNodeDumpOutput(outbuf, doc, cur, 0, 1, NULL);
2323 xmlOutputBufferClose(outbuf);
2324 }
2325
2326 /************************************************************************
2327 * *
2328 * Saving functions front-ends *
2329 * *
2330 ************************************************************************/
2331
2332 /**
2333 * xmlNodeDumpOutput:
2334 * @buf: the XML buffer output
2335 * @doc: the document
2336 * @cur: the current node
2337 * @level: the imbrication level for indenting
2338 * @format: is formatting allowed
2339 * @encoding: an optional encoding string
2340 *
2341 * Dump an XML node, recursive behaviour, children are printed too.
2342 * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
2343 * or xmlKeepBlanksDefault(0) was called
2344 */
2345 void
2346 xmlNodeDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur,
2347 int level, int format, const char *encoding)
2348 {
2349 xmlSaveCtxt ctxt;
2350 #ifdef LIBXML_HTML_ENABLED
2351 xmlDtdPtr dtd;
2352 int is_xhtml = 0;
2353 #endif
2354
2355 xmlInitParser();
2356
2357 if ((buf == NULL) || (cur == NULL)) return;
2358
2359 if (encoding == NULL)
2360 encoding = "UTF-8";
2361
2362 memset(&ctxt, 0, sizeof(ctxt));
2363 ctxt.doc = doc;
2364 ctxt.buf = buf;
2365 ctxt.level = level;
2366 ctxt.format = format ? 1 : 0;
2367 ctxt.encoding = (const xmlChar *) encoding;
2368 xmlSaveCtxtInit(&ctxt);
2369 ctxt.options |= XML_SAVE_AS_XML;
2370
2371 #ifdef LIBXML_HTML_ENABLED
2372 dtd = xmlGetIntSubset(doc);
2373 if (dtd != NULL) {
2374 is_xhtml = xmlIsXHTML(dtd->SystemID, dtd->ExternalID);
2375 if (is_xhtml < 0)
2376 is_xhtml = 0;
2377 }
2378
2379 if (is_xhtml)
2380 xhtmlNodeDumpOutput(&ctxt, cur);
2381 else
2382 #endif
2383 xmlNodeDumpOutputInternal(&ctxt, cur);
2384 }
2385
2386 /**
2387 * xmlDocDumpFormatMemoryEnc:
2388 * @out_doc: Document to generate XML text from
2389 * @doc_txt_ptr: Memory pointer for allocated XML text
2390 * @doc_txt_len: Length of the generated XML text
2391 * @txt_encoding: Character encoding to use when generating XML text
2392 * @format: should formatting spaces been added
2393 *
2394 * Dump the current DOM tree into memory using the character encoding specified
2395 * by the caller. Note it is up to the caller of this function to free the
2396 * allocated memory with xmlFree().
2397 * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
2398 * or xmlKeepBlanksDefault(0) was called
2399 */
2400
2401 void
2402 xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc, xmlChar **doc_txt_ptr,
2403 int * doc_txt_len, const char * txt_encoding,
2404 int format) {
2405 xmlSaveCtxt ctxt;
2406 int dummy = 0;
2407 xmlOutputBufferPtr out_buff = NULL;
2408 xmlCharEncodingHandlerPtr conv_hdlr = NULL;
2409
2410 if (doc_txt_len == NULL) {
2411 doc_txt_len = &dummy; /* Continue, caller just won't get length */
2412 }
2413
2414 if (doc_txt_ptr == NULL) {
2415 *doc_txt_len = 0;
2416 return;
2417 }
2418
2419 *doc_txt_ptr = NULL;
2420 *doc_txt_len = 0;
2421
2422 if (out_doc == NULL) {
2423 /* No document, no output */
2424 return;
2425 }
2426
2427 /*
2428 * Validate the encoding value, if provided.
2429 * This logic is copied from xmlSaveFileEnc.
2430 */
2431
2432 if (txt_encoding == NULL)
2433 txt_encoding = (const char *) out_doc->encoding;
2434 if (txt_encoding != NULL) {
2435 conv_hdlr = xmlFindCharEncodingHandler(txt_encoding);
2436 if ( conv_hdlr == NULL ) {
2437 xmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, (xmlNodePtr) out_doc,
2438 txt_encoding);
2439 return;
2440 }
2441 }
2442
2443 if ((out_buff = xmlAllocOutputBuffer(conv_hdlr)) == NULL ) {
2444 xmlSaveErrMemory("creating buffer");
2445 return;
2446 }
2447
2448 memset(&ctxt, 0, sizeof(ctxt));
2449 ctxt.doc = out_doc;
2450 ctxt.buf = out_buff;
2451 ctxt.level = 0;
2452 ctxt.format = format ? 1 : 0;
2453 ctxt.encoding = (const xmlChar *) txt_encoding;
2454 xmlSaveCtxtInit(&ctxt);
2455 ctxt.options |= XML_SAVE_AS_XML;
2456 xmlDocContentDumpOutput(&ctxt, out_doc);
2457 xmlOutputBufferFlush(out_buff);
2458 if (out_buff->conv != NULL) {
2459 *doc_txt_len = xmlBufUse(out_buff->conv);
2460 *doc_txt_ptr = xmlStrndup(xmlBufContent(out_buff->conv), *doc_txt_len);
2461 } else {
2462 *doc_txt_len = xmlBufUse(out_buff->buffer);
2463 *doc_txt_ptr = xmlStrndup(xmlBufContent(out_buff->buffer),*doc_txt_len);
2464 }
2465 (void)xmlOutputBufferClose(out_buff);
2466
2467 if ((*doc_txt_ptr == NULL) && (*doc_txt_len > 0)) {
2468 *doc_txt_len = 0;
2469 xmlSaveErrMemory("creating output");
2470 }
2471
2472 return;
2473 }
2474
2475 /**
2476 * xmlDocDumpMemory:
2477 * @cur: the document
2478 * @mem: OUT: the memory pointer
2479 * @size: OUT: the memory length
2480 *
2481 * Dump an XML document in memory and return the #xmlChar * and it's size
2482 * in bytes. It's up to the caller to free the memory with xmlFree().
2483 * The resulting byte array is zero terminated, though the last 0 is not
2484 * included in the returned size.
2485 */
2486 void
2487 xmlDocDumpMemory(xmlDocPtr cur, xmlChar**mem, int *size) {
2488 xmlDocDumpFormatMemoryEnc(cur, mem, size, NULL, 0);
2489 }
2490
2491 /**
2492 * xmlDocDumpFormatMemory:
2493 * @cur: the document
2494 * @mem: OUT: the memory pointer
2495 * @size: OUT: the memory length
2496 * @format: should formatting spaces been added
2497 *
2498 *
2499 * Dump an XML document in memory and return the #xmlChar * and it's size.
2500 * It's up to the caller to free the memory with xmlFree().
2501 * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
2502 * or xmlKeepBlanksDefault(0) was called
2503 */
2504 void
2505 xmlDocDumpFormatMemory(xmlDocPtr cur, xmlChar**mem, int *size, int format) {
2506 xmlDocDumpFormatMemoryEnc(cur, mem, size, NULL, format);
2507 }
2508
2509 /**
2510 * xmlDocDumpMemoryEnc:
2511 * @out_doc: Document to generate XML text from
2512 * @doc_txt_ptr: Memory pointer for allocated XML text
2513 * @doc_txt_len: Length of the generated XML text
2514 * @txt_encoding: Character encoding to use when generating XML text
2515 *
2516 * Dump the current DOM tree into memory using the character encoding specified
2517 * by the caller. Note it is up to the caller of this function to free the
2518 * allocated memory with xmlFree().
2519 */
2520
2521 void
2522 xmlDocDumpMemoryEnc(xmlDocPtr out_doc, xmlChar **doc_txt_ptr,
2523 int * doc_txt_len, const char * txt_encoding) {
2524 xmlDocDumpFormatMemoryEnc(out_doc, doc_txt_ptr, doc_txt_len,
2525 txt_encoding, 0);
2526 }
2527
2528 /**
2529 * xmlDocFormatDump:
2530 * @f: the FILE*
2531 * @cur: the document
2532 * @format: should formatting spaces been added
2533 *
2534 * Dump an XML document to an open FILE.
2535 *
2536 * returns: the number of bytes written or -1 in case of failure.
2537 * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
2538 * or xmlKeepBlanksDefault(0) was called
2539 */
2540 int
2541 xmlDocFormatDump(FILE *f, xmlDocPtr cur, int format) {
2542 xmlSaveCtxt ctxt;
2543 xmlOutputBufferPtr buf;
2544 const char * encoding;
2545 xmlCharEncodingHandlerPtr handler = NULL;
2546 int ret;
2547
2548 if (cur == NULL) {
2549 #ifdef DEBUG_TREE
2550 xmlGenericError(xmlGenericErrorContext,
2551 "xmlDocDump : document == NULL\n");
2552 #endif
2553 return(-1);
2554 }
2555 encoding = (const char *) cur->encoding;
2556
2557 if (encoding != NULL) {
2558 handler = xmlFindCharEncodingHandler(encoding);
2559 if (handler == NULL) {
2560 xmlFree((char *) cur->encoding);
2561 cur->encoding = NULL;
2562 encoding = NULL;
2563 }
2564 }
2565 buf = xmlOutputBufferCreateFile(f, handler);
2566 if (buf == NULL) return(-1);
2567 memset(&ctxt, 0, sizeof(ctxt));
2568 ctxt.doc = cur;
2569 ctxt.buf = buf;
2570 ctxt.level = 0;
2571 ctxt.format = format ? 1 : 0;
2572 ctxt.encoding = (const xmlChar *) encoding;
2573 xmlSaveCtxtInit(&ctxt);
2574 ctxt.options |= XML_SAVE_AS_XML;
2575 xmlDocContentDumpOutput(&ctxt, cur);
2576
2577 ret = xmlOutputBufferClose(buf);
2578 return(ret);
2579 }
2580
2581 /**
2582 * xmlDocDump:
2583 * @f: the FILE*
2584 * @cur: the document
2585 *
2586 * Dump an XML document to an open FILE.
2587 *
2588 * returns: the number of bytes written or -1 in case of failure.
2589 */
2590 int
2591 xmlDocDump(FILE *f, xmlDocPtr cur) {
2592 return(xmlDocFormatDump (f, cur, 0));
2593 }
2594
2595 /**
2596 * xmlSaveFileTo:
2597 * @buf: an output I/O buffer
2598 * @cur: the document
2599 * @encoding: the encoding if any assuming the I/O layer handles the trancoding
2600 *
2601 * Dump an XML document to an I/O buffer.
2602 * Warning ! This call xmlOutputBufferClose() on buf which is not available
2603 * after this call.
2604 *
2605 * returns: the number of bytes written or -1 in case of failure.
2606 */
2607 int
2608 xmlSaveFileTo(xmlOutputBufferPtr buf, xmlDocPtr cur, const char *encoding) {
2609 xmlSaveCtxt ctxt;
2610 int ret;
2611
2612 if (buf == NULL) return(-1);
2613 if (cur == NULL) {
2614 xmlOutputBufferClose(buf);
2615 return(-1);
2616 }
2617 memset(&ctxt, 0, sizeof(ctxt));
2618 ctxt.doc = cur;
2619 ctxt.buf = buf;
2620 ctxt.level = 0;
2621 ctxt.format = 0;
2622 ctxt.encoding = (const xmlChar *) encoding;
2623 xmlSaveCtxtInit(&ctxt);
2624 ctxt.options |= XML_SAVE_AS_XML;
2625 xmlDocContentDumpOutput(&ctxt, cur);
2626 ret = xmlOutputBufferClose(buf);
2627 return(ret);
2628 }
2629
2630 /**
2631 * xmlSaveFormatFileTo:
2632 * @buf: an output I/O buffer
2633 * @cur: the document
2634 * @encoding: the encoding if any assuming the I/O layer handles the trancoding
2635 * @format: should formatting spaces been added
2636 *
2637 * Dump an XML document to an I/O buffer.
2638 * Warning ! This call xmlOutputBufferClose() on buf which is not available
2639 * after this call.
2640 *
2641 * returns: the number of bytes written or -1 in case of failure.
2642 */
2643 int
2644 xmlSaveFormatFileTo(xmlOutputBufferPtr buf, xmlDocPtr cur,
2645 const char *encoding, int format)
2646 {
2647 xmlSaveCtxt ctxt;
2648 int ret;
2649
2650 if (buf == NULL) return(-1);
2651 if ((cur == NULL) ||
2652 ((cur->type != XML_DOCUMENT_NODE) &&
2653 (cur->type != XML_HTML_DOCUMENT_NODE))) {
2654 xmlOutputBufferClose(buf);
2655 return(-1);
2656 }
2657 memset(&ctxt, 0, sizeof(ctxt));
2658 ctxt.doc = cur;
2659 ctxt.buf = buf;
2660 ctxt.level = 0;
2661 ctxt.format = format ? 1 : 0;
2662 ctxt.encoding = (const xmlChar *) encoding;
2663 xmlSaveCtxtInit(&ctxt);
2664 ctxt.options |= XML_SAVE_AS_XML;
2665 xmlDocContentDumpOutput(&ctxt, cur);
2666 ret = xmlOutputBufferClose(buf);
2667 return (ret);
2668 }
2669
2670 /**
2671 * xmlSaveFormatFileEnc:
2672 * @filename: the filename or URL to output
2673 * @cur: the document being saved
2674 * @encoding: the name of the encoding to use or NULL.
2675 * @format: should formatting spaces be added.
2676 *
2677 * Dump an XML document to a file or an URL.
2678 *
2679 * Returns the number of bytes written or -1 in case of error.
2680 * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
2681 * or xmlKeepBlanksDefault(0) was called
2682 */
2683 int
2684 xmlSaveFormatFileEnc( const char * filename, xmlDocPtr cur,
2685 const char * encoding, int format ) {
2686 xmlSaveCtxt ctxt;
2687 xmlOutputBufferPtr buf;
2688 xmlCharEncodingHandlerPtr handler = NULL;
2689 int ret;
2690
2691 if (cur == NULL)
2692 return(-1);
2693
2694 if (encoding == NULL)
2695 encoding = (const char *) cur->encoding;
2696
2697 if (encoding != NULL) {
2698
2699 handler = xmlFindCharEncodingHandler(encoding);
2700 if (handler == NULL)
2701 return(-1);
2702 }
2703
2704 #ifdef LIBXML_ZLIB_ENABLED
2705 if (cur->compression < 0) cur->compression = xmlGetCompressMode();
2706 #endif
2707 /*
2708 * save the content to a temp buffer.
2709 */
2710 buf = xmlOutputBufferCreateFilename(filename, handler, cur->compression);
2711 if (buf == NULL) return(-1);
2712 memset(&ctxt, 0, sizeof(ctxt));
2713 ctxt.doc = cur;
2714 ctxt.buf = buf;
2715 ctxt.level = 0;
2716 ctxt.format = format ? 1 : 0;
2717 ctxt.encoding = (const xmlChar *) encoding;
2718 xmlSaveCtxtInit(&ctxt);
2719 ctxt.options |= XML_SAVE_AS_XML;
2720
2721 xmlDocContentDumpOutput(&ctxt, cur);
2722
2723 ret = xmlOutputBufferClose(buf);
2724 return(ret);
2725 }
2726
2727
2728 /**
2729 * xmlSaveFileEnc:
2730 * @filename: the filename (or URL)
2731 * @cur: the document
2732 * @encoding: the name of an encoding (or NULL)
2733 *
2734 * Dump an XML document, converting it to the given encoding
2735 *
2736 * returns: the number of bytes written or -1 in case of failure.
2737 */
2738 int
2739 xmlSaveFileEnc(const char *filename, xmlDocPtr cur, const char *encoding) {
2740 return ( xmlSaveFormatFileEnc( filename, cur, encoding, 0 ) );
2741 }
2742
2743 /**
2744 * xmlSaveFormatFile:
2745 * @filename: the filename (or URL)
2746 * @cur: the document
2747 * @format: should formatting spaces been added
2748 *
2749 * Dump an XML document to a file. Will use compression if
2750 * compiled in and enabled. If @filename is "-" the stdout file is
2751 * used. If @format is set then the document will be indented on output.
2752 * Note that @format = 1 provide node indenting only if xmlIndentTreeOutput = 1
2753 * or xmlKeepBlanksDefault(0) was called
2754 *
2755 * returns: the number of bytes written or -1 in case of failure.
2756 */
2757 int
2758 xmlSaveFormatFile(const char *filename, xmlDocPtr cur, int format) {
2759 return ( xmlSaveFormatFileEnc( filename, cur, NULL, format ) );
2760 }
2761
2762 /**
2763 * xmlSaveFile:
2764 * @filename: the filename (or URL)
2765 * @cur: the document
2766 *
2767 * Dump an XML document to a file. Will use compression if
2768 * compiled in and enabled. If @filename is "-" the stdout file is
2769 * used.
2770 * returns: the number of bytes written or -1 in case of failure.
2771 */
2772 int
2773 xmlSaveFile(const char *filename, xmlDocPtr cur) {
2774 return(xmlSaveFormatFileEnc(filename, cur, NULL, 0));
2775 }
2776
2777 #endif /* LIBXML_OUTPUT_ENABLED */
2778
2779 #define bottom_xmlsave
2780 #include "elfgcchack.h"
A free Windows-compatible Operating System