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