xmlsave.c@ 11580

Last change on this file since 11580 was 6076, checked in by vboxsync, 17 years ago
Merged dmik/s2 branch (r25959:26751) to the trunk.
Property svn:eol-style set to `native` Property svn:keywords set to `Date Revision Author Id`
File size: 65.8 KB

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

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/libxml2-2.6.30/xmlsave.c@ 11580

Download in other formats: