Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/testlimits.c

+/*
+ * testlimits.c: C program to run libxml2 regression tests checking various
+ *       limits in document size. Will consume a lot of RAM and CPU cycles
+ *
+ * To compile on Unixes:
+ * cc -o testlimits `xml2-config --cflags` testlimits.c `xml2-config --libs` -lpthread
+ *
+ * See Copyright for the status of this software.
+ *
+ * daniel@veillard.com
+ */
+
+#include "libxml.h"
+#include <stdio.h>
+
+#if !defined(_WIN32) || defined(__CYGWIN__)
+#include <unistd.h>
+#endif
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <time.h>
+
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h>
+#include <libxml/tree.h>
+#include <libxml/uri.h>
+#ifdef LIBXML_READER_ENABLED
+#include <libxml/xmlreader.h>
+#endif
+
+static int verbose = 0;
+static int tests_quiet = 0;
+
+/************************************************************************
+ *                                                                      *
+ *              time handling                                           *
+ *                                                                      *
+ ************************************************************************/
+
+/* maximum time for one parsing before declaring a timeout */
+#define MAX_TIME 2 /* seconds */
+
+static clock_t t0;
+int timeout = 0;
+
+static void reset_timout(void) {
+    timeout = 0;
+    t0 = clock();
+}
+
+static int check_time(void) {
+    clock_t tnow = clock();
+    if (((tnow - t0) / CLOCKS_PER_SEC) > MAX_TIME) {
+        timeout = 1;
+        return(0);
+    }
+    return(1);
+}
+
+/************************************************************************
+ *                                                                      *
+ *              Huge document generator                                 *
+ *                                                                      *
+ ************************************************************************/
+
+#include <libxml/xmlIO.h>
+
+/*
+ * Huge documents are built using fixed start and end chunks
+ * and filling between the two an unconventional amount of char data
+ */
+typedef struct hugeTest hugeTest;
+typedef hugeTest *hugeTestPtr;
+struct hugeTest {
+    const char *description;
+    const char *name;
+    const char *start;
+    const char *end;
+};
+
+static struct hugeTest hugeTests[] = {
+    { "Huge text node", "huge:textNode", "<foo>", "</foo>" },
+    { "Huge attribute node", "huge:attrNode", "<foo bar='", "'/>" },
+    { "Huge comment node", "huge:commentNode", "<foo><!--", "--></foo>" },
+    { "Huge PI node", "huge:piNode", "<foo><?bar ", "?></foo>" },
+};
+
+static const char *current;
+static int rlen;
+static unsigned int currentTest = 0;
+static int instate = 0;
+
+/**
+ * hugeMatch:
+ * @URI: an URI to test
+ *
+ * Check for an huge: query
+ *
+ * Returns 1 if yes and 0 if another Input module should be used
+ */
+static int
+hugeMatch(const char * URI) {
+    if ((URI != NULL) && (!strncmp(URI, "huge:", 5)))
+        return(1);
+    return(0);
+}
+
+/**
+ * hugeOpen:
+ * @URI: an URI to test
+ *
+ * Return a pointer to the huge: query handler, in this example simply
+ * the current pointer...
+ *
+ * Returns an Input context or NULL in case or error
+ */
+static void *
+hugeOpen(const char * URI) {
+    if ((URI == NULL) || (strncmp(URI, "huge:", 5)))
+        return(NULL);
+
+    for (currentTest = 0;currentTest < sizeof(hugeTests)/sizeof(hugeTests[0]);
+         currentTest++)
+         if (!strcmp(hugeTests[currentTest].name, URI))
+             goto found;
+
+    return(NULL);
+
+found:
+    rlen = strlen(hugeTests[currentTest].start);
+    current = hugeTests[currentTest].start;
+    instate = 0;
+    return((void *) current);
+}
+
+/**
+ * hugeClose:
+ * @context: the read context
+ *
+ * Close the huge: query handler
+ *
+ * Returns 0 or -1 in case of error
+ */
+static int
+hugeClose(void * context) {
+    if (context == NULL) return(-1);
+    fprintf(stderr, "\n");
+    return(0);
+}
+
+#define CHUNK 4096
+
+char filling[CHUNK + 1];
+
+static void fillFilling(void) {
+    int i;
+
+    for (i = 0;i < CHUNK;i++) {
+        filling[i] = 'a';
+    }
+    filling[CHUNK] = 0;
+}
+
+size_t maxlen = 64 * 1024 * 1024;
+size_t curlen = 0;
+size_t dotlen;
+
+/**
+ * hugeRead:
+ * @context: the read context
+ * @buffer: where to store data
+ * @len: number of bytes to read
+ *
+ * Implement an huge: query read.
+ *
+ * Returns the number of bytes read or -1 in case of error
+ */
+static int
+hugeRead(void *context, char *buffer, int len)
+{
+    if ((context == NULL) || (buffer == NULL) || (len < 0))
+        return (-1);
+
+    if (instate == 0) {
+        if (len >= rlen) {
+            len = rlen;
+            rlen = 0;
+            memcpy(buffer, current, len);
+            instate = 1;
+            curlen = 0;
+            dotlen = maxlen / 10;
+        } else {
+            memcpy(buffer, current, len);
+            rlen -= len;
+            current += len;
+        }
+    } else if (instate == 2) {
+        if (len >= rlen) {
+            len = rlen;
+            rlen = 0;
+            memcpy(buffer, current, len);
+            instate = 3;
+            curlen = 0;
+        } else {
+            memcpy(buffer, current, len);
+            rlen -= len;
+            current += len;
+        }
+    } else if (instate == 1) {
+        if (len > CHUNK) len = CHUNK;
+        memcpy(buffer, &filling[0], len);
+        curlen += len;
+        if (curlen >= maxlen) {
+            rlen = strlen(hugeTests[currentTest].end);
+            current = hugeTests[currentTest].end;
+            instate = 2;
+        } else {
+            if (curlen > dotlen) {
+                fprintf(stderr, ".");
+                dotlen += maxlen / 10;
+            }
+        }
+    } else
+      len = 0;
+    return (len);
+}
+
+/************************************************************************
+ *                                                                      *
+ *              Crazy document generator                                *
+ *                                                                      *
+ ************************************************************************/
+
+unsigned int crazy_indx = 0;
+
+const char *crazy = "<?xml version='1.0' encoding='UTF-8'?>\
+<?tst ?>\
+<!-- tst -->\
+<!DOCTYPE foo [\
+<?tst ?>\
+<!-- tst -->\
+<!ELEMENT foo (#PCDATA)>\
+<!ELEMENT p (#PCDATA|emph)* >\
+]>\
+<?tst ?>\
+<!-- tst -->\
+<foo bar='foo'>\
+<?tst ?>\
+<!-- tst -->\
+foo\
+<![CDATA[ ]]>\
+</foo>\
+<?tst ?>\
+<!-- tst -->";
+
+/**
+ * crazyMatch:
+ * @URI: an URI to test
+ *
+ * Check for a crazy: query
+ *
+ * Returns 1 if yes and 0 if another Input module should be used
+ */
+static int
+crazyMatch(const char * URI) {
+    if ((URI != NULL) && (!strncmp(URI, "crazy:", 6)))
+        return(1);
+    return(0);
+}
+
+/**
+ * crazyOpen:
+ * @URI: an URI to test
+ *
+ * Return a pointer to the crazy: query handler, in this example simply
+ * the current pointer...
+ *
+ * Returns an Input context or NULL in case or error
+ */
+static void *
+crazyOpen(const char * URI) {
+    if ((URI == NULL) || (strncmp(URI, "crazy:", 6)))
+        return(NULL);
+
+    if (crazy_indx > strlen(crazy))
+        return(NULL);
+    reset_timout();
+    rlen = crazy_indx;
+    current = &crazy[0];
+    instate = 0;
+    return((void *) current);
+}
+
+/**
+ * crazyClose:
+ * @context: the read context
+ *
+ * Close the crazy: query handler
+ *
+ * Returns 0 or -1 in case of error
+ */
+static int
+crazyClose(void * context) {
+    if (context == NULL) return(-1);
+    return(0);
+}
+
+
+/**
+ * crazyRead:
+ * @context: the read context
+ * @buffer: where to store data
+ * @len: number of bytes to read
+ *
+ * Implement an crazy: query read.
+ *
+ * Returns the number of bytes read or -1 in case of error
+ */
+static int
+crazyRead(void *context, char *buffer, int len)
+{
+    if ((context == NULL) || (buffer == NULL) || (len < 0))
+        return (-1);
+
+    if ((check_time() <= 0) && (instate == 1)) {
+        fprintf(stderr, "\ntimeout in crazy(%d)\n", crazy_indx);
+        rlen = strlen(crazy) - crazy_indx;
+        current = &crazy[crazy_indx];
+        instate = 2;
+    }
+    if (instate == 0) {
+        if (len >= rlen) {
+            len = rlen;
+            rlen = 0;
+            memcpy(buffer, current, len);
+            instate = 1;
+            curlen = 0;
+        } else {
+            memcpy(buffer, current, len);
+            rlen -= len;
+            current += len;
+        }
+    } else if (instate == 2) {
+        if (len >= rlen) {
+            len = rlen;
+            rlen = 0;
+            memcpy(buffer, current, len);
+            instate = 3;
+            curlen = 0;
+        } else {
+            memcpy(buffer, current, len);
+            rlen -= len;
+            current += len;
+        }
+    } else if (instate == 1) {
+        if (len > CHUNK) len = CHUNK;
+        memcpy(buffer, &filling[0], len);
+        curlen += len;
+        if (curlen >= maxlen) {
+            rlen = strlen(crazy) - crazy_indx;
+            current = &crazy[crazy_indx];
+            instate = 2;
+        }
+    } else
+      len = 0;
+    return (len);
+}
+/************************************************************************
+ *                                                                      *
+ *              Libxml2 specific routines                               *
+ *                                                                      *
+ ************************************************************************/
+
+static int nb_tests = 0;
+static int nb_errors = 0;
+static int nb_leaks = 0;
+static int extraMemoryFromResolver = 0;
+
+/*
+ * We need to trap calls to the resolver to not account memory for the catalog
+ * which is shared to the current running test. We also don't want to have
+ * network downloads modifying tests.
+ */
+static xmlParserInputPtr
+testExternalEntityLoader(const char *URL, const char *ID,
+                         xmlParserCtxtPtr ctxt) {
+    xmlParserInputPtr ret;
+    int memused = xmlMemUsed();
+
+    ret = xmlNoNetExternalEntityLoader(URL, ID, ctxt);
+    extraMemoryFromResolver += xmlMemUsed() - memused;
+
+    return(ret);
+}
+
+/*
+ * Trapping the error messages at the generic level to grab the equivalent of
+ * stderr messages on CLI tools.
+ */
+static char testErrors[32769];
+static int testErrorsSize = 0;
+
+static void XMLCDECL
+channel(void *ctx  ATTRIBUTE_UNUSED, const char *msg, ...) {
+    va_list args;
+    int res;
+
+    if (testErrorsSize >= 32768)
+        return;
+    va_start(args, msg);
+    res = vsnprintf(&testErrors[testErrorsSize],
+                    32768 - testErrorsSize,
+                    msg, args);
+    va_end(args);
+    if (testErrorsSize + res >= 32768) {
+        /* buffer is full */
+        testErrorsSize = 32768;
+        testErrors[testErrorsSize] = 0;
+    } else {
+        testErrorsSize += res;
+    }
+    testErrors[testErrorsSize] = 0;
+}
+
+/**
+ * xmlParserPrintFileContext:
+ * @input:  an xmlParserInputPtr input
+ *
+ * Displays current context within the input content for error tracking
+ */
+
+static void
+xmlParserPrintFileContextInternal(xmlParserInputPtr input ,
+                xmlGenericErrorFunc chanl, void *data ) {
+    const xmlChar *cur, *base;
+    unsigned int n, col;        /* GCC warns if signed, because compared with sizeof() */
+    xmlChar  content[81]; /* space for 80 chars + line terminator */
+    xmlChar *ctnt;
+
+    if (input == NULL) return;
+    cur = input->cur;
+    base = input->base;
+    /* skip backwards over any end-of-lines */
+    while ((cur > base) && ((*(cur) == '\n') || (*(cur) == '\r'))) {
+        cur--;
+    }
+    n = 0;
+    /* search backwards for beginning-of-line (to max buff size) */
+    while ((n++ < (sizeof(content)-1)) && (cur > base) &&
+   (*(cur) != '\n') && (*(cur) != '\r'))
+        cur--;
+    if ((*(cur) == '\n') || (*(cur) == '\r')) cur++;
+    /* calculate the error position in terms of the current position */
+    col = input->cur - cur;
+    /* search forward for end-of-line (to max buff size) */
+    n = 0;
+    ctnt = content;
+    /* copy selected text to our buffer */
+    while ((*cur != 0) && (*(cur) != '\n') &&
+   (*(cur) != '\r') && (n < sizeof(content)-1)) {
+                *ctnt++ = *cur++;
+        n++;
+    }
+    *ctnt = 0;
+    /* print out the selected text */
+    chanl(data ,"%s\n", content);
+    /* create blank line with problem pointer */
+    n = 0;
+    ctnt = content;
+    /* (leave buffer space for pointer + line terminator) */
+    while ((n<col) && (n++ < sizeof(content)-2) && (*ctnt != 0)) {
+        if (*(ctnt) != '\t')
+            *(ctnt) = ' ';
+        ctnt++;
+    }
+    *ctnt++ = '^';
+    *ctnt = 0;
+    chanl(data ,"%s\n", content);
+}
+
+static void
+testStructuredErrorHandler(void *ctx  ATTRIBUTE_UNUSED, xmlErrorPtr err) {
+    char *file = NULL;
+    int line = 0;
+    int code = -1;
+    int domain;
+    void *data = NULL;
+    const char *str;
+    const xmlChar *name = NULL;
+    xmlNodePtr node;
+    xmlErrorLevel level;
+    xmlParserInputPtr input = NULL;
+    xmlParserInputPtr cur = NULL;
+    xmlParserCtxtPtr ctxt = NULL;
+
+    if (err == NULL)
+        return;
+
+    file = err->file;
+    line = err->line;
+    code = err->code;
+    domain = err->domain;
+    level = err->level;
+    node = err->node;
+    if ((domain == XML_FROM_PARSER) || (domain == XML_FROM_HTML) ||
+        (domain == XML_FROM_DTD) || (domain == XML_FROM_NAMESPACE) ||
+        (domain == XML_FROM_IO) || (domain == XML_FROM_VALID)) {
+        ctxt = err->ctxt;
+    }
+    str = err->message;
+
+    if (code == XML_ERR_OK)
+        return;
+
+    if ((node != NULL) && (node->type == XML_ELEMENT_NODE))
+        name = node->name;
+
+    /*
+     * Maintain the compatibility with the legacy error handling
+     */
+    if (ctxt != NULL) {
+        input = ctxt->input;
+        if ((input != NULL) && (input->filename == NULL) &&
+            (ctxt->inputNr > 1)) {
+            cur = input;
+            input = ctxt->inputTab[ctxt->inputNr - 2];
+        }
+        if (input != NULL) {
+            if (input->filename)
+                channel(data, "%s:%d: ", input->filename, input->line);
+            else if ((line != 0) && (domain == XML_FROM_PARSER))
+                channel(data, "Entity: line %d: ", input->line);
+        }
+    } else {
+        if (file != NULL)
+            channel(data, "%s:%d: ", file, line);
+        else if ((line != 0) && (domain == XML_FROM_PARSER))
+            channel(data, "Entity: line %d: ", line);
+    }
+    if (name != NULL) {
+        channel(data, "element %s: ", name);
+    }
+    if (code == XML_ERR_OK)
+        return;
+    switch (domain) {
+        case XML_FROM_PARSER:
+            channel(data, "parser ");
+            break;
+        case XML_FROM_NAMESPACE:
+            channel(data, "namespace ");
+            break;
+        case XML_FROM_DTD:
+        case XML_FROM_VALID:
+            channel(data, "validity ");
+            break;
+        case XML_FROM_HTML:
+            channel(data, "HTML parser ");
+            break;
+        case XML_FROM_MEMORY:
+            channel(data, "memory ");
+            break;
+        case XML_FROM_OUTPUT:
+            channel(data, "output ");
+            break;
+        case XML_FROM_IO:
+            channel(data, "I/O ");
+            break;
+        case XML_FROM_XINCLUDE:
+            channel(data, "XInclude ");
+            break;
+        case XML_FROM_XPATH:
+            channel(data, "XPath ");
+            break;
+        case XML_FROM_XPOINTER:
+            channel(data, "parser ");
+            break;
+        case XML_FROM_REGEXP:
+            channel(data, "regexp ");
+            break;
+        case XML_FROM_MODULE:
+            channel(data, "module ");
+            break;
+        case XML_FROM_SCHEMASV:
+            channel(data, "Schemas validity ");
+            break;
+        case XML_FROM_SCHEMASP:
+            channel(data, "Schemas parser ");
+            break;
+        case XML_FROM_RELAXNGP:
+            channel(data, "Relax-NG parser ");
+            break;
+        case XML_FROM_RELAXNGV:
+            channel(data, "Relax-NG validity ");
+            break;
+        case XML_FROM_CATALOG:
+            channel(data, "Catalog ");
+            break;
+        case XML_FROM_C14N:
+            channel(data, "C14N ");
+            break;
+        case XML_FROM_XSLT:
+            channel(data, "XSLT ");
+            break;
+        default:
+            break;
+    }
+    if (code == XML_ERR_OK)
+        return;
+    switch (level) {
+        case XML_ERR_NONE:
+            channel(data, ": ");
+            break;
+        case XML_ERR_WARNING:
+            channel(data, "warning : ");
+            break;
+        case XML_ERR_ERROR:
+            channel(data, "error : ");
+            break;
+        case XML_ERR_FATAL:
+            channel(data, "error : ");
+            break;
+    }
+    if (code == XML_ERR_OK)
+        return;
+    if (str != NULL) {
+        int len;
+        len = xmlStrlen((const xmlChar *)str);
+        if ((len > 0) && (str[len - 1] != '\n'))
+            channel(data, "%s\n", str);
+        else
+            channel(data, "%s", str);
+    } else {
+        channel(data, "%s\n", "out of memory error");
+    }
+    if (code == XML_ERR_OK)
+        return;
+
+    if (ctxt != NULL) {
+        xmlParserPrintFileContextInternal(input, channel, data);
+        if (cur != NULL) {
+            if (cur->filename)
+                channel(data, "%s:%d: \n", cur->filename, cur->line);
+            else if ((line != 0) && (domain == XML_FROM_PARSER))
+                channel(data, "Entity: line %d: \n", cur->line);
+            xmlParserPrintFileContextInternal(cur, channel, data);
+        }
+    }
+    if ((domain == XML_FROM_XPATH) && (err->str1 != NULL) &&
+        (err->int1 < 100) &&
+        (err->int1 < xmlStrlen((const xmlChar *)err->str1))) {
+        xmlChar buf[150];
+        int i;
+
+        channel(data, "%s\n", err->str1);
+        for (i=0;i < err->int1;i++)
+             buf[i] = ' ';
+        buf[i++] = '^';
+        buf[i] = 0;
+        channel(data, "%s\n", buf);
+    }
+}
+
+static void
+initializeLibxml2(void) {
+    xmlGetWarningsDefaultValue = 0;
+    xmlPedanticParserDefault(0);
+
+    xmlMemSetup(xmlMemFree, xmlMemMalloc, xmlMemRealloc, xmlMemoryStrdup);
+    xmlInitParser();
+    xmlSetExternalEntityLoader(testExternalEntityLoader);
+    xmlSetStructuredErrorFunc(NULL, testStructuredErrorHandler);
+    /*
+     * register the new I/O handlers
+     */
+    if (xmlRegisterInputCallbacks(hugeMatch, hugeOpen,
+                                  hugeRead, hugeClose) < 0) {
+        fprintf(stderr, "failed to register Huge handlers\n");
+        exit(1);
+    }
+    if (xmlRegisterInputCallbacks(crazyMatch, crazyOpen,
+                                  crazyRead, crazyClose) < 0) {
+        fprintf(stderr, "failed to register Crazy handlers\n");
+        exit(1);
+    }
+}
+
+/************************************************************************
+ *                                                                      *
+ *              SAX empty callbacks                                     *
+ *                                                                      *
+ ************************************************************************/
+
+unsigned long callbacks = 0;
+
+/**
+ * isStandaloneCallback:
+ * @ctxt:  An XML parser context
+ *
+ * Is this document tagged standalone ?
+ *
+ * Returns 1 if true
+ */
+static int
+isStandaloneCallback(void *ctx ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return (0);
+}
+
+/**
+ * hasInternalSubsetCallback:
+ * @ctxt:  An XML parser context
+ *
+ * Does this document has an internal subset
+ *
+ * Returns 1 if true
+ */
+static int
+hasInternalSubsetCallback(void *ctx ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return (0);
+}
+
+/**
+ * hasExternalSubsetCallback:
+ * @ctxt:  An XML parser context
+ *
+ * Does this document has an external subset
+ *
+ * Returns 1 if true
+ */
+static int
+hasExternalSubsetCallback(void *ctx ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return (0);
+}
+
+/**
+ * internalSubsetCallback:
+ * @ctxt:  An XML parser context
+ *
+ * Does this document has an internal subset
+ */
+static void
+internalSubsetCallback(void *ctx ATTRIBUTE_UNUSED,
+                       const xmlChar * name ATTRIBUTE_UNUSED,
+                       const xmlChar * ExternalID ATTRIBUTE_UNUSED,
+                       const xmlChar * SystemID ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return;
+}
+
+/**
+ * externalSubsetCallback:
+ * @ctxt:  An XML parser context
+ *
+ * Does this document has an external subset
+ */
+static void
+externalSubsetCallback(void *ctx ATTRIBUTE_UNUSED,
+                       const xmlChar * name ATTRIBUTE_UNUSED,
+                       const xmlChar * ExternalID ATTRIBUTE_UNUSED,
+                       const xmlChar * SystemID ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return;
+}
+
+/**
+ * resolveEntityCallback:
+ * @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 xmlParserInputPtr
+resolveEntityCallback(void *ctx ATTRIBUTE_UNUSED,
+                      const xmlChar * publicId ATTRIBUTE_UNUSED,
+                      const xmlChar * systemId ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return (NULL);
+}
+
+/**
+ * getEntityCallback:
+ * @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 xmlEntityPtr
+getEntityCallback(void *ctx ATTRIBUTE_UNUSED,
+                  const xmlChar * name ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return (NULL);
+}
+
+/**
+ * getParameterEntityCallback:
+ * @ctxt:  An XML parser context
+ * @name: The entity name
+ *
+ * Get a parameter entity by name
+ *
+ * Returns the xmlParserInputPtr
+ */
+static xmlEntityPtr
+getParameterEntityCallback(void *ctx ATTRIBUTE_UNUSED,
+                           const xmlChar * name ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return (NULL);
+}
+
+
+/**
+ * entityDeclCallback:
+ * @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 void
+entityDeclCallback(void *ctx ATTRIBUTE_UNUSED,
+                   const xmlChar * name ATTRIBUTE_UNUSED,
+                   int type ATTRIBUTE_UNUSED,
+                   const xmlChar * publicId ATTRIBUTE_UNUSED,
+                   const xmlChar * systemId ATTRIBUTE_UNUSED,
+                   xmlChar * content ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return;
+}
+
+/**
+ * attributeDeclCallback:
+ * @ctxt:  An XML parser context
+ * @name:  the attribute name
+ * @type:  the attribute type
+ *
+ * An attribute definition has been parsed
+ */
+static void
+attributeDeclCallback(void *ctx ATTRIBUTE_UNUSED,
+                      const xmlChar * elem ATTRIBUTE_UNUSED,
+                      const xmlChar * name ATTRIBUTE_UNUSED,
+                      int type ATTRIBUTE_UNUSED, int def ATTRIBUTE_UNUSED,
+                      const xmlChar * defaultValue ATTRIBUTE_UNUSED,
+                      xmlEnumerationPtr tree ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return;
+}
+
+/**
+ * elementDeclCallback:
+ * @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 void
+elementDeclCallback(void *ctx ATTRIBUTE_UNUSED,
+                    const xmlChar * name ATTRIBUTE_UNUSED,
+                    int type ATTRIBUTE_UNUSED,
+                    xmlElementContentPtr content ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return;
+}
+
+/**
+ * notationDeclCallback:
+ * @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 void
+notationDeclCallback(void *ctx ATTRIBUTE_UNUSED,
+                     const xmlChar * name ATTRIBUTE_UNUSED,
+                     const xmlChar * publicId ATTRIBUTE_UNUSED,
+                     const xmlChar * systemId ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return;
+}
+
+/**
+ * unparsedEntityDeclCallback:
+ * @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 void
+unparsedEntityDeclCallback(void *ctx ATTRIBUTE_UNUSED,
+                           const xmlChar * name ATTRIBUTE_UNUSED,
+                           const xmlChar * publicId ATTRIBUTE_UNUSED,
+                           const xmlChar * systemId ATTRIBUTE_UNUSED,
+                           const xmlChar * notationName ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return;
+}
+
+/**
+ * setDocumentLocatorCallback:
+ * @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 void
+setDocumentLocatorCallback(void *ctx ATTRIBUTE_UNUSED,
+                           xmlSAXLocatorPtr loc ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return;
+}
+
+/**
+ * startDocumentCallback:
+ * @ctxt:  An XML parser context
+ *
+ * called when the document start being processed.
+ */
+static void
+startDocumentCallback(void *ctx ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return;
+}
+
+/**
+ * endDocumentCallback:
+ * @ctxt:  An XML parser context
+ *
+ * called when the document end has been detected.
+ */
+static void
+endDocumentCallback(void *ctx ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return;
+}
+
+#if 0
+/**
+ * startElementCallback:
+ * @ctxt:  An XML parser context
+ * @name:  The element name
+ *
+ * called when an opening tag has been processed.
+ */
+static void
+startElementCallback(void *ctx ATTRIBUTE_UNUSED,
+                     const xmlChar * name ATTRIBUTE_UNUSED,
+                     const xmlChar ** atts ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return;
+}
+
+/**
+ * endElementCallback:
+ * @ctxt:  An XML parser context
+ * @name:  The element name
+ *
+ * called when the end of an element has been detected.
+ */
+static void
+endElementCallback(void *ctx ATTRIBUTE_UNUSED,
+                   const xmlChar * name ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return;
+}
+#endif
+
+/**
+ * charactersCallback:
+ * @ctxt:  An XML parser context
+ * @ch:  a xmlChar string
+ * @len: the number of xmlChar
+ *
+ * receiving some chars from the parser.
+ * Question: how much at a time ???
+ */
+static void
+charactersCallback(void *ctx ATTRIBUTE_UNUSED,
+                   const xmlChar * ch ATTRIBUTE_UNUSED,
+                   int len ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return;
+}
+
+/**
+ * referenceCallback:
+ * @ctxt:  An XML parser context
+ * @name:  The entity name
+ *
+ * called when an entity reference is detected.
+ */
+static void
+referenceCallback(void *ctx ATTRIBUTE_UNUSED,
+                  const xmlChar * name ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return;
+}
+
+/**
+ * ignorableWhitespaceCallback:
+ * @ctxt:  An XML parser context
+ * @ch:  a xmlChar string
+ * @start: the first char in the string
+ * @len: the number of xmlChar
+ *
+ * receiving some ignorable whitespaces from the parser.
+ * Question: how much at a time ???
+ */
+static void
+ignorableWhitespaceCallback(void *ctx ATTRIBUTE_UNUSED,
+                            const xmlChar * ch ATTRIBUTE_UNUSED,
+                            int len ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return;
+}
+
+/**
+ * processingInstructionCallback:
+ * @ctxt:  An XML parser context
+ * @target:  the target name
+ * @data: the PI data's
+ * @len: the number of xmlChar
+ *
+ * A processing instruction has been parsed.
+ */
+static void
+processingInstructionCallback(void *ctx ATTRIBUTE_UNUSED,
+                              const xmlChar * target ATTRIBUTE_UNUSED,
+                              const xmlChar * data ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return;
+}
+
+/**
+ * cdataBlockCallback:
+ * @ctx: the user data (XML parser context)
+ * @value:  The pcdata content
+ * @len:  the block length
+ *
+ * called when a pcdata block has been parsed
+ */
+static void
+cdataBlockCallback(void *ctx ATTRIBUTE_UNUSED,
+                   const xmlChar * value ATTRIBUTE_UNUSED,
+                   int len ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return;
+}
+
+/**
+ * commentCallback:
+ * @ctxt:  An XML parser context
+ * @value:  the comment content
+ *
+ * A comment has been parsed.
+ */
+static void
+commentCallback(void *ctx ATTRIBUTE_UNUSED,
+                const xmlChar * value ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return;
+}
+
+/**
+ * warningCallback:
+ * @ctxt:  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
+warningCallback(void *ctx ATTRIBUTE_UNUSED,
+                const char *msg ATTRIBUTE_UNUSED, ...)
+{
+    callbacks++;
+    return;
+}
+
+/**
+ * errorCallback:
+ * @ctxt:  An XML parser context
+ * @msg:  the message to display/transmit
+ * @...:  extra parameters for the message display
+ *
+ * Display and format a error messages, gives file, line, position and
+ * extra parameters.
+ */
+static void XMLCDECL
+errorCallback(void *ctx ATTRIBUTE_UNUSED, const char *msg ATTRIBUTE_UNUSED,
+              ...)
+{
+    callbacks++;
+    return;
+}
+
+/**
+ * fatalErrorCallback:
+ * @ctxt:  An XML parser context
+ * @msg:  the message to display/transmit
+ * @...:  extra parameters for the message display
+ *
+ * Display and format a fatalError messages, gives file, line, position and
+ * extra parameters.
+ */
+static void XMLCDECL
+fatalErrorCallback(void *ctx ATTRIBUTE_UNUSED,
+                   const char *msg ATTRIBUTE_UNUSED, ...)
+{
+    return;
+}
+
+
+/*
+ * SAX2 specific callbacks
+ */
+
+/**
+ * startElementNsCallback:
+ * @ctxt:  An XML parser context
+ * @name:  The element name
+ *
+ * called when an opening tag has been processed.
+ */
+static void
+startElementNsCallback(void *ctx ATTRIBUTE_UNUSED,
+                       const xmlChar * localname ATTRIBUTE_UNUSED,
+                       const xmlChar * prefix ATTRIBUTE_UNUSED,
+                       const xmlChar * URI ATTRIBUTE_UNUSED,
+                       int nb_namespaces ATTRIBUTE_UNUSED,
+                       const xmlChar ** namespaces ATTRIBUTE_UNUSED,
+                       int nb_attributes ATTRIBUTE_UNUSED,
+                       int nb_defaulted ATTRIBUTE_UNUSED,
+                       const xmlChar ** attributes ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return;
+}
+
+/**
+ * endElementCallback:
+ * @ctxt:  An XML parser context
+ * @name:  The element name
+ *
+ * called when the end of an element has been detected.
+ */
+static void
+endElementNsCallback(void *ctx ATTRIBUTE_UNUSED,
+                     const xmlChar * localname ATTRIBUTE_UNUSED,
+                     const xmlChar * prefix ATTRIBUTE_UNUSED,
+                     const xmlChar * URI ATTRIBUTE_UNUSED)
+{
+    callbacks++;
+    return;
+}
+
+static xmlSAXHandler callbackSAX2HandlerStruct = {
+    internalSubsetCallback,
+    isStandaloneCallback,
+    hasInternalSubsetCallback,
+    hasExternalSubsetCallback,
+    resolveEntityCallback,
+    getEntityCallback,
+    entityDeclCallback,
+    notationDeclCallback,
+    attributeDeclCallback,
+    elementDeclCallback,
+    unparsedEntityDeclCallback,
+    setDocumentLocatorCallback,
+    startDocumentCallback,
+    endDocumentCallback,
+    NULL,
+    NULL,
+    referenceCallback,
+    charactersCallback,
+    ignorableWhitespaceCallback,
+    processingInstructionCallback,
+    commentCallback,
+    warningCallback,
+    errorCallback,
+    fatalErrorCallback,
+    getParameterEntityCallback,
+    cdataBlockCallback,
+    externalSubsetCallback,
+    XML_SAX2_MAGIC,
+    NULL,
+    startElementNsCallback,
+    endElementNsCallback,
+    NULL
+};
+
+static xmlSAXHandlerPtr callbackSAX2Handler = &callbackSAX2HandlerStruct;
+
+/************************************************************************
+ *                                                                      *
+ *              The tests front-ends                                     *
+ *                                                                      *
+ ************************************************************************/
+
+/**
+ * readerTest:
+ * @filename: the file to parse
+ * @max_size: size of the limit to test
+ * @options: parsing options
+ * @fail: should a failure be reported
+ *
+ * Parse a memory generated file using SAX
+ *
+ * Returns 0 in case of success, an error code otherwise
+ */
+static int
+saxTest(const char *filename, size_t limit, int options, int fail) {
+    int res = 0;
+    xmlParserCtxtPtr ctxt;
+    xmlDocPtr doc;
+    xmlSAXHandlerPtr old_sax;
+
+    nb_tests++;
+
+    maxlen = limit;
+    ctxt = xmlNewParserCtxt();
+    if (ctxt == NULL) {
+        fprintf(stderr, "Failed to create parser context\n");
+        return(1);
+    }
+    old_sax = ctxt->sax;
+    ctxt->sax = callbackSAX2Handler;
+    ctxt->userData = NULL;
+    doc = xmlCtxtReadFile(ctxt, filename, NULL, options);
+
+    if (doc != NULL) {
+        fprintf(stderr, "SAX parsing generated a document !\n");
+        xmlFreeDoc(doc);
+        res = 0;
+    } else if (ctxt->wellFormed == 0) {
+        if (fail)
+            res = 0;
+        else {
+            fprintf(stderr, "Failed to parse '%s' %lu\n", filename, limit);
+            res = 1;
+        }
+    } else {
+        if (fail) {
+            fprintf(stderr, "Failed to get failure for '%s' %lu\n",
+                    filename, limit);
+            res = 1;
+        } else
+            res = 0;
+    }
+    ctxt->sax = old_sax;
+    xmlFreeParserCtxt(ctxt);
+
+    return(res);
+}
+#ifdef LIBXML_READER_ENABLED
+/**
+ * readerTest:
+ * @filename: the file to parse
+ * @max_size: size of the limit to test
+ * @options: parsing options
+ * @fail: should a failure be reported
+ *
+ * Parse a memory generated file using the xmlReader
+ *
+ * Returns 0 in case of success, an error code otherwise
+ */
+static int
+readerTest(const char *filename, size_t limit, int options, int fail) {
+    xmlTextReaderPtr reader;
+    int res = 0;
+    int ret;
+
+    nb_tests++;
+
+    maxlen = limit;
+    reader = xmlReaderForFile(filename , NULL, options);
+    if (reader == NULL) {
+        fprintf(stderr, "Failed to open '%s' test\n", filename);
+        return(1);
+    }
+    ret = xmlTextReaderRead(reader);
+    while (ret == 1) {
+        ret = xmlTextReaderRead(reader);
+    }
+    if (ret != 0) {
+        if (fail)
+            res = 0;
+        else {
+            if (strncmp(filename, "crazy:", 6) == 0)
+                fprintf(stderr, "Failed to parse '%s' %u\n",
+                        filename, crazy_indx);
+            else
+                fprintf(stderr, "Failed to parse '%s' %lu\n",
+                        filename, limit);
+            res = 1;
+        }
+    } else {
+        if (fail) {
+            if (strncmp(filename, "crazy:", 6) == 0)
+                fprintf(stderr, "Failed to get failure for '%s' %u\n",
+                        filename, crazy_indx);
+            else
+                fprintf(stderr, "Failed to get failure for '%s' %lu\n",
+                        filename, limit);
+            res = 1;
+        } else
+            res = 0;
+    }
+    if (timeout)
+        res = 1;
+    xmlFreeTextReader(reader);
+
+    return(res);
+}
+#endif
+
+/************************************************************************
+ *                                                                      *
+ *                      Tests descriptions                              *
+ *                                                                      *
+ ************************************************************************/
+
+typedef int (*functest) (const char *filename, size_t limit, int options,
+                         int fail);
+
+typedef struct limitDesc limitDesc;
+typedef limitDesc *limitDescPtr;
+struct limitDesc {
+    const char *name; /* the huge generator name */
+    size_t limit;     /* the limit to test */
+    int options;      /* extra parser options */
+    int fail;         /* whether the test should fail */
+};
+
+static limitDesc limitDescriptions[] = {
+    /* max length of a text node in content */
+    {"huge:textNode", XML_MAX_TEXT_LENGTH - CHUNK, 0, 0},
+    {"huge:textNode", XML_MAX_TEXT_LENGTH + CHUNK, 0, 1},
+    {"huge:textNode", XML_MAX_TEXT_LENGTH + CHUNK, XML_PARSE_HUGE, 0},
+    /* max length of a text node in content */
+    {"huge:attrNode", XML_MAX_TEXT_LENGTH - CHUNK, 0, 0},
+    {"huge:attrNode", XML_MAX_TEXT_LENGTH + CHUNK, 0, 1},
+    {"huge:attrNode", XML_MAX_TEXT_LENGTH + CHUNK, XML_PARSE_HUGE, 0},
+    /* max length of a comment node */
+    {"huge:commentNode", XML_MAX_TEXT_LENGTH - CHUNK, 0, 0},
+    {"huge:commentNode", XML_MAX_TEXT_LENGTH + CHUNK, 0, 1},
+    {"huge:commentNode", XML_MAX_TEXT_LENGTH + CHUNK, XML_PARSE_HUGE, 0},
+    /* max length of a PI node */
+    {"huge:piNode", XML_MAX_TEXT_LENGTH - CHUNK, 0, 0},
+    {"huge:piNode", XML_MAX_TEXT_LENGTH + CHUNK, 0, 1},
+    {"huge:piNode", XML_MAX_TEXT_LENGTH + CHUNK, XML_PARSE_HUGE, 0},
+};
+
+typedef struct testDesc testDesc;
+typedef testDesc *testDescPtr;
+struct testDesc {
+    const char *desc; /* descripton of the test */
+    functest    func; /* function implementing the test */
+};
+
+static
+testDesc testDescriptions[] = {
+    { "Parsing of huge files with the sax parser", saxTest},
+/*    { "Parsing of huge files with the tree parser", treeTest}, */
+#ifdef LIBXML_READER_ENABLED
+    { "Parsing of huge files with the reader", readerTest},
+#endif
+    {NULL, NULL}
+};
+
+typedef struct testException testException;
+typedef testException *testExceptionPtr;
+struct testException {
+    unsigned int test;  /* the parser test number */
+    unsigned int limit; /* the limit test number */
+    int fail;           /* new fail value or -1*/
+    size_t size;        /* new limit value or 0 */
+};
+
+static
+testException testExceptions[] = {
+    /* the SAX parser doesn't hit a limit of XML_MAX_TEXT_LENGTH text nodes */
+    { 0, 1, 0, 0},
+};
+
+static int
+launchTests(testDescPtr tst, unsigned int test) {
+    int res = 0, err = 0;
+    unsigned int i, j;
+    size_t limit;
+    int fail;
+
+    if (tst == NULL) return(-1);
+
+    for (i = 0;i < sizeof(limitDescriptions)/sizeof(limitDescriptions[0]);i++) {
+        limit = limitDescriptions[i].limit;
+        fail = limitDescriptions[i].fail;
+        /*
+         * Handle exceptions if any
+         */
+        for (j = 0;j < sizeof(testExceptions)/sizeof(testExceptions[0]);j++) {
+            if ((testExceptions[j].test == test) &&
+                (testExceptions[j].limit == i)) {
+                if (testExceptions[j].fail != -1)
+                    fail = testExceptions[j].fail;
+                if (testExceptions[j].size != 0)
+                    limit = testExceptions[j].size;
+                break;
+            }
+        }
+        res = tst->func(limitDescriptions[i].name, limit,
+                        limitDescriptions[i].options, fail);
+        if (res != 0) {
+            nb_errors++;
+            err++;
+        }
+    }
+    return(err);
+}
+
+
+static int
+runtest(unsigned int i) {
+    int ret = 0, res;
+    int old_errors, old_tests, old_leaks;
+
+    old_errors = nb_errors;
+    old_tests = nb_tests;
+    old_leaks = nb_leaks;
+    if ((tests_quiet == 0) && (testDescriptions[i].desc != NULL))
+        printf("## %s\n", testDescriptions[i].desc);
+    res = launchTests(&testDescriptions[i], i);
+    if (res != 0)
+        ret++;
+    if (verbose) {
+        if ((nb_errors == old_errors) && (nb_leaks == old_leaks))
+            printf("Ran %d tests, no errors\n", nb_tests - old_tests);
+        else
+            printf("Ran %d tests, %d errors, %d leaks\n",
+                   nb_tests - old_tests,
+                   nb_errors - old_errors,
+                   nb_leaks - old_leaks);
+    }
+    return(ret);
+}
+
+static int
+launchCrazySAX(unsigned int test, int fail) {
+    int res = 0, err = 0;
+
+    crazy_indx = test;
+
+    res = saxTest("crazy::test", XML_MAX_LOOKUP_LIMIT - CHUNK, 0, fail);
+    if (res != 0) {
+        nb_errors++;
+        err++;
+    }
+    if (tests_quiet == 0)
+        fprintf(stderr, "%c", crazy[test]);
+
+    return(err);
+}
+
+#ifdef LIBXML_READER_ENABLED
+static int
+launchCrazy(unsigned int test, int fail) {
+    int res = 0, err = 0;
+
+    crazy_indx = test;
+
+    res = readerTest("crazy::test", XML_MAX_LOOKUP_LIMIT - CHUNK, 0, fail);
+    if (res != 0) {
+        nb_errors++;
+        err++;
+    }
+    if (tests_quiet == 0)
+        fprintf(stderr, "%c", crazy[test]);
+
+    return(err);
+}
+#endif
+
+static int get_crazy_fail(int test) {
+    /*
+     * adding 1000000 of character 'a' leads to parser failure mostly
+     * everywhere except in those special spots. Need to be updated
+     * each time crazy is updated
+     */
+    int fail = 1;
+    if ((test == 44) || /* PI in Misc */
+        ((test >= 50) && (test <= 55)) || /* Comment in Misc */
+        (test == 79) || /* PI in DTD */
+        ((test >= 85) && (test <= 90)) || /* Comment in DTD */
+        (test == 154) || /* PI in Misc */
+        ((test >= 160) && (test <= 165)) || /* Comment in Misc */
+        ((test >= 178) && (test <= 181)) || /* attribute value */
+        (test == 183) || /* Text */
+        (test == 189) || /* PI in Content */
+        (test == 191) || /* Text */
+        ((test >= 195) && (test <= 200)) || /* Comment in Content */
+        ((test >= 203) && (test <= 206)) || /* Text */
+        (test == 215) || (test == 216) || /* in CDATA */
+        (test == 219) || /* Text */
+        (test == 231) || /* PI in Misc */
+        ((test >= 237) && (test <= 242))) /* Comment in Misc */
+        fail = 0;
+    return(fail);
+}
+
+static int
+runcrazy(void) {
+    int ret = 0, res = 0;
+    int old_errors, old_tests, old_leaks;
+    unsigned int i;
+
+    old_errors = nb_errors;
+    old_tests = nb_tests;
+    old_leaks = nb_leaks;
+
+#ifdef LIBXML_READER_ENABLED
+    if (tests_quiet == 0) {
+        printf("## Crazy tests on reader\n");
+    }
+    for (i = 0;i < strlen(crazy);i++) {
+        res += launchCrazy(i, get_crazy_fail(i));
+        if (res != 0)
+            ret++;
+    }
+#endif
+
+    if (tests_quiet == 0) {
+        printf("\n## Crazy tests on SAX\n");
+    }
+    for (i = 0;i < strlen(crazy);i++) {
+        res += launchCrazySAX(i, get_crazy_fail(i));
+        if (res != 0)
+            ret++;
+    }
+    if (tests_quiet == 0)
+        fprintf(stderr, "\n");
+    if (verbose) {
+        if ((nb_errors == old_errors) && (nb_leaks == old_leaks))
+            printf("Ran %d tests, no errors\n", nb_tests - old_tests);
+        else
+            printf("Ran %d tests, %d errors, %d leaks\n",
+                   nb_tests - old_tests,
+                   nb_errors - old_errors,
+                   nb_leaks - old_leaks);
+    }
+    return(ret);
+}
+
+
+int
+main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
+    int i, a, ret = 0;
+    int subset = 0;
+
+    fillFilling();
+    initializeLibxml2();
+
+    for (a = 1; a < argc;a++) {
+        if (!strcmp(argv[a], "-v"))
+            verbose = 1;
+        else if (!strcmp(argv[a], "-quiet"))
+            tests_quiet = 1;
+        else if (!strcmp(argv[a], "-crazy"))
+            subset = 1;
+    }
+    if (subset == 0) {
+        for (i = 0; testDescriptions[i].func != NULL; i++) {
+            ret += runtest(i);
+        }
+    }
+    ret += runcrazy();
+    if ((nb_errors == 0) && (nb_leaks == 0)) {
+        ret = 0;
+        printf("Total %d tests, no errors\n",
+               nb_tests);
+    } else {
+        ret = 1;
+        printf("Total %d tests, %d errors, %d leaks\n",
+               nb_tests, nb_errors, nb_leaks);
+    }
+    xmlCleanupParser();
+    xmlMemoryDump();
+
+    return(ret);
+}