/*

 * xmllint.c : a small tester program for XML input.

 *

 * See Copyright for the status of this software.

 *

 * daniel@veillard.com

 */

#include "libxml.h"

#include <string.h>

#include <stdarg.h>

#include <assert.h>

#ifdef HAVE_SYS_TIME_H

#include <sys/time.h>

#endif

#ifdef HAVE_TIME_H

#include <time.h>

#endif

#ifdef HAVE_SYS_TIMEB_H

#include <sys/timeb.h>

#endif

#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_SYS_MMAN_H

#include <sys/mman.h>

/* seems needed for Solaris */

#ifndef MAP_FAILED

#define MAP_FAILED ((void *) -1)

#endif

#endif

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#ifdef HAVE_LIBREADLINE

#include <readline/readline.h>

#ifdef HAVE_LIBHISTORY

#include <readline/history.h>

#endif

#endif

#include <libxml/xmlmemory.h>

#include <libxml/parser.h>

#include <libxml/parserInternals.h>

#include <libxml/HTMLparser.h>

#include <libxml/HTMLtree.h>

#include <libxml/tree.h>

#include <libxml/xpath.h>

#include <libxml/debugXML.h>

#include <libxml/xmlerror.h>

#ifdef LIBXML_XINCLUDE_ENABLED

#include <libxml/xinclude.h>

#endif

#ifdef LIBXML_CATALOG_ENABLED

#include <libxml/catalog.h>

#endif

#include <libxml/globals.h>

#include <libxml/xmlreader.h>

#ifdef LIBXML_SCHEMATRON_ENABLED

#include <libxml/schematron.h>

#endif

#ifdef LIBXML_SCHEMAS_ENABLED

#include <libxml/relaxng.h>

#include <libxml/xmlschemas.h>

#endif

#ifdef LIBXML_PATTERN_ENABLED

#include <libxml/pattern.h>

#endif

#ifdef LIBXML_C14N_ENABLED

#include <libxml/c14n.h>

#endif

#ifdef LIBXML_OUTPUT_ENABLED

#include <libxml/xmlsave.h>

#endif

#ifndef XML_XML_DEFAULT_CATALOG

#define XML_XML_DEFAULT_CATALOG "file:///etc/xml/catalog"

#endif

typedef enum {

    XMLLINT_RETURN_OK = 0,	/* No error */

    XMLLINT_ERR_UNCLASS = 1,	/* Unclassified */

    XMLLINT_ERR_DTD = 2,	/* Error in DTD */

    XMLLINT_ERR_VALID = 3,	/* Validation error */

    XMLLINT_ERR_RDFILE = 4,	/* CtxtReadFile error */

    XMLLINT_ERR_SCHEMACOMP = 5,	/* Schema compilation */

    XMLLINT_ERR_OUT = 6,	/* Error writing output */

    XMLLINT_ERR_SCHEMAPAT = 7,	/* Error in schema pattern */

    XMLLINT_ERR_RDREGIS = 8,	/* Error in Reader registration */

    XMLLINT_ERR_MEM = 9,	/* Out of memory error */

    XMLLINT_ERR_XPATH = 10	/* XPath evaluation error */

} xmllintReturnCode;

#ifdef LIBXML_DEBUG_ENABLED

static int shell = 0;

static int debugent = 0;

#endif

static int debug = 0;

static int maxmem = 0;

#ifdef LIBXML_TREE_ENABLED

static int copy = 0;

#endif /* LIBXML_TREE_ENABLED */

static int recovery = 0;

static int noent = 0;

static int noenc = 0;

static int noblanks = 0;

static int noout = 0;

static int nowrap = 0;

#ifdef LIBXML_OUTPUT_ENABLED

static int format = 0;

static const char *output = NULL;

static int compress = 0;

static int oldout = 0;

#endif /* LIBXML_OUTPUT_ENABLED */

#ifdef LIBXML_VALID_ENABLED

static int valid = 0;

static int postvalid = 0;

static char * dtdvalid = NULL;

static char * dtdvalidfpi = NULL;

#endif

#ifdef LIBXML_SCHEMAS_ENABLED

static char * relaxng = NULL;

static xmlRelaxNGPtr relaxngschemas = NULL;

static char * schema = NULL;

static xmlSchemaPtr wxschemas = NULL;

#endif

#ifdef LIBXML_SCHEMATRON_ENABLED

static char * schematron = NULL;

static xmlSchematronPtr wxschematron = NULL;

#endif

static int repeat = 0;

