Home | History | Annotate | Download | only in libxml2 
      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 (at) veillard.com
      7  */
      8 
      9 #include "libxml.h"
     10 
     11 #ifdef HAVE_SYS_TIME_H
     12 #include <sys/time.h>
     13 #endif
     14 #ifdef HAVE_SYS_TIMEB_H
     15 #include <sys/timeb.h>
     16 #endif
     17 #ifdef HAVE_TIME_H
     18 #include <time.h>
     19 #endif
     20 
     21 #ifdef LIBXML_SAX1_ENABLED
     22 #include <string.h>
     23 #include <stdarg.h>
     24 
     25 #ifdef HAVE_SYS_TYPES_H
     26 #include <sys/types.h>
     27 #endif
     28 #ifdef HAVE_SYS_STAT_H
     29 #include <sys/stat.h>
     30 #endif
     31 #ifdef HAVE_FCNTL_H
     32 #include <fcntl.h>
     33 #endif
     34 #ifdef HAVE_UNISTD_H
     35 #include <unistd.h>
     36 #endif
     37 #ifdef HAVE_STDLIB_H
     38 #include <stdlib.h>
     39 #endif
     40 #ifdef HAVE_STRING_H
     41 #include <string.h>
     42 #endif
     43 
     44 
     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>
     52 
     53 static int debug = 0;
     54 static int copy = 0;
     55 static int recovery = 0;
     56 static int push = 0;
     57 static int speed = 0;
     58 static int noent = 0;
     59 static int quiet = 0;
     60 static int nonull = 0;
     61 static int sax2 = 0;
     62 static int repeat = 0;
     63 static int callbacks = 0;
     64 static int timing = 0;
     65 
     66 /*
     67  * Timing routines.
     68  */
     69 /*
     70  * Internal timing routines to remove the necessity to have unix-specific
     71  * function calls
     72  */
     73 
     74 #ifndef HAVE_GETTIMEOFDAY
     75 #ifdef HAVE_SYS_TIMEB_H
     76 #ifdef HAVE_SYS_TIME_H
     77 #ifdef HAVE_FTIME
     78 
     79 static int
     80 my_gettimeofday(struct timeval *tvp, void *tzp)
     81 {
     82 	struct timeb timebuffer;
     83 
     84 	ftime(&timebuffer);
     85 	if (tvp) {
     86 		tvp->tv_sec = timebuffer.time;
     87 		tvp->tv_usec = timebuffer.millitm * 1000L;
     88 	}
     89 	return (0);
     90 }
     91 #define HAVE_GETTIMEOFDAY 1
     92 #define gettimeofday my_gettimeofday
     93 
     94 #endif /* HAVE_FTIME */
     95 #endif /* HAVE_SYS_TIME_H */
     96 #endif /* HAVE_SYS_TIMEB_H */
     97 #endif /* !HAVE_GETTIMEOFDAY */
     98 
     99 #if defined(HAVE_GETTIMEOFDAY)
    100 static struct timeval begin, end;
    101 
    102 /*
    103  * startTimer: call where you want to start timing
    104  */
    105 static void
    106 startTimer(void)
    107 {
    108     gettimeofday(&begin, NULL);
    109 }
    110 
    111 /*
    112  * endTimer: call where you want to stop timing and to print out a
    113  *           message about the timing performed; format is a printf
    114  *           type argument
    115  */
    116 static void XMLCDECL
    117 endTimer(const char *fmt, ...)
    118 {
    119     long msec;
    120     va_list ap;
    121 
    122     gettimeofday(&end, NULL);
    123     msec = end.tv_sec - begin.tv_sec;
    124     msec *= 1000;
    125     msec += (end.tv_usec - begin.tv_usec) / 1000;
    126 
    127 #ifndef HAVE_STDARG_H
    128 #error "endTimer required stdarg functions"
    129 #endif
    130     va_start(ap, fmt);
    131     vfprintf(stderr, fmt, ap);
    132     va_end(ap);
    133 
    134     fprintf(stderr, " took %ld ms\n", msec);
    135 }
    136 #elif defined(HAVE_TIME_H)
    137 /*
    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
    140  * that.
    141  */
    142 #ifndef CLOCKS_PER_SEC
    143 #define CLOCKS_PER_SEC 100
    144 #endif
    145 
    146 static clock_t begin, end;
    147 static void
    148 startTimer(void)
    149 {
    150     begin = clock();
    151 }
    152 static void XMLCDECL
    153 endTimer(const char *fmt, ...)
    154 {
    155     long msec;
    156     va_list ap;
    157 
    158     end = clock();
    159     msec = ((end - begin) * 1000) / CLOCKS_PER_SEC;
    160 
    161 #ifndef HAVE_STDARG_H
    162 #error "endTimer required stdarg functions"
    163 #endif
    164     va_start(ap, fmt);
    165     vfprintf(stderr, fmt, ap);
    166     va_end(ap);
    167     fprintf(stderr, " took %ld ms\n", msec);
    168 }
    169 #else
    170 
    171 /*
    172  * We don't have a gettimeofday or time.h, so we just don't do timing
    173  */
    174 static void
    175 startTimer(void)
    176 {
    177     /*
    178      * Do nothing
    179      */
    180 }
    181 static void XMLCDECL
    182 endTimer(char *format, ...)
    183 {
    184     /*
    185      * We cannot do anything because we don't have a timing function
    186      */
    187 #ifdef HAVE_STDARG_H
    188     va_start(ap, format);
    189     vfprintf(stderr, format, ap);
    190     va_end(ap);
    191     fprintf(stderr, " was not timed\n", msec);
    192 #else
    193     /* We don't have gettimeofday, time or stdarg.h, what crazy world is
    194      * this ?!
    195      */
    196 #endif
    197 }
    198 #endif
    199 
    200 /*
    201  * empty SAX block
    202  */
    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 */
    224     NULL, /* comment */
    225     NULL, /* xmlParserWarning */
    226     NULL, /* xmlParserError */
    227     NULL, /* xmlParserError */
    228     NULL, /* getParameterEntity */
    229     NULL, /* cdataBlock; */
    230     NULL, /* externalSubset; */
    231     1,
    232     NULL,
    233     NULL, /* startElementNs */
    234     NULL, /* endElementNs */
    235     NULL  /* xmlStructuredErrorFunc */
    236 };
    237 
    238 static xmlSAXHandlerPtr emptySAXHandler = &emptySAXHandlerStruct;
    239 extern xmlSAXHandlerPtr debugSAXHandler;
    240 
    241 /************************************************************************
    242  *									*
    243  *				Debug Handlers				*
    244  *									*
    245  ************************************************************************/
    246 
    247 /**
    248  * isStandaloneDebug:
    249  * @ctxt:  An XML parser context
    250  *
    251  * Is this document tagged standalone ?
    252  *
    253  * Returns 1 if true
    254  */
    255 static int
    256 isStandaloneDebug(void *ctx ATTRIBUTE_UNUSED)
    257 {
    258     callbacks++;
    259     if (quiet)
    260 	return(0);
    261     fprintf(stdout, "SAX.isStandalone()\n");
    262     return(0);
    263 }
    264 
    265 /**
    266  * hasInternalSubsetDebug:
    267  * @ctxt:  An XML parser context
    268  *
    269  * Does this document has an internal subset
    270  *
    271  * Returns 1 if true
    272  */
    273 static int
    274 hasInternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED)
    275 {
    276     callbacks++;
    277     if (quiet)
    278 	return(0);
    279     fprintf(stdout, "SAX.hasInternalSubset()\n");
    280     return(0);
    281 }
    282 
    283 /**
    284  * hasExternalSubsetDebug:
    285  * @ctxt:  An XML parser context
    286  *
    287  * Does this document has an external subset
    288  *
    289  * Returns 1 if true
    290  */
    291 static int
    292 hasExternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED)
    293 {
    294     callbacks++;
    295     if (quiet)
    296 	return(0);
    297     fprintf(stdout, "SAX.hasExternalSubset()\n");
    298     return(0);
    299 }
    300 
    301 /**
    302  * internalSubsetDebug:
    303  * @ctxt:  An XML parser context
    304  *
    305  * Does this document has an internal subset
    306  */
    307 static void
    308 internalSubsetDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
    309 	       const xmlChar *ExternalID, const xmlChar *SystemID)
    310 {
    311     callbacks++;
    312     if (quiet)
    313 	return;
    314     fprintf(stdout, "SAX.internalSubset(%s,", name);
    315     if (ExternalID == NULL)
    316 	fprintf(stdout, " ,");
    317     else
    318 	fprintf(stdout, " %s,", ExternalID);
    319     if (SystemID == NULL)
    320 	fprintf(stdout, " )\n");
    321     else
    322 	fprintf(stdout, " %s)\n", SystemID);
    323 }
    324 
    325 /**
    326  * externalSubsetDebug:
    327  * @ctxt:  An XML parser context
    328  *
    329  * Does this document has an external subset
    330  */
    331 static void
    332 externalSubsetDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
    333 	       const xmlChar *ExternalID, const xmlChar *SystemID)
    334 {
    335     callbacks++;
    336     if (quiet)
    337 	return;
    338     fprintf(stdout, "SAX.externalSubset(%s,", name);
    339     if (ExternalID == NULL)
    340 	fprintf(stdout, " ,");
    341     else
    342 	fprintf(stdout, " %s,", ExternalID);
    343     if (SystemID == NULL)
    344 	fprintf(stdout, " )\n");
    345     else
    346 	fprintf(stdout, " %s)\n", SystemID);
    347 }
    348 
    349 /**
    350  * resolveEntityDebug:
    351  * @ctxt:  An XML parser context
    352  * @publicId: The public ID of the entity
    353  * @systemId: The system ID of the entity
    354  *
    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
    359  * values).
    360  *
    361  * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
    362  */
    363 static xmlParserInputPtr
    364 resolveEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *publicId, const xmlChar *systemId)
    365 {
    366     callbacks++;
    367     if (quiet)
    368 	return(NULL);
    369     /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
    370 
    371 
    372     fprintf(stdout, "SAX.resolveEntity(");
    373     if (publicId != NULL)
    374 	fprintf(stdout, "%s", (char *)publicId);
    375     else
    376 	fprintf(stdout, " ");
    377     if (systemId != NULL)
    378 	fprintf(stdout, ", %s)\n", (char *)systemId);
    379     else
    380 	fprintf(stdout, ", )\n");
    381 /*********
    382     if (systemId != NULL) {
    383         return(xmlNewInputFromFile(ctxt, (char *) systemId));
    384     }
    385  *********/
    386     return(NULL);
    387 }
    388 
    389 /**
    390  * getEntityDebug:
    391  * @ctxt:  An XML parser context
    392  * @name: The entity name
    393  *
    394  * Get an entity by name
    395  *
    396  * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
    397  */
    398 static xmlEntityPtr
    399 getEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
    400 {
    401     callbacks++;
    402     if (quiet)
    403 	return(NULL);
    404     fprintf(stdout, "SAX.getEntity(%s)\n", name);
    405     return(NULL);
    406 }
    407 
    408 /**
    409  * getParameterEntityDebug:
    410  * @ctxt:  An XML parser context
    411  * @name: The entity name
    412  *
    413  * Get a parameter entity by name
    414  *
    415  * Returns the xmlParserInputPtr
    416  */
    417 static xmlEntityPtr
    418 getParameterEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
    419 {
    420     callbacks++;
    421     if (quiet)
    422 	return(NULL);
    423     fprintf(stdout, "SAX.getParameterEntity(%s)\n", name);
    424     return(NULL);
    425 }
    426 
    427 
    428 /**
    429  * entityDeclDebug:
    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).
    436  *
    437  * An entity definition has been parsed
    438  */
    439 static void
    440 entityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
    441           const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
    442 {
    443 const xmlChar *nullstr = BAD_CAST "(null)";
    444     /* not all libraries handle printing null pointers nicely */
    445     if (publicId == NULL)
    446         publicId = nullstr;
    447     if (systemId == NULL)
    448         systemId = nullstr;
    449     if (content == NULL)
    450         content = (xmlChar *)nullstr;
    451     callbacks++;
    452     if (quiet)
    453 	return;
    454     fprintf(stdout, "SAX.entityDecl(%s, %d, %s, %s, %s)\n",
    455             name, type, publicId, systemId, content);
    456 }
    457 
    458 /**
    459  * attributeDeclDebug:
    460  * @ctxt:  An XML parser context
    461  * @name:  the attribute name
    462  * @type:  the attribute type
    463  *
    464  * An attribute definition has been parsed
    465  */
    466 static void
    467 attributeDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar * elem,
    468                    const xmlChar * name, int type, int def,
    469                    const xmlChar * defaultValue, xmlEnumerationPtr tree)
    470 {
    471     callbacks++;
    472     if (quiet)
    473         return;
    474     if (defaultValue == NULL)
    475         fprintf(stdout, "SAX.attributeDecl(%s, %s, %d, %d, NULL, ...)\n",
    476                 elem, name, type, def);
    477     else
    478         fprintf(stdout, "SAX.attributeDecl(%s, %s, %d, %d, %s, ...)\n",
    479                 elem, name, type, def, defaultValue);
    480     xmlFreeEnumeration(tree);
    481 }
    482 
    483 /**
    484  * elementDeclDebug:
    485  * @ctxt:  An XML parser context
    486  * @name:  the element name
    487  * @type:  the element type
    488  * @content: the element value (without processing).
    489  *
    490  * An element definition has been parsed
    491  */
    492 static void
    493 elementDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
    494 	    xmlElementContentPtr content ATTRIBUTE_UNUSED)
    495 {
    496     callbacks++;
    497     if (quiet)
    498 	return;
    499     fprintf(stdout, "SAX.elementDecl(%s, %d, ...)\n",
    500             name, type);
    501 }
    502 
    503 /**
    504  * notationDeclDebug:
    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
    509  *
    510  * What to do when a notation declaration has been parsed.
    511  */
    512 static void
    513 notationDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
    514 	     const xmlChar *publicId, const xmlChar *systemId)
    515 {
    516     callbacks++;
    517     if (quiet)
    518 	return;
    519     fprintf(stdout, "SAX.notationDecl(%s, %s, %s)\n",
    520             (char *) name, (char *) publicId, (char *) systemId);
    521 }
    522 
    523 /**
    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
    530  *
    531  * What to do when an unparsed entity declaration is parsed
    532  */
    533 static void
    534 unparsedEntityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
    535 		   const xmlChar *publicId, const xmlChar *systemId,
    536 		   const xmlChar *notationName)
    537 {
    538 const xmlChar *nullstr = BAD_CAST "(null)";
    539 
    540     if (publicId == NULL)
    541         publicId = nullstr;
    542     if (systemId == NULL)
    543         systemId = nullstr;
    544     if (notationName == NULL)
    545         notationName = nullstr;
    546     callbacks++;
    547     if (quiet)
    548 	return;
    549     fprintf(stdout, "SAX.unparsedEntityDecl(%s, %s, %s, %s)\n",
    550             (char *) name, (char *) publicId, (char *) systemId,
    551 	    (char *) notationName);
    552 }
    553 
    554 /**
    555  * setDocumentLocatorDebug:
    556  * @ctxt:  An XML parser context
    557  * @loc: A SAX Locator
    558  *
    559  * Receive the document locator at startup, actually xmlDefaultSAXLocator
    560  * Everything is available on the context, so this is useless in our case.
    561  */
    562 static void
    563 setDocumentLocatorDebug(void *ctx ATTRIBUTE_UNUSED, xmlSAXLocatorPtr loc ATTRIBUTE_UNUSED)
    564 {
    565     callbacks++;
    566     if (quiet)
    567 	return;
    568     fprintf(stdout, "SAX.setDocumentLocator()\n");
    569 }
    570 
    571 /**
    572  * startDocumentDebug:
    573  * @ctxt:  An XML parser context
    574  *
    575  * called when the document start being processed.
    576  */
    577 static void
    578 startDocumentDebug(void *ctx ATTRIBUTE_UNUSED)
    579 {
    580     callbacks++;
    581     if (quiet)
    582 	return;
    583     fprintf(stdout, "SAX.startDocument()\n");
    584 }
    585 
    586 /**
    587  * endDocumentDebug:
    588  * @ctxt:  An XML parser context
    589  *
    590  * called when the document end has been detected.
    591  */
    592 static void
    593 endDocumentDebug(void *ctx ATTRIBUTE_UNUSED)
    594 {
    595     callbacks++;
    596     if (quiet)
    597 	return;
    598     fprintf(stdout, "SAX.endDocument()\n");
    599 }
    600 
    601 /**
    602  * startElementDebug:
    603  * @ctxt:  An XML parser context
    604  * @name:  The element name
    605  *
    606  * called when an opening tag has been processed.
    607  */
    608 static void
    609 startElementDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, const xmlChar **atts)
    610 {
    611     int i;
    612 
    613     callbacks++;
    614     if (quiet)
    615 	return;
    616     fprintf(stdout, "SAX.startElement(%s", (char *) name);
    617     if (atts != NULL) {
    618         for (i = 0;(atts[i] != NULL);i++) {
    619 	    fprintf(stdout, ", %s='", atts[i++]);
    620 	    if (atts[i] != NULL)
    621 	        fprintf(stdout, "%s'", atts[i]);
    622 	}
    623     }
    624     fprintf(stdout, ")\n");
    625 }
    626 
    627 /**
    628  * endElementDebug:
    629  * @ctxt:  An XML parser context
    630  * @name:  The element name
    631  *
    632  * called when the end of an element has been detected.
    633  */
    634 static void
    635 endElementDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
    636 {
    637     callbacks++;
    638     if (quiet)
    639 	return;
    640     fprintf(stdout, "SAX.endElement(%s)\n", (char *) name);
    641 }
    642 
    643 /**
    644  * charactersDebug:
    645  * @ctxt:  An XML parser context
    646  * @ch:  a xmlChar string
    647  * @len: the number of xmlChar
    648  *
    649  * receiving some chars from the parser.
    650  * Question: how much at a time ???
    651  */
    652 static void
    653 charactersDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
    654 {
    655     char output[40];
    656     int i;
    657 
    658     callbacks++;
    659     if (quiet)
    660 	return;
    661     for (i = 0;(i<len) && (i < 30);i++)
    662 	output[i] = ch[i];
    663     output[i] = 0;
    664 
    665     fprintf(stdout, "SAX.characters(%s, %d)\n", output, len);
    666 }
    667 
    668 /**
    669  * referenceDebug:
    670  * @ctxt:  An XML parser context
    671  * @name:  The entity name
    672  *
    673  * called when an entity reference is detected.
    674  */
    675 static void
    676 referenceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
    677 {
    678     callbacks++;
    679     if (quiet)
    680 	return;
    681     fprintf(stdout, "SAX.reference(%s)\n", name);
    682 }
    683 
    684 /**
    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
    690  *
    691  * receiving some ignorable whitespaces from the parser.
    692  * Question: how much at a time ???
    693  */
    694 static void
    695 ignorableWhitespaceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
    696 {
    697     char output[40];
    698     int i;
    699 
    700     callbacks++;
    701     if (quiet)
    702 	return;
    703     for (i = 0;(i<len) && (i < 30);i++)
    704 	output[i] = ch[i];
    705     output[i] = 0;
    706     fprintf(stdout, "SAX.ignorableWhitespace(%s, %d)\n", output, len);
    707 }
    708 
    709 /**
    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
    715  *
    716  * A processing instruction has been parsed.
    717  */
    718 static void
    719 processingInstructionDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *target,
    720                       const xmlChar *data)
    721 {
    722     callbacks++;
    723     if (quiet)
    724 	return;
    725     if (data != NULL)
    726 	fprintf(stdout, "SAX.processingInstruction(%s, %s)\n",
    727 		(char *) target, (char *) data);
    728     else
    729 	fprintf(stdout, "SAX.processingInstruction(%s, NULL)\n",
    730 		(char *) target);
    731 }
    732 
    733 /**
    734  * cdataBlockDebug:
    735  * @ctx: the user data (XML parser context)
    736  * @value:  The pcdata content
    737  * @len:  the block length
    738  *
    739  * called when a pcdata block has been parsed
    740  */
    741 static void
    742 cdataBlockDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *value, int len)
    743 {
    744     callbacks++;
    745     if (quiet)
    746 	return;
    747     fprintf(stdout, "SAX.pcdata(%.20s, %d)\n",
    748 	    (char *) value, len);
    749 }
    750 
    751 /**
    752  * commentDebug:
    753  * @ctxt:  An XML parser context
    754  * @value:  the comment content
    755  *
    756  * A comment has been parsed.
    757  */
    758 static void
    759 commentDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *value)
    760 {
    761     callbacks++;
    762     if (quiet)
    763 	return;
    764     fprintf(stdout, "SAX.comment(%s)\n", value);
    765 }
    766 
    767 /**
    768  * warningDebug:
    769  * @ctxt:  An XML parser context
    770  * @msg:  the message to display/transmit
    771  * @...:  extra parameters for the message display
    772  *
    773  * Display and format a warning messages, gives file, line, position and
    774  * extra parameters.
    775  */
    776 static void XMLCDECL
    777 warningDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
    778 {
    779     va_list args;
    780 
    781     callbacks++;
    782     if (quiet)
    783 	return;
    784     va_start(args, msg);
    785     fprintf(stdout, "SAX.warning: ");
    786     vfprintf(stdout, msg, args);
    787     va_end(args);
    788 }
    789 
    790 /**
    791  * errorDebug:
    792  * @ctxt:  An XML parser context
    793  * @msg:  the message to display/transmit
    794  * @...:  extra parameters for the message display
    795  *
    796  * Display and format a error messages, gives file, line, position and
    797  * extra parameters.
    798  */
    799 static void XMLCDECL
    800 errorDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
    801 {
    802     va_list args;
    803 
    804     callbacks++;
    805     if (quiet)
    806 	return;
    807     va_start(args, msg);
    808     fprintf(stdout, "SAX.error: ");
    809     vfprintf(stdout, msg, args);
    810     va_end(args);
    811 }
    812 
    813 /**
    814  * fatalErrorDebug:
    815  * @ctxt:  An XML parser context
    816  * @msg:  the message to display/transmit
    817  * @...:  extra parameters for the message display
    818  *
    819  * Display and format a fatalError messages, gives file, line, position and
    820  * extra parameters.
    821  */
    822 static void XMLCDECL
    823 fatalErrorDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
    824 {
    825     va_list args;
    826 
    827     callbacks++;
    828     if (quiet)
    829 	return;
    830     va_start(args, msg);
    831     fprintf(stdout, "SAX.fatalError: ");
    832     vfprintf(stdout, msg, args);
    833     va_end(args);
    834 }
    835 
    836 static xmlSAXHandler debugSAXHandlerStruct = {
    837     internalSubsetDebug,
    838     isStandaloneDebug,
    839     hasInternalSubsetDebug,
    840     hasExternalSubsetDebug,
    841     resolveEntityDebug,
    842     getEntityDebug,
    843     entityDeclDebug,
    844     notationDeclDebug,
    845     attributeDeclDebug,
    846     elementDeclDebug,
    847     unparsedEntityDeclDebug,
    848     setDocumentLocatorDebug,
    849     startDocumentDebug,
    850     endDocumentDebug,
    851     startElementDebug,
    852     endElementDebug,
    853     referenceDebug,
    854     charactersDebug,
    855     ignorableWhitespaceDebug,
    856     processingInstructionDebug,
    857     commentDebug,
    858     warningDebug,
    859     errorDebug,
    860     fatalErrorDebug,
    861     getParameterEntityDebug,
    862     cdataBlockDebug,
    863     externalSubsetDebug,
    864     1,
    865     NULL,
    866     NULL,
    867     NULL,
    868     NULL
    869 };
    870 
    871 xmlSAXHandlerPtr debugSAXHandler = &debugSAXHandlerStruct;
    872 
    873 /*
    874  * SAX2 specific callbacks
    875  */
    876 /**
    877  * startElementNsDebug:
    878  * @ctxt:  An XML parser context
    879  * @name:  The element name
    880  *
    881  * called when an opening tag has been processed.
    882  */
    883 static void
    884 startElementNsDebug(void *ctx ATTRIBUTE_UNUSED,
    885                     const xmlChar *localname,
    886                     const xmlChar *prefix,
    887                     const xmlChar *URI,
    888 		    int nb_namespaces,
    889 		    const xmlChar **namespaces,
    890 		    int nb_attributes,
    891 		    int nb_defaulted,
    892 		    const xmlChar **attributes)
    893 {
    894     int i;
    895 
    896     callbacks++;
    897     if (quiet)
    898 	return;
    899     fprintf(stdout, "SAX.startElementNs(%s", (char *) localname);
    900     if (prefix == NULL)
    901 	fprintf(stdout, ", NULL");
    902     else
    903 	fprintf(stdout, ", %s", (char *) prefix);
    904     if (URI == NULL)
    905 	fprintf(stdout, ", NULL");
    906     else
    907 	fprintf(stdout, ", '%s'", (char *) URI);
    908     fprintf(stdout, ", %d", nb_namespaces);
    909 
    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]);
    915 	    i++;
    916 	    fprintf(stdout, "='%s'", namespaces[i]);
    917 	}
    918     }
    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]);
    924 	    else
    925 		fprintf(stdout, ", %s='", attributes[i]);
    926 	    fprintf(stdout, "%.4s...', %d", attributes[i + 3],
    927 		    (int)(attributes[i + 4] - attributes[i + 3]));
    928 	}
    929     }
    930     fprintf(stdout, ")\n");
    931 }
    932 
    933 /**
    934  * endElementDebug:
    935  * @ctxt:  An XML parser context
    936  * @name:  The element name
    937  *
    938  * called when the end of an element has been detected.
    939  */
    940 static void
    941 endElementNsDebug(void *ctx ATTRIBUTE_UNUSED,
    942                   const xmlChar *localname,
    943                   const xmlChar *prefix,
    944                   const xmlChar *URI)
    945 {
    946     callbacks++;
    947     if (quiet)
    948 	return;
    949     fprintf(stdout, "SAX.endElementNs(%s", (char *) localname);
    950     if (prefix == NULL)
    951 	fprintf(stdout, ", NULL");
    952     else
    953 	fprintf(stdout, ", %s", (char *) prefix);
    954     if (URI == NULL)
    955 	fprintf(stdout, ", NULL)\n");
    956     else
    957 	fprintf(stdout, ", '%s')\n", (char *) URI);
    958 }
    959 
    960 static xmlSAXHandler debugSAX2HandlerStruct = {
    961     internalSubsetDebug,
    962     isStandaloneDebug,
    963     hasInternalSubsetDebug,
    964     hasExternalSubsetDebug,
    965     resolveEntityDebug,
    966     getEntityDebug,
    967     entityDeclDebug,
    968     notationDeclDebug,
    969     attributeDeclDebug,
    970     elementDeclDebug,
    971     unparsedEntityDeclDebug,
    972     setDocumentLocatorDebug,
    973     startDocumentDebug,
    974     endDocumentDebug,
    975     NULL,
    976     NULL,
    977     referenceDebug,
    978     charactersDebug,
    979     ignorableWhitespaceDebug,
    980     processingInstructionDebug,
    981     commentDebug,
    982     warningDebug,
    983     errorDebug,
    984     fatalErrorDebug,
    985     getParameterEntityDebug,
    986     cdataBlockDebug,
    987     externalSubsetDebug,
    988     XML_SAX2_MAGIC,
    989     NULL,
    990     startElementNsDebug,
    991     endElementNsDebug,
    992     NULL
    993 };
    994 
    995 static xmlSAXHandlerPtr debugSAX2Handler = &debugSAX2HandlerStruct;
    996 
    997 /************************************************************************
    998  *									*
    999  *				Debug					*
   1000  *									*
   1001  ************************************************************************/
   1002 
   1003 static void
   1004 parseAndPrintFile(char *filename) {
   1005     int res;
   1006 
   1007 #ifdef LIBXML_PUSH_ENABLED
   1008     if (push) {
   1009 	FILE *f;
   1010 
   1011         if ((!quiet) && (!nonull)) {
   1012 	    /*
   1013 	     * Empty callbacks for checking
   1014 	     */
   1015 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
   1016 	    f = fopen(filename, "rb");
   1017 #else
   1018 	    f = fopen(filename, "r");
   1019 #endif
   1020 	    if (f != NULL) {
   1021 		int ret;
   1022 		char chars[10];
   1023 		xmlParserCtxtPtr ctxt;
   1024 
   1025 		ret = fread(chars, 1, 4, f);
   1026 		if (ret > 0) {
   1027 		    ctxt = xmlCreatePushParserCtxt(emptySAXHandler, NULL,
   1028 				chars, ret, filename);
   1029 		    while ((ret = fread(chars, 1, 3, f)) > 0) {
   1030 			xmlParseChunk(ctxt, chars, ret, 0);
   1031 		    }
   1032 		    xmlParseChunk(ctxt, chars, 0, 1);
   1033 		    xmlFreeParserCtxt(ctxt);
   1034 		}
   1035 		fclose(f);
   1036 	    } else {
   1037 		xmlGenericError(xmlGenericErrorContext,
   1038 			"Cannot read file %s\n", filename);
   1039 	    }
   1040 	}
   1041 	/*
   1042 	 * Debug callback
   1043 	 */
   1044 #if defined(_WIN32) || defined (__DJGPP__) && !defined (__CYGWIN__)
   1045 	f = fopen(filename, "rb");
   1046 #else
   1047 	f = fopen(filename, "r");
   1048 #endif
   1049 	if (f != NULL) {
   1050 	    int ret;
   1051 	    char chars[10];
   1052 	    xmlParserCtxtPtr ctxt;
   1053 
   1054 	    ret = fread(chars, 1, 4, f);
   1055 	    if (ret > 0) {
   1056 	        if (sax2)
   1057 		    ctxt = xmlCreatePushParserCtxt(debugSAX2Handler, NULL,
   1058 				chars, ret, filename);
   1059 		else
   1060 		    ctxt = xmlCreatePushParserCtxt(debugSAXHandler, NULL,
   1061 				chars, ret, filename);
   1062 		while ((ret = fread(chars, 1, 3, f)) > 0) {
   1063 		    xmlParseChunk(ctxt, chars, ret, 0);
   1064 		}
   1065 		ret = xmlParseChunk(ctxt, chars, 0, 1);
   1066 		xmlFreeParserCtxt(ctxt);
   1067 		if (ret != 0) {
   1068 		    fprintf(stdout,
   1069 		            "xmlSAXUserParseFile returned error %d\n", ret);
   1070 		}
   1071 	    }
   1072 	    fclose(f);
   1073 	}
   1074     } else {
   1075 #endif /* LIBXML_PUSH_ENABLED */
   1076 	if (!speed) {
   1077 	    /*
   1078 	     * Empty callbacks for checking
   1079 	     */
   1080 	    if ((!quiet) && (!nonull)) {
   1081 		res = xmlSAXUserParseFile(emptySAXHandler, NULL, filename);
   1082 		if (res != 0) {
   1083 		    fprintf(stdout, "xmlSAXUserParseFile returned error %d\n", res);
   1084 		}
   1085 	    }
   1086 
   1087 	    /*
   1088 	     * Debug callback
   1089 	     */
   1090 	    callbacks = 0;
   1091 	    if (repeat) {
   1092 	        int i;
   1093 		for (i = 0;i < 99;i++) {
   1094 		    if (sax2)
   1095 			res = xmlSAXUserParseFile(debugSAX2Handler, NULL,
   1096 			                          filename);
   1097 		    else
   1098 			res = xmlSAXUserParseFile(debugSAXHandler, NULL,
   1099 			                          filename);
   1100 		}
   1101 	    }
   1102 	    if (sax2)
   1103 	        res = xmlSAXUserParseFile(debugSAX2Handler, NULL, filename);
   1104 	    else
   1105 		res = xmlSAXUserParseFile(debugSAXHandler, NULL, filename);
   1106 	    if (res != 0) {
   1107 		fprintf(stdout, "xmlSAXUserParseFile returned error %d\n", res);
   1108 	    }
   1109 	    if (quiet)
   1110 		fprintf(stdout, "%d callbacks generated\n", callbacks);
   1111 	} else {
   1112 	    /*
   1113 	     * test 100x the SAX parse
   1114 	     */
   1115 	    int i;
   1116 
   1117 	    for (i = 0; i<100;i++)
   1118 		res = xmlSAXUserParseFile(emptySAXHandler, NULL, filename);
   1119 	    if (res != 0) {
   1120 		fprintf(stdout, "xmlSAXUserParseFile returned error %d\n", res);
   1121 	    }
   1122 	}
   1123 #ifdef LIBXML_PUSH_ENABLED
   1124     }
   1125 #endif
   1126 }
   1127 
   1128 
   1129 int main(int argc, char **argv) {
   1130     int i;
   1131     int files = 0;
   1132 
   1133     LIBXML_TEST_VERSION	/* be safe, plus calls xmlInitParser */
   1134 
   1135     for (i = 1; i < argc ; i++) {
   1136 	if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug")))
   1137 	    debug++;
   1138 	else if ((!strcmp(argv[i], "-copy")) || (!strcmp(argv[i], "--copy")))
   1139 	    copy++;
   1140 	else if ((!strcmp(argv[i], "-recover")) ||
   1141 	         (!strcmp(argv[i], "--recover")))
   1142 	    recovery++;
   1143 	else if ((!strcmp(argv[i], "-push")) ||
   1144 	         (!strcmp(argv[i], "--push")))
   1145 #ifdef LIBXML_PUSH_ENABLED
   1146 	    push++;
   1147 #else
   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")))
   1152 	    speed++;
   1153 	else if ((!strcmp(argv[i], "-timing")) ||
   1154 	         (!strcmp(argv[i], "--timing"))) {
   1155 	    nonull++;
   1156 	    timing++;
   1157 	    quiet++;
   1158 	} else if ((!strcmp(argv[i], "-repeat")) ||
   1159 	         (!strcmp(argv[i], "--repeat"))) {
   1160 	    repeat++;
   1161 	    quiet++;
   1162 	} else if ((!strcmp(argv[i], "-noent")) ||
   1163 	         (!strcmp(argv[i], "--noent")))
   1164 	    noent++;
   1165 	else if ((!strcmp(argv[i], "-quiet")) ||
   1166 	         (!strcmp(argv[i], "--quiet")))
   1167 	    quiet++;
   1168 	else if ((!strcmp(argv[i], "-sax2")) ||
   1169 	         (!strcmp(argv[i], "--sax2")))
   1170 	    sax2++;
   1171 	else if ((!strcmp(argv[i], "-nonull")) ||
   1172 	         (!strcmp(argv[i], "--nonull")))
   1173 	    nonull++;
   1174     }
   1175     if (noent != 0) xmlSubstituteEntitiesDefault(1);
   1176     for (i = 1; i < argc ; i++) {
   1177 	if (argv[i][0] != '-') {
   1178 	    if (timing) {
   1179 		startTimer();
   1180 	    }
   1181 	    parseAndPrintFile(argv[i]);
   1182 	    if (timing) {
   1183 		endTimer("Parsing");
   1184 	    }
   1185 	    files ++;
   1186 	}
   1187     }
   1188     xmlCleanupParser();
   1189     xmlMemoryDump();
   1190 
   1191     return(0);
   1192 }
   1193 #else
   1194 int main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
   1195     printf("%s : SAX1 parsing support not compiled in\n", argv[0]);
   1196     return(0);
   1197 }
   1198 #endif /* LIBXML_SAX1_ENABLED */
   1199