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