1: /*
2: * testHTML.c : a small tester program for HTML input.
3: *
4: * See Copyright for the status of this software.
5: *
6: * daniel@veillard.com
7: */
8:
9: #include "libxml.h"
10:
11: #ifdef LIBXML_HTML_ENABLED
12:
13: #include <string.h>
14: #include <stdarg.h>
15:
16:
17: #ifdef HAVE_SYS_TYPES_H
18: #include <sys/types.h>
19: #endif
20: #ifdef HAVE_SYS_STAT_H
21: #include <sys/stat.h>
22: #endif
23: #ifdef HAVE_FCNTL_H
24: #include <fcntl.h>
25: #endif
26: #ifdef HAVE_UNISTD_H
27: #include <unistd.h>
28: #endif
29: #ifdef HAVE_STDLIB_H
30: #include <stdlib.h>
31: #endif
32:
33: #include <libxml/xmlmemory.h>
34: #include <libxml/HTMLparser.h>
35: #include <libxml/HTMLtree.h>
36: #include <libxml/debugXML.h>
37: #include <libxml/xmlerror.h>
38: #include <libxml/globals.h>
39:
40: #ifdef LIBXML_DEBUG_ENABLED
41: static int debug = 0;
42: #endif
43: static int copy = 0;
44: static int sax = 0;
45: static int repeat = 0;
46: static int noout = 0;
47: #ifdef LIBXML_PUSH_ENABLED
48: static int push = 0;
49: #endif /* LIBXML_PUSH_ENABLED */
50: static char *encoding = NULL;
51: static int options = 0;
52:
53: static xmlSAXHandler emptySAXHandlerStruct = {
54: NULL, /* internalSubset */
55: NULL, /* isStandalone */
56: NULL, /* hasInternalSubset */
57: NULL, /* hasExternalSubset */
58: NULL, /* resolveEntity */
59: NULL, /* getEntity */
60: NULL, /* entityDecl */
61: NULL, /* notationDecl */
62: NULL, /* attributeDecl */
63: NULL, /* elementDecl */
64: NULL, /* unparsedEntityDecl */
65: NULL, /* setDocumentLocator */
66: NULL, /* startDocument */
67: NULL, /* endDocument */
68: NULL, /* startElement */
69: NULL, /* endElement */
70: NULL, /* reference */
71: NULL, /* characters */
72: NULL, /* ignorableWhitespace */
73: NULL, /* processingInstruction */
74: NULL, /* comment */
75: NULL, /* xmlParserWarning */
76: NULL, /* xmlParserError */
77: NULL, /* xmlParserError */
78: NULL, /* getParameterEntity */
79: NULL, /* cdataBlock */
80: NULL, /* externalSubset */
81: 1, /* initialized */
82: NULL, /* private */
83: NULL, /* startElementNsSAX2Func */
84: NULL, /* endElementNsSAX2Func */
85: NULL /* xmlStructuredErrorFunc */
86: };
87:
88: static xmlSAXHandlerPtr emptySAXHandler = &emptySAXHandlerStruct;
89: extern xmlSAXHandlerPtr debugSAXHandler;
90:
91: /************************************************************************
92: * *
93: * Debug Handlers *
94: * *
95: ************************************************************************/
96:
97: /**
98: * isStandaloneDebug:
99: * @ctxt: An XML parser context
100: *
101: * Is this document tagged standalone ?
102: *
103: * Returns 1 if true
104: */
105: static int
106: isStandaloneDebug(void *ctx ATTRIBUTE_UNUSED)
107: {
108: fprintf(stdout, "SAX.isStandalone()\n");
109: return(0);
110: }
111:
112: /**
113: * hasInternalSubsetDebug:
114: * @ctxt: An XML parser context
115: *
116: * Does this document has an internal subset
117: *
118: * Returns 1 if true
119: */
120: static int
121: hasInternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED)
122: {
123: fprintf(stdout, "SAX.hasInternalSubset()\n");
124: return(0);
125: }
126:
127: /**
128: * hasExternalSubsetDebug:
129: * @ctxt: An XML parser context
130: *
131: * Does this document has an external subset
132: *
133: * Returns 1 if true
134: */
135: static int
136: hasExternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED)
137: {
138: fprintf(stdout, "SAX.hasExternalSubset()\n");
139: return(0);
140: }
141:
142: /**
143: * hasInternalSubsetDebug:
144: * @ctxt: An XML parser context
145: *
146: * Does this document has an internal subset
147: */
148: static void
149: internalSubsetDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
150: const xmlChar *ExternalID, const xmlChar *SystemID)
151: {
152: fprintf(stdout, "SAX.internalSubset(%s,", name);
153: if (ExternalID == NULL)
154: fprintf(stdout, " ,");
155: else
156: fprintf(stdout, " %s,", ExternalID);
157: if (SystemID == NULL)
158: fprintf(stdout, " )\n");
159: else
160: fprintf(stdout, " %s)\n", SystemID);
161: }
162:
163: /**
164: * resolveEntityDebug:
165: * @ctxt: An XML parser context
166: * @publicId: The public ID of the entity
167: * @systemId: The system ID of the entity
168: *
169: * Special entity resolver, better left to the parser, it has
170: * more context than the application layer.
171: * The default behaviour is to NOT resolve the entities, in that case
172: * the ENTITY_REF nodes are built in the structure (and the parameter
173: * values).
174: *
175: * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
176: */
177: static xmlParserInputPtr
178: resolveEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *publicId, const xmlChar *systemId)
179: {
180: /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
181:
182:
183: fprintf(stdout, "SAX.resolveEntity(");
184: if (publicId != NULL)
185: fprintf(stdout, "%s", (char *)publicId);
186: else
187: fprintf(stdout, " ");
188: if (systemId != NULL)
189: fprintf(stdout, ", %s)\n", (char *)systemId);
190: else
191: fprintf(stdout, ", )\n");
192: /*********
193: if (systemId != NULL) {
194: return(xmlNewInputFromFile(ctxt, (char *) systemId));
195: }
196: *********/
197: return(NULL);
198: }
199:
200: /**
201: * getEntityDebug:
202: * @ctxt: An XML parser context
203: * @name: The entity name
204: *
205: * Get an entity by name
206: *
207: * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
208: */
209: static xmlEntityPtr
210: getEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
211: {
212: fprintf(stdout, "SAX.getEntity(%s)\n", name);
213: return(NULL);
214: }
215:
216: /**
217: * getParameterEntityDebug:
218: * @ctxt: An XML parser context
219: * @name: The entity name
220: *
221: * Get a parameter entity by name
222: *
223: * Returns the xmlParserInputPtr
224: */
225: static xmlEntityPtr
226: getParameterEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
227: {
228: fprintf(stdout, "SAX.getParameterEntity(%s)\n", name);
229: return(NULL);
230: }
231:
232:
233: /**
234: * entityDeclDebug:
235: * @ctxt: An XML parser context
236: * @name: the entity name
237: * @type: the entity type
238: * @publicId: The public ID of the entity
239: * @systemId: The system ID of the entity
240: * @content: the entity value (without processing).
241: *
242: * An entity definition has been parsed
243: */
244: static void
245: entityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
246: const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
247: {
248: fprintf(stdout, "SAX.entityDecl(%s, %d, %s, %s, %s)\n",
249: name, type, publicId, systemId, content);
250: }
251:
252: /**
253: * attributeDeclDebug:
254: * @ctxt: An XML parser context
255: * @name: the attribute name
256: * @type: the attribute type
257: *
258: * An attribute definition has been parsed
259: */
260: static void
261: attributeDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *elem, const xmlChar *name,
262: int type, int def, const xmlChar *defaultValue,
263: xmlEnumerationPtr tree ATTRIBUTE_UNUSED)
264: {
265: fprintf(stdout, "SAX.attributeDecl(%s, %s, %d, %d, %s, ...)\n",
266: elem, name, type, def, defaultValue);
267: }
268:
269: /**
270: * elementDeclDebug:
271: * @ctxt: An XML parser context
272: * @name: the element name
273: * @type: the element type
274: * @content: the element value (without processing).
275: *
276: * An element definition has been parsed
277: */
278: static void
279: elementDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
280: xmlElementContentPtr content ATTRIBUTE_UNUSED)
281: {
282: fprintf(stdout, "SAX.elementDecl(%s, %d, ...)\n",
283: name, type);
284: }
285:
286: /**
287: * notationDeclDebug:
288: * @ctxt: An XML parser context
289: * @name: The name of the notation
290: * @publicId: The public ID of the entity
291: * @systemId: The system ID of the entity
292: *
293: * What to do when a notation declaration has been parsed.
294: */
295: static void
296: notationDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
297: const xmlChar *publicId, const xmlChar *systemId)
298: {
299: fprintf(stdout, "SAX.notationDecl(%s, %s, %s)\n",
300: (char *) name, (char *) publicId, (char *) systemId);
301: }
302:
303: /**
304: * unparsedEntityDeclDebug:
305: * @ctxt: An XML parser context
306: * @name: The name of the entity
307: * @publicId: The public ID of the entity
308: * @systemId: The system ID of the entity
309: * @notationName: the name of the notation
310: *
311: * What to do when an unparsed entity declaration is parsed
312: */
313: static void
314: unparsedEntityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
315: const xmlChar *publicId, const xmlChar *systemId,
316: const xmlChar *notationName)
317: {
318: fprintf(stdout, "SAX.unparsedEntityDecl(%s, %s, %s, %s)\n",
319: (char *) name, (char *) publicId, (char *) systemId,
320: (char *) notationName);
321: }
322:
323: /**
324: * setDocumentLocatorDebug:
325: * @ctxt: An XML parser context
326: * @loc: A SAX Locator
327: *
328: * Receive the document locator at startup, actually xmlDefaultSAXLocator
329: * Everything is available on the context, so this is useless in our case.
330: */
331: static void
332: setDocumentLocatorDebug(void *ctx ATTRIBUTE_UNUSED, xmlSAXLocatorPtr loc ATTRIBUTE_UNUSED)
333: {
334: fprintf(stdout, "SAX.setDocumentLocator()\n");
335: }
336:
337: /**
338: * startDocumentDebug:
339: * @ctxt: An XML parser context
340: *
341: * called when the document start being processed.
342: */
343: static void
344: startDocumentDebug(void *ctx ATTRIBUTE_UNUSED)
345: {
346: fprintf(stdout, "SAX.startDocument()\n");
347: }
348:
349: /**
350: * endDocumentDebug:
351: * @ctxt: An XML parser context
352: *
353: * called when the document end has been detected.
354: */
355: static void
356: endDocumentDebug(void *ctx ATTRIBUTE_UNUSED)
357: {
358: fprintf(stdout, "SAX.endDocument()\n");
359: }
360:
361: /**
362: * startElementDebug:
363: * @ctxt: An XML parser context
364: * @name: The element name
365: *
366: * called when an opening tag has been processed.
367: */
368: static void
369: startElementDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, const xmlChar **atts)
370: {
371: int i;
372:
373: fprintf(stdout, "SAX.startElement(%s", (char *) name);
374: if (atts != NULL) {
375: for (i = 0;(atts[i] != NULL);i++) {
376: fprintf(stdout, ", %s", atts[i++]);
377: if (atts[i] != NULL) {
378: unsigned char output[40];
379: const unsigned char *att = atts[i];
380: int outlen, attlen;
381: fprintf(stdout, "='");
382: while ((attlen = strlen((char*)att)) > 0) {
383: outlen = sizeof output - 1;
384: htmlEncodeEntities(output, &outlen, att, &attlen, '\'');
385: output[outlen] = 0;
386: fprintf(stdout, "%s", (char *) output);
387: att += attlen;
388: }
389: fprintf(stdout, "'");
390: }
391: }
392: }
393: fprintf(stdout, ")\n");
394: }
395:
396: /**
397: * endElementDebug:
398: * @ctxt: An XML parser context
399: * @name: The element name
400: *
401: * called when the end of an element has been detected.
402: */
403: static void
404: endElementDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
405: {
406: fprintf(stdout, "SAX.endElement(%s)\n", (char *) name);
407: }
408:
409: /**
410: * charactersDebug:
411: * @ctxt: An XML parser context
412: * @ch: a xmlChar string
413: * @len: the number of xmlChar
414: *
415: * receiving some chars from the parser.
416: * Question: how much at a time ???
417: */
418: static void
419: charactersDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
420: {
421: unsigned char output[40];
422: int inlen = len, outlen = 30;
423:
424: htmlEncodeEntities(output, &outlen, ch, &inlen, 0);
425: output[outlen] = 0;
426:
427: fprintf(stdout, "SAX.characters(%s, %d)\n", output, len);
428: }
429:
430: /**
431: * cdataDebug:
432: * @ctxt: An XML parser context
433: * @ch: a xmlChar string
434: * @len: the number of xmlChar
435: *
436: * receiving some cdata chars from the parser.
437: * Question: how much at a time ???
438: */
439: static void
440: cdataDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
441: {
442: unsigned char output[40];
443: int inlen = len, outlen = 30;
444:
445: htmlEncodeEntities(output, &outlen, ch, &inlen, 0);
446: output[outlen] = 0;
447:
448: fprintf(stdout, "SAX.cdata(%s, %d)\n", output, len);
449: }
450:
451: /**
452: * referenceDebug:
453: * @ctxt: An XML parser context
454: * @name: The entity name
455: *
456: * called when an entity reference is detected.
457: */
458: static void
459: referenceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
460: {
461: fprintf(stdout, "SAX.reference(%s)\n", name);
462: }
463:
464: /**
465: * ignorableWhitespaceDebug:
466: * @ctxt: An XML parser context
467: * @ch: a xmlChar string
468: * @start: the first char in the string
469: * @len: the number of xmlChar
470: *
471: * receiving some ignorable whitespaces from the parser.
472: * Question: how much at a time ???
473: */
474: static void
475: ignorableWhitespaceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
476: {
477: char output[40];
478: int i;
479:
480: for (i = 0;(i<len) && (i < 30);i++)
481: output[i] = ch[i];
482: output[i] = 0;
483:
484: fprintf(stdout, "SAX.ignorableWhitespace(%s, %d)\n", output, len);
485: }
486:
487: /**
488: * processingInstructionDebug:
489: * @ctxt: An XML parser context
490: * @target: the target name
491: * @data: the PI data's
492: * @len: the number of xmlChar
493: *
494: * A processing instruction has been parsed.
495: */
496: static void
497: processingInstructionDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *target,
498: const xmlChar *data)
499: {
500: fprintf(stdout, "SAX.processingInstruction(%s, %s)\n",
501: (char *) target, (char *) data);
502: }
503:
504: /**
505: * commentDebug:
506: * @ctxt: An XML parser context
507: * @value: the comment content
508: *
509: * A comment has been parsed.
510: */
511: static void
512: commentDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *value)
513: {
514: fprintf(stdout, "SAX.comment(%s)\n", value);
515: }
516:
517: /**
518: * warningDebug:
519: * @ctxt: An XML parser context
520: * @msg: the message to display/transmit
521: * @...: extra parameters for the message display
522: *
523: * Display and format a warning messages, gives file, line, position and
524: * extra parameters.
525: */
526: static void XMLCDECL
527: warningDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
528: {
529: va_list args;
530:
531: va_start(args, msg);
532: fprintf(stdout, "SAX.warning: ");
533: vfprintf(stdout, msg, args);
534: va_end(args);
535: }
536:
537: /**
538: * errorDebug:
539: * @ctxt: An XML parser context
540: * @msg: the message to display/transmit
541: * @...: extra parameters for the message display
542: *
543: * Display and format a error messages, gives file, line, position and
544: * extra parameters.
545: */
546: static void XMLCDECL
547: errorDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
548: {
549: va_list args;
550:
551: va_start(args, msg);
552: fprintf(stdout, "SAX.error: ");
553: vfprintf(stdout, msg, args);
554: va_end(args);
555: }
556:
557: /**
558: * fatalErrorDebug:
559: * @ctxt: An XML parser context
560: * @msg: the message to display/transmit
561: * @...: extra parameters for the message display
562: *
563: * Display and format a fatalError messages, gives file, line, position and
564: * extra parameters.
565: */
566: static void XMLCDECL
567: fatalErrorDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
568: {
569: va_list args;
570:
571: va_start(args, msg);
572: fprintf(stdout, "SAX.fatalError: ");
573: vfprintf(stdout, msg, args);
574: va_end(args);
575: }
576:
577: static xmlSAXHandler debugSAXHandlerStruct = {
578: internalSubsetDebug,
579: isStandaloneDebug,
580: hasInternalSubsetDebug,
581: hasExternalSubsetDebug,
582: resolveEntityDebug,
583: getEntityDebug,
584: entityDeclDebug,
585: notationDeclDebug,
586: attributeDeclDebug,
587: elementDeclDebug,
588: unparsedEntityDeclDebug,
589: setDocumentLocatorDebug,
590: startDocumentDebug,
591: endDocumentDebug,
592: startElementDebug,
593: endElementDebug,
594: referenceDebug,
595: charactersDebug,
596: ignorableWhitespaceDebug,
597: processingInstructionDebug,
598: commentDebug,
599: warningDebug,
600: errorDebug,
601: fatalErrorDebug,
602: getParameterEntityDebug,
603: cdataDebug,
604: NULL,
605: 1,
606: NULL,
607: NULL,
608: NULL,
609: NULL
610: };
611:
612: xmlSAXHandlerPtr debugSAXHandler = &debugSAXHandlerStruct;
613: /************************************************************************
614: * *
615: * Debug *
616: * *
617: ************************************************************************/
618:
619: static void
620: parseSAXFile(char *filename) {
621: htmlDocPtr doc = NULL;
622:
623: /*
624: * Empty callbacks for checking
625: */
626: #ifdef LIBXML_PUSH_ENABLED
627: if (push) {
628: FILE *f;
629:
630: #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
631: f = fopen(filename, "rb");
632: #else
633: f = fopen(filename, "r");
634: #endif
635: if (f != NULL) {
636: int res, size = 3;
637: char chars[4096];
638: htmlParserCtxtPtr ctxt;
639:
640: /* if (repeat) */
641: size = 4096;
642: res = fread(chars, 1, 4, f);
643: if (res > 0) {
644: ctxt = htmlCreatePushParserCtxt(emptySAXHandler, NULL,
645: chars, res, filename, XML_CHAR_ENCODING_NONE);
646: while ((res = fread(chars, 1, size, f)) > 0) {
647: htmlParseChunk(ctxt, chars, res, 0);
648: }
649: htmlParseChunk(ctxt, chars, 0, 1);
650: doc = ctxt->myDoc;
651: htmlFreeParserCtxt(ctxt);
652: }
653: if (doc != NULL) {
654: fprintf(stdout, "htmlSAXParseFile returned non-NULL\n");
655: xmlFreeDoc(doc);
656: }
657: fclose(f);
658: }
659: if (!noout) {
660: #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
661: f = fopen(filename, "rb");
662: #else
663: f = fopen(filename, "r");
664: #endif
665: if (f != NULL) {
666: int res, size = 3;
667: char chars[4096];
668: htmlParserCtxtPtr ctxt;
669:
670: /* if (repeat) */
671: size = 4096;
672: res = fread(chars, 1, 4, f);
673: if (res > 0) {
674: ctxt = htmlCreatePushParserCtxt(debugSAXHandler, NULL,
675: chars, res, filename, XML_CHAR_ENCODING_NONE);
676: while ((res = fread(chars, 1, size, f)) > 0) {
677: htmlParseChunk(ctxt, chars, res, 0);
678: }
679: htmlParseChunk(ctxt, chars, 0, 1);
680: doc = ctxt->myDoc;
681: htmlFreeParserCtxt(ctxt);
682: }
683: if (doc != NULL) {
684: fprintf(stdout, "htmlSAXParseFile returned non-NULL\n");
685: xmlFreeDoc(doc);
686: }
687: fclose(f);
688: }
689: }
690: } else {
691: #endif /* LIBXML_PUSH_ENABLED */
692: doc = htmlSAXParseFile(filename, NULL, emptySAXHandler, NULL);
693: if (doc != NULL) {
694: fprintf(stdout, "htmlSAXParseFile returned non-NULL\n");
695: xmlFreeDoc(doc);
696: }
697:
698: if (!noout) {
699: /*
700: * Debug callback
701: */
702: doc = htmlSAXParseFile(filename, NULL, debugSAXHandler, NULL);
703: if (doc != NULL) {
704: fprintf(stdout, "htmlSAXParseFile returned non-NULL\n");
705: xmlFreeDoc(doc);
706: }
707: }
708: #ifdef LIBXML_PUSH_ENABLED
709: }
710: #endif /* LIBXML_PUSH_ENABLED */
711: }
712:
713: static void
714: parseAndPrintFile(char *filename) {
715: htmlDocPtr doc = NULL;
716:
717: /*
718: * build an HTML tree from a string;
719: */
720: #ifdef LIBXML_PUSH_ENABLED
721: if (push) {
722: FILE *f;
723:
724: #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
725: f = fopen(filename, "rb");
726: #else
727: f = fopen(filename, "r");
728: #endif
729: if (f != NULL) {
730: int res, size = 3;
731: char chars[4096];
732: htmlParserCtxtPtr ctxt;
733:
734: /* if (repeat) */
735: size = 4096;
736: res = fread(chars, 1, 4, f);
737: if (res > 0) {
738: ctxt = htmlCreatePushParserCtxt(NULL, NULL,
739: chars, res, filename, XML_CHAR_ENCODING_NONE);
740: while ((res = fread(chars, 1, size, f)) > 0) {
741: htmlParseChunk(ctxt, chars, res, 0);
742: }
743: htmlParseChunk(ctxt, chars, 0, 1);
744: doc = ctxt->myDoc;
745: htmlFreeParserCtxt(ctxt);
746: }
747: fclose(f);
748: }
749: } else {
750: doc = htmlReadFile(filename, NULL, options);
751: }
752: #else
753: doc = htmlReadFile(filename,NULL,options);
754: #endif
755: if (doc == NULL) {
756: xmlGenericError(xmlGenericErrorContext,
757: "Could not parse %s\n", filename);
758: }
759:
760: #ifdef LIBXML_TREE_ENABLED
761: /*
762: * test intermediate copy if needed.
763: */
764: if (copy) {
765: htmlDocPtr tmp;
766:
767: tmp = doc;
768: doc = xmlCopyDoc(doc, 1);
769: xmlFreeDoc(tmp);
770: }
771: #endif
772:
773: #ifdef LIBXML_OUTPUT_ENABLED
774: /*
775: * print it.
776: */
777: if (!noout) {
778: #ifdef LIBXML_DEBUG_ENABLED
779: if (!debug) {
780: if (encoding)
781: htmlSaveFileEnc("-", doc, encoding);
782: else
783: htmlDocDump(stdout, doc);
784: } else
785: xmlDebugDumpDocument(stdout, doc);
786: #else
787: if (encoding)
788: htmlSaveFileEnc("-", doc, encoding);
789: else
790: htmlDocDump(stdout, doc);
791: #endif
792: }
793: #endif /* LIBXML_OUTPUT_ENABLED */
794:
795: /*
796: * free it.
797: */
798: xmlFreeDoc(doc);
799: }
800:
801: int main(int argc, char **argv) {
802: int i, count;
803: int files = 0;
804:
805: for (i = 1; i < argc ; i++) {
806: #ifdef LIBXML_DEBUG_ENABLED
807: if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug")))
808: debug++;
809: else
810: #endif
811: if ((!strcmp(argv[i], "-copy")) || (!strcmp(argv[i], "--copy")))
812: copy++;
813: #ifdef LIBXML_PUSH_ENABLED
814: else if ((!strcmp(argv[i], "-push")) || (!strcmp(argv[i], "--push")))
815: push++;
816: #endif /* LIBXML_PUSH_ENABLED */
817: else if ((!strcmp(argv[i], "-sax")) || (!strcmp(argv[i], "--sax")))
818: sax++;
819: else if ((!strcmp(argv[i], "-noout")) || (!strcmp(argv[i], "--noout")))
820: noout++;
821: else if ((!strcmp(argv[i], "-repeat")) ||
822: (!strcmp(argv[i], "--repeat")))
823: repeat++;
824: else if ((!strcmp(argv[i], "-encode")) ||
825: (!strcmp(argv[i], "--encode"))) {
826: i++;
827: encoding = argv[i];
828: }
829: }
830: for (i = 1; i < argc ; i++) {
831: if ((!strcmp(argv[i], "-encode")) ||
832: (!strcmp(argv[i], "--encode"))) {
833: i++;
834: continue;
835: }
836: if (argv[i][0] != '-') {
837: if (repeat) {
838: for (count = 0;count < 100 * repeat;count++) {
839: if (sax)
840: parseSAXFile(argv[i]);
841: else
842: parseAndPrintFile(argv[i]);
843: }
844: } else {
845: if (sax)
846: parseSAXFile(argv[i]);
847: else
848: parseAndPrintFile(argv[i]);
849: }
850: files ++;
851: }
852: }
853: if (files == 0) {
854: printf("Usage : %s [--debug] [--copy] [--copy] HTMLfiles ...\n",
855: argv[0]);
856: printf("\tParse the HTML files and output the result of the parsing\n");
857: #ifdef LIBXML_DEBUG_ENABLED
858: printf("\t--debug : dump a debug tree of the in-memory document\n");
859: #endif
860: printf("\t--copy : used to test the internal copy implementation\n");
861: printf("\t--sax : debug the sequence of SAX callbacks\n");
862: printf("\t--repeat : parse the file 100 times, for timing\n");
863: printf("\t--noout : do not print the result\n");
864: #ifdef LIBXML_PUSH_ENABLED
865: printf("\t--push : use the push mode parser\n");
866: #endif /* LIBXML_PUSH_ENABLED */
867: printf("\t--encode encoding : output in the given encoding\n");
868: }
869: xmlCleanupParser();
870: xmlMemoryDump();
871:
872: return(0);
873: }
874: #else /* !LIBXML_HTML_ENABLED */
875: #include <stdio.h>
876: int main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
877: printf("%s : HTML support not compiled in\n", argv[0]);
878: return(0);
879: }
880: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to testHTML.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