Imported Upstream version 2.9.1
[platform/upstream/libxml2.git] / HTMLtree.c
1 /*
2  * HTMLtree.c : implementation of access function for an HTML tree.
3  *
4  * See Copyright for the status of this software.
5  *
6  * daniel@veillard.com
7  */
8
9
10 #define IN_LIBXML
11 #include "libxml.h"
12 #ifdef LIBXML_HTML_ENABLED
13
14 #include <string.h> /* for memset() only ! */
15
16 #ifdef HAVE_CTYPE_H
17 #include <ctype.h>
18 #endif
19 #ifdef HAVE_STDLIB_H
20 #include <stdlib.h>
21 #endif
22
23 #include <libxml/xmlmemory.h>
24 #include <libxml/HTMLparser.h>
25 #include <libxml/HTMLtree.h>
26 #include <libxml/entities.h>
27 #include <libxml/valid.h>
28 #include <libxml/xmlerror.h>
29 #include <libxml/parserInternals.h>
30 #include <libxml/globals.h>
31 #include <libxml/uri.h>
32
33 #include "buf.h"
34
35 /************************************************************************
36  *                                                                      *
37  *              Getting/Setting encoding meta tags                      *
38  *                                                                      *
39  ************************************************************************/
40
41 /**
42  * htmlGetMetaEncoding:
43  * @doc:  the document
44  *
45  * Encoding definition lookup in the Meta tags
46  *
47  * Returns the current encoding as flagged in the HTML source
48  */
49 const xmlChar *
50 htmlGetMetaEncoding(htmlDocPtr doc) {
51     htmlNodePtr cur;
52     const xmlChar *content;
53     const xmlChar *encoding;
54
55     if (doc == NULL)
56         return(NULL);
57     cur = doc->children;
58
59     /*
60      * Search the html
61      */
62     while (cur != NULL) {
63         if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {
64             if (xmlStrEqual(cur->name, BAD_CAST"html"))
65                 break;
66             if (xmlStrEqual(cur->name, BAD_CAST"head"))
67                 goto found_head;
68             if (xmlStrEqual(cur->name, BAD_CAST"meta"))
69                 goto found_meta;
70         }
71         cur = cur->next;
72     }
73     if (cur == NULL)
74         return(NULL);
75     cur = cur->children;
76
77     /*
78      * Search the head
79      */
80     while (cur != NULL) {
81         if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {
82             if (xmlStrEqual(cur->name, BAD_CAST"head"))
83                 break;
84             if (xmlStrEqual(cur->name, BAD_CAST"meta"))
85                 goto found_meta;
86         }
87         cur = cur->next;
88     }
89     if (cur == NULL)
90         return(NULL);
91 found_head:
92     cur = cur->children;
93
94     /*
95      * Search the meta elements
96      */
97 found_meta:
98     while (cur != NULL) {
99         if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {
100             if (xmlStrEqual(cur->name, BAD_CAST"meta")) {
101                 xmlAttrPtr attr = cur->properties;
102                 int http;
103                 const xmlChar *value;
104
105                 content = NULL;
106                 http = 0;
107                 while (attr != NULL) {
108                     if ((attr->children != NULL) &&
109                         (attr->children->type == XML_TEXT_NODE) &&
110                         (attr->children->next == NULL)) {
111                         value = attr->children->content;
112                         if ((!xmlStrcasecmp(attr->name, BAD_CAST"http-equiv"))
113                          && (!xmlStrcasecmp(value, BAD_CAST"Content-Type")))
114                             http = 1;
115                         else if ((value != NULL)
116                          && (!xmlStrcasecmp(attr->name, BAD_CAST"content")))
117                             content = value;
118                         if ((http != 0) && (content != NULL))
119                             goto found_content;
120                     }
121                     attr = attr->next;
122                 }
123             }
124         }
125         cur = cur->next;
126     }
127     return(NULL);
128
129 found_content:
130     encoding = xmlStrstr(content, BAD_CAST"charset=");
131     if (encoding == NULL)
132         encoding = xmlStrstr(content, BAD_CAST"Charset=");
133     if (encoding == NULL)
134         encoding = xmlStrstr(content, BAD_CAST"CHARSET=");
135     if (encoding != NULL) {
136         encoding += 8;
137     } else {
138         encoding = xmlStrstr(content, BAD_CAST"charset =");
139         if (encoding == NULL)
140             encoding = xmlStrstr(content, BAD_CAST"Charset =");
141         if (encoding == NULL)
142             encoding = xmlStrstr(content, BAD_CAST"CHARSET =");
143         if (encoding != NULL)
144             encoding += 9;
145     }
146     if (encoding != NULL) {
147         while ((*encoding == ' ') || (*encoding == '\t')) encoding++;
148     }
149     return(encoding);
150 }
151
152 /**
153  * htmlSetMetaEncoding:
154  * @doc:  the document
155  * @encoding:  the encoding string
156  *
157  * Sets the current encoding in the Meta tags
158  * NOTE: this will not change the document content encoding, just
159  * the META flag associated.
160  *
161  * Returns 0 in case of success and -1 in case of error
162  */
163 int
164 htmlSetMetaEncoding(htmlDocPtr doc, const xmlChar *encoding) {
165     htmlNodePtr cur, meta = NULL, head = NULL;
166     const xmlChar *content = NULL;
167     char newcontent[100];
168
169     newcontent[0] = 0;
170
171     if (doc == NULL)
172         return(-1);
173
174     /* html isn't a real encoding it's just libxml2 way to get entities */
175     if (!xmlStrcasecmp(encoding, BAD_CAST "html"))
176         return(-1);
177
178     if (encoding != NULL) {
179         snprintf(newcontent, sizeof(newcontent), "text/html; charset=%s",
180                 (char *)encoding);
181         newcontent[sizeof(newcontent) - 1] = 0;
182     }
183
184     cur = doc->children;
185
186     /*
187      * Search the html
188      */
189     while (cur != NULL) {
190         if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {
191             if (xmlStrcasecmp(cur->name, BAD_CAST"html") == 0)
192                 break;
193             if (xmlStrcasecmp(cur->name, BAD_CAST"head") == 0)
194                 goto found_head;
195             if (xmlStrcasecmp(cur->name, BAD_CAST"meta") == 0)
196                 goto found_meta;
197         }
198         cur = cur->next;
199     }
200     if (cur == NULL)
201         return(-1);
202     cur = cur->children;
203
204     /*
205      * Search the head
206      */
207     while (cur != NULL) {
208         if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {
209             if (xmlStrcasecmp(cur->name, BAD_CAST"head") == 0)
210                 break;
211             if (xmlStrcasecmp(cur->name, BAD_CAST"meta") == 0) {
212                 head = cur->parent;
213                 goto found_meta;
214             }
215         }
216         cur = cur->next;
217     }
218     if (cur == NULL)
219         return(-1);
220 found_head:
221     head = cur;
222     if (cur->children == NULL)
223         goto create;
224     cur = cur->children;
225
226 found_meta:
227     /*
228      * Search and update all the remaining the meta elements carrying
229      * encoding informations
230      */
231     while (cur != NULL) {
232         if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {
233             if (xmlStrcasecmp(cur->name, BAD_CAST"meta") == 0) {
234                 xmlAttrPtr attr = cur->properties;
235                 int http;
236                 const xmlChar *value;
237
238                 content = NULL;
239                 http = 0;
240                 while (attr != NULL) {
241                     if ((attr->children != NULL) &&
242                         (attr->children->type == XML_TEXT_NODE) &&
243                         (attr->children->next == NULL)) {
244                         value = attr->children->content;
245                         if ((!xmlStrcasecmp(attr->name, BAD_CAST"http-equiv"))
246                          && (!xmlStrcasecmp(value, BAD_CAST"Content-Type")))
247                             http = 1;
248                         else
249                         {
250                            if ((value != NULL) &&
251                                (!xmlStrcasecmp(attr->name, BAD_CAST"content")))
252                                content = value;
253                         }
254                         if ((http != 0) && (content != NULL))
255                             break;
256                     }
257                     attr = attr->next;
258                 }
259                 if ((http != 0) && (content != NULL)) {
260                     meta = cur;
261                     break;
262                 }
263
264             }
265         }
266         cur = cur->next;
267     }
268 create:
269     if (meta == NULL) {
270         if ((encoding != NULL) && (head != NULL)) {
271             /*
272              * Create a new Meta element with the right attributes
273              */
274
275             meta = xmlNewDocNode(doc, NULL, BAD_CAST"meta", NULL);
276             if (head->children == NULL)
277                 xmlAddChild(head, meta);
278             else
279                 xmlAddPrevSibling(head->children, meta);
280             xmlNewProp(meta, BAD_CAST"http-equiv", BAD_CAST"Content-Type");
281             xmlNewProp(meta, BAD_CAST"content", BAD_CAST newcontent);
282         }
283     } else {
284         /* remove the meta tag if NULL is passed */
285         if (encoding == NULL) {
286             xmlUnlinkNode(meta);
287             xmlFreeNode(meta);
288         }
289         /* change the document only if there is a real encoding change */
290         else if (xmlStrcasestr(content, encoding) == NULL) {
291             xmlSetProp(meta, BAD_CAST"content", BAD_CAST newcontent);
292         }
293     }
294
295
296     return(0);
297 }
298
299 /**
300  * booleanHTMLAttrs:
301  *
302  * These are the HTML attributes which will be output
303  * in minimized form, i.e. <option selected="selected"> will be
304  * output as <option selected>, as per XSLT 1.0 16.2 "HTML Output Method"
305  *
306  */
307 static const char* htmlBooleanAttrs[] = {
308   "checked", "compact", "declare", "defer", "disabled", "ismap",
309   "multiple", "nohref", "noresize", "noshade", "nowrap", "readonly",
310   "selected", NULL
311 };
312
313
314 /**
315  * htmlIsBooleanAttr:
316  * @name:  the name of the attribute to check
317  *
318  * Determine if a given attribute is a boolean attribute.
319  *
320  * returns: false if the attribute is not boolean, true otherwise.
321  */
322 int
323 htmlIsBooleanAttr(const xmlChar *name)
324 {
325     int i = 0;
326
327     while (htmlBooleanAttrs[i] != NULL) {
328         if (xmlStrcasecmp((const xmlChar *)htmlBooleanAttrs[i], name) == 0)
329             return 1;
330         i++;
331     }
332     return 0;
333 }
334
335 #ifdef LIBXML_OUTPUT_ENABLED
336 /*
337  * private routine exported from xmlIO.c
338  */
339 xmlOutputBufferPtr
340 xmlAllocOutputBufferInternal(xmlCharEncodingHandlerPtr encoder);
341 /************************************************************************
342  *                                                                      *
343  *                      Output error handlers                           *
344  *                                                                      *
345  ************************************************************************/
346 /**
347  * htmlSaveErrMemory:
348  * @extra:  extra informations
349  *
350  * Handle an out of memory condition
351  */
352 static void
353 htmlSaveErrMemory(const char *extra)
354 {
355     __xmlSimpleError(XML_FROM_OUTPUT, XML_ERR_NO_MEMORY, NULL, NULL, extra);
356 }
357
358 /**
359  * htmlSaveErr:
360  * @code:  the error number
361  * @node:  the location of the error.
362  * @extra:  extra informations
363  *
364  * Handle an out of memory condition
365  */
366 static void
367 htmlSaveErr(int code, xmlNodePtr node, const char *extra)
368 {
369     const char *msg = NULL;
370
371     switch(code) {
372         case XML_SAVE_NOT_UTF8:
373             msg = "string is not in UTF-8\n";
374             break;
375         case XML_SAVE_CHAR_INVALID:
376             msg = "invalid character value\n";
377             break;
378         case XML_SAVE_UNKNOWN_ENCODING:
379             msg = "unknown encoding %s\n";
380             break;
381         case XML_SAVE_NO_DOCTYPE:
382             msg = "HTML has no DOCTYPE\n";
383             break;
384         default:
385             msg = "unexpected error number\n";
386     }
387     __xmlSimpleError(XML_FROM_OUTPUT, code, node, msg, extra);
388 }
389
390 /************************************************************************
391  *                                                                      *
392  *              Dumping HTML tree content to a simple buffer            *
393  *                                                                      *
394  ************************************************************************/
395
396 /**
397  * htmlBufNodeDumpFormat:
398  * @buf:  the xmlBufPtr output
399  * @doc:  the document
400  * @cur:  the current node
401  * @format:  should formatting spaces been added
402  *
403  * Dump an HTML node, recursive behaviour,children are printed too.
404  *
405  * Returns the number of byte written or -1 in case of error
406  */
407 static size_t
408 htmlBufNodeDumpFormat(xmlBufPtr buf, xmlDocPtr doc, xmlNodePtr cur,
409                    int format) {
410     size_t use;
411     int ret;
412     xmlOutputBufferPtr outbuf;
413
414     if (cur == NULL) {
415         return (-1);
416     }
417     if (buf == NULL) {
418         return (-1);
419     }
420     outbuf = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer));
421     if (outbuf == NULL) {
422         htmlSaveErrMemory("allocating HTML output buffer");
423         return (-1);
424     }
425     memset(outbuf, 0, (size_t) sizeof(xmlOutputBuffer));
426     outbuf->buffer = buf;
427     outbuf->encoder = NULL;
428     outbuf->writecallback = NULL;
429     outbuf->closecallback = NULL;
430     outbuf->context = NULL;
431     outbuf->written = 0;
432
433     use = xmlBufUse(buf);
434     htmlNodeDumpFormatOutput(outbuf, doc, cur, NULL, format);
435     xmlFree(outbuf);
436     ret = xmlBufUse(buf) - use;
437     return (ret);
438 }
439
440 /**
441  * htmlNodeDump:
442  * @buf:  the HTML buffer output
443  * @doc:  the document
444  * @cur:  the current node
445  *
446  * Dump an HTML node, recursive behaviour,children are printed too,
447  * and formatting returns are added.
448  *
449  * Returns the number of byte written or -1 in case of error
450  */
451 int
452 htmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur) {
453     xmlBufPtr buffer;
454     size_t ret;
455
456     if ((buf == NULL) || (cur == NULL))
457         return(-1);
458
459     xmlInitParser();
460     buffer = xmlBufFromBuffer(buf);
461     if (buffer == NULL)
462         return(-1);
463
464     ret = htmlBufNodeDumpFormat(buffer, doc, cur, 1);
465
466     xmlBufBackToBuffer(buffer);
467
468     if (ret > INT_MAX)
469         return(-1);
470     return((int) ret);
471 }
472
473 /**
474  * htmlNodeDumpFileFormat:
475  * @out:  the FILE pointer
476  * @doc:  the document
477  * @cur:  the current node
478  * @encoding: the document encoding
479  * @format:  should formatting spaces been added
480  *
481  * Dump an HTML node, recursive behaviour,children are printed too.
482  *
483  * TODO: if encoding == NULL try to save in the doc encoding
484  *
485  * returns: the number of byte written or -1 in case of failure.
486  */
487 int
488 htmlNodeDumpFileFormat(FILE *out, xmlDocPtr doc,
489                        xmlNodePtr cur, const char *encoding, int format) {
490     xmlOutputBufferPtr buf;
491     xmlCharEncodingHandlerPtr handler = NULL;
492     int ret;
493
494     xmlInitParser();
495
496     if (encoding != NULL) {
497         xmlCharEncoding enc;
498
499         enc = xmlParseCharEncoding(encoding);
500         if (enc != XML_CHAR_ENCODING_UTF8) {
501             handler = xmlFindCharEncodingHandler(encoding);
502             if (handler == NULL)
503                 htmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding);
504         }
505     }
506
507     /*
508      * Fallback to HTML or ASCII when the encoding is unspecified
509      */
510     if (handler == NULL)
511         handler = xmlFindCharEncodingHandler("HTML");
512     if (handler == NULL)
513         handler = xmlFindCharEncodingHandler("ascii");
514
515     /*
516      * save the content to a temp buffer.
517      */
518     buf = xmlOutputBufferCreateFile(out, handler);
519     if (buf == NULL) return(0);
520
521     htmlNodeDumpFormatOutput(buf, doc, cur, encoding, format);
522
523     ret = xmlOutputBufferClose(buf);
524     return(ret);
525 }
526
527 /**
528  * htmlNodeDumpFile:
529  * @out:  the FILE pointer
530  * @doc:  the document
531  * @cur:  the current node
532  *
533  * Dump an HTML node, recursive behaviour,children are printed too,
534  * and formatting returns are added.
535  */
536 void
537 htmlNodeDumpFile(FILE *out, xmlDocPtr doc, xmlNodePtr cur) {
538     htmlNodeDumpFileFormat(out, doc, cur, NULL, 1);
539 }
540
541 /**
542  * htmlDocDumpMemoryFormat:
543  * @cur:  the document
544  * @mem:  OUT: the memory pointer
545  * @size:  OUT: the memory length
546  * @format:  should formatting spaces been added
547  *
548  * Dump an HTML document in memory and return the xmlChar * and it's size.
549  * It's up to the caller to free the memory.
550  */
551 void
552 htmlDocDumpMemoryFormat(xmlDocPtr cur, xmlChar**mem, int *size, int format) {
553     xmlOutputBufferPtr buf;
554     xmlCharEncodingHandlerPtr handler = NULL;
555     const char *encoding;
556
557     xmlInitParser();
558
559     if ((mem == NULL) || (size == NULL))
560         return;
561     if (cur == NULL) {
562         *mem = NULL;
563         *size = 0;
564         return;
565     }
566
567     encoding = (const char *) htmlGetMetaEncoding(cur);
568
569     if (encoding != NULL) {
570         xmlCharEncoding enc;
571
572         enc = xmlParseCharEncoding(encoding);
573         if (enc != cur->charset) {
574             if (cur->charset != XML_CHAR_ENCODING_UTF8) {
575                 /*
576                  * Not supported yet
577                  */
578                 *mem = NULL;
579                 *size = 0;
580                 return;
581             }
582
583             handler = xmlFindCharEncodingHandler(encoding);
584             if (handler == NULL)
585                 htmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding);
586
587         } else {
588             handler = xmlFindCharEncodingHandler(encoding);
589         }
590     }
591
592     /*
593      * Fallback to HTML or ASCII when the encoding is unspecified
594      */
595     if (handler == NULL)
596         handler = xmlFindCharEncodingHandler("HTML");
597     if (handler == NULL)
598         handler = xmlFindCharEncodingHandler("ascii");
599
600     buf = xmlAllocOutputBufferInternal(handler);
601     if (buf == NULL) {
602         *mem = NULL;
603         *size = 0;
604         return;
605     }
606
607     htmlDocContentDumpFormatOutput(buf, cur, NULL, format);
608
609     xmlOutputBufferFlush(buf);
610     if (buf->conv != NULL) {
611         *size = xmlBufUse(buf->conv);
612         *mem = xmlStrndup(xmlBufContent(buf->conv), *size);
613     } else {
614         *size = xmlBufUse(buf->buffer);
615         *mem = xmlStrndup(xmlBufContent(buf->buffer), *size);
616     }
617     (void)xmlOutputBufferClose(buf);
618 }
619
620 /**
621  * htmlDocDumpMemory:
622  * @cur:  the document
623  * @mem:  OUT: the memory pointer
624  * @size:  OUT: the memory length
625  *
626  * Dump an HTML document in memory and return the xmlChar * and it's size.
627  * It's up to the caller to free the memory.
628  */
629 void
630 htmlDocDumpMemory(xmlDocPtr cur, xmlChar**mem, int *size) {
631         htmlDocDumpMemoryFormat(cur, mem, size, 1);
632 }
633
634
635 /************************************************************************
636  *                                                                      *
637  *              Dumping HTML tree content to an I/O output buffer       *
638  *                                                                      *
639  ************************************************************************/
640
641 void xmlNsListDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr cur);
642
643 /**
644  * htmlDtdDumpOutput:
645  * @buf:  the HTML buffer output
646  * @doc:  the document
647  * @encoding:  the encoding string
648  *
649  * TODO: check whether encoding is needed
650  *
651  * Dump the HTML document DTD, if any.
652  */
653 static void
654 htmlDtdDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
655                   const char *encoding ATTRIBUTE_UNUSED) {
656     xmlDtdPtr cur = doc->intSubset;
657
658     if (cur == NULL) {
659         htmlSaveErr(XML_SAVE_NO_DOCTYPE, (xmlNodePtr) doc, NULL);
660         return;
661     }
662     xmlOutputBufferWriteString(buf, "<!DOCTYPE ");
663     xmlOutputBufferWriteString(buf, (const char *)cur->name);
664     if (cur->ExternalID != NULL) {
665         xmlOutputBufferWriteString(buf, " PUBLIC ");
666         xmlBufWriteQuotedString(buf->buffer, cur->ExternalID);
667         if (cur->SystemID != NULL) {
668             xmlOutputBufferWriteString(buf, " ");
669             xmlBufWriteQuotedString(buf->buffer, cur->SystemID);
670         }
671     }  else if (cur->SystemID != NULL) {
672         xmlOutputBufferWriteString(buf, " SYSTEM ");
673         xmlBufWriteQuotedString(buf->buffer, cur->SystemID);
674     }
675     xmlOutputBufferWriteString(buf, ">\n");
676 }
677
678 /**
679  * htmlAttrDumpOutput:
680  * @buf:  the HTML buffer output
681  * @doc:  the document
682  * @cur:  the attribute pointer
683  * @encoding:  the encoding string
684  *
685  * Dump an HTML attribute
686  */
687 static void
688 htmlAttrDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc, xmlAttrPtr cur,
689                    const char *encoding ATTRIBUTE_UNUSED) {
690     xmlChar *value;
691
692     /*
693      * The html output method should not escape a & character
694      * occurring in an attribute value immediately followed by
695      * a { character (see Section B.7.1 of the HTML 4.0 Recommendation).
696      * This is implemented in xmlEncodeEntitiesReentrant
697      */
698
699     if (cur == NULL) {
700         return;
701     }
702     xmlOutputBufferWriteString(buf, " ");
703     if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
704         xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
705         xmlOutputBufferWriteString(buf, ":");
706     }
707     xmlOutputBufferWriteString(buf, (const char *)cur->name);
708     if ((cur->children != NULL) && (!htmlIsBooleanAttr(cur->name))) {
709         value = xmlNodeListGetString(doc, cur->children, 0);
710         if (value) {
711             xmlOutputBufferWriteString(buf, "=");
712             if ((cur->ns == NULL) && (cur->parent != NULL) &&
713                 (cur->parent->ns == NULL) &&
714                 ((!xmlStrcasecmp(cur->name, BAD_CAST "href")) ||
715                  (!xmlStrcasecmp(cur->name, BAD_CAST "action")) ||
716                  (!xmlStrcasecmp(cur->name, BAD_CAST "src")) ||
717                  ((!xmlStrcasecmp(cur->name, BAD_CAST "name")) &&
718                   (!xmlStrcasecmp(cur->parent->name, BAD_CAST "a"))))) {
719                 xmlChar *escaped;
720                 xmlChar *tmp = value;
721
722                 while (IS_BLANK_CH(*tmp)) tmp++;
723
724                 /*
725                  * the < and > have already been escaped at the entity level
726                  * And doing so here breaks server side includes
727                  */
728                 escaped = xmlURIEscapeStr(tmp, BAD_CAST"@/:=?;#%&,+<>");
729                 if (escaped != NULL) {
730                     xmlBufWriteQuotedString(buf->buffer, escaped);
731                     xmlFree(escaped);
732                 } else {
733                     xmlBufWriteQuotedString(buf->buffer, value);
734                 }
735             } else {
736                 xmlBufWriteQuotedString(buf->buffer, value);
737             }
738             xmlFree(value);
739         } else  {
740             xmlOutputBufferWriteString(buf, "=\"\"");
741         }
742     }
743 }
744
745 /**
746  * htmlAttrListDumpOutput:
747  * @buf:  the HTML buffer output
748  * @doc:  the document
749  * @cur:  the first attribute pointer
750  * @encoding:  the encoding string
751  *
752  * Dump a list of HTML attributes
753  */
754 static void
755 htmlAttrListDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc, xmlAttrPtr cur, const char *encoding) {
756     if (cur == NULL) {
757         return;
758     }
759     while (cur != NULL) {
760         htmlAttrDumpOutput(buf, doc, cur, encoding);
761         cur = cur->next;
762     }
763 }
764
765
766
767 /**
768  * htmlNodeListDumpOutput:
769  * @buf:  the HTML buffer output
770  * @doc:  the document
771  * @cur:  the first node
772  * @encoding:  the encoding string
773  * @format:  should formatting spaces been added
774  *
775  * Dump an HTML node list, recursive behaviour,children are printed too.
776  */
777 static void
778 htmlNodeListDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
779                        xmlNodePtr cur, const char *encoding, int format) {
780     if (cur == NULL) {
781         return;
782     }
783     while (cur != NULL) {
784         htmlNodeDumpFormatOutput(buf, doc, cur, encoding, format);
785         cur = cur->next;
786     }
787 }
788
789 /**
790  * htmlNodeDumpFormatOutput:
791  * @buf:  the HTML buffer output
792  * @doc:  the document
793  * @cur:  the current node
794  * @encoding:  the encoding string
795  * @format:  should formatting spaces been added
796  *
797  * Dump an HTML node, recursive behaviour,children are printed too.
798  */
799 void
800 htmlNodeDumpFormatOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
801                          xmlNodePtr cur, const char *encoding, int format) {
802     const htmlElemDesc * info;
803
804     xmlInitParser();
805
806     if ((cur == NULL) || (buf == NULL)) {
807         return;
808     }
809     /*
810      * Special cases.
811      */
812     if (cur->type == XML_DTD_NODE)
813         return;
814     if ((cur->type == XML_HTML_DOCUMENT_NODE) ||
815         (cur->type == XML_DOCUMENT_NODE)){
816         htmlDocContentDumpOutput(buf, (xmlDocPtr) cur, encoding);
817         return;
818     }
819     if (cur->type == XML_ATTRIBUTE_NODE) {
820         htmlAttrDumpOutput(buf, doc, (xmlAttrPtr) cur, encoding);
821         return;
822     }
823     if (cur->type == HTML_TEXT_NODE) {
824         if (cur->content != NULL) {
825             if (((cur->name == (const xmlChar *)xmlStringText) ||
826                  (cur->name != (const xmlChar *)xmlStringTextNoenc)) &&
827                 ((cur->parent == NULL) ||
828                  ((xmlStrcasecmp(cur->parent->name, BAD_CAST "script")) &&
829                   (xmlStrcasecmp(cur->parent->name, BAD_CAST "style"))))) {
830                 xmlChar *buffer;
831
832                 buffer = xmlEncodeEntitiesReentrant(doc, cur->content);
833                 if (buffer != NULL) {
834                     xmlOutputBufferWriteString(buf, (const char *)buffer);
835                     xmlFree(buffer);
836                 }
837             } else {
838                 xmlOutputBufferWriteString(buf, (const char *)cur->content);
839             }
840         }
841         return;
842     }
843     if (cur->type == HTML_COMMENT_NODE) {
844         if (cur->content != NULL) {
845             xmlOutputBufferWriteString(buf, "<!--");
846             xmlOutputBufferWriteString(buf, (const char *)cur->content);
847             xmlOutputBufferWriteString(buf, "-->");
848         }
849         return;
850     }
851     if (cur->type == HTML_PI_NODE) {
852         if (cur->name == NULL)
853             return;
854         xmlOutputBufferWriteString(buf, "<?");
855         xmlOutputBufferWriteString(buf, (const char *)cur->name);
856         if (cur->content != NULL) {
857             xmlOutputBufferWriteString(buf, " ");
858             xmlOutputBufferWriteString(buf, (const char *)cur->content);
859         }
860         xmlOutputBufferWriteString(buf, ">");
861         return;
862     }
863     if (cur->type == HTML_ENTITY_REF_NODE) {
864         xmlOutputBufferWriteString(buf, "&");
865         xmlOutputBufferWriteString(buf, (const char *)cur->name);
866         xmlOutputBufferWriteString(buf, ";");
867         return;
868     }
869     if (cur->type == HTML_PRESERVE_NODE) {
870         if (cur->content != NULL) {
871             xmlOutputBufferWriteString(buf, (const char *)cur->content);
872         }
873         return;
874     }
875
876     /*
877      * Get specific HTML info for that node.
878      */
879     if (cur->ns == NULL)
880         info = htmlTagLookup(cur->name);
881     else
882         info = NULL;
883
884     xmlOutputBufferWriteString(buf, "<");
885     if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
886         xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
887         xmlOutputBufferWriteString(buf, ":");
888     }
889     xmlOutputBufferWriteString(buf, (const char *)cur->name);
890     if (cur->nsDef)
891         xmlNsListDumpOutput(buf, cur->nsDef);
892     if (cur->properties != NULL)
893         htmlAttrListDumpOutput(buf, doc, cur->properties, encoding);
894
895     if ((info != NULL) && (info->empty)) {
896         xmlOutputBufferWriteString(buf, ">");
897         if ((format) && (!info->isinline) && (cur->next != NULL)) {
898             if ((cur->next->type != HTML_TEXT_NODE) &&
899                 (cur->next->type != HTML_ENTITY_REF_NODE) &&
900                 (cur->parent != NULL) &&
901                 (cur->parent->name != NULL) &&
902                 (cur->parent->name[0] != 'p')) /* p, pre, param */
903                 xmlOutputBufferWriteString(buf, "\n");
904         }
905         return;
906     }
907     if (((cur->type == XML_ELEMENT_NODE) || (cur->content == NULL)) &&
908         (cur->children == NULL)) {
909         if ((info != NULL) && (info->saveEndTag != 0) &&
910             (xmlStrcmp(BAD_CAST info->name, BAD_CAST "html")) &&
911             (xmlStrcmp(BAD_CAST info->name, BAD_CAST "body"))) {
912             xmlOutputBufferWriteString(buf, ">");
913         } else {
914             xmlOutputBufferWriteString(buf, "></");
915             if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
916                 xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
917                 xmlOutputBufferWriteString(buf, ":");
918             }
919             xmlOutputBufferWriteString(buf, (const char *)cur->name);
920             xmlOutputBufferWriteString(buf, ">");
921         }
922         if ((format) && (cur->next != NULL) &&
923             (info != NULL) && (!info->isinline)) {
924             if ((cur->next->type != HTML_TEXT_NODE) &&
925                 (cur->next->type != HTML_ENTITY_REF_NODE) &&
926                 (cur->parent != NULL) &&
927                 (cur->parent->name != NULL) &&
928                 (cur->parent->name[0] != 'p')) /* p, pre, param */
929                 xmlOutputBufferWriteString(buf, "\n");
930         }
931         return;
932     }
933     xmlOutputBufferWriteString(buf, ">");
934     if ((cur->type != XML_ELEMENT_NODE) &&
935         (cur->content != NULL)) {
936             /*
937              * Uses the OutputBuffer property to automatically convert
938              * invalids to charrefs
939              */
940
941             xmlOutputBufferWriteString(buf, (const char *) cur->content);
942     }
943     if (cur->children != NULL) {
944         if ((format) && (info != NULL) && (!info->isinline) &&
945             (cur->children->type != HTML_TEXT_NODE) &&
946             (cur->children->type != HTML_ENTITY_REF_NODE) &&
947             (cur->children != cur->last) &&
948             (cur->name != NULL) &&
949             (cur->name[0] != 'p')) /* p, pre, param */
950             xmlOutputBufferWriteString(buf, "\n");
951         htmlNodeListDumpOutput(buf, doc, cur->children, encoding, format);
952         if ((format) && (info != NULL) && (!info->isinline) &&
953             (cur->last->type != HTML_TEXT_NODE) &&
954             (cur->last->type != HTML_ENTITY_REF_NODE) &&
955             (cur->children != cur->last) &&
956             (cur->name != NULL) &&
957             (cur->name[0] != 'p')) /* p, pre, param */
958             xmlOutputBufferWriteString(buf, "\n");
959     }
960     xmlOutputBufferWriteString(buf, "</");
961     if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
962         xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
963         xmlOutputBufferWriteString(buf, ":");
964     }
965     xmlOutputBufferWriteString(buf, (const char *)cur->name);
966     xmlOutputBufferWriteString(buf, ">");
967     if ((format) && (info != NULL) && (!info->isinline) &&
968         (cur->next != NULL)) {
969         if ((cur->next->type != HTML_TEXT_NODE) &&
970             (cur->next->type != HTML_ENTITY_REF_NODE) &&
971             (cur->parent != NULL) &&
972             (cur->parent->name != NULL) &&
973             (cur->parent->name[0] != 'p')) /* p, pre, param */
974             xmlOutputBufferWriteString(buf, "\n");
975     }
976 }
977
978 /**
979  * htmlNodeDumpOutput:
980  * @buf:  the HTML buffer output
981  * @doc:  the document
982  * @cur:  the current node
983  * @encoding:  the encoding string
984  *
985  * Dump an HTML node, recursive behaviour,children are printed too,
986  * and formatting returns/spaces are added.
987  */
988 void
989 htmlNodeDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
990                    xmlNodePtr cur, const char *encoding) {
991     htmlNodeDumpFormatOutput(buf, doc, cur, encoding, 1);
992 }
993
994 /**
995  * htmlDocContentDumpFormatOutput:
996  * @buf:  the HTML buffer output
997  * @cur:  the document
998  * @encoding:  the encoding string
999  * @format:  should formatting spaces been added
1000  *
1001  * Dump an HTML document.
1002  */
1003 void
1004 htmlDocContentDumpFormatOutput(xmlOutputBufferPtr buf, xmlDocPtr cur,
1005                                const char *encoding, int format) {
1006     int type;
1007
1008     xmlInitParser();
1009
1010     if ((buf == NULL) || (cur == NULL))
1011         return;
1012
1013     /*
1014      * force to output the stuff as HTML, especially for entities
1015      */
1016     type = cur->type;
1017     cur->type = XML_HTML_DOCUMENT_NODE;
1018     if (cur->intSubset != NULL) {
1019         htmlDtdDumpOutput(buf, cur, NULL);
1020     }
1021     if (cur->children != NULL) {
1022         htmlNodeListDumpOutput(buf, cur, cur->children, encoding, format);
1023     }
1024     xmlOutputBufferWriteString(buf, "\n");
1025     cur->type = (xmlElementType) type;
1026 }
1027
1028 /**
1029  * htmlDocContentDumpOutput:
1030  * @buf:  the HTML buffer output
1031  * @cur:  the document
1032  * @encoding:  the encoding string
1033  *
1034  * Dump an HTML document. Formating return/spaces are added.
1035  */
1036 void
1037 htmlDocContentDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr cur,
1038                          const char *encoding) {
1039     htmlDocContentDumpFormatOutput(buf, cur, encoding, 1);
1040 }
1041
1042 /************************************************************************
1043  *                                                                      *
1044  *              Saving functions front-ends                             *
1045  *                                                                      *
1046  ************************************************************************/
1047
1048 /**
1049  * htmlDocDump:
1050  * @f:  the FILE*
1051  * @cur:  the document
1052  *
1053  * Dump an HTML document to an open FILE.
1054  *
1055  * returns: the number of byte written or -1 in case of failure.
1056  */
1057 int
1058 htmlDocDump(FILE *f, xmlDocPtr cur) {
1059     xmlOutputBufferPtr buf;
1060     xmlCharEncodingHandlerPtr handler = NULL;
1061     const char *encoding;
1062     int ret;
1063
1064     xmlInitParser();
1065
1066     if ((cur == NULL) || (f == NULL)) {
1067         return(-1);
1068     }
1069
1070     encoding = (const char *) htmlGetMetaEncoding(cur);
1071
1072     if (encoding != NULL) {
1073         xmlCharEncoding enc;
1074
1075         enc = xmlParseCharEncoding(encoding);
1076         if (enc != cur->charset) {
1077             if (cur->charset != XML_CHAR_ENCODING_UTF8) {
1078                 /*
1079                  * Not supported yet
1080                  */
1081                 return(-1);
1082             }
1083
1084             handler = xmlFindCharEncodingHandler(encoding);
1085             if (handler == NULL)
1086                 htmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding);
1087         } else {
1088             handler = xmlFindCharEncodingHandler(encoding);
1089         }
1090     }
1091
1092     /*
1093      * Fallback to HTML or ASCII when the encoding is unspecified
1094      */
1095     if (handler == NULL)
1096         handler = xmlFindCharEncodingHandler("HTML");
1097     if (handler == NULL)
1098         handler = xmlFindCharEncodingHandler("ascii");
1099
1100     buf = xmlOutputBufferCreateFile(f, handler);
1101     if (buf == NULL) return(-1);
1102     htmlDocContentDumpOutput(buf, cur, NULL);
1103
1104     ret = xmlOutputBufferClose(buf);
1105     return(ret);
1106 }
1107
1108 /**
1109  * htmlSaveFile:
1110  * @filename:  the filename (or URL)
1111  * @cur:  the document
1112  *
1113  * Dump an HTML document to a file. If @filename is "-" the stdout file is
1114  * used.
1115  * returns: the number of byte written or -1 in case of failure.
1116  */
1117 int
1118 htmlSaveFile(const char *filename, xmlDocPtr cur) {
1119     xmlOutputBufferPtr buf;
1120     xmlCharEncodingHandlerPtr handler = NULL;
1121     const char *encoding;
1122     int ret;
1123
1124     if ((cur == NULL) || (filename == NULL))
1125         return(-1);
1126
1127     xmlInitParser();
1128
1129     encoding = (const char *) htmlGetMetaEncoding(cur);
1130
1131     if (encoding != NULL) {
1132         xmlCharEncoding enc;
1133
1134         enc = xmlParseCharEncoding(encoding);
1135         if (enc != cur->charset) {
1136             if (cur->charset != XML_CHAR_ENCODING_UTF8) {
1137                 /*
1138                  * Not supported yet
1139                  */
1140                 return(-1);
1141             }
1142
1143             handler = xmlFindCharEncodingHandler(encoding);
1144             if (handler == NULL)
1145                 htmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding);
1146         }
1147     }
1148
1149     /*
1150      * Fallback to HTML or ASCII when the encoding is unspecified
1151      */
1152     if (handler == NULL)
1153         handler = xmlFindCharEncodingHandler("HTML");
1154     if (handler == NULL)
1155         handler = xmlFindCharEncodingHandler("ascii");
1156
1157     /*
1158      * save the content to a temp buffer.
1159      */
1160     buf = xmlOutputBufferCreateFilename(filename, handler, cur->compression);
1161     if (buf == NULL) return(0);
1162
1163     htmlDocContentDumpOutput(buf, cur, NULL);
1164
1165     ret = xmlOutputBufferClose(buf);
1166     return(ret);
1167 }
1168
1169 /**
1170  * htmlSaveFileFormat:
1171  * @filename:  the filename
1172  * @cur:  the document
1173  * @format:  should formatting spaces been added
1174  * @encoding: the document encoding
1175  *
1176  * Dump an HTML document to a file using a given encoding.
1177  *
1178  * returns: the number of byte written or -1 in case of failure.
1179  */
1180 int
1181 htmlSaveFileFormat(const char *filename, xmlDocPtr cur,
1182                    const char *encoding, int format) {
1183     xmlOutputBufferPtr buf;
1184     xmlCharEncodingHandlerPtr handler = NULL;
1185     int ret;
1186
1187     if ((cur == NULL) || (filename == NULL))
1188         return(-1);
1189
1190     xmlInitParser();
1191
1192     if (encoding != NULL) {
1193         xmlCharEncoding enc;
1194
1195         enc = xmlParseCharEncoding(encoding);
1196         if (enc != cur->charset) {
1197             if (cur->charset != XML_CHAR_ENCODING_UTF8) {
1198                 /*
1199                  * Not supported yet
1200                  */
1201                 return(-1);
1202             }
1203
1204             handler = xmlFindCharEncodingHandler(encoding);
1205             if (handler == NULL)
1206                 htmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding);
1207         }
1208         htmlSetMetaEncoding(cur, (const xmlChar *) encoding);
1209     } else {
1210         htmlSetMetaEncoding(cur, (const xmlChar *) "UTF-8");
1211     }
1212
1213     /*
1214      * Fallback to HTML or ASCII when the encoding is unspecified
1215      */
1216     if (handler == NULL)
1217         handler = xmlFindCharEncodingHandler("HTML");
1218     if (handler == NULL)
1219         handler = xmlFindCharEncodingHandler("ascii");
1220
1221     /*
1222      * save the content to a temp buffer.
1223      */
1224     buf = xmlOutputBufferCreateFilename(filename, handler, 0);
1225     if (buf == NULL) return(0);
1226
1227     htmlDocContentDumpFormatOutput(buf, cur, encoding, format);
1228
1229     ret = xmlOutputBufferClose(buf);
1230     return(ret);
1231 }
1232
1233 /**
1234  * htmlSaveFileEnc:
1235  * @filename:  the filename
1236  * @cur:  the document
1237  * @encoding: the document encoding
1238  *
1239  * Dump an HTML document to a file using a given encoding
1240  * and formatting returns/spaces are added.
1241  *
1242  * returns: the number of byte written or -1 in case of failure.
1243  */
1244 int
1245 htmlSaveFileEnc(const char *filename, xmlDocPtr cur, const char *encoding) {
1246     return(htmlSaveFileFormat(filename, cur, encoding, 1));
1247 }
1248
1249 #endif /* LIBXML_OUTPUT_ENABLED */
1250
1251 #define bottom_HTMLtree
1252 #include "elfgcchack.h"
1253 #endif /* LIBXML_HTML_ENABLED */