static int insert = 0;

#if defined(LIBXML_HTML_ENABLED) || defined(LIBXML_VALID_ENABLED)

static int html = 0;

static int xmlout = 0;

#endif

static int htmlout = 0;

#if defined(LIBXML_HTML_ENABLED)

static int nodefdtd = 0;

#endif

#ifdef LIBXML_PUSH_ENABLED

static int push = 0;

static int pushsize = 4096;

#endif /* LIBXML_PUSH_ENABLED */

#ifdef HAVE_MMAP

static int memory = 0;

#endif

static int testIO = 0;

static char *encoding = NULL;

#ifdef LIBXML_XINCLUDE_ENABLED

static int xinclude = 0;

#endif

static int dtdattrs = 0;

static int loaddtd = 0;

static xmllintReturnCode progresult = XMLLINT_RETURN_OK;

static int timing = 0;

static int generate = 0;

static int dropdtd = 0;

#ifdef LIBXML_CATALOG_ENABLED

static int catalogs = 0;

static int nocatalogs = 0;

#endif

#ifdef LIBXML_C14N_ENABLED

static int canonical = 0;

static int canonical_11 = 0;

static int exc_canonical = 0;

#endif

#ifdef LIBXML_READER_ENABLED

static int stream = 0;

static int walker = 0;

#endif /* LIBXML_READER_ENABLED */

static int chkregister = 0;

static int nbregister = 0;

#ifdef LIBXML_SAX1_ENABLED

static int sax1 = 0;

#endif /* LIBXML_SAX1_ENABLED */

#ifdef LIBXML_PATTERN_ENABLED

static const char *pattern = NULL;

static xmlPatternPtr patternc = NULL;

static xmlStreamCtxtPtr patstream = NULL;

#endif

#ifdef LIBXML_XPATH_ENABLED

static const char *xpathquery = NULL;

#endif

static int options = XML_PARSE_COMPACT | XML_PARSE_BIG_LINES;

static int sax = 0;

static int oldxml10 = 0;

/************************************************************************

 *									*

 *		 Entity loading control and customization.		*

 *									*

 ************************************************************************/

#define MAX_PATHS 64

#ifdef _WIN32

# define PATH_SEPARATOR ';'

#else

# define PATH_SEPARATOR ':'

#endif

static xmlChar *paths[MAX_PATHS + 1];

static int nbpaths = 0;

static int load_trace = 0;

static

void parsePath(const xmlChar *path) {

    const xmlChar *cur;

    if (path == NULL)

	return;

    while (*path != 0) {

	if (nbpaths >= MAX_PATHS) {

	    fprintf(stderr, "MAX_PATHS reached: too many paths\n");

	    return;

	}

	cur = path;

	while ((*cur == ' ') || (*cur == PATH_SEPARATOR))

	    cur++;

	path = cur;

	while ((*cur != 0) && (*cur != ' ') && (*cur != PATH_SEPARATOR))

	    cur++;

	if (cur != path) {

	    paths[nbpaths] = xmlStrndup(path, cur - path);

	    if (paths[nbpaths] != NULL)

		nbpaths++;

	    path = cur;

	}

    }

}

static xmlExternalEntityLoader defaultEntityLoader = NULL;

static xmlParserInputPtr

