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 */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to HTMLtree.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2