testHTML.c@ 16591

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

Line
1	/*
2	* testHTML.c : a small tester program for HTML input.
3	*
4	* See Copyright for the status of this software.
5	*
6	* [email protected]
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

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

source: vbox/trunk/src/libs/libxml2-2.6.30/testHTML.c@ 16591

Download in other formats: