/* * testSAX.c : a small tester program for parsing using the SAX API. * * See Copyright for the status of this software. * * daniel@veillard.com */#include "libxml.h"#ifdef HAVE_SYS_TIME_H#include <sys/time.h>#endif#ifdef HAVE_SYS_TIMEB_H#include <sys/timeb.h>#endif#ifdef HAVE_TIME_H#include <time.h>#endif#ifdef LIBXML_SAX1_ENABLED#include <string.h>#include <stdarg.h>#ifdef HAVE_SYS_TYPES_H#include <sys/types.h>#endif#ifdef HAVE_SYS_STAT_H#include <sys/stat.h>#endif#ifdef HAVE_FCNTL_H#include <fcntl.h>#endif#ifdef HAVE_UNISTD_H#include <unistd.h>#endif#ifdef HAVE_STDLIB_H#include <stdlib.h>#endif#ifdef HAVE_STRING_H#include <string.h>#endif#include <libxml/globals.h>#include <libxml/xmlerror.h>#include <libxml/parser.h>#include <libxml/parserInternals.h> /* only for xmlNewInputFromFile() */#include <libxml/tree.h>#include <libxml/debugXML.h>#include <libxml/xmlmemory.h>static int debug = 0;static int copy = 0;static int recovery = 0;static int push = 0;static int speed = 0;static int noent = 0;static int quiet = 0;static int nonull = 0;static int sax2 = 0;static int repeat = 0;static int callbacks = 0;static int timing = 0;/* * Timing routines. *//* * Internal timing routines to remove the necessity to have unix-specific * function calls */#ifndef HAVE_GETTIMEOFDAY #ifdef HAVE_SYS_TIMEB_H#ifdef HAVE_SYS_TIME_H#ifdef HAVE_FTIMEstatic intmy_gettimeofday(struct timeval *tvp, void *tzp){	struct timeb timebuffer;	ftime(&timebuffer);	if (tvp) {		tvp->tv_sec = timebuffer.time;		tvp->tv_usec = timebuffer.millitm * 1000L;	}	return (0);}#define HAVE_GETTIMEOFDAY 1#define gettimeofday my_gettimeofday#endif /* HAVE_FTIME */#endif /* HAVE_SYS_TIME_H */#endif /* HAVE_SYS_TIMEB_H */#endif /* !HAVE_GETTIMEOFDAY */#if defined(HAVE_GETTIMEOFDAY)static struct timeval begin, end;/* * startTimer: call where you want to start timing */static voidstartTimer(void){    gettimeofday(&begin, NULL);}/* * endTimer: call where you want to stop timing and to print out a *           message about the timing performed; format is a printf *           type argument */static void XMLCDECLendTimer(const char *fmt, ...){    long msec;    va_list ap;    gettimeofday(&end, NULL);    msec = end.tv_sec - begin.tv_sec;    msec *= 1000;    msec += (end.tv_usec - begin.tv_usec) / 1000;#ifndef HAVE_STDARG_H#error "endTimer required stdarg functions"#endif    va_start(ap, fmt);    vfprintf(stderr, fmt, ap);    va_end(ap);    fprintf(stderr, " took %ld ms\n", msec);}#elif defined(HAVE_TIME_H)/* * No gettimeofday function, so we have to make do with calling clock. * This is obviously less accurate, but there's little we can do about * that. */#ifndef CLOCKS_PER_SEC#define CLOCKS_PER_SEC 100#endifstatic clock_t begin, end;static voidstartTimer(void){    begin = clock();}static void XMLCDECLendTimer(const char *fmt, ...){    long msec;    va_list ap;    end = clock();    msec = ((end - begin) * 1000) / CLOCKS_PER_SEC;#ifndef HAVE_STDARG_H#error "endTimer required stdarg functions"#endif    va_start(ap, fmt);    vfprintf(stderr, fmt, ap);    va_end(ap);    fprintf(stderr, " took %ld ms\n", msec);}#else/* * We don't have a gettimeofday or time.h, so we just don't do timing */static voidstartTimer(void){    /*     * Do nothing     */}static void XMLCDECLendTimer(char *format, ...){    /*     * We cannot do anything because we don't have a timing function     */#ifdef HAVE_STDARG_H    va_start(ap, format);    vfprintf(stderr, format, ap);    va_end(ap);    fprintf(stderr, " was not timed\n", msec);#else    /* We don't have gettimeofday, time or stdarg.h, what crazy world is     * this ?!     */#endif}#endif/* * empty SAX block */static xmlSAXHandler emptySAXHandlerStruct = {    NULL, /* internalSubset */    NULL, /* isStandalone */    NULL, /* hasInternalSubset */    NULL, /* hasExternalSubset */    NULL, /* resolveEntity */    NULL, /* getEntity */    NULL, /* entityDecl */    NULL, /* notationDecl */    NULL, /* attributeDecl */    NULL, /* elementDecl */    NULL, /* unparsedEntityDecl */    NULL, /* setDocumentLocator */    NULL, /* startDocument */    NULL, /* endDocument */    NULL, /* startElement */    NULL, /* endElement */    NULL, /* reference */    NULL, /* characters */    NULL, /* ignorableWhitespace */    NULL, /* processingInstruction */    NULL, /* comment */    NULL, /* xmlParserWarning */    NULL, /* xmlParserError */    NULL, /* xmlParserError */    NULL, /* getParameterEntity */    NULL, /* cdataBlock; */    NULL, /* externalSubset; */    1,    NULL,    NULL, /* startElementNs */    NULL, /* endElementNs */    NULL  /* xmlStructuredErrorFunc */};static xmlSAXHandlerPtr emptySAXHandler = &emptySAXHandlerStruct;extern xmlSAXHandlerPtr debugSAXHandler;/************************************************************************ *									* *				Debug Handlers				* *									* ************************************************************************//** * isStandaloneDebug: * @ctxt:  An XML parser context * * Is this document tagged standalone ? * * Returns 1 if true */static intisStandaloneDebug(void *ctx ATTRIBUTE_UNUSED){    callbacks++;    if (quiet)	return(0);    fprintf(stdout, "SAX.isStandalone()\n");    return(0);}/** * hasInternalSubsetDebug: * @ctxt:  An XML parser context * * Does this document has an internal subset * * Returns 1 if true */static inthasInternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED){    callbacks++;    if (quiet)	return(0);    fprintf(stdout, "SAX.hasInternalSubset()\n");    return(0);}/** * hasExternalSubsetDebug: * @ctxt:  An XML parser context * * Does this document has an external subset * * Returns 1 if true */static inthasExternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED){    callbacks++;    if (quiet)	return(0);    fprintf(stdout, "SAX.hasExternalSubset()\n");    return(0);}/** * internalSubsetDebug: * @ctxt:  An XML parser context * * Does this document has an internal subset */static voidinternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,	       const xmlChar *ExternalID, const xmlChar *SystemID){    callbacks++;    if (quiet)	return;    fprintf(stdout, "SAX.internalSubset(%s,", name);    if (ExternalID == NULL)	fprintf(stdout, " ,");    else	fprintf(stdout, " %s,", ExternalID);    if (SystemID == NULL)	fprintf(stdout, " )\n");    else	fprintf(stdout, " %s)\n", SystemID);}/** * externalSubsetDebug: * @ctxt:  An XML parser context * * Does this document has an external subset */static voidexternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,	       const xmlChar *ExternalID, const xmlChar *SystemID){    callbacks++;    if (quiet)	return;    fprintf(stdout, "SAX.externalSubset(%s,", name);    if (ExternalID == NULL)	fprintf(stdout, " ,");    else	fprintf(stdout, " %s,", ExternalID);    if (SystemID == NULL)	fprintf(stdout, " )\n");    else	fprintf(stdout, " %s)\n", SystemID);}/** * resolveEntityDebug: * @ctxt:  An XML parser context * @publicId: The public ID of the entity * @systemId: The system ID of the entity * * Special entity resolver, better left to the parser, it has * more context than the application layer. * The default behaviour is to NOT resolve the entities, in that case * the ENTITY_REF nodes are built in the structure (and the parameter * values). * * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour. */static xmlParserInputPtrresolveEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *publicId, const xmlChar *systemId){    callbacks++;    if (quiet)	return(NULL);    /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */        fprintf(stdout, "SAX.resolveEntity(");    if (publicId != NULL)	fprintf(stdout, "%s", (char *)publicId);    else	fprintf(stdout, " ");    if (systemId != NULL)	fprintf(stdout, ", %s)\n", (char *)systemId);    else	fprintf(stdout, ", )\n");/*********    if (systemId != NULL) {        return(xmlNewInputFromFile(ctxt, (char *) systemId));    } *********/    return(NULL);}/** * getEntityDebug: * @ctxt:  An XML parser context * @name: The entity name * * Get an entity by name * * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour. */static xmlEntityPtrgetEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name){    callbacks++;    if (quiet)	return(NULL);    fprintf(stdout, "SAX.getEntity(%s)\n", name);    return(NULL);}/** * getParameterEntityDebug: * @ctxt:  An XML parser context * @name: The entity name * * Get a parameter entity by name * * Returns the xmlParserInputPtr */static xmlEntityPtrgetParameterEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name){    callbacks++;    if (quiet)	return(NULL);    fprintf(stdout, "SAX.getParameterEntity(%s)\n", name);    return(NULL);}/** * entityDeclDebug: * @ctxt:  An XML parser context * @name:  the entity name  * @type:  the entity type  * @publicId: The public ID of the entity * @systemId: The system ID of the entity * @content: the entity value (without processing). * * An entity definition has been parsed */static voidentityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,          const xmlChar *publicId, const xmlChar *systemId, xmlChar *content){const xmlChar *nullstr = BAD_CAST "(null)";    /* not all libraries handle printing null pointers nicely */    if (publicId == NULL)        publicId = nullstr;    if (systemId == NULL)        systemId = nullstr;    if (content == NULL)        content = (xmlChar *)nullstr;    callbacks++;    if (quiet)	return;    fprintf(stdout, "SAX.entityDecl(%s, %d, %s, %s, %s)\n",            name, type, publicId, systemId, content);}/** * attributeDeclDebug: * @ctxt:  An XML parser context * @name:  the attribute name  * @type:  the attribute type  * * An attribute definition has been parsed */static voidattributeDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar * elem,                   const xmlChar * name, int type, int def,                   const xmlChar * defaultValue, xmlEnumerationPtr tree){    callbacks++;    if (quiet)        return;    if (defaultValue == NULL)        fprintf(stdout, "SAX.attributeDecl(%s, %s, %d, %d, NULL, ...)\n",                elem, name, type, def);    else        fprintf(stdout, "SAX.attributeDecl(%s, %s, %d, %d, %s, ...)\n",                elem, name, type, def, defaultValue);    xmlFreeEnumeration(tree);}/** * elementDeclDebug: * @ctxt:  An XML parser context * @name:  the element name  * @type:  the element type  * @content: the element value (without processing). * * An element definition has been parsed */static voidelementDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,	    xmlElementContentPtr content ATTRIBUTE_UNUSED){    callbacks++;    if (quiet)	return;    fprintf(stdout, "SAX.elementDecl(%s, %d, ...)\n",            name, type);}/** * notationDeclDebug: * @ctxt:  An XML parser context * @name: The name of the notation * @publicId: The public ID of the entity * @systemId: The system ID of the entity * * What to do when a notation declaration has been parsed. */static voidnotationDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,	     const xmlChar *publicId, const xmlChar *systemId){    callbacks++;    if (quiet)	return;    fprintf(stdout, "SAX.notationDecl(%s, %s, %s)\n",            (char *) name, (char *) publicId, (char *) systemId);}/** * unparsedEntityDeclDebug: * @ctxt:  An XML parser context * @name: The name of the entity * @publicId: The public ID of the entity * @systemId: The system ID of the entity * @notationName: the name of the notation * * What to do when an unparsed entity declaration is parsed */static voidunparsedEntityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,		   const xmlChar *publicId, const xmlChar *systemId,		   const xmlChar *notationName){const xmlChar *nullstr = BAD_CAST "(null)";    if (publicId == NULL)        publicId = nullstr;    if (systemId == NULL)        systemId = nullstr;    if (notationName == NULL)        notationName = nullstr;    callbacks++;    if (quiet)	return;    fprintf(stdout, "SAX.unparsedEntityDecl(%s, %s, %s, %s)\n",            (char *) name, (char *) publicId, (char *) systemId,	    (char *) notationName);}/** * setDocumentLocatorDebug: * @ctxt:  An XML parser context * @loc: A SAX Locator * * Receive the document locator at startup, actually xmlDefaultSAXLocator * Everything is available on the context, so this is useless in our case. */static voidsetDocumentLocatorDebug(void *ctx ATTRIBUTE_UNUSED, xmlSAXLocatorPtr loc ATTRIBUTE_UNUSED){    callbacks++;    if (quiet)	return;    fprintf(stdout, "SAX.setDocumentLocator()\n");}/** * startDocumentDebug: * @ctxt:  An XML parser context * * called when the document start being processed. */static voidstartDocumentDebug(void *ctx ATTRIBUTE_UNUSED){    callbacks++;    if (quiet)	return;    fprintf(stdout, "SAX.startDocument()\n");}/** * endDocumentDebug: * @ctxt:  An XML parser context * * called when the document end has been detected. */static voidendDocumentDebug(void *ctx ATTRIBUTE_UNUSED){    callbacks++;    if (quiet)	return;    fprintf(stdout, "SAX.endDocument()\n");}