xmllintExternalEntityLoader(const char *URL, const char *ID,

			     xmlParserCtxtPtr ctxt) {

    xmlParserInputPtr ret;

    warningSAXFunc warning = NULL;

    errorSAXFunc err = NULL;

    int i;

    const char *lastsegment = URL;

    const char *iter = URL;

    if ((nbpaths > 0) && (iter != NULL)) {

	while (*iter != 0) {

	    if (*iter == '/')

		lastsegment = iter + 1;

	    iter++;

	}

    }

    if ((ctxt != NULL) && (ctxt->sax != NULL)) {

	warning = ctxt->sax->warning;

	err = ctxt->sax->error;

	ctxt->sax->warning = NULL;

	ctxt->sax->error = NULL;

    }

    if (defaultEntityLoader != NULL) {

	ret = defaultEntityLoader(URL, ID, ctxt);

	if (ret != NULL) {

	    if (warning != NULL)

		ctxt->sax->warning = warning;

	    if (err != NULL)

		ctxt->sax->error = err;

	    if (load_trace) {

		fprintf \

			(stderr,

			 "Loaded URL=\"%s\" ID=\"%s\"\n",

			 URL ? URL : "(null)",

			 ID ? ID : "(null)");

	    }

	    return(ret);

	}

    }

    for (i = 0;i < nbpaths;i++) {

	xmlChar *newURL;

	newURL = xmlStrdup((const xmlChar *) paths[i]);

	newURL = xmlStrcat(newURL, (const xmlChar *) "/");

	newURL = xmlStrcat(newURL, (const xmlChar *) lastsegment);

	if (newURL != NULL) {

	    ret = defaultEntityLoader((const char *)newURL, ID, ctxt);

	    if (ret != NULL) {

		if (warning != NULL)

		    ctxt->sax->warning = warning;

		if (err != NULL)

		    ctxt->sax->error = err;

		if (load_trace) {

		    fprintf \

			(stderr,

			 "Loaded URL=\"%s\" ID=\"%s\"\n",

			 newURL,

			 ID ? ID : "(null)");

		}

		xmlFree(newURL);

		return(ret);

	    }

	    xmlFree(newURL);

	}

    }

    if (err != NULL)

        ctxt->sax->error = err;

    if (warning != NULL) {

	ctxt->sax->warning = warning;

	if (URL != NULL)

	    warning(ctxt, "failed to load external entity \"%s\"\n", URL);

	else if (ID != NULL)

	    warning(ctxt, "failed to load external entity \"%s\"\n", ID);

    }

    return(NULL);

}

/************************************************************************

 *									*

 * Memory allocation consumption debugging				*

 *									*

 ************************************************************************/

static void

OOM(void)

{

    fprintf(stderr, "Ran out of memory needs > %d bytes\n", maxmem);

    progresult = XMLLINT_ERR_MEM;

}

static void

myFreeFunc(void *mem)

{

    xmlMemFree(mem);

}

static void *

myMallocFunc(size_t size)

{

    void *ret;

    ret = xmlMemMalloc(size);

    if (ret != NULL) {

        if (xmlMemUsed() > maxmem) {

            OOM();

            xmlMemFree(ret);

            return (NULL);

        }

    }

    return (ret);

}

static void *

myReallocFunc(void *mem, size_t size)

{

    void *ret;

    ret = xmlMemRealloc(mem, size);

    if (ret != NULL) {

        if (xmlMemUsed() > maxmem) {

            OOM();

            xmlMemFree(ret);

            return (NULL);

        }

    }

    return (ret);

}

static char *

myStrdupFunc(const char *str)

{

    char *ret;

    ret = xmlMemoryStrdup(str);

    if (ret != NULL) {

        if (xmlMemUsed() > maxmem) {

            OOM();

            xmlFree(ret);

            return (NULL);

        }

    }

    return (ret);

}

/************************************************************************

 *									*

 * 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_FTIME

static int

my_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 void

startTimer(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 XMLCDECL LIBXML_ATTR_FORMAT(1,2)

endTimer(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

#endif

static clock_t begin, end;

static void

startTimer(void)

{

    begin = clock();

}

static void XMLCDECL LIBXML_ATTR_FORMAT(1,2)

endTimer(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 void

startTimer(void)

{

    /*

     * Do nothing

     */

}

static void XMLCDECL LIBXML_ATTR_FORMAT(1,2)

endTimer(char *format, ...)

{

    /*

     * We cannot do anything because we don't have a timing function

     */

#ifdef HAVE_STDARG_H

    va_list ap;

    va_start(ap, format);

    vfprintf(stderr, format, ap);

    va_end(ap);

    fprintf(stderr, " was not timed\n");

#else

    /* We don't have gettimeofday, time or stdarg.h, what crazy world is

     * this ?!

     */

#endif

}

#endif

/************************************************************************

 *									*

 *			HTML ouput					*

 *									*

 ************************************************************************/

static char buffer[50000];

static void

xmlHTMLEncodeSend(void) {

    char *result;

    result = (char *) xmlEncodeEntitiesReentrant(NULL, BAD_CAST buffer);

    if (result) {

	xmlGenericError(xmlGenericErrorContext, "%s", result);

	xmlFree(result);

    }

    buffer[0] = 0;

}

/**

 * xmlHTMLPrintFileInfo:

 * @input:  an xmlParserInputPtr input

 *

 * Displays the associated file and line informations for the current input

 */

static void

xmlHTMLPrintFileInfo(xmlParserInputPtr input) {

    int len;

    xmlGenericError(xmlGenericErrorContext, "
");

    len = strlen(buffer);

    if (input != NULL) {

	if (input->filename) {

	    snprintf(&buffer[len], sizeof(buffer) - len, "%s:%d: ", input->filename,

		    input->line);

	} else {

	    snprintf(&buffer[len], sizeof(buffer) - len, "Entity: line %d: ", input->line);

	}

    }

    xmlHTMLEncodeSend();

}

/**

 * xmlHTMLPrintFileContext:

 * @input:  an xmlParserInputPtr input

 *

 * Displays current context within the input content for error tracking

 */

static void

xmlHTMLPrintFileContext(xmlParserInputPtr input) {

    const xmlChar *cur, *base;

    int len;

    int n;

    if (input == NULL) return;

    xmlGenericError(xmlGenericErrorContext, "
\n");

    cur = input->cur;

    base = input->base;

    while ((cur > base) && ((*cur == '\n') || (*cur == '\r'))) {

	cur--;

    }

    n = 0;

    while ((n++ < 80) && (cur > base) && (*cur != '\n') && (*cur != '\r'))

        cur--;

    if ((*cur == '\n') || (*cur == '\r')) cur++;

    base = cur;

    n = 0;

    while ((*cur != 0) && (*cur != '\n') && (*cur != '\r') && (n < 79)) {

	len = strlen(buffer);

        snprintf(&buffer[len], sizeof(buffer) - len, "%c",

		    (unsigned char) *cur++);

	n++;

    }

    len = strlen(buffer);

    snprintf(&buffer[len], sizeof(buffer) - len, "\n");

    cur = input->cur;

    while ((*cur == '\n') || (*cur == '\r'))

	cur--;

    n = 0;

    while ((cur != base) && (n++ < 80)) {

	len = strlen(buffer);

        snprintf(&buffer[len], sizeof(buffer) - len, " ");

        base++;

    }

    len = strlen(buffer);

    snprintf(&buffer[len], sizeof(buffer) - len, "^\n");

    xmlHTMLEncodeSend();

    xmlGenericError(xmlGenericErrorContext, "");

}

/**

 * xmlHTMLError:

 * @ctx:  an XML parser context

 * @msg:  the message to display/transmit

 * @...:  extra parameters for the message display

 *

 * Display and format an error messages, gives file, line, position and

 * extra parameters.

 */

static void XMLCDECL LIBXML_ATTR_FORMAT(2,3)

xmlHTMLError(void *ctx, const char *msg, ...)

{

    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;

    xmlParserInputPtr input;

    va_list args;

    int len;

    buffer[0] = 0;

    input = ctxt->input;

    if ((input != NULL) && (input->filename == NULL) && (ctxt->inputNr > 1)) {

        input = ctxt->inputTab[ctxt->inputNr - 2];

    }

    xmlHTMLPrintFileInfo(input);

    xmlGenericError(xmlGenericErrorContext, "error: ");

    va_start(args, msg);

    len = strlen(buffer);

    vsnprintf(&buffer[len],  sizeof(buffer) - len, msg, args);

    va_end(args);

    xmlHTMLEncodeSend();

    xmlGenericError(xmlGenericErrorContext, "
\n");

    xmlHTMLPrintFileContext(input);

    xmlHTMLEncodeSend();

}

/**

 * xmlHTMLWarning:

 * @ctx:  an XML parser context

 * @msg:  the message to display/transmit

 * @...:  extra parameters for the message display

 *

 * Display and format a warning messages, gives file, line, position and

 * extra parameters.

 */

static void XMLCDECL LIBXML_ATTR_FORMAT(2,3)

xmlHTMLWarning(void *ctx, const char *msg, ...)

{

    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;

    xmlParserInputPtr input;

    va_list args;

    int len;

    buffer[0] = 0;

    input = ctxt->input;

    if ((input != NULL) && (input->filename == NULL) && (ctxt->inputNr > 1)) {

        input = ctxt->inputTab[ctxt->inputNr - 2];

    }

    xmlHTMLPrintFileInfo(input);

    xmlGenericError(xmlGenericErrorContext, "warning: ");

    va_start(args, msg);

    len = strlen(buffer);

    vsnprintf(&buffer[len],  sizeof(buffer) - len, msg, args);

    va_end(args);

    xmlHTMLEncodeSend();

    xmlGenericError(xmlGenericErrorContext, "
\n");

    xmlHTMLPrintFileContext(input);

    xmlHTMLEncodeSend();

}

/**

 * xmlHTMLValidityError:

 * @ctx:  an XML parser context

 * @msg:  the message to display/transmit

 * @...:  extra parameters for the message display

 *

 * Display and format an validity error messages, gives file,

 * line, position and extra parameters.

 */

static void XMLCDECL LIBXML_ATTR_FORMAT(2,3)

xmlHTMLValidityError(void *ctx, const char *msg, ...)

{

    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;

    xmlParserInputPtr input;

    va_list args;

    int len;

    buffer[0] = 0;

    input = ctxt->input;

    if ((input->filename == NULL) && (ctxt->inputNr > 1))

        input = ctxt->inputTab[ctxt->inputNr - 2];

    xmlHTMLPrintFileInfo(input);

    xmlGenericError(xmlGenericErrorContext, "validity error: ");

    len = strlen(buffer);

    va_start(args, msg);

    vsnprintf(&buffer[len],  sizeof(buffer) - len, msg, args);

    va_end(args);

    xmlHTMLEncodeSend();

    xmlGenericError(xmlGenericErrorContext, "
\n");

    xmlHTMLPrintFileContext(input);

    xmlHTMLEncodeSend();

    progresult = XMLLINT_ERR_VALID;

}

/**

 * xmlHTMLValidityWarning:

 * @ctx:  an XML parser context

 * @msg:  the message to display/transmit

 * @...:  extra parameters for the message display

 *

 * Display and format a validity warning messages, gives file, line,

 * position and extra parameters.

 */

static void XMLCDECL LIBXML_ATTR_FORMAT(2,3)

xmlHTMLValidityWarning(void *ctx, const char *msg, ...)

{

    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;

    xmlParserInputPtr input;

    va_list args;

    int len;

    buffer[0] = 0;

    input = ctxt->input;

    if ((input->filename == NULL) && (ctxt->inputNr > 1))

        input = ctxt->inputTab[ctxt->inputNr - 2];

    xmlHTMLPrintFileInfo(input);

    xmlGenericError(xmlGenericErrorContext, "validity warning: ");

    va_start(args, msg);

    len = strlen(buffer);

    vsnprintf(&buffer[len],  sizeof(buffer) - len, msg, args);

    va_end(args);

    xmlHTMLEncodeSend();

    xmlGenericError(xmlGenericErrorContext, "
\n");

    xmlHTMLPrintFileContext(input);

    xmlHTMLEncodeSend();

}

/************************************************************************

 *									*

 *			Shell Interface					*

 *									*

 ************************************************************************/

#ifdef LIBXML_DEBUG_ENABLED

#ifdef LIBXML_XPATH_ENABLED

/**

 * xmlShellReadline:

 * @prompt:  the prompt value

 *

 * Read a string

 *

 * Returns a pointer to it or NULL on EOF the caller is expected to

 *     free the returned string.

 */

static char *

xmlShellReadline(char *prompt) {

#ifdef HAVE_LIBREADLINE

    char *line_read;

    /* Get a line from the user. */

    line_read = readline (prompt);

    /* If the line has any text in it, save it on the history. */

    if (line_read && *line_read)

	add_history (line_read);

    return (line_read);

#else

    char line_read[501];

    char *ret;

    int len;

    if (prompt != NULL)

	fprintf(stdout, "%s", prompt);

    fflush(stdout);

    if (!fgets(line_read, 500, stdin))

        return(NULL);

    line_read[500] = 0;

    len = strlen(line_read);

    ret = (char *) malloc(len + 1);

    if (ret != NULL) {

	memcpy (ret, line_read, len + 1);

    }

    return(ret);

#endif

}

#endif /* LIBXML_XPATH_ENABLED */

#endif /* LIBXML_DEBUG_ENABLED */

/************************************************************************

 *									*

 *			I/O Interfaces					*

 *									*

 ************************************************************************/

static int myRead(FILE *f, char * buf, int len) {

    return(fread(buf, 1, len, f));

}

static void myClose(FILE *f) {

  if (f != stdin) {

    fclose(f);

  }

}

/************************************************************************

 *									*

 *			SAX based tests					*

 *									*

 ************************************************************************/

/*

 * 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; */

    XML_SAX2_MAGIC,

    NULL,

    NULL, /* startElementNs */

    NULL, /* endElementNs */

    NULL  /* xmlStructuredErrorFunc */

};

static xmlSAXHandlerPtr emptySAXHandler = &emptySAXHandlerStruct;

extern xmlSAXHandlerPtr debugSAXHandler;

static int callbacks;

/**

 * isStandaloneDebug:

 * @ctxt:  An XML parser context

 *

 * Is this document tagged standalone ?

 *