2 * testSAX.c : a small tester program for parsing using the SAX API.
4 * See Copyright for the status of this software.
11 #ifdef HAVE_SYS_TIME_H
14 #ifdef HAVE_SYS_TIMEB_H
15 #include <sys/timeb.h>
21 #ifdef LIBXML_SAX1_ENABLED
25 #ifdef HAVE_SYS_TYPES_H
26 #include <sys/types.h>
28 #ifdef HAVE_SYS_STAT_H
45 #include <libxml/globals.h>
46 #include <libxml/xmlerror.h>
47 #include <libxml/parser.h>
48 #include <libxml/parserInternals.h> /* only for xmlNewInputFromFile() */
49 #include <libxml/tree.h>
50 #include <libxml/debugXML.h>
51 #include <libxml/xmlmemory.h>
55 static int recovery = 0;
60 static int nonull = 0;
62 static int repeat = 0;
63 static int callbacks = 0;
64 static int timing = 0;
70 * Internal timing routines to remove the necessity to have unix-specific
74 #ifndef HAVE_GETTIMEOFDAY
75 #ifdef HAVE_SYS_TIMEB_H
76 #ifdef HAVE_SYS_TIME_H
80 my_gettimeofday(struct timeval *tvp, void *tzp)
82 struct timeb timebuffer;
86 tvp->tv_sec = timebuffer.time;
87 tvp->tv_usec = timebuffer.millitm * 1000L;
91 #define HAVE_GETTIMEOFDAY 1
92 #define gettimeofday my_gettimeofday
94 #endif /* HAVE_FTIME */
95 #endif /* HAVE_SYS_TIME_H */
96 #endif /* HAVE_SYS_TIMEB_H */
97 #endif /* !HAVE_GETTIMEOFDAY */
99 #if defined(HAVE_GETTIMEOFDAY)
100 static struct timeval begin, end;
103 * startTimer: call where you want to start timing
108 gettimeofday(&begin, NULL);
112 * endTimer: call where you want to stop timing and to print out a
113 * message about the timing performed; format is a printf
117 endTimer(const char *fmt, ...)
122 gettimeofday(&end, NULL);
123 msec = end.tv_sec - begin.tv_sec;
125 msec += (end.tv_usec - begin.tv_usec) / 1000;
127 #ifndef HAVE_STDARG_H
128 #error "endTimer required stdarg functions"
131 vfprintf(stderr, fmt, ap);
134 fprintf(stderr, " took %ld ms\n", msec);
136 #elif defined(HAVE_TIME_H)
138 * No gettimeofday function, so we have to make do with calling clock.
139 * This is obviously less accurate, but there's little we can do about
142 #ifndef CLOCKS_PER_SEC
143 #define CLOCKS_PER_SEC 100
146 static clock_t begin, end;
153 endTimer(const char *fmt, ...)
159 msec = ((end - begin) * 1000) / CLOCKS_PER_SEC;
161 #ifndef HAVE_STDARG_H
162 #error "endTimer required stdarg functions"
165 vfprintf(stderr, fmt, ap);
167 fprintf(stderr, " took %ld ms\n", msec);
172 * We don't have a gettimeofday or time.h, so we just don't do timing
182 endTimer(char *format, ...)
185 * We cannot do anything because we don't have a timing function
188 va_start(ap, format);
189 vfprintf(stderr, format, ap);
191 fprintf(stderr, " was not timed\n", msec);
193 /* We don't have gettimeofday, time or stdarg.h, what crazy world is
203 static xmlSAXHandler emptySAXHandlerStruct = {
204 NULL, /* internalSubset */
205 NULL, /* isStandalone */
206 NULL, /* hasInternalSubset */
207 NULL, /* hasExternalSubset */
208 NULL, /* resolveEntity */
209 NULL, /* getEntity */
210 NULL, /* entityDecl */
211 NULL, /* notationDecl */
212 NULL, /* attributeDecl */
213 NULL, /* elementDecl */
214 NULL, /* unparsedEntityDecl */
215 NULL, /* setDocumentLocator */
216 NULL, /* startDocument */
217 NULL, /* endDocument */
218 NULL, /* startElement */
219 NULL, /* endElement */
220 NULL, /* reference */
221 NULL, /* characters */
222 NULL, /* ignorableWhitespace */
223 NULL, /* processingInstruction */
225 NULL, /* xmlParserWarning */
226 NULL, /* xmlParserError */
227 NULL, /* xmlParserError */
228 NULL, /* getParameterEntity */
229 NULL, /* cdataBlock; */
230 NULL, /* externalSubset; */
233 NULL, /* startElementNs */
234 NULL, /* endElementNs */
235 NULL /* xmlStructuredErrorFunc */
238 static xmlSAXHandlerPtr emptySAXHandler = &emptySAXHandlerStruct;
239 extern xmlSAXHandlerPtr debugSAXHandler;
241 /************************************************************************
245 ************************************************************************/
249 * @ctxt: An XML parser context
251 * Is this document tagged standalone ?
256 isStandaloneDebug(void *ctx ATTRIBUTE_UNUSED)
261 fprintf(stdout, "SAX.isStandalone()\n");
266 * hasInternalSubsetDebug:
267 * @ctxt: An XML parser context
269 * Does this document has an internal subset
274 hasInternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED)
279 fprintf(stdout, "SAX.hasInternalSubset()\n");
284 * hasExternalSubsetDebug:
285 * @ctxt: An XML parser context
287 * Does this document has an external subset
292 hasExternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED)
297 fprintf(stdout, "SAX.hasExternalSubset()\n");
302 * internalSubsetDebug:
303 * @ctxt: An XML parser context
305 * Does this document has an internal subset
308 internalSubsetDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
309 const xmlChar *ExternalID, const xmlChar *SystemID)
314 fprintf(stdout, "SAX.internalSubset(%s,", name);
315 if (ExternalID == NULL)
316 fprintf(stdout, " ,");
318 fprintf(stdout, " %s,", ExternalID);
319 if (SystemID == NULL)
320 fprintf(stdout, " )\n");
322 fprintf(stdout, " %s)\n", SystemID);
326 * externalSubsetDebug:
327 * @ctxt: An XML parser context
329 * Does this document has an external subset
332 externalSubsetDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
333 const xmlChar *ExternalID, const xmlChar *SystemID)
338 fprintf(stdout, "SAX.externalSubset(%s,", name);
339 if (ExternalID == NULL)
340 fprintf(stdout, " ,");
342 fprintf(stdout, " %s,", ExternalID);
343 if (SystemID == NULL)
344 fprintf(stdout, " )\n");
346 fprintf(stdout, " %s)\n", SystemID);
350 * resolveEntityDebug:
351 * @ctxt: An XML parser context
352 * @publicId: The public ID of the entity
353 * @systemId: The system ID of the entity
355 * Special entity resolver, better left to the parser, it has
356 * more context than the application layer.
357 * The default behaviour is to NOT resolve the entities, in that case
358 * the ENTITY_REF nodes are built in the structure (and the parameter
361 * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
363 static xmlParserInputPtr
364 resolveEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *publicId, const xmlChar *systemId)
369 /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
372 fprintf(stdout, "SAX.resolveEntity(");
373 if (publicId != NULL)
374 fprintf(stdout, "%s", (char *)publicId);
376 fprintf(stdout, " ");
377 if (systemId != NULL)
378 fprintf(stdout, ", %s)\n", (char *)systemId);
380 fprintf(stdout, ", )\n");
382 if (systemId != NULL) {
383 return(xmlNewInputFromFile(ctxt, (char *) systemId));
391 * @ctxt: An XML parser context
392 * @name: The entity name
394 * Get an entity by name
396 * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
399 getEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
404 fprintf(stdout, "SAX.getEntity(%s)\n", name);
409 * getParameterEntityDebug:
410 * @ctxt: An XML parser context
411 * @name: The entity name
413 * Get a parameter entity by name
415 * Returns the xmlParserInputPtr
418 getParameterEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
423 fprintf(stdout, "SAX.getParameterEntity(%s)\n", name);
430 * @ctxt: An XML parser context
431 * @name: the entity name
432 * @type: the entity type
433 * @publicId: The public ID of the entity
434 * @systemId: The system ID of the entity
435 * @content: the entity value (without processing).
437 * An entity definition has been parsed
440 entityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
441 const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
443 const xmlChar *nullstr = BAD_CAST "(null)";
444 /* not all libraries handle printing null pointers nicely */
445 if (publicId == NULL)
447 if (systemId == NULL)
450 content = (xmlChar *)nullstr;
454 fprintf(stdout, "SAX.entityDecl(%s, %d, %s, %s, %s)\n",
455 name, type, publicId, systemId, content);
459 * attributeDeclDebug:
460 * @ctxt: An XML parser context
461 * @name: the attribute name
462 * @type: the attribute type
464 * An attribute definition has been parsed
467 attributeDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar * elem,
468 const xmlChar * name, int type, int def,
469 const xmlChar * defaultValue, xmlEnumerationPtr tree)
474 if (defaultValue == NULL)
475 fprintf(stdout, "SAX.attributeDecl(%s, %s, %d, %d, NULL, ...)\n",
476 elem, name, type, def);
478 fprintf(stdout, "SAX.attributeDecl(%s, %s, %d, %d, %s, ...)\n",
479 elem, name, type, def, defaultValue);
480 xmlFreeEnumeration(tree);
485 * @ctxt: An XML parser context
486 * @name: the element name
487 * @type: the element type
488 * @content: the element value (without processing).
490 * An element definition has been parsed
493 elementDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
494 xmlElementContentPtr content ATTRIBUTE_UNUSED)
499 fprintf(stdout, "SAX.elementDecl(%s, %d, ...)\n",
505 * @ctxt: An XML parser context
506 * @name: The name of the notation
507 * @publicId: The public ID of the entity
508 * @systemId: The system ID of the entity
510 * What to do when a notation declaration has been parsed.
513 notationDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
514 const xmlChar *publicId, const xmlChar *systemId)
519 fprintf(stdout, "SAX.notationDecl(%s, %s, %s)\n",
520 (char *) name, (char *) publicId, (char *) systemId);
524 * unparsedEntityDeclDebug:
525 * @ctxt: An XML parser context
526 * @name: The name of the entity
527 * @publicId: The public ID of the entity
528 * @systemId: The system ID of the entity
529 * @notationName: the name of the notation
531 * What to do when an unparsed entity declaration is parsed
534 unparsedEntityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
535 const xmlChar *publicId, const xmlChar *systemId,
536 const xmlChar *notationName)
538 const xmlChar *nullstr = BAD_CAST "(null)";
540 if (publicId == NULL)
542 if (systemId == NULL)
544 if (notationName == NULL)
545 notationName = nullstr;
549 fprintf(stdout, "SAX.unparsedEntityDecl(%s, %s, %s, %s)\n",
550 (char *) name, (char *) publicId, (char *) systemId,
551 (char *) notationName);
555 * setDocumentLocatorDebug:
556 * @ctxt: An XML parser context
557 * @loc: A SAX Locator
559 * Receive the document locator at startup, actually xmlDefaultSAXLocator
560 * Everything is available on the context, so this is useless in our case.
563 setDocumentLocatorDebug(void *ctx ATTRIBUTE_UNUSED, xmlSAXLocatorPtr loc ATTRIBUTE_UNUSED)
568 fprintf(stdout, "SAX.setDocumentLocator()\n");
572 * startDocumentDebug:
573 * @ctxt: An XML parser context
575 * called when the document start being processed.
578 startDocumentDebug(void *ctx ATTRIBUTE_UNUSED)
583 fprintf(stdout, "SAX.startDocument()\n");
588 * @ctxt: An XML parser context
590 * called when the document end has been detected.
593 endDocumentDebug(void *ctx ATTRIBUTE_UNUSED)
598 fprintf(stdout, "SAX.endDocument()\n");
603 * @ctxt: An XML parser context
604 * @name: The element name
606 * called when an opening tag has been processed.
609 startElementDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, const xmlChar **atts)
616 fprintf(stdout, "SAX.startElement(%s", (char *) name);
618 for (i = 0;(atts[i] != NULL);i++) {
619 fprintf(stdout, ", %s='", atts[i++]);
621 fprintf(stdout, "%s'", atts[i]);
624 fprintf(stdout, ")\n");
629 * @ctxt: An XML parser context
630 * @name: The element name
632 * called when the end of an element has been detected.
635 endElementDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
640 fprintf(stdout, "SAX.endElement(%s)\n", (char *) name);
645 * @ctxt: An XML parser context
646 * @ch: a xmlChar string
647 * @len: the number of xmlChar
649 * receiving some chars from the parser.
650 * Question: how much at a time ???
653 charactersDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
661 for (i = 0;(i<len) && (i < 30);i++)
665 fprintf(stdout, "SAX.characters(%s, %d)\n", output, len);
670 * @ctxt: An XML parser context
671 * @name: The entity name
673 * called when an entity reference is detected.
676 referenceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
681 fprintf(stdout, "SAX.reference(%s)\n", name);
685 * ignorableWhitespaceDebug:
686 * @ctxt: An XML parser context
687 * @ch: a xmlChar string
688 * @start: the first char in the string
689 * @len: the number of xmlChar
691 * receiving some ignorable whitespaces from the parser.
692 * Question: how much at a time ???
695 ignorableWhitespaceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
703 for (i = 0;(i<len) && (i < 30);i++)
706 fprintf(stdout, "SAX.ignorableWhitespace(%s, %d)\n", output, len);
710 * processingInstructionDebug:
711 * @ctxt: An XML parser context
712 * @target: the target name
713 * @data: the PI data's
714 * @len: the number of xmlChar
716 * A processing instruction has been parsed.
719 processingInstructionDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *target,
726 fprintf(stdout, "SAX.processingInstruction(%s, %s)\n",
727 (char *) target, (char *) data);
729 fprintf(stdout, "SAX.processingInstruction(%s, NULL)\n",
735 * @ctx: the user data (XML parser context)
736 * @value: The pcdata content
737 * @len: the block length
739 * called when a pcdata block has been parsed
742 cdataBlockDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *value, int len)
747 fprintf(stdout, "SAX.pcdata(%.20s, %d)\n",
748 (char *) value, len);
753 * @ctxt: An XML parser context
754 * @value: the comment content
756 * A comment has been parsed.
759 commentDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *value)
764 fprintf(stdout, "SAX.comment(%s)\n", value);
769 * @ctxt: An XML parser context
770 * @msg: the message to display/transmit
771 * @...: extra parameters for the message display
773 * Display and format a warning messages, gives file, line, position and
777 warningDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
785 fprintf(stdout, "SAX.warning: ");
786 vfprintf(stdout, msg, args);
792 * @ctxt: An XML parser context
793 * @msg: the message to display/transmit
794 * @...: extra parameters for the message display
796 * Display and format a error messages, gives file, line, position and
800 errorDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
808 fprintf(stdout, "SAX.error: ");
809 vfprintf(stdout, msg, args);
815 * @ctxt: An XML parser context
816 * @msg: the message to display/transmit
817 * @...: extra parameters for the message display
819 * Display and format a fatalError messages, gives file, line, position and
823 fatalErrorDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
831 fprintf(stdout, "SAX.fatalError: ");
832 vfprintf(stdout, msg, args);
836 static xmlSAXHandler debugSAXHandlerStruct = {
839 hasInternalSubsetDebug,
840 hasExternalSubsetDebug,
847 unparsedEntityDeclDebug,
848 setDocumentLocatorDebug,
855 ignorableWhitespaceDebug,
856 processingInstructionDebug,
861 getParameterEntityDebug,
871 xmlSAXHandlerPtr debugSAXHandler = &debugSAXHandlerStruct;
874 * SAX2 specific callbacks
877 * startElementNsDebug:
878 * @ctxt: An XML parser context
879 * @name: The element name
881 * called when an opening tag has been processed.
884 startElementNsDebug(void *ctx ATTRIBUTE_UNUSED,
885 const xmlChar *localname,
886 const xmlChar *prefix,
889 const xmlChar **namespaces,
892 const xmlChar **attributes)
899 fprintf(stdout, "SAX.startElementNs(%s", (char *) localname);
901 fprintf(stdout, ", NULL");
903 fprintf(stdout, ", %s", (char *) prefix);
905 fprintf(stdout, ", NULL");
907 fprintf(stdout, ", '%s'", (char *) URI);
908 fprintf(stdout, ", %d", nb_namespaces);
910 if (namespaces != NULL) {
911 for (i = 0;i < nb_namespaces * 2;i++) {
912 fprintf(stdout, ", xmlns");
913 if (namespaces[i] != NULL)
914 fprintf(stdout, ":%s", namespaces[i]);
916 fprintf(stdout, "='%s'", namespaces[i]);
919 fprintf(stdout, ", %d, %d", nb_attributes, nb_defaulted);
920 if (attributes != NULL) {
921 for (i = 0;i < nb_attributes * 5;i += 5) {
922 if (attributes[i + 1] != NULL)
923 fprintf(stdout, ", %s:%s='", attributes[i + 1], attributes[i]);
925 fprintf(stdout, ", %s='", attributes[i]);
926 fprintf(stdout, "%.4s...', %d", attributes[i + 3],
927 (int)(attributes[i + 4] - attributes[i + 3]));
930 fprintf(stdout, ")\n");
935 * @ctxt: An XML parser context
936 * @name: The element name
938 * called when the end of an element has been detected.
941 endElementNsDebug(void *ctx ATTRIBUTE_UNUSED,
942 const xmlChar *localname,
943 const xmlChar *prefix,
949 fprintf(stdout, "SAX.endElementNs(%s", (char *) localname);
951 fprintf(stdout, ", NULL");
953 fprintf(stdout, ", %s", (char *) prefix);
955 fprintf(stdout, ", NULL)\n");
957 fprintf(stdout, ", '%s')\n", (char *) URI);
960 static xmlSAXHandler debugSAX2HandlerStruct = {
963 hasInternalSubsetDebug,
964 hasExternalSubsetDebug,
971 unparsedEntityDeclDebug,
972 setDocumentLocatorDebug,
979 ignorableWhitespaceDebug,
980 processingInstructionDebug,
985 getParameterEntityDebug,
995 static xmlSAXHandlerPtr debugSAX2Handler = &debugSAX2HandlerStruct;
997 /************************************************************************
1001 ************************************************************************/
1004 parseAndPrintFile(char *filename) {
1007 #ifdef LIBXML_PUSH_ENABLED
1011 if ((!quiet) && (!nonull)) {
1013 * Empty callbacks for checking
1015 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
1016 f = fopen(filename, "rb");
1018 f = fopen(filename, "r");
1023 xmlParserCtxtPtr ctxt;
1025 ret = fread(chars, 1, 4, f);
1027 ctxt = xmlCreatePushParserCtxt(emptySAXHandler, NULL,
1028 chars, ret, filename);
1029 while ((ret = fread(chars, 1, 3, f)) > 0) {
1030 xmlParseChunk(ctxt, chars, ret, 0);
1032 xmlParseChunk(ctxt, chars, 0, 1);
1033 xmlFreeParserCtxt(ctxt);
1037 xmlGenericError(xmlGenericErrorContext,
1038 "Cannot read file %s\n", filename);
1044 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
1045 f = fopen(filename, "rb");
1047 f = fopen(filename, "r");
1052 xmlParserCtxtPtr ctxt;
1054 ret = fread(chars, 1, 4, f);
1057 ctxt = xmlCreatePushParserCtxt(debugSAX2Handler, NULL,
1058 chars, ret, filename);
1060 ctxt = xmlCreatePushParserCtxt(debugSAXHandler, NULL,
1061 chars, ret, filename);
1062 while ((ret = fread(chars, 1, 3, f)) > 0) {
1063 xmlParseChunk(ctxt, chars, ret, 0);
1065 ret = xmlParseChunk(ctxt, chars, 0, 1);
1066 xmlFreeParserCtxt(ctxt);
1069 "xmlSAXUserParseFile returned error %d\n", ret);
1075 #endif /* LIBXML_PUSH_ENABLED */
1078 * Empty callbacks for checking
1080 if ((!quiet) && (!nonull)) {
1081 res = xmlSAXUserParseFile(emptySAXHandler, NULL, filename);
1083 fprintf(stdout, "xmlSAXUserParseFile returned error %d\n", res);
1093 for (i = 0;i < 99;i++) {
1095 res = xmlSAXUserParseFile(debugSAX2Handler, NULL,
1098 res = xmlSAXUserParseFile(debugSAXHandler, NULL,
1103 res = xmlSAXUserParseFile(debugSAX2Handler, NULL, filename);
1105 res = xmlSAXUserParseFile(debugSAXHandler, NULL, filename);
1107 fprintf(stdout, "xmlSAXUserParseFile returned error %d\n", res);
1110 fprintf(stdout, "%d callbacks generated\n", callbacks);
1113 * test 100x the SAX parse
1117 for (i = 0; i<100;i++)
1118 res = xmlSAXUserParseFile(emptySAXHandler, NULL, filename);
1120 fprintf(stdout, "xmlSAXUserParseFile returned error %d\n", res);
1123 #ifdef LIBXML_PUSH_ENABLED
1129 int main(int argc, char **argv) {
1133 LIBXML_TEST_VERSION /* be safe, plus calls xmlInitParser */
1135 for (i = 1; i < argc ; i++) {
1136 if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug")))
1138 else if ((!strcmp(argv[i], "-copy")) || (!strcmp(argv[i], "--copy")))
1140 else if ((!strcmp(argv[i], "-recover")) ||
1141 (!strcmp(argv[i], "--recover")))
1143 else if ((!strcmp(argv[i], "-push")) ||
1144 (!strcmp(argv[i], "--push")))
1145 #ifdef LIBXML_PUSH_ENABLED
1148 fprintf(stderr,"'push' not enabled in library - ignoring\n");
1149 #endif /* LIBXML_PUSH_ENABLED */
1150 else if ((!strcmp(argv[i], "-speed")) ||
1151 (!strcmp(argv[i], "--speed")))
1153 else if ((!strcmp(argv[i], "-timing")) ||
1154 (!strcmp(argv[i], "--timing"))) {
1158 } else if ((!strcmp(argv[i], "-repeat")) ||
1159 (!strcmp(argv[i], "--repeat"))) {
1162 } else if ((!strcmp(argv[i], "-noent")) ||
1163 (!strcmp(argv[i], "--noent")))
1165 else if ((!strcmp(argv[i], "-quiet")) ||
1166 (!strcmp(argv[i], "--quiet")))
1168 else if ((!strcmp(argv[i], "-sax2")) ||
1169 (!strcmp(argv[i], "--sax2")))
1171 else if ((!strcmp(argv[i], "-nonull")) ||
1172 (!strcmp(argv[i], "--nonull")))
1175 if (noent != 0) xmlSubstituteEntitiesDefault(1);
1176 for (i = 1; i < argc ; i++) {
1177 if (argv[i][0] != '-') {
1181 parseAndPrintFile(argv[i]);
1183 endTimer("Parsing");
1194 int main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
1195 printf("%s : SAX1 parsing support not compiled in\n", argv[0]);
1198 #endif /* LIBXML_SAX1_ENABLED */