source: trunk/third/libxml/parserold.c @ 17093

/*
 * parserold.c : the 1.8.11 XML parser core added for compatibility
 *
 * See Copyright for the status of this software.
 *
 * Daniel.Veillard@w3.org
 */

#ifdef WIN32
#include "win32config.h"
#else
#include "config.h"
#endif

#include <stdio.h>
#include <string.h> /* for memset() only */
#ifdef HAVE_CTYPE_H
#include <ctype.h>
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.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_ZLIB_H
#include <zlib.h>
#endif

#include "xmlmemory.h"
#include "tree.h"
#include "parser.h"
#include "entities.h"
#include "encoding.h"
#include "valid.h"
#include "parserInternals.h"
#include "xmlIO.h"
#include "xml-error.h"

#define XML_PARSER_BIG_BUFFER_SIZE 1000
#define XML_PARSER_BUFFER_SIZE 100

/*
 * List of XML prefixed PI allowed by W3C specs
 */

static const char *xmlW3CPIs[] = {
    "xml-stylesheet",
    NULL
};

/************************************************************************
 *                                                                      *
 *              Tweaks for plugging in the old parser                   *
 *                                                                      *
 ************************************************************************/

static void xmlOldFreeInputStream(xmlParserInputPtr input);
static xmlChar * xmlOldParseName(xmlParserCtxtPtr ctxt);
static xmlEntityPtr xmlOldParseEntityRef(xmlParserCtxtPtr ctxt);
static void xmlOldParsePEReference(xmlParserCtxtPtr ctxt);
static void xmlOldParseReference(xmlParserCtxtPtr ctxt);
static xmlChar * xmlOldParseVersionInfo(xmlParserCtxtPtr ctxt);
static xmlChar * xmlOldParseEncodingDecl(xmlParserCtxtPtr ctxt);
static void xmlOldParseElement(xmlParserCtxtPtr ctxt);
static xmlChar * xmlOldScanName(xmlParserCtxtPtr ctxt);
static xmlEntityPtr
xmlOldParseStringEntityRef(xmlParserCtxtPtr ctxt, const xmlChar ** str);
static xmlEntityPtr
xmlOldParseStringPEReference(xmlParserCtxtPtr ctxt, const xmlChar **str);

extern xmlChar * xmlCharStrdup(const char *cur);

/************************************************************************
 *                                                                      *
 *              Input handling functions for progressive parsing        *
 *                                                                      *
 ************************************************************************/

/* #define DEBUG_INPUT */
/* #define DEBUG_STACK */
/* #define DEBUG_PUSH */


#define INPUT_CHUNK     250
/* we need to keep enough input to show errors in context */
#define LINE_LEN        80

#ifdef DEBUG_INPUT
#define CHECK_BUFFER(in) check_buffer(in)

static void old_check_buffer(xmlParserInputPtr in) {
    if (in->base != in->buf->buffer->content) {
        fprintf(stderr, "xmlParserInput: base mismatch problem\n");
    }
    if (in->cur < in->base) {
        fprintf(stderr, "xmlParserInput: cur < base problem\n");
    }
    if (in->cur > in->base + in->buf->buffer->use) {
        fprintf(stderr, "xmlParserInput: cur > base + use problem\n");
    }
    fprintf(stderr,"buffer %x : content %x, cur %d, use %d, size %d\n",
            (int) in, (int) in->buf->buffer->content, in->cur - in->base,
            in->buf->buffer->use, in->buf->buffer->size);
}

#else
#define CHECK_BUFFER(in) 
#endif


/**
 * xmlOldParserInputRead:
 * @in:  an XML parser input
 * @len:  an indicative size for the lookahead
 *
 * This function refresh the input for the parser. It doesn't try to
 * preserve pointers to the input buffer, and discard already read data
 *
 * Returns the number of xmlChars read, or -1 in case of error, 0 indicate the
 * end of this entity
 */
static int
xmlOldParserInputRead(xmlParserInputPtr in, int len) {
    int ret;
    int used;
    int index;

#ifdef DEBUG_INPUT
    fprintf(stderr, "Read\n");
#endif
    if (in->buf == NULL) return(-1);
    if (in->base == NULL) return(-1);
    if (in->cur == NULL) return(-1);
    if (in->buf->buffer == NULL) return(-1);

    CHECK_BUFFER(in);

    used = in->cur - in->buf->buffer->content;
    ret = xmlBufferShrink(in->buf->buffer, used);
    if (ret > 0) {
        in->cur -= ret;
        in->consumed += ret;
    }
    ret = xmlParserInputBufferRead(in->buf, len);
    if (in->base != in->buf->buffer->content) {
        /*
         * the buffer has been realloced
         */
        index = in->cur - in->base;
        in->base = in->buf->buffer->content;
        in->cur = &in->buf->buffer->content[index];
    }

    CHECK_BUFFER(in);

    return(ret);
}

/**
 * xmlOldParserInputGrow:
 * @in:  an XML parser input
 * @len:  an indicative size for the lookahead
 *
 * This function increase the input for the parser. It tries to
 * preserve pointers to the input buffer, and keep already read data
 *
 * Returns the number of xmlChars read, or -1 in case of error, 0 indicate the
 * end of this entity
 */
static int
xmlOldParserInputGrow(xmlParserInputPtr in, int len) {
    int ret;
    int index;

#ifdef DEBUG_INPUT
    fprintf(stderr, "Grow\n");
#endif
    if (in->buf == NULL) return(-1);
    if (in->base == NULL) return(-1);
    if (in->cur == NULL) return(-1);
    if (in->buf->buffer == NULL) return(-1);

    CHECK_BUFFER(in);

    index = in->cur - in->base;
    if (in->buf->buffer->use > index + INPUT_CHUNK) {

        CHECK_BUFFER(in);

        return(0);
    }
    if ((in->buf->httpIO != NULL) || (in->buf->ftpIO != NULL) ||
        (in->buf->file != NULL) ||
#ifdef HAVE_ZLIB_H
        (in->buf->gzfile != NULL) ||
#endif
        (in->buf->fd >= 0))
        ret = xmlParserInputBufferGrow(in->buf, len);
    else        
        return(0);

    /*
     * NOTE : in->base may be a "dandling" i.e. freed pointer in this
     *        block, but we use it really as an integer to do some
     *        pointer arithmetic. Insure will raise it as a bug but in
     *        that specific case, that's not !
     */
    if (in->base != in->buf->buffer->content) {
        /*
         * the buffer has been realloced
         */
        index = in->cur - in->base;
        in->base = in->buf->buffer->content;
        in->cur = &in->buf->buffer->content[index];
    }

    CHECK_BUFFER(in);

    return(ret);
}

/**
 * xmlOldParserInputShrink:
 * @in:  an XML parser input
 *
 * This function removes used input for the parser.
 */
static void
xmlOldParserInputShrink(xmlParserInputPtr in) {
    int used;
    int ret;
    int index;

#ifdef DEBUG_INPUT
    fprintf(stderr, "Shrink\n");
#endif
    if (in->buf == NULL) return;
    if (in->base == NULL) return;
    if (in->cur == NULL) return;
    if (in->buf->buffer == NULL) return;

    CHECK_BUFFER(in);

    used = in->cur - in->buf->buffer->content;
    if (used > INPUT_CHUNK) {
        ret = xmlBufferShrink(in->buf->buffer, used - LINE_LEN);
        if (ret > 0) {
            in->cur -= ret;
            in->consumed += ret;
        }
    }

    CHECK_BUFFER(in);

    if (in->buf->buffer->use > INPUT_CHUNK) {
        return;
    }
    xmlParserInputBufferRead(in->buf, 2 * INPUT_CHUNK);
    if (in->base != in->buf->buffer->content) {
        /*
         * the buffer has been realloced
         */
        index = in->cur - in->base;
        in->base = in->buf->buffer->content;
        in->cur = &in->buf->buffer->content[index];
    }

    CHECK_BUFFER(in);
}

/************************************************************************
 *                                                                      *
 *              Parser stacks related functions and macros              *
 *                                                                      *
 ************************************************************************/

extern int xmlSubstituteEntitiesDefaultValue;
extern int xmlDoValidityCheckingDefaultValue;
extern int xmlKeepBlanksDefaultValue;
xmlEntityPtr xmlOldParseStringEntityRef(xmlParserCtxtPtr ctxt,
                                     const xmlChar ** str);

/*
 * Generic function for accessing stacks in the Parser Context
 */

#define PUSH_AND_POP(scope, type, name)                                 \
scope int name##OldPush(xmlParserCtxtPtr ctxt, type value) {            \
    if (ctxt->name##Nr >= ctxt->name##Max) {                            \
        ctxt->name##Max *= 2;                                           \
        ctxt->name##Tab = (void *) xmlRealloc(ctxt->name##Tab,          \
                     ctxt->name##Max * sizeof(ctxt->name##Tab[0]));     \
        if (ctxt->name##Tab == NULL) {                                  \
            fprintf(stderr, "realloc failed !\n");                      \
            return(0);                                                  \
        }                                                               \
    }                                                                   \
    ctxt->name##Tab[ctxt->name##Nr] = value;                            \
    ctxt->name = value;                                                 \
    return(ctxt->name##Nr++);                                           \
}                                                                       \
scope type name##OldPop(xmlParserCtxtPtr ctxt) {                        \
    type ret;                                                           \
    if (ctxt->name##Nr <= 0) return(0);                                 \
    ctxt->name##Nr--;                                                   \
    if (ctxt->name##Nr > 0)                                             \
        ctxt->name = ctxt->name##Tab[ctxt->name##Nr - 1];               \
    else                                                                \
        ctxt->name = NULL;                                              \
    ret = ctxt->name##Tab[ctxt->name##Nr];                              \
    ctxt->name##Tab[ctxt->name##Nr] = 0;                                \
    return(ret);                                                        \
}                                                                       \

PUSH_AND_POP(static, xmlParserInputPtr, input)
PUSH_AND_POP(static, xmlNodePtr, node)
PUSH_AND_POP(static, xmlChar*, name)

/*
 * Macros for accessing the content. Those should be used only by the parser,
 * and not exported.
 *
 * Dirty macros, i.e. one need to make assumption on the context to use them
 *
 *   CUR_PTR return the current pointer to the xmlChar to be parsed.
 *   CUR     returns the current xmlChar value, i.e. a 8 bit value if compiled
 *           in ISO-Latin or UTF-8, and the current 16 bit value if compiled
 *           in UNICODE mode. This should be used internally by the parser
 *           only to compare to ASCII values otherwise it would break when
 *           running with UTF-8 encoding.
 *   NXT(n)  returns the n'th next xmlChar. Same as CUR is should be used only
 *           to compare on ASCII based substring.
 *   SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
 *           strings within the parser.
 *
 * Clean macros, not dependent of an ASCII context, expect UTF-8 encoding
 *
 *   CURRENT Returns the current char value, with the full decoding of
 *           UTF-8 if we are using this mode. It returns an int.
 *   NEXT    Skip to the next character, this does the proper decoding
 *           in UTF-8 mode. It also pop-up unfinished entities on the fly.
 *   COPY(to) copy one char to *to, increment CUR_PTR and to accordingly
 */

#define RAW (ctxt->token ? -1 : (*ctxt->input->cur))
#define CUR (ctxt->token ? ctxt->token : (*ctxt->input->cur))
#define SKIP(val) ctxt->nbChars += (val),ctxt->input->cur += (val)
#define NXT(val) ctxt->input->cur[(val)]
#define CUR_PTR ctxt->input->cur
#define SHRINK  xmlOldParserInputShrink(ctxt->input);                   \
    if ((*ctxt->input->cur == 0) &&                                     \
        (xmlOldParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))         \
            xmlOldPopInput(ctxt)

#define GROW  xmlOldParserInputGrow(ctxt->input, INPUT_CHUNK);          \
    if ((*ctxt->input->cur == 0) &&                                     \
        (xmlOldParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))         \
            xmlOldPopInput(ctxt)

#define SKIP_BLANKS                                                     \
    do {                                                                \
        while (IS_BLANK(CUR)) NEXT;                                     \
        while ((CUR == 0) && (ctxt->inputNr > 1))                       \
            xmlOldPopInput(ctxt);                                               \
        if (*ctxt->input->cur == '%') xmlOldParserHandlePEReference(ctxt);      \
        if (*ctxt->input->cur == '&') xmlOldParserHandleReference(ctxt);        \
    } while (IS_BLANK(CUR));

#define CURRENT (*ctxt->input->cur)
#define NEXT {                                                          \
    if (ctxt->token != 0) ctxt->token = 0;                              \
    else {                                                              \
    if ((*ctxt->input->cur == 0) &&                                     \
        (xmlOldParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) {               \
            xmlOldPopInput(ctxt);                                               \
    } else {                                                            \
        if (*(ctxt->input->cur) == '\n') {                              \
            ctxt->input->line++; ctxt->input->col = 1;                  \
        } else ctxt->input->col++;                                      \
        ctxt->input->cur++;                                             \
        ctxt->nbChars++;                                                \
        if (*ctxt->input->cur == 0)                                     \
            xmlOldParserInputGrow(ctxt->input, INPUT_CHUNK);            \
    }                                                                   \
    if (*ctxt->input->cur == '%') xmlOldParserHandlePEReference(ctxt);  \
    if (*ctxt->input->cur == '&') xmlOldParserHandleReference(ctxt);    \
}}


/************************************************************************
 *                                                                      *
 *      Commodity functions to handle entities processing               *
 *                                                                      *
 ************************************************************************/

/**
 * xmlOldPopInput:
 * @ctxt:  an XML parser context
 *
 * xmlOldPopInput: the current input pointed by ctxt->input came to an end
 *          pop it and return the next char.
 *
 * Returns the current xmlChar in the parser context
 */
static xmlChar
xmlOldPopInput(xmlParserCtxtPtr ctxt) {
    if (ctxt->inputNr == 1) return(0); /* End of main Input */
    xmlOldFreeInputStream(inputOldPop(ctxt));
    if ((*ctxt->input->cur == 0) &&
        (xmlOldParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
            return(xmlOldPopInput(ctxt));
    return(CUR);
}

/**
 * xmlOldPushInput:
 * @ctxt:  an XML parser context
 * @input:  an XML parser input fragment (entity, XML fragment ...).
 *
 * xmlOldPushInput: switch to a new input stream which is stacked on top
 *               of the previous one(s).
 */
void
xmlOldPushInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr input) {
    if (input == NULL) return;
    inputOldPush(ctxt, input);
}

/**
 * xmlOldFreeInputStream:
 * @input:  an xmlParserInputPtr
 *
 * Free up an input stream.
 */
static void
xmlOldFreeInputStream(xmlParserInputPtr input) {
    if (input == NULL) return;

    if (input->filename != NULL) xmlFree((char *) input->filename);
    if (input->directory != NULL) xmlFree((char *) input->directory);
    if ((input->free != NULL) && (input->base != NULL))
        input->free((xmlChar *) input->base);
    if (input->buf != NULL) 
        xmlFreeParserInputBuffer(input->buf);
    memset(input, -1, sizeof(xmlParserInput));
    xmlFree(input);
}

/**
 * xmlOldNewInputStream:
 * @ctxt:  an XML parser context
 *
 * Create a new input stream structure
 * Returns the new input stream or NULL
 */
static xmlParserInputPtr
xmlOldNewInputStream(xmlParserCtxtPtr ctxt) {
    xmlParserInputPtr input;

    input = (xmlParserInputPtr) xmlMalloc(sizeof(xmlParserInput));
    if (input == NULL) {
        ctxt->errNo = XML_ERR_NO_MEMORY;
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData, 
                             "malloc: couldn't allocate a new input stream\n");
        ctxt->errNo = XML_ERR_NO_MEMORY;
        return(NULL);
    }
    input->filename = NULL;
    input->directory = NULL;
    input->base = NULL;
    input->cur = NULL;
    input->buf = NULL;
    input->line = 1;
    input->col = 1;
    input->buf = NULL;
    input->free = NULL;
    input->consumed = 0;
    input->length = 0;
    return(input);
}

/**
 * xmlOldNewEntityInputStream:
 * @ctxt:  an XML parser context
 * @entity:  an Entity pointer
 *
 * Create a new input stream based on an xmlEntityPtr
 *
 * Returns the new input stream or NULL
 */
static xmlParserInputPtr
xmlOldNewEntityInputStream(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
    xmlParserInputPtr input;

    if (entity == NULL) {
        ctxt->errNo = XML_ERR_INTERNAL_ERROR;
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
              "internal: xmlOldNewEntityInputStream entity = NULL\n");
        ctxt->errNo = XML_ERR_INTERNAL_ERROR;
        return(NULL);
    }
    if (entity->content == NULL) {
        switch (entity->type) {
            case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
                ctxt->errNo = XML_ERR_UNPARSED_ENTITY;
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData,
                      "xmlNewEntityInputStream unparsed entity !\n");
                break;
            case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
            case XML_EXTERNAL_PARAMETER_ENTITY:
                return(xmlLoadExternalEntity((char *) entity->SystemID,
                       (char *) entity->ExternalID, ctxt));
            case XML_INTERNAL_GENERAL_ENTITY:
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData,
          "Internal entity %s without content !\n", entity->name);
                break;
            case XML_INTERNAL_PARAMETER_ENTITY:
                ctxt->errNo = XML_ERR_INTERNAL_ERROR;
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData,
          "Internal parameter entity %s without content !\n", entity->name);
                break;
            case XML_INTERNAL_PREDEFINED_ENTITY:
                ctxt->errNo = XML_ERR_INTERNAL_ERROR;
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData,
              "Predefined entity %s without content !\n", entity->name);
                break;
        }
        return(NULL);
    }
    input = xmlOldNewInputStream(ctxt);
    if (input == NULL) {
        return(NULL);
    }
    input->filename = (char *) entity->SystemID; /* TODO !!! char <- xmlChar */
    input->base = entity->content;
    input->cur = entity->content;
    input->length = entity->length;
    return(input);
}

/**
 * xmlOldNewStringInputStream:
 * @ctxt:  an XML parser context
 * @buffer:  an memory buffer
 *
 * Create a new input stream based on a memory buffer.
 * Returns the new input stream
 */
static xmlParserInputPtr
xmlOldNewStringInputStream(xmlParserCtxtPtr ctxt, const xmlChar *buffer) {
    xmlParserInputPtr input;

    if (buffer == NULL) {
        ctxt->errNo = XML_ERR_INTERNAL_ERROR;
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
              "internal: xmlOldNewStringInputStream string = NULL\n");
        return(NULL);
    }
    input = xmlOldNewInputStream(ctxt);
    if (input == NULL) {
        return(NULL);
    }
    input->base = buffer;
    input->cur = buffer;
    input->length = xmlStrlen(buffer);
    return(input);
}

/**
 * xmlOldNewInputFromFile:
 * @ctxt:  an XML parser context
 * @filename:  the filename to use as entity
 *
 * Create a new input stream based on a file.
 *
 * Returns the new input stream or NULL in case of error
 */
static xmlParserInputPtr
xmlOldNewInputFromFile(xmlParserCtxtPtr ctxt, const char *filename) {
    xmlParserInputBufferPtr buf;
    xmlParserInputPtr inputStream;
    char *directory = NULL;

    if (ctxt == NULL) return(NULL);
    buf = xmlParserInputBufferCreateFilename(filename, XML_CHAR_ENCODING_NONE);
    if (buf == NULL) {
        char name[XML_PARSER_BIG_BUFFER_SIZE];

        if ((ctxt->input != NULL) && (ctxt->input->directory != NULL)) {
#ifdef WIN32
            sprintf(name, "%s\\%s", ctxt->input->directory, filename);
#else
            sprintf(name, "%s/%s", ctxt->input->directory, filename);
#endif
            buf = xmlParserInputBufferCreateFilename(name,
                                                     XML_CHAR_ENCODING_NONE);
            if (buf != NULL)
                directory = xmlParserGetDirectory(name);
        }
        if ((buf == NULL) && (ctxt->directory != NULL)) {
#ifdef WIN32
            sprintf(name, "%s\\%s", ctxt->directory, filename);
#else
            sprintf(name, "%s/%s", ctxt->directory, filename);
#endif
            buf = xmlParserInputBufferCreateFilename(name,
                                                     XML_CHAR_ENCODING_NONE);
            if (buf != NULL)
                directory = xmlParserGetDirectory(name);
        }
        if (buf == NULL)
            return(NULL);
    }
    if (directory == NULL)
        directory = xmlParserGetDirectory(filename);

    inputStream = xmlOldNewInputStream(ctxt);
    if (inputStream == NULL) {
        if (directory != NULL) xmlFree((char *) directory);
        return(NULL);
    }

    inputStream->filename = xmlMemStrdup(filename);
    inputStream->directory = directory;
    inputStream->buf = buf;

    inputStream->base = inputStream->buf->buffer->content;
    inputStream->cur = inputStream->buf->buffer->content;
    if ((ctxt->directory == NULL) && (directory != NULL))
        ctxt->directory = (char *) xmlStrdup((const xmlChar *) directory);
    return(inputStream);
}

/************************************************************************
 *                                                                      *
 *              Commodity functions to handle entities                  *
 *                                                                      *
 ************************************************************************/

static void xmlOldParserHandleReference(xmlParserCtxtPtr ctxt);
static void xmlOldParserHandlePEReference(xmlParserCtxtPtr ctxt);
xmlEntityPtr xmlOldParseStringPEReference(xmlParserCtxtPtr ctxt,
                                       const xmlChar **str);

/**
 * xmlOldParseCharRef:
 * @ctxt:  an XML parser context
 *
 * parse Reference declarations
 *
 * [66] CharRef ::= '&#' [0-9]+ ';' |
 *                  '&#x' [0-9a-fA-F]+ ';'
 *
 * [ WFC: Legal Character ]
 * Characters referred to using character references must match the
 * production for Char. 
 *
 * Returns the value parsed (as an int), 0 in case of error
 */
static int
xmlOldParseCharRef(xmlParserCtxtPtr ctxt) {
    int val = 0;

    if (ctxt->token != 0) {
        val = ctxt->token;
        ctxt->token = 0;
        return(val);
    }
    if ((CUR == '&') && (NXT(1) == '#') &&
        (NXT(2) == 'x')) {
        SKIP(3);
        while (CUR != ';') {
            if ((CUR >= '0') && (CUR <= '9')) 
                val = val * 16 + (CUR - '0');
            else if ((CUR >= 'a') && (CUR <= 'f'))
                val = val * 16 + (CUR - 'a') + 10;
            else if ((CUR >= 'A') && (CUR <= 'F'))
                val = val * 16 + (CUR - 'A') + 10;
            else {
                ctxt->errNo = XML_ERR_INVALID_HEX_CHARREF;
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData, 
                         "xmlParseCharRef: invalid hexadecimal value\n");
                ctxt->wellFormed = 0;
                val = 0;
                break;
            }
            NEXT;
        }
        if (CUR == ';')
            SKIP(1); /* on purpose to avoid reentrancy problems with NEXT */
    } else if  ((CUR == '&') && (NXT(1) == '#')) {
        SKIP(2);
        while (CUR != ';') {
            if ((CUR >= '0') && (CUR <= '9')) 
                val = val * 10 + (CUR - '0');
            else {
                ctxt->errNo = XML_ERR_INVALID_DEC_CHARREF;
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData, 
                         "xmlParseCharRef: invalid decimal value\n");
                ctxt->wellFormed = 0;
                val = 0;
                break;
            }
            NEXT;
        }
        if (CUR == ';')
            SKIP(1); /* on purpose to avoid reentrancy problems with NEXT */
    } else {
        ctxt->errNo = XML_ERR_INVALID_CHARREF;
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
               "xmlParseCharRef: invalid value\n");
        ctxt->wellFormed = 0;
    }

    /*
     * [ WFC: Legal Character ]
     * Characters referred to using character references must match the
     * production for Char. 
     */
    if (IS_CHAR(val)) {
        return(val);
    } else {
        ctxt->errNo = XML_ERR_INVALID_CHAR;
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData, "CharRef: invalid xmlChar value %d\n",
                             val);
        ctxt->wellFormed = 0;
    }
    return(0);
}

/**
 * xmlOldParseStringCharRef:
 * @ctxt:  an XML parser context
 * @str:  a pointer to an index in the string
 *
 * parse Reference declarations, variant parsing from a string rather
 * than an an input flow.
 *
 * [66] CharRef ::= '&#' [0-9]+ ';' |
 *                  '&#x' [0-9a-fA-F]+ ';'
 *
 * [ WFC: Legal Character ]
 * Characters referred to using character references must match the
 * production for Char. 
 *
 * Returns the value parsed (as an int), 0 in case of error, str will be
 *         updated to the current value of the index
 */
static int
xmlOldParseStringCharRef(xmlParserCtxtPtr ctxt, const xmlChar **str) {
    const xmlChar *ptr;
    xmlChar cur;
    int val = 0;

    if ((str == NULL) || (*str == NULL)) return(0);
    ptr = *str;
    cur = *ptr;
    if ((cur == '&') && (ptr[1] == '#') && (ptr[2] == 'x')) {
        ptr += 3;
        cur = *ptr;
        while (cur != ';') {
            if ((cur >= '0') && (cur <= '9')) 
                val = val * 16 + (cur - '0');
            else if ((cur >= 'a') && (cur <= 'f'))
                val = val * 16 + (cur - 'a') + 10;
            else if ((cur >= 'A') && (cur <= 'F'))
                val = val * 16 + (cur - 'A') + 10;
            else {
                ctxt->errNo = XML_ERR_INVALID_HEX_CHARREF;
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData, 
                         "xmlParseCharRef: invalid hexadecimal value\n");
                ctxt->wellFormed = 0;
                val = 0;
                break;
            }
            ptr++;
            cur = *ptr;
        }
        if (cur == ';')
            ptr++;
    } else if  ((cur == '&') && (ptr[1] == '#')){
        ptr += 2;
        cur = *ptr;
        while (cur != ';') {
            if ((cur >= '0') && (cur <= '9')) 
                val = val * 10 + (cur - '0');
            else {
                ctxt->errNo = XML_ERR_INVALID_DEC_CHARREF;
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData, 
                         "xmlParseCharRef: invalid decimal value\n");
                ctxt->wellFormed = 0;
                val = 0;
                break;
            }
            ptr++;
            cur = *ptr;
        }
        if (cur == ';')
            ptr++;
    } else {
        ctxt->errNo = XML_ERR_INVALID_CHARREF;
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
               "xmlParseCharRef: invalid value\n");
        ctxt->wellFormed = 0;
        return(0);
    }
    *str = ptr;

    /*
     * [ WFC: Legal Character ]
     * Characters referred to using character references must match the
     * production for Char. 
     */
    if (IS_CHAR(val)) {
        return(val);
    } else {
        ctxt->errNo = XML_ERR_INVALID_CHAR;
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
                             "CharRef: invalid xmlChar value %d\n", val);
        ctxt->wellFormed = 0;
    }
    return(0);
}

/**
 * xmlOldParserHandleReference:
 * @ctxt:  the parser context
 * 
 * [67] Reference ::= EntityRef | CharRef
 *
 * [68] EntityRef ::= '&' Name ';'
 *
 * [ WFC: Entity Declared ]
 * the Name given in the entity reference must match that in an entity
 * declaration, except that well-formed documents need not declare any
 * of the following entities: amp, lt, gt, apos, quot. 
 *
 * [ WFC: Parsed Entity ]
 * An entity reference must not contain the name of an unparsed entity
 *
 * [66] CharRef ::= '&#' [0-9]+ ';' |
 *                  '&#x' [0-9a-fA-F]+ ';'
 *
 * A PEReference may have been detectect in the current input stream
 * the handling is done accordingly to 
 *      http://www.w3.org/TR/REC-xml#entproc
 */
static void
xmlOldParserHandleReference(xmlParserCtxtPtr ctxt) {
    xmlParserInputPtr input;
    xmlChar *name;
    xmlEntityPtr ent = NULL;

    if (ctxt->token != 0) {
        return;
    }   
    if (CUR != '&') return;
    GROW;
    if ((CUR == '&') && (NXT(1) == '#')) {
        switch(ctxt->instate) {
            case XML_PARSER_ENTITY_DECL:
            case XML_PARSER_PI:
            case XML_PARSER_CDATA_SECTION:
            case XML_PARSER_COMMENT:
                /* we just ignore it there */
                return;
            case XML_PARSER_START_TAG:
                return;
            case XML_PARSER_END_TAG:
                return;
            case XML_PARSER_EOF:
                ctxt->errNo = XML_ERR_CHARREF_AT_EOF;
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData, "CharRef at EOF\n");
                ctxt->wellFormed = 0;
                return;
            case XML_PARSER_PROLOG:
            case XML_PARSER_START:
            case XML_PARSER_MISC:
                ctxt->errNo = XML_ERR_CHARREF_IN_PROLOG;
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData, "CharRef in prolog!\n");
                ctxt->wellFormed = 0;
                return;
            case XML_PARSER_EPILOG:
                ctxt->errNo = XML_ERR_CHARREF_IN_EPILOG;
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData, "CharRef in epilog!\n");
                ctxt->wellFormed = 0;
                return;
            case XML_PARSER_DTD:
                ctxt->errNo = XML_ERR_CHARREF_IN_DTD;
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData, 
                           "CharRef are forbiden in DTDs!\n");
                ctxt->wellFormed = 0;
                return;
            case XML_PARSER_ENTITY_VALUE:
                /*
                 * NOTE: in the case of entity values, we don't do the
                 *       substitution here since we need the literal
                 *       entity value to be able to save the internal
                 *       subset of the document.
                 *       This will be handled by xmlOldDecodeEntities
                 */
                return;
            case XML_PARSER_CONTENT:
            case XML_PARSER_ATTRIBUTE_VALUE:
                /* !!! this may not be Ok for UTF-8, multibyte sequence */
                ctxt->token = xmlOldParseCharRef(ctxt);
                return;
        }
        return;
    }

    switch(ctxt->instate) {
        case XML_PARSER_CDATA_SECTION:
            return;
        case XML_PARSER_PI:
        case XML_PARSER_COMMENT:
            return;
        case XML_PARSER_START_TAG:
            return;
        case XML_PARSER_END_TAG:
            return;
        case XML_PARSER_EOF:
            ctxt->errNo = XML_ERR_ENTITYREF_AT_EOF;
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData, "Reference at EOF\n");
            ctxt->wellFormed = 0;
            return;
        case XML_PARSER_PROLOG:
        case XML_PARSER_START:
        case XML_PARSER_MISC:
            ctxt->errNo = XML_ERR_ENTITYREF_IN_PROLOG;
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData, "Reference in prolog!\n");
            ctxt->wellFormed = 0;
            return;
        case XML_PARSER_EPILOG:
            ctxt->errNo = XML_ERR_ENTITYREF_IN_EPILOG;
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData, "Reference in epilog!\n");
            ctxt->wellFormed = 0;
            return;
        case XML_PARSER_ENTITY_VALUE:
            /*
             * NOTE: in the case of entity values, we don't do the
             *       substitution here since we need the literal
             *       entity value to be able to save the internal
             *       subset of the document.
             *       This will be handled by xmlOldDecodeEntities
             */
            return;
        case XML_PARSER_ATTRIBUTE_VALUE:
            /*
             * NOTE: in the case of attributes values, we don't do the
             *       substitution here unless we are in a mode where
             *       the parser is explicitely asked to substitute
             *       entities. The SAX callback is called with values
             *       without entity substitution.
             *       This will then be handled by xmlOldDecodeEntities
             */
            return;
        case XML_PARSER_ENTITY_DECL:
            /*
             * we just ignore it there
             * the substitution will be done once the entity is referenced
             */
            return;
        case XML_PARSER_DTD:
            ctxt->errNo = XML_ERR_ENTITYREF_IN_DTD;
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData, 
                       "Entity references are forbiden in DTDs!\n");
            ctxt->wellFormed = 0;
            return;
        case XML_PARSER_CONTENT:
            return;
    }

    NEXT;
    name = xmlOldScanName(ctxt);
    if (name == NULL) {
        ctxt->errNo = XML_ERR_ENTITYREF_NO_NAME;
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData, "Entity reference: no name\n");
        ctxt->wellFormed = 0;
        ctxt->token = '&';
        return;
    }
    if (NXT(xmlStrlen(name)) != ';') {
        ctxt->errNo = XML_ERR_ENTITYREF_SEMICOL_MISSING;
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData, 
                             "Entity reference: ';' expected\n");
        ctxt->wellFormed = 0;
        ctxt->token = '&';
        xmlFree(name);
        return;
    }
    SKIP(xmlStrlen(name) + 1);
    if (ctxt->sax != NULL) {
        if (ctxt->sax->getEntity != NULL)
            ent = ctxt->sax->getEntity(ctxt->userData, name);
    }

    /*
     * [ WFC: Entity Declared ]
     * the Name given in the entity reference must match that in an entity
     * declaration, except that well-formed documents need not declare any
     * of the following entities: amp, lt, gt, apos, quot. 
     */
    if (ent == NULL)
        ent = xmlGetPredefinedEntity(name);
    if (ent == NULL) {
        ctxt->errNo = XML_ERR_UNDECLARED_ENTITY;
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData, 
                             "Entity reference: entity %s not declared\n",
                             name);
        ctxt->wellFormed = 0;
        xmlFree(name);
        return;
    }

    /*
     * [ WFC: Parsed Entity ]
     * An entity reference must not contain the name of an unparsed entity
     */
    if (ent->type == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
        ctxt->errNo = XML_ERR_UNPARSED_ENTITY;
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData, 
                         "Entity reference to unparsed entity %s\n", name);
        ctxt->wellFormed = 0;
    }

    if (ent->type == XML_INTERNAL_PREDEFINED_ENTITY) {
        ctxt->token = ent->content[0];
        xmlFree(name);
        return;
    }
    input = xmlOldNewEntityInputStream(ctxt, ent);
    xmlOldPushInput(ctxt, input);
    xmlFree(name);
    return;
}

/**
 * xmlOldParserHandlePEReference:
 * @ctxt:  the parser context
 * 
 * [69] PEReference ::= '%' Name ';'
 *
 * [ WFC: No Recursion ]
 * TODO A parsed entity must not contain a recursive
 * reference to itself, either directly or indirectly. 
 *
 * [ WFC: Entity Declared ]
 * In a document without any DTD, a document with only an internal DTD
 * subset which contains no parameter entity references, or a document
 * with "standalone='yes'", ...  ... The declaration of a parameter
 * entity must precede any reference to it...
 *
 * [ VC: Entity Declared ]
 * In a document with an external subset or external parameter entities
 * with "standalone='no'", ...  ... The declaration of a parameter entity
 * must precede any reference to it...
 *
 * [ WFC: In DTD ]
 * Parameter-entity references may only appear in the DTD.
 * NOTE: misleading but this is handled.
 *
 * A PEReference may have been detected in the current input stream
 * the handling is done accordingly to 
 *      http://www.w3.org/TR/REC-xml#entproc
 * i.e. 
 *   - Included in literal in entity values
 *   - Included as Paraemeter Entity reference within DTDs
 */
static void
xmlOldParserHandlePEReference(xmlParserCtxtPtr ctxt) {
    xmlChar *name;
    xmlEntityPtr entity = NULL;
    xmlParserInputPtr input;

    if (ctxt->token != 0) {
        return;
    }   
    if (CUR != '%') return;
    switch(ctxt->instate) {
        case XML_PARSER_CDATA_SECTION:
            return;
        case XML_PARSER_COMMENT:
            return;
        case XML_PARSER_START_TAG:
            return;
        case XML_PARSER_END_TAG:
            return;
        case XML_PARSER_EOF:
            ctxt->errNo = XML_ERR_PEREF_AT_EOF;
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData, "PEReference at EOF\n");
            ctxt->wellFormed = 0;
            return;
        case XML_PARSER_PROLOG:
        case XML_PARSER_START:
        case XML_PARSER_MISC:
            ctxt->errNo = XML_ERR_PEREF_IN_PROLOG;
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData, "PEReference in prolog!\n");
            ctxt->wellFormed = 0;
            return;
        case XML_PARSER_ENTITY_DECL:
        case XML_PARSER_CONTENT:
        case XML_PARSER_ATTRIBUTE_VALUE:
        case XML_PARSER_PI:
            /* we just ignore it there */
            return;
        case XML_PARSER_EPILOG:
            ctxt->errNo = XML_ERR_PEREF_IN_EPILOG;
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData, "PEReference in epilog!\n");
            ctxt->wellFormed = 0;
            return;
        case XML_PARSER_ENTITY_VALUE:
            /*
             * NOTE: in the case of entity values, we don't do the
             *       substitution here since we need the literal
             *       entity value to be able to save the internal
             *       subset of the document.
             *       This will be handled by xmlOldDecodeEntities
             */
            return;
        case XML_PARSER_DTD:
            /*
             * [WFC: Well-Formedness Constraint: PEs in Internal Subset]
             * In the internal DTD subset, parameter-entity references
             * can occur only where markup declarations can occur, not
             * within markup declarations.
             * In that case this is handled in xmlOldParseMarkupDecl
             */
            if ((ctxt->external == 0) && (ctxt->inputNr == 1))
                return;
    }

    NEXT;
    name = xmlOldParseName(ctxt);
    if (name == NULL) {
        ctxt->errNo = XML_ERR_PEREF_NO_NAME;
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData, "xmlHandlePEReference: no name\n");
        ctxt->wellFormed = 0;
    } else {
        if (CUR == ';') {
            NEXT;
            if ((ctxt->sax != NULL) && (ctxt->sax->getParameterEntity != NULL))
                entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
            if (entity == NULL) {
                
                /*
                 * [ WFC: Entity Declared ]
                 * In a document without any DTD, a document with only an
                 * internal DTD subset which contains no parameter entity
                 * references, or a document with "standalone='yes'", ...
                 * ... The declaration of a parameter entity must precede
                 * any reference to it...
                 */
                if ((ctxt->standalone == 1) ||
                    ((ctxt->hasExternalSubset == 0) &&
                     (ctxt->hasPErefs == 0))) {
                    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                        ctxt->sax->error(ctxt->userData,
                         "PEReference: %%%s; not found\n", name);
                    ctxt->wellFormed = 0;
                } else {
                    /*
                     * [ VC: Entity Declared ]
                     * In a document with an external subset or external
                     * parameter entities with "standalone='no'", ...
                     * ... The declaration of a parameter entity must precede
                     * any reference to it...
                     */
                    if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
                        ctxt->sax->warning(ctxt->userData,
                         "PEReference: %%%s; not found\n", name);
                    ctxt->valid = 0;
                }
            } else {
                if ((entity->type == XML_INTERNAL_PARAMETER_ENTITY) ||
                    (entity->type == XML_EXTERNAL_PARAMETER_ENTITY)) {
                    /*
                     * TODO !!!! handle the extra spaces added before and after
                     * c.f. http://www.w3.org/TR/REC-xml#as-PE
                     * TODO !!!! Avoid quote processing in parameters value
                     * c.f. http://www.w3.org/TR/REC-xml#inliteral
                     */
                    input = xmlOldNewEntityInputStream(ctxt, entity);
                    xmlOldPushInput(ctxt, input);
                } else {
                    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                        ctxt->sax->error(ctxt->userData,
                         "xmlHandlePEReference: %s is not a parameter entity\n",
                                         name);
                    ctxt->wellFormed = 0;
                }
            }
        } else {
            ctxt->errNo = XML_ERR_PEREF_SEMICOL_MISSING;
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
                                 "xmlHandlePEReference: expecting ';'\n");
            ctxt->wellFormed = 0;
        }
        xmlFree(name);
    }
}

/*
 * Macro used to grow the current buffer.
 */
#define growBuffer(buffer) {                                            \
    buffer##_size *= 2;                                                 \
    buffer = (xmlChar *)                                                \
                xmlRealloc(buffer, buffer##_size * sizeof(xmlChar));    \
    if (buffer == NULL) {                                               \
        perror("realloc failed");                                       \
        return(NULL);                                                   \
    }                                                                   \
}

/**
 * xmlOldDecodeEntities:
 * @ctxt:  the parser context
 * @what:  combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF
 * @len:  the len to decode (in bytes !), -1 for no size limit
 * @end:  an end marker xmlChar, 0 if none
 * @end2:  an end marker xmlChar, 0 if none
 * @end3:  an end marker xmlChar, 0 if none
 * 
 * [67] Reference ::= EntityRef | CharRef
 *
 * [69] PEReference ::= '%' Name ';'
 *
 * Returns A newly allocated string with the substitution done. The caller
 *      must deallocate it !
 */
static xmlChar *
xmlOldDecodeEntities(xmlParserCtxtPtr ctxt, int len, int what,
                  xmlChar end, xmlChar  end2, xmlChar end3) {
    xmlChar *buffer = NULL;
    int buffer_size = 0;
    xmlChar *out = NULL;

    xmlChar *current = NULL;
    xmlEntityPtr ent;
    int nbchars = 0;
    unsigned int max = (unsigned int) len;
    xmlChar cur;

    /*
     * allocate a translation buffer.
     */
    buffer_size = XML_PARSER_BIG_BUFFER_SIZE;
    buffer = (xmlChar *) xmlMalloc(buffer_size * sizeof(xmlChar));
    if (buffer == NULL) {
        perror("xmlDecodeEntities: malloc failed");
        return(NULL);
    }
    out = buffer;

    /*
     * Ok loop until we reach one of the ending char or a size limit.
     */
    cur = CUR;
    while ((nbchars < max) && (cur != end) &&
           (cur != end2) && (cur != end3)) {

        if (cur == 0) break;
        if ((cur == '&') && (NXT(1) == '#')) {
            int val = xmlOldParseCharRef(ctxt);
            *out++ = val;
            nbchars += 3; 
        } else if ((cur == '&') && (what & XML_SUBSTITUTE_REF)) {
            ent = xmlOldParseEntityRef(ctxt);
            if ((ent != NULL) && 
                (ctxt->replaceEntities != 0)) {
                current = ent->content;
                while (*current != 0) {
                    *out++ = *current++;
                    if (out - buffer > buffer_size - XML_PARSER_BUFFER_SIZE) {
                        int index = out - buffer;

                        growBuffer(buffer);
                        out = &buffer[index];
                    }
                }
                nbchars += 3 + xmlStrlen(ent->name);
            } else if (ent != NULL) {
                int i = xmlStrlen(ent->name);
                const xmlChar *cur = ent->name;

                nbchars += i + 2;
                *out++ = '&';
                if (out - buffer > buffer_size - i - XML_PARSER_BUFFER_SIZE) {
                    int index = out - buffer;

                    growBuffer(buffer);
                    out = &buffer[index];
                }
                for (;i > 0;i--)
                    *out++ = *cur++;
                *out++ = ';';
            }
        } else if (cur == '%' && (what & XML_SUBSTITUTE_PEREF)) {
            /*
             * a PEReference induce to switch the entity flow,
             * we break here to flush the current set of chars
             * parsed if any. We will be called back later.
             */
            if (nbchars != 0) break;

            xmlOldParsePEReference(ctxt);

            /*
             * Pop-up of finished entities.
             */
            while ((CUR == 0) && (ctxt->inputNr > 1))
                xmlOldPopInput(ctxt);

            break;
        } else {
            /*  invalid for UTF-8 , use COPY(out); !!!!!! */
            *out++ = cur;
            nbchars++;
            if (out - buffer > buffer_size - XML_PARSER_BUFFER_SIZE) {
              int index = out - buffer;
              
              growBuffer(buffer);
              out = &buffer[index];
            }
            NEXT;
        }
        cur = CUR;
    }
    *out++ = 0;
    return(buffer);
}

/**
 * xmlOldStringDecodeEntities:
 * @ctxt:  the parser context
 * @str:  the input string
 * @what:  combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF
 * @end:  an end marker xmlChar, 0 if none
 * @end2:  an end marker xmlChar, 0 if none
 * @end3:  an end marker xmlChar, 0 if none
 * 
 * [67] Reference ::= EntityRef | CharRef
 *
 * [69] PEReference ::= '%' Name ';'
 *
 * Returns A newly allocated string with the substitution done. The caller
 *      must deallocate it !
 */
static xmlChar *
xmlOldStringDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int what,
                        xmlChar end, xmlChar  end2, xmlChar end3) {
    xmlChar *buffer = NULL;
    int buffer_size = 0;
    xmlChar *out = NULL;

    xmlChar *current = NULL;
    xmlEntityPtr ent;
    xmlChar cur;

    /*
     * allocate a translation buffer.
     */
    buffer_size = XML_PARSER_BIG_BUFFER_SIZE;
    buffer = (xmlChar *) xmlMalloc(buffer_size * sizeof(xmlChar));
    if (buffer == NULL) {
        perror("xmlStringDecodeEntities: malloc failed");
        return(NULL);
    }
    out = buffer;

    /*
     * Ok loop until we reach one of the ending char or a size limit.
     */
    cur = *str;
    while ((cur != 0) && (cur != end) &&
           (cur != end2) && (cur != end3)) {

        if (cur == 0) break;
        if ((cur == '&') && (str[1] == '#')) {
            int val = xmlOldParseStringCharRef(ctxt, &str);
            if (val != 0)
                *out++ = val;
        } else if ((cur == '&') && (what & XML_SUBSTITUTE_REF)) {
            ent = xmlOldParseStringEntityRef(ctxt, &str);
            if ((ent != NULL) && 
                (ctxt->replaceEntities != 0)) {
                current = ent->content;
                while (*current != 0) {
                    *out++ = *current++;
                    if (out - buffer > buffer_size - XML_PARSER_BUFFER_SIZE) {
                        int index = out - buffer;

                        growBuffer(buffer);
                        out = &buffer[index];
                    }
                }
            } else if (ent != NULL) {
                int i = xmlStrlen(ent->name);
                const xmlChar *cur = ent->name;

                *out++ = '&';
                if (out - buffer > buffer_size - i - XML_PARSER_BUFFER_SIZE) {
                    int index = out - buffer;

                    growBuffer(buffer);
                    out = &buffer[index];
                }
                for (;i > 0;i--)
                    *out++ = *cur++;
                *out++ = ';';
            }
        } else if (cur == '%' && (what & XML_SUBSTITUTE_PEREF)) {
            ent = xmlOldParseStringPEReference(ctxt, &str);
            if (ent != NULL) {
                current = ent->content;
                while (*current != 0) {
                    *out++ = *current++;
                    if (out - buffer > buffer_size - XML_PARSER_BUFFER_SIZE) {
                        int index = out - buffer;

                        growBuffer(buffer);
                        out = &buffer[index];
                    }
                }
            }
        } else {
            /*  invalid for UTF-8 , use COPY(out); !!!!!! */
            *out++ = cur;
            if (out - buffer > buffer_size - XML_PARSER_BUFFER_SIZE) {
              int index = out - buffer;
              
              growBuffer(buffer);
              out = &buffer[index];
            }
            str++;
        }
        cur = *str;
    }
    *out = 0;
    return(buffer);
}

/************************************************************************
 *                                                                      *
 *              Commodity functions, cleanup needed ?                   *
 *                                                                      *
 ************************************************************************/

/**
 * areBlanksOld:
 * @ctxt:  an XML parser context
 * @str:  a xmlChar *
 * @len:  the size of @str
 *
 * Is this a sequence of blank chars that one can ignore ?
 *
 * Returns 1 if ignorable 0 otherwise.
 */

static int areBlanksOld(xmlParserCtxtPtr ctxt, const xmlChar *str, int len) {
    int i, ret;
    xmlNodePtr lastChild;

    /*
     * Check that the string is made of blanks
     */
    for (i = 0;i < len;i++)
        if (!(IS_BLANK(str[i]))) return(0);

    /*
     * Look if the element is mixed content in the Dtd if available
     */
    if (ctxt->myDoc != NULL) {
        ret = xmlIsMixedElement(ctxt->myDoc, ctxt->node->name);
        if (ret == 0) return(1);
        if (ret == 1) return(0);
    }

    /*
     * Do we allow an heuristic on white space
     */
    if (ctxt->keepBlanks)
        return(0);
    if (CUR != '<') return(0);
    if (ctxt->node == NULL) return(0);
    if ((ctxt->node->childs == NULL) &&
        (CUR == '<') && (NXT(1) == '/')) return(0);

    lastChild = xmlGetLastChild(ctxt->node);
    if (lastChild == NULL) {
        if (ctxt->node->content != NULL) return(0);
    } else if (xmlNodeIsText(lastChild))
        return(0);
    else if ((ctxt->node->childs != NULL) &&
             (xmlNodeIsText(ctxt->node->childs)))
        return(0);
    return(1);
}

/**
 * xmlOldHandleEntity:
 * @ctxt:  an XML parser context
 * @entity:  an XML entity pointer.
 *
 * Default handling of defined entities, when should we define a new input
 * stream ? When do we just handle that as a set of chars ?
 *
 * OBSOLETE: to be removed at some point.
 */

static void
xmlOldHandleEntity(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
    int len;
    xmlParserInputPtr input;

    if (entity->content == NULL) {
        ctxt->errNo = XML_ERR_INTERNAL_ERROR;
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData, "xmlHandleEntity %s: content == NULL\n",
                       entity->name);
        ctxt->wellFormed = 0;
        return;
    }
    len = xmlStrlen(entity->content);
    if (len <= 2) goto handle_as_char;

    /*
     * Redefine its content as an input stream.
     */
    input = xmlOldNewEntityInputStream(ctxt, entity);
    xmlOldPushInput(ctxt, input);
    return;

handle_as_char:
    /*
     * Just handle the content as a set of chars.
     */
    if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL))
        ctxt->sax->characters(ctxt->userData, entity->content, len);

}

/************************************************************************
 *                                                                      *
 *              Extra stuff for namespace support                       *
 *      Relates to http://www.w3.org/TR/WD-xml-names                    *
 *                                                                      *
 ************************************************************************/

/**
 * xmlOldNamespaceParseNCName:
 * @ctxt:  an XML parser context
 *
 * parse an XML namespace name.
 *
 * [NS 3] NCName ::= (Letter | '_') (NCNameChar)*
 *
 * [NS 4] NCNameChar ::= Letter | Digit | '.' | '-' | '_' |
 *                       CombiningChar | Extender
 *
 * Returns the namespace name or NULL
 */

static xmlChar *
xmlOldNamespaceParseNCName(xmlParserCtxtPtr ctxt) {
    xmlChar buf[XML_MAX_NAMELEN];
    int len = 0;

    if (!IS_LETTER(CUR) && (CUR != '_')) return(NULL);

    while ((IS_LETTER(CUR)) || (IS_DIGIT(CUR)) ||
           (CUR == '.') || (CUR == '-') ||
           (CUR == '_') ||
           (IS_COMBINING(CUR)) ||
           (IS_EXTENDER(CUR))) {
        buf[len++] = CUR;
        NEXT;
        if (len >= XML_MAX_NAMELEN) {
            fprintf(stderr, 
               "xmlNamespaceParseNCName: reached XML_MAX_NAMELEN limit\n");
            while ((IS_LETTER(CUR)) || (IS_DIGIT(CUR)) ||
                   (CUR == '.') || (CUR == '-') ||
                   (CUR == '_') ||
                   (IS_COMBINING(CUR)) ||
                   (IS_EXTENDER(CUR)))
                 NEXT;
            break;
        }
    }
    return(xmlStrndup(buf, len));
}

/**
 * xmlOldNamespaceParseQName:
 * @ctxt:  an XML parser context
 * @prefix:  a xmlChar ** 
 *
 * parse an XML qualified name
 *
 * [NS 5] QName ::= (Prefix ':')? LocalPart
 *
 * [NS 6] Prefix ::= NCName
 *
 * [NS 7] LocalPart ::= NCName
 *
 * Returns the local part, and prefix is updated
 *   to get the Prefix if any.
 */

static xmlChar *
xmlOldNamespaceParseQName(xmlParserCtxtPtr ctxt, xmlChar **prefix) {
    xmlChar *ret = NULL;

    *prefix = NULL;
    ret = xmlOldNamespaceParseNCName(ctxt);
    if (CUR == ':') {
        *prefix = ret;
        NEXT;
        ret = xmlOldNamespaceParseNCName(ctxt);
    }

    return(ret);
}

/**
 * xmlOldParseQuotedString:
 * @ctxt:  an XML parser context
 *
 * [OLD] Parse and return a string between quotes or doublequotes
 * To be removed at next drop of binary compatibility
 *
 * Returns the string parser or NULL.
 */
static xmlChar *
xmlOldParseQuotedString(xmlParserCtxtPtr ctxt) {
    xmlChar *buf = NULL;
    int len = 0;
    int size = XML_PARSER_BUFFER_SIZE;
    xmlChar c;

    buf = (xmlChar *) xmlMalloc(size * sizeof(xmlChar));
    if (buf == NULL) {
        fprintf(stderr, "malloc of %d byte failed\n", size);
        return(NULL);
    }
    if (CUR == '"') {
        NEXT;
        c = CUR;
        while (IS_CHAR(c) && (c != '"')) {
            if (len + 1 >= size) {
                size *= 2;
                buf = xmlRealloc(buf, size * sizeof(xmlChar));
                if (buf == NULL) {
                    fprintf(stderr, "realloc of %d byte failed\n", size);
                    return(NULL);
                }
            }
            buf[len++] = c;
            NEXT;
            c = CUR;
        }
        if (c != '"') {
            ctxt->errNo = XML_ERR_STRING_NOT_CLOSED;
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData, 
                                 "String not closed \"%.50s\"\n", buf);
            ctxt->wellFormed = 0;
        } else {
            NEXT;
        }
    } else if (CUR == '\''){
        NEXT;
        c = CUR;
        while (IS_CHAR(c) && (c != '\'')) {
            if (len + 1 >= size) {
                size *= 2;
                buf = xmlRealloc(buf, size * sizeof(xmlChar));
                if (buf == NULL) {
                    fprintf(stderr, "realloc of %d byte failed\n", size);
                    return(NULL);
                }
            }
            buf[len++] = c;
            NEXT;
            c = CUR;
        }
        if (CUR != '\'') {
            ctxt->errNo = XML_ERR_STRING_NOT_CLOSED;
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
                                 "String not closed \"%.50s\"\n", buf);
            ctxt->wellFormed = 0;
        } else {
            NEXT;
        }
    }
    return(buf);
}

/**
 * xmlOldParseNamespace:
 * @ctxt:  an XML parser context
 *
 * [OLD] xmlOldParseNamespace: parse specific PI '<?namespace ...' constructs.
 *
 * This is what the older xml-name Working Draft specified, a bunch of
 * other stuff may still rely on it, so support is still here as
 * if it was declared on the root of the Tree:-(
 *
 * To be removed at next drop of binary compatibility
 */

static void
xmlOldParseNamespace(xmlParserCtxtPtr ctxt) {
    xmlChar *href = NULL;
    xmlChar *prefix = NULL;
    int garbage = 0;

    /*
     * We just skipped "namespace" or "xml:namespace"
     */
    SKIP_BLANKS;

    while (IS_CHAR(CUR) && (CUR != '>')) {
        /*
         * We can have "ns" or "prefix" attributes
         * Old encoding as 'href' or 'AS' attributes is still supported
         */
        if ((CUR == 'n') && (NXT(1) == 's')) {
            garbage = 0;
            SKIP(2);
            SKIP_BLANKS;

            if (CUR != '=') continue;
            NEXT;
            SKIP_BLANKS;

            href = xmlOldParseQuotedString(ctxt);
            SKIP_BLANKS;
        } else if ((CUR == 'h') && (NXT(1) == 'r') &&
            (NXT(2) == 'e') && (NXT(3) == 'f')) {
            garbage = 0;
            SKIP(4);
            SKIP_BLANKS;

            if (CUR != '=') continue;
            NEXT;
            SKIP_BLANKS;

            href = xmlOldParseQuotedString(ctxt);
            SKIP_BLANKS;
        } else if ((CUR == 'p') && (NXT(1) == 'r') &&
                   (NXT(2) == 'e') && (NXT(3) == 'f') &&
                   (NXT(4) == 'i') && (NXT(5) == 'x')) {
            garbage = 0;
            SKIP(6);
            SKIP_BLANKS;

            if (CUR != '=') continue;
            NEXT;
            SKIP_BLANKS;

            prefix = xmlOldParseQuotedString(ctxt);
            SKIP_BLANKS;
        } else if ((CUR == 'A') && (NXT(1) == 'S')) {
            garbage = 0;
            SKIP(2);
            SKIP_BLANKS;

            if (CUR != '=') continue;
            NEXT;
            SKIP_BLANKS;

            prefix = xmlOldParseQuotedString(ctxt);
            SKIP_BLANKS;
        } else if ((CUR == '?') && (NXT(1) == '>')) {
            garbage = 0;
            NEXT;
        } else {
            /*
             * Found garbage when parsing the namespace
             */
            if (!garbage) {
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData,
                                     "xmlParseNamespace found garbage\n");
            }
            ctxt->errNo = XML_ERR_NS_DECL_ERROR;
            ctxt->wellFormed = 0;
            NEXT;
        }
    }

    MOVETO_ENDTAG(CUR_PTR);
    NEXT;

    /*
     * Register the DTD.
    if (href != NULL)
        if ((ctxt->sax != NULL) && (ctxt->sax->globalNamespace != NULL))
            ctxt->sax->globalNamespace(ctxt->userData, href, prefix);
     */

    if (prefix != NULL) xmlFree(prefix);
    if (href != NULL) xmlFree(href);
}

/************************************************************************
 *                                                                      *
 *                      The parser itself                               *
 *      Relates to http://www.w3.org/TR/REC-xml                         *
 *                                                                      *
 ************************************************************************/

/**
 * xmlOldScanName:
 * @ctxt:  an XML parser context
 *
 * Trickery: parse an XML name but without consuming the input flow
 * Needed for rollback cases.
 *
 * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
 *                  CombiningChar | Extender
 *
 * [5] Name ::= (Letter | '_' | ':') (NameChar)*
 *
 * [6] Names ::= Name (S Name)*
 *
 * Returns the Name parsed or NULL
 */

static xmlChar *
xmlOldScanName(xmlParserCtxtPtr ctxt) {
    xmlChar buf[XML_MAX_NAMELEN];
    int len = 0;

    GROW;
    if (!IS_LETTER(CUR) && (CUR != '_') &&
        (CUR != ':')) {
        return(NULL);
    }

    while ((IS_LETTER(NXT(len))) || (IS_DIGIT(NXT(len))) ||
           (NXT(len) == '.') || (NXT(len) == '-') ||
           (NXT(len) == '_') || (NXT(len) == ':') || 
           (IS_COMBINING(NXT(len))) ||
           (IS_EXTENDER(NXT(len)))) {
        buf[len] = NXT(len);
        len++;
        if (len >= XML_MAX_NAMELEN) {
            fprintf(stderr, 
               "xmlScanName: reached XML_MAX_NAMELEN limit\n");
            while ((IS_LETTER(NXT(len))) || (IS_DIGIT(NXT(len))) ||
                   (NXT(len) == '.') || (NXT(len) == '-') ||
                   (NXT(len) == '_') || (NXT(len) == ':') || 
                   (IS_COMBINING(NXT(len))) ||
                   (IS_EXTENDER(NXT(len))))
                 len++;
            break;
        }
    }
    return(xmlStrndup(buf, len));
}

/**
 * xmlOldParseName:
 * @ctxt:  an XML parser context
 *
 * parse an XML name.
 *
 * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
 *                  CombiningChar | Extender
 *
 * [5] Name ::= (Letter | '_' | ':') (NameChar)*
 *
 * [6] Names ::= Name (S Name)*
 *
 * Returns the Name parsed or NULL
 */

static xmlChar *
xmlOldParseName(xmlParserCtxtPtr ctxt) {
    xmlChar buf[XML_MAX_NAMELEN];
    int len = 0;
    xmlChar cur;

    GROW;
    cur = CUR;
    if (!IS_LETTER(cur) && (cur != '_') &&
        (cur != ':')) {
        return(NULL);
    }

    while ((IS_LETTER(cur)) || (IS_DIGIT(cur)) ||
           (cur == '.') || (cur == '-') ||
           (cur == '_') || (cur == ':') || 
           (IS_COMBINING(cur)) ||
           (IS_EXTENDER(cur))) {
        buf[len++] = cur;
        NEXT;
        cur = CUR;
        if (len >= XML_MAX_NAMELEN) {
            fprintf(stderr, 
               "xmlParseName: reached XML_MAX_NAMELEN limit\n");
            while ((IS_LETTER(cur)) || (IS_DIGIT(cur)) ||
                   (cur == '.') || (cur == '-') ||
                   (cur == '_') || (cur == ':') || 
                   (IS_COMBINING(cur)) ||
                   (IS_EXTENDER(cur))) {
                NEXT;
                cur = CUR;
            }
            break;
        }
    }
    return(xmlStrndup(buf, len));
}

/**
 * xmlOldParseStringName:
 * @ctxt:  an XML parser context
 * @str:  a pointer to an index in the string
 *
 * parse an XML name.
 *
 * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
 *                  CombiningChar | Extender
 *
 * [5] Name ::= (Letter | '_' | ':') (NameChar)*
 *
 * [6] Names ::= Name (S Name)*
 *
 * Returns the Name parsed or NULL. The str pointer 
 * is updated to the current location in the string.
 */

static xmlChar *
xmlOldParseStringName(xmlParserCtxtPtr ctxt, const xmlChar** str) {
    const xmlChar *ptr;
    const xmlChar *start;
    xmlChar cur;

    if ((str == NULL) || (*str == NULL)) return(NULL);

    start = ptr = *str;
    cur = *ptr;
    if (!IS_LETTER(cur) && (cur != '_') &&
        (cur != ':')) {
        return(NULL);
    }

    while ((IS_LETTER(cur)) || (IS_DIGIT(cur)) ||
           (cur == '.') || (cur == '-') ||
           (cur == '_') || (cur == ':') || 
           (IS_COMBINING(cur)) ||
           (IS_EXTENDER(cur))) {
        ptr++;
        cur = *ptr;
    }
    *str = ptr;
    return(xmlStrndup(start, ptr - start ));
}

/**
 * xmlOldParseNmtoken:
 * @ctxt:  an XML parser context
 * 
 * parse an XML Nmtoken.
 *
 * [7] Nmtoken ::= (NameChar)+
 *
 * [8] Nmtokens ::= Nmtoken (S Nmtoken)*
 *
 * Returns the Nmtoken parsed or NULL
 */

static xmlChar *
xmlOldParseNmtoken(xmlParserCtxtPtr ctxt) {
    xmlChar buf[XML_MAX_NAMELEN];
    int len = 0;

    GROW;
    while ((IS_LETTER(CUR)) || (IS_DIGIT(CUR)) ||
           (CUR == '.') || (CUR == '-') ||
           (CUR == '_') || (CUR == ':') || 
           (IS_COMBINING(CUR)) ||
           (IS_EXTENDER(CUR))) {
        buf[len++] = CUR;
        NEXT;
        if (len >= XML_MAX_NAMELEN) {
            fprintf(stderr, 
               "xmlParseNmtoken: reached XML_MAX_NAMELEN limit\n");
            while ((IS_LETTER(CUR)) || (IS_DIGIT(CUR)) ||
                   (CUR == '.') || (CUR == '-') ||
                   (CUR == '_') || (CUR == ':') || 
                   (IS_COMBINING(CUR)) ||
                   (IS_EXTENDER(CUR)))
                 NEXT;
            break;
        }
    }
    return(xmlStrndup(buf, len));
}

/**
 * xmlOldParseEntityValue:
 * @ctxt:  an XML parser context
 * @orig:  if non-NULL store a copy of the original entity value
 *
 * parse a value for ENTITY decl.
 *
 * [9] EntityValue ::= '"' ([^%&"] | PEReference | Reference)* '"' |
 *                     "'" ([^%&'] | PEReference | Reference)* "'"
 *
 * Returns the EntityValue parsed with reference substitued or NULL
 */

static xmlChar *
xmlOldParseEntityValue(xmlParserCtxtPtr ctxt, xmlChar **orig) {
    xmlChar *buf = NULL;
    int len = 0;
    int size = XML_PARSER_BUFFER_SIZE;
    xmlChar c;
    xmlChar stop;
    xmlChar *ret = NULL;
    xmlParserInputPtr input;

    if (CUR == '"') stop = '"';
    else if (CUR == '\'') stop = '\'';
    else {
        ctxt->errNo = XML_ERR_ENTITY_NOT_STARTED;
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData, "EntityValue: \" or ' expected\n");
        ctxt->wellFormed = 0;
        return(NULL);
    }
    buf = (xmlChar *) xmlMalloc(size * sizeof(xmlChar));
    if (buf == NULL) {
        fprintf(stderr, "malloc of %d byte failed\n", size);
        return(NULL);
    }

    /*
     * The content of the entity definition is copied in a buffer.
     */

    ctxt->instate = XML_PARSER_ENTITY_VALUE;
    input = ctxt->input;
    GROW;
    NEXT;
    c = CUR;
    /*
     * NOTE: 4.4.5 Included in Literal
     * When a parameter entity reference appears in a literal entity
     * value, ... a single or double quote character in the replacement
     * text is always treated as a normal data character and will not
     * terminate the literal. 
     * In practice it means we stop the loop only when back at parsing
     * the initial entity and the quote is found
     */
    while (IS_CHAR(c) && ((c != stop) || (ctxt->input != input))) {
        if (len + 1 >= size) {
            size *= 2;
            buf = xmlRealloc(buf, size * sizeof(xmlChar));
            if (buf == NULL) {
                fprintf(stderr, "realloc of %d byte failed\n", size);
                return(NULL);
            }
        }
        buf[len++] = c;
        NEXT;
        /*
         * Pop-up of finished entities.
         */
        while ((CUR == 0) && (ctxt->inputNr > 1))
            xmlOldPopInput(ctxt);
        c = CUR;
        if (c == 0) {
            GROW;
            c = CUR;
        }
    }
    buf[len] = 0;

    /*
     * Then PEReference entities are substituted.
     */
    if (c != stop) {
        ctxt->errNo = XML_ERR_ENTITY_NOT_FINISHED;
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData, "EntityValue: \" expected\n");
        ctxt->wellFormed = 0;
    } else {
        NEXT;
        /*
         * NOTE: 4.4.7 Bypassed
         * When a general entity reference appears in the EntityValue in
         * an entity declaration, it is bypassed and left as is.
         * so XML_SUBSTITUTE_REF is not set.
         */
        ret = xmlOldStringDecodeEntities(ctxt, buf, XML_SUBSTITUTE_PEREF,
                                      0, 0, 0);
        if (orig != NULL) 
            *orig = buf;
        else
            xmlFree(buf);
    }
    
    return(ret);
}

/**
 * xmlOldParseAttValue:
 * @ctxt:  an XML parser context
 *
 * parse a value for an attribute
 * Note: the parser won't do substitution of entities here, this
 * will be handled later in xmlStringGetNodeList
 *
 * [10] AttValue ::= '"' ([^<&"] | Reference)* '"' |
 *                   "'" ([^<&'] | Reference)* "'"
 *
 * 3.3.3 Attribute-Value Normalization:
 * Before the value of an attribute is passed to the application or
 * checked for validity, the XML processor must normalize it as follows: 
 * - a character reference is processed by appending the referenced
 *   character to the attribute value
 * - an entity reference is processed by recursively processing the
 *   replacement text of the entity 
 * - a whitespace character (#x20, #xD, #xA, #x9) is processed by
 *   appending #x20 to the normalized value, except that only a single
 *   #x20 is appended for a "#xD#xA" sequence that is part of an external
 *   parsed entity or the literal entity value of an internal parsed entity 
 * - other characters are processed by appending them to the normalized value 
 * If the declared value is not CDATA, then the XML processor must further
 * process the normalized attribute value by discarding any leading and
 * trailing space (#x20) characters, and by replacing sequences of space
 * (#x20) characters by a single space (#x20) character.  
 * All attributes for which no declaration has been read should be treated
 * by a non-validating parser as if declared CDATA.
 *
 * Returns the AttValue parsed or NULL. The value has to be freed by the caller.
 */

static xmlChar *
xmlOldParseAttValue(xmlParserCtxtPtr ctxt) {
    xmlChar limit = 0;
    xmlChar *buffer = NULL;
    int buffer_size = 0;
    xmlChar *out = NULL;

    xmlChar *current = NULL;
    xmlEntityPtr ent;
    xmlChar cur;


    SHRINK;
    if (CUR == '"') {
        ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
        limit = '"';
        NEXT;
    } else if (CUR == '\'') {
        limit = '\'';
        ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
        NEXT;
    } else {
        ctxt->errNo = XML_ERR_ATTRIBUTE_NOT_STARTED;
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData, "AttValue: \" or ' expected\n");
        ctxt->wellFormed = 0;
        return(NULL);
    }
    
    /*
     * allocate a translation buffer.
     */
    buffer_size = XML_PARSER_BUFFER_SIZE;
    buffer = (xmlChar *) xmlMalloc(buffer_size * sizeof(xmlChar));
    if (buffer == NULL) {
        perror("xmlParseAttValue: malloc failed");
        return(NULL);
    }
    out = buffer;

    /*
     * Ok loop until we reach one of the ending char or a size limit.
     */
    cur = CUR;
    while ((ctxt->token != 0) ||
           ((cur != limit) && (cur != '<'))) {
        if (cur == 0) break;
        if (cur == '&') { GROW; }
        if (ctxt->token == '&') {
            /*
             * The reparsing will be done in xmlStringGetNodeList()
             * called by the attribute() function in SAX.c
             */
            static xmlChar quote[6] = "&#38;";

            if (out - buffer > buffer_size - 10) {
                int index = out - buffer;

                growBuffer(buffer);
                out = &buffer[index];
            }
            current = &quote[0];
            while (*current != 0) { /* non input consuming */
                *out++ = *current++;
            }
            NEXT;
        } else if ((cur == '&') && (NXT(1) == '#')) {
            int val = xmlOldParseCharRef(ctxt);
            *out++ = val;
            if (out - buffer > buffer_size - 10) {
                int index = out - buffer;

                growBuffer(buffer);
                out = &buffer[index];
            }
        } else if (cur == '&') {
            ent = xmlOldParseEntityRef(ctxt);
            if ((ent != NULL) && 
                (ctxt->replaceEntities != 0)) {
                current = ent->content;
                while (*current != 0) {
                    *out++ = *current++;
                    if (out - buffer > buffer_size - 10) {
                        int index = out - buffer;

                        growBuffer(buffer);
                        out = &buffer[index];
                    }
                }
            } else if (ent != NULL) {
                int i = xmlStrlen(ent->name);
                const xmlChar *cur = ent->name;

                *out++ = '&';
                while (out - buffer > buffer_size - i - 10) {
                    int index = out - buffer;

                    growBuffer(buffer);
                    out = &buffer[index];
                }
                for (;i > 0;i--)
                    *out++ = *cur++;
                *out++ = ';';
            }
        } else {
            /*  invalid for UTF-8 , use COPY(out); !!!!!! */
            if ((ctxt->token == 0) && ((cur == 0x20) || (cur == 0xD) || (cur == 0xA) || (cur == 0x9))) {
                *out++ = 0x20;
                if (out - buffer > buffer_size - 10) {
                  int index = out - buffer;
                  
                  growBuffer(buffer);
                  out = &buffer[index];
                }
            } else {
                *out++ = cur;
                if (out - buffer > buffer_size - 10) {
                  int index = out - buffer;
                  
                  growBuffer(buffer);
                  out = &buffer[index];
                }
            }
            NEXT;
        }
        cur = CUR;
    }
    *out++ = 0;
    if (CUR == '<') {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
               "Unescaped '<' not allowed in attributes values\n");
        ctxt->errNo = XML_ERR_LT_IN_ATTRIBUTE;
        ctxt->wellFormed = 0;
    } else if (CUR != limit) {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData, "AttValue: ' expected\n");
        ctxt->errNo = XML_ERR_ATTRIBUTE_NOT_FINISHED;
        ctxt->wellFormed = 0;
    } else
        NEXT;
    return(buffer);
}

/**
 * xmlOldParseSystemLiteral:
 * @ctxt:  an XML parser context
 * 
 * parse an XML Literal
 *
 * [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'")
 *
 * Returns the SystemLiteral parsed or NULL
 */

static xmlChar *
xmlOldParseSystemLiteral(xmlParserCtxtPtr ctxt) {
    xmlChar *buf = NULL;
    int len = 0;
    int size = XML_PARSER_BUFFER_SIZE;
    xmlChar cur;
    xmlChar stop;

    SHRINK;
    if (CUR == '"') {
        NEXT;
        stop = '"';
    } else if (CUR == '\'') {
        NEXT;
        stop = '\'';
    } else {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
                             "SystemLiteral \" or ' expected\n");
        ctxt->errNo = XML_ERR_LITERAL_NOT_STARTED;
        ctxt->wellFormed = 0;
        return(NULL);
    }
    
    buf = (xmlChar *) xmlMalloc(size * sizeof(xmlChar));
    if (buf == NULL) {
        fprintf(stderr, "malloc of %d byte failed\n", size);
        return(NULL);
    }
    cur = CUR;
    while ((IS_CHAR(cur)) && (cur != stop)) {
        if (len + 1 >= size) {
            size *= 2;
            buf = xmlRealloc(buf, size * sizeof(xmlChar));
            if (buf == NULL) {
                fprintf(stderr, "realloc of %d byte failed\n", size);
                return(NULL);
            }
        }
        buf[len++] = cur;
        NEXT;
        cur = CUR;
        if (cur == 0) {
            GROW;
            SHRINK;
            cur = CUR;
        }
    }
    buf[len] = 0;
    if (!IS_CHAR(cur)) {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData, "Unfinished SystemLiteral\n");
        ctxt->errNo = XML_ERR_LITERAL_NOT_FINISHED;
        ctxt->wellFormed = 0;
    } else {
        NEXT;
    }
    return(buf);
}

/**
 * xmlOldParsePubidLiteral:
 * @ctxt:  an XML parser context
 *
 * parse an XML public literal
 *
 * [12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'"
 *
 * Returns the PubidLiteral parsed or NULL.
 */

static xmlChar *
xmlOldParsePubidLiteral(xmlParserCtxtPtr ctxt) {
    xmlChar *buf = NULL;
    int len = 0;
    int size = XML_PARSER_BUFFER_SIZE;
    xmlChar cur;
    xmlChar stop;

    SHRINK;
    if (CUR == '"') {
        NEXT;
        stop = '"';
    } else if (CUR == '\'') {
        NEXT;
        stop = '\'';
    } else {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
                             "SystemLiteral \" or ' expected\n");
        ctxt->errNo = XML_ERR_LITERAL_NOT_STARTED;
        ctxt->wellFormed = 0;
        return(NULL);
    }
    buf = (xmlChar *) xmlMalloc(size * sizeof(xmlChar));
    if (buf == NULL) {
        fprintf(stderr, "malloc of %d byte failed\n", size);
        return(NULL);
    }
    cur = CUR;
    while ((IS_PUBIDCHAR(cur)) && (cur != stop)) {
        if (len + 1 >= size) {
            size *= 2;
            buf = xmlRealloc(buf, size * sizeof(xmlChar));
            if (buf == NULL) {
                fprintf(stderr, "realloc of %d byte failed\n", size);
                return(NULL);
            }
        }
        buf[len++] = cur;
        NEXT;
        cur = CUR;
        if (cur == 0) {
            GROW;
            SHRINK;
            cur = CUR;
        }
    }
    buf[len] = 0;
    if (cur != stop) {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData, "Unfinished PubidLiteral\n");
        ctxt->errNo = XML_ERR_LITERAL_NOT_FINISHED;
        ctxt->wellFormed = 0;
    } else {
        NEXT;
    }
    return(buf);
}

/**
 * xmlOldParseCharData:
 * @ctxt:  an XML parser context
 * @cdata:  int indicating whether we are within a CDATA section
 *
 * parse a CharData section.
 * if we are within a CDATA section ']]>' marks an end of section.
 *
 * [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)
 */

static void
xmlOldParseCharData(xmlParserCtxtPtr ctxt, int cdata) {
    xmlChar buf[XML_PARSER_BIG_BUFFER_SIZE];
    int nbchar = 0;
    xmlChar cur;

    SHRINK;
    cur = CUR;
    while (((cur != '<') || (ctxt->token == '<')) &&
           ((cur != '&') || (ctxt->token == '&')) && 
           (IS_CHAR(cur))) {
        if ((cur == ']') && (NXT(1) == ']') &&
            (NXT(2) == '>')) {
            if (cdata) break;
            else {
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->warning(ctxt->userData,
                       "Sequence ']]>' not allowed in content\n");
                ctxt->errNo = XML_ERR_MISPLACED_CDATA_END;
            }
        }
        buf[nbchar++] = CUR;
        if (nbchar == XML_PARSER_BIG_BUFFER_SIZE) {
            /*
             * Ok the segment is to be consumed as chars.
             */
            if (ctxt->sax != NULL) {
                if (areBlanksOld(ctxt, buf, nbchar)) {
                    if (ctxt->sax->ignorableWhitespace != NULL)
                        ctxt->sax->ignorableWhitespace(ctxt->userData,
                                                       buf, nbchar);
                } else {
                    if (ctxt->sax->characters != NULL)
                        ctxt->sax->characters(ctxt->userData, buf, nbchar);
                }
            }
            nbchar = 0;
        }
        NEXT;
        cur = CUR;
    }
    if (nbchar != 0) {
        /*
         * Ok the segment is to be consumed as chars.
         */
        if (ctxt->sax != NULL) {
            if (areBlanksOld(ctxt, buf, nbchar)) {
                if (ctxt->sax->ignorableWhitespace != NULL)
                    ctxt->sax->ignorableWhitespace(ctxt->userData, buf, nbchar);
            } else {
                if (ctxt->sax->characters != NULL)
                    ctxt->sax->characters(ctxt->userData, buf, nbchar);
            }
        }
    }
}

/**
 * xmlOldParseExternalID:
 * @ctxt:  an XML parser context
 * @publicID:  a xmlChar** receiving PubidLiteral
 * @strict: indicate whether we should restrict parsing to only
 *          production [75], see NOTE below
 *
 * Parse an External ID or a Public ID
 *
 * NOTE: Productions [75] and [83] interract badly since [75] can generate
 *       'PUBLIC' S PubidLiteral S SystemLiteral
 *
 * [75] ExternalID ::= 'SYSTEM' S SystemLiteral
 *                   | 'PUBLIC' S PubidLiteral S SystemLiteral
 *
 * [83] PublicID ::= 'PUBLIC' S PubidLiteral
 *
 * Returns the function returns SystemLiteral and in the second
 *                case publicID receives PubidLiteral, is strict is off
 *                it is possible to return NULL and have publicID set.
 */

static xmlChar *
xmlOldParseExternalID(xmlParserCtxtPtr ctxt, xmlChar **publicID, int strict) {
    xmlChar *URI = NULL;

    SHRINK;
    if ((CUR == 'S') && (NXT(1) == 'Y') &&
         (NXT(2) == 'S') && (NXT(3) == 'T') &&
         (NXT(4) == 'E') && (NXT(5) == 'M')) {
        SKIP(6);
        if (!IS_BLANK(CUR)) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
                    "Space required after 'SYSTEM'\n");
            ctxt->errNo = XML_ERR_SPACE_REQUIRED;
            ctxt->wellFormed = 0;
        }
        SKIP_BLANKS;
        URI = xmlOldParseSystemLiteral(ctxt);
        if (URI == NULL) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
                  "xmlParseExternalID: SYSTEM, no URI\n");
            ctxt->errNo = XML_ERR_URI_REQUIRED;
            ctxt->wellFormed = 0;
        }
    } else if ((CUR == 'P') && (NXT(1) == 'U') &&
               (NXT(2) == 'B') && (NXT(3) == 'L') &&
               (NXT(4) == 'I') && (NXT(5) == 'C')) {
        SKIP(6);
        if (!IS_BLANK(CUR)) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
                    "Space required after 'PUBLIC'\n");
            ctxt->errNo = XML_ERR_SPACE_REQUIRED;
            ctxt->wellFormed = 0;
        }
        SKIP_BLANKS;
        *publicID = xmlOldParsePubidLiteral(ctxt);
        if (*publicID == NULL) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData, 
                  "xmlParseExternalID: PUBLIC, no Public Identifier\n");
            ctxt->errNo = XML_ERR_PUBID_REQUIRED;
            ctxt->wellFormed = 0;
        }
        if (strict) {
            /*
             * We don't handle [83] so "S SystemLiteral" is required.
             */
            if (!IS_BLANK(CUR)) {
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData,
                        "Space required after the Public Identifier\n");
                ctxt->errNo = XML_ERR_SPACE_REQUIRED;
                ctxt->wellFormed = 0;
            }
        } else {
            /*
             * We handle [83] so we return immediately, if 
             * "S SystemLiteral" is not detected. From a purely parsing
             * point of view that's a nice mess.
             */
            const xmlChar *ptr;
            GROW;

            ptr = CUR_PTR;
            if (!IS_BLANK(*ptr)) return(NULL);
            
            while (IS_BLANK(*ptr)) ptr++;
            if ((*ptr != '\'') || (*ptr != '"')) return(NULL);
        }
        SKIP_BLANKS;
        URI = xmlOldParseSystemLiteral(ctxt);
        if (URI == NULL) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData, 
                   "xmlParseExternalID: PUBLIC, no URI\n");
            ctxt->errNo = XML_ERR_URI_REQUIRED;
            ctxt->wellFormed = 0;
        }
    }
    return(URI);
}

/**
 * xmlOldParseComment:
 * @ctxt:  an XML parser context
 *
 * Skip an XML (SGML) comment <!-- .... -->
 *  The spec says that "For compatibility, the string "--" (double-hyphen)
 *  must not occur within comments. "
 *
 * [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
 */
static void
xmlOldParseComment(xmlParserCtxtPtr ctxt) {
    xmlChar *buf = NULL;
    int len = 0;
    int size = XML_PARSER_BUFFER_SIZE;
    xmlChar q;
    xmlChar r;
    xmlChar cur;
    xmlParserInputState state;

    /*
     * Check that there is a comment right here.
     */
    if ((CUR != '<') || (NXT(1) != '!') ||
        (NXT(2) != '-') || (NXT(3) != '-')) return;

    state = ctxt->instate;
    ctxt->instate = XML_PARSER_COMMENT;
    SHRINK;
    SKIP(4);
    buf = (xmlChar *) xmlMalloc(size * sizeof(xmlChar));
    if (buf == NULL) {
        fprintf(stderr, "malloc of %d byte failed\n", size);
        ctxt->instate = state;
        return;
    }
    q = CUR;
    NEXT;
    r = CUR;
    NEXT;
    cur = CUR;
    while (IS_CHAR(cur) &&
           ((cur != '>') ||
            (r != '-') || (q != '-'))) {
        if ((r == '-') && (q == '-')) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
               "Comment must not contain '--' (double-hyphen)`\n");
            ctxt->errNo = XML_ERR_HYPHEN_IN_COMMENT;
            ctxt->wellFormed = 0;
        }
        if (len + 1 >= size) {
            size *= 2;
            buf = xmlRealloc(buf, size * sizeof(xmlChar));
            if (buf == NULL) {
                fprintf(stderr, "realloc of %d byte failed\n", size);
                ctxt->instate = state;
                return;
            }
        }
        buf[len++] = q;
        q = r;
        r = cur;
        NEXT;
        cur = CUR;
        if (cur == 0) {
            SHRINK;
            GROW;
            cur = CUR;
        }
    }
    buf[len] = 0;
    if (!IS_CHAR(cur)) {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
                             "Comment not terminated \n<!--%.50s\n", buf);
        ctxt->errNo = XML_ERR_COMMENT_NOT_FINISHED;
        ctxt->wellFormed = 0;
    } else {
        NEXT;
        if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL))
            ctxt->sax->comment(ctxt->userData, buf);
        xmlFree(buf);
    }
    ctxt->instate = state;
}

/**
 * xmlOldParsePITarget:
 * @ctxt:  an XML parser context
 * 
 * parse the name of a PI
 *
 * [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l'))
 *
 * Returns the PITarget name or NULL
 */

static xmlChar *
xmlOldParsePITarget(xmlParserCtxtPtr ctxt) {
    xmlChar *name;

    name = xmlOldParseName(ctxt);
    if ((name != NULL) &&
        ((name[0] == 'x') || (name[0] == 'X')) &&
        ((name[1] == 'm') || (name[1] == 'M')) &&
        ((name[2] == 'l') || (name[2] == 'L'))) {
        int i;
        for (i = 0;;i++) {
            if (xmlW3CPIs[i] == NULL) break;
            if (!xmlStrcmp(name, (const xmlChar *)xmlW3CPIs[i]))
                return(name);
        }
        if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL)) {
            ctxt->sax->warning(ctxt->userData,
                 "xmlParsePItarget: invalid name prefix 'xml'\n");
            ctxt->errNo = XML_ERR_RESERVED_XML_NAME;
        }
    }
    return(name);
}

/**
 * xmlOldParsePI:
 * @ctxt:  an XML parser context
 * 
 * parse an XML Processing Instruction.
 *
 * [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>'
 *
 * The processing is transfered to SAX once parsed.
 */

static void
xmlOldParsePI(xmlParserCtxtPtr ctxt) {
    xmlChar *buf = NULL;
    int len = 0;
    int size = XML_PARSER_BUFFER_SIZE;
    xmlChar cur;
    xmlChar *target;
    xmlParserInputState state;

    if ((CUR == '<') && (NXT(1) == '?')) {
        state = ctxt->instate;
        ctxt->instate = XML_PARSER_PI;
        /*
         * this is a Processing Instruction.
         */
        SKIP(2);
        SHRINK;

        /*
         * Parse the target name and check for special support like
         * namespace.
         */
        target = xmlOldParsePITarget(ctxt);
        if (target != NULL) {
            buf = (xmlChar *) xmlMalloc(size * sizeof(xmlChar));
            if (buf == NULL) {
                fprintf(stderr, "malloc of %d byte failed\n", size);
                ctxt->instate = state;
                return;
            }
            cur = CUR;
            if (!IS_BLANK(cur)) {
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData,
                      "xmlParsePI: PI %s space expected\n", target);
                ctxt->errNo = XML_ERR_SPACE_REQUIRED;
                ctxt->wellFormed = 0;
            }
            SKIP_BLANKS;
            cur = CUR;
            while (IS_CHAR(cur) &&
                   ((cur != '?') || (NXT(1) != '>'))) {
                if (len + 1 >= size) {
                    size *= 2;
                    buf = xmlRealloc(buf, size * sizeof(xmlChar));
                    if (buf == NULL) {
                        fprintf(stderr, "realloc of %d byte failed\n", size);
                        ctxt->instate = state;
                        return;
                    }
                }
                buf[len++] = cur;
                NEXT;
                cur = CUR;
                if (cur == 0) {
                    SHRINK;
                    GROW;
                    cur = CUR;
                }
            }
            buf[len] = 0;
            if (!IS_CHAR(cur)) {
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData,
                      "xmlParsePI: PI %s never end ...\n", target);
                ctxt->errNo = XML_ERR_PI_NOT_FINISHED;
                ctxt->wellFormed = 0;
            } else {
                SKIP(2);

                /*
                 * SAX: PI detected.
                 */
                if ((ctxt->sax) &&
                    (ctxt->sax->processingInstruction != NULL))
                    ctxt->sax->processingInstruction(ctxt->userData,
                                                     target, buf);
            }
            xmlFree(buf);
            xmlFree(target);
        } else {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
                       "xmlParsePI : no target name\n");
            ctxt->errNo = XML_ERR_PI_NOT_STARTED;
            ctxt->wellFormed = 0;
        }
        ctxt->instate = state;
    }
}

/**
 * xmlOldParseNotationDecl:
 * @ctxt:  an XML parser context
 *
 * parse a notation declaration
 *
 * [82] NotationDecl ::= '<!NOTATION' S Name S (ExternalID |  PublicID) S? '>'
 *
 * Hence there is actually 3 choices:
 *     'PUBLIC' S PubidLiteral
 *     'PUBLIC' S PubidLiteral S SystemLiteral
 * and 'SYSTEM' S SystemLiteral
 *
 * See the NOTE on xmlOldParseExternalID().
 */

static void
xmlOldParseNotationDecl(xmlParserCtxtPtr ctxt) {
    xmlChar *name;
    xmlChar *Pubid;
    xmlChar *Systemid;
    
    if ((CUR == '<') && (NXT(1) == '!') &&
        (NXT(2) == 'N') && (NXT(3) == 'O') &&
        (NXT(4) == 'T') && (NXT(5) == 'A') &&
        (NXT(6) == 'T') && (NXT(7) == 'I') &&
        (NXT(8) == 'O') && (NXT(9) == 'N')) {
        SHRINK;
        SKIP(10);
        if (!IS_BLANK(CUR)) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
                                 "Space required after '<!NOTATION'\n");
            ctxt->errNo = XML_ERR_SPACE_REQUIRED;
            ctxt->wellFormed = 0;
            return;
        }
        SKIP_BLANKS;

        name = xmlOldParseName(ctxt);
        if (name == NULL) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
                                 "NOTATION: Name expected here\n");
            ctxt->errNo = XML_ERR_NOTATION_NOT_STARTED;
            ctxt->wellFormed = 0;
            return;
        }
        if (!IS_BLANK(CUR)) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData, 
                     "Space required after the NOTATION name'\n");
            ctxt->errNo = XML_ERR_SPACE_REQUIRED;
            ctxt->wellFormed = 0;
            return;
        }
        SKIP_BLANKS;

        /*
         * Parse the IDs.
         */
        Systemid = xmlOldParseExternalID(ctxt, &Pubid, 1);
        SKIP_BLANKS;

        if (CUR == '>') {
            NEXT;
            if ((ctxt->sax != NULL) && (ctxt->sax->notationDecl != NULL))
                ctxt->sax->notationDecl(ctxt->userData, name, Pubid, Systemid);
        } else {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
                       "'>' required to close NOTATION declaration\n");
            ctxt->errNo = XML_ERR_NOTATION_NOT_FINISHED;
            ctxt->wellFormed = 0;
        }
        xmlFree(name);
        if (Systemid != NULL) xmlFree(Systemid);
        if (Pubid != NULL) xmlFree(Pubid);
    }
}

/**
 * xmlOldParseEntityDecl:
 * @ctxt:  an XML parser context
 *
 * parse <!ENTITY declarations
 *
 * [70] EntityDecl ::= GEDecl | PEDecl
 *
 * [71] GEDecl ::= '<!ENTITY' S Name S EntityDef S? '>'
 *
 * [72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>'
 *
 * [73] EntityDef ::= EntityValue | (ExternalID NDataDecl?)
 *
 * [74] PEDef ::= EntityValue | ExternalID
 *
 * [76] NDataDecl ::= S 'NDATA' S Name
 *
 * [ VC: Notation Declared ]
 * The Name must match the declared name of a notation.
 */

static void
xmlOldParseEntityDecl(xmlParserCtxtPtr ctxt) {
    xmlChar *name = NULL;
    xmlChar *value = NULL;
    xmlChar *URI = NULL, *literal = NULL;
    xmlChar *ndata = NULL;
    int isParameter = 0;
    xmlChar *orig = NULL;
    
    GROW;
    if ((CUR == '<') && (NXT(1) == '!') &&
        (NXT(2) == 'E') && (NXT(3) == 'N') &&
        (NXT(4) == 'T') && (NXT(5) == 'I') &&
        (NXT(6) == 'T') && (NXT(7) == 'Y')) {
        ctxt->instate = XML_PARSER_ENTITY_DECL;
        SHRINK;
        SKIP(8);
        if (!IS_BLANK(CUR)) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
                                 "Space required after '<!ENTITY'\n");
            ctxt->errNo = XML_ERR_SPACE_REQUIRED;
            ctxt->wellFormed = 0;
        }
        SKIP_BLANKS;

        if (CUR == '%') {
            NEXT;
            if (!IS_BLANK(CUR)) {
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData,
                                     "Space required after '%'\n");
                ctxt->errNo = XML_ERR_SPACE_REQUIRED;
                ctxt->wellFormed = 0;
            }
            SKIP_BLANKS;
            isParameter = 1;
        }

        name = xmlOldParseName(ctxt);
        if (name == NULL) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData, "xmlParseEntityDecl: no name\n");
            ctxt->errNo = XML_ERR_NAME_REQUIRED;
            ctxt->wellFormed = 0;
            return;
        }
        if (!IS_BLANK(CUR)) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
                     "Space required after the entity name\n");
            ctxt->errNo = XML_ERR_SPACE_REQUIRED;
            ctxt->wellFormed = 0;
        }
        SKIP_BLANKS;

        /*
         * handle the various case of definitions...
         */
        if (isParameter) {
            if ((CUR == '"') || (CUR == '\''))
                value = xmlOldParseEntityValue(ctxt, &orig);
                if (value) {
                    if ((ctxt->sax != NULL) && (ctxt->sax->entityDecl != NULL))
                        ctxt->sax->entityDecl(ctxt->userData, name,
                                    XML_INTERNAL_PARAMETER_ENTITY,
                                    NULL, NULL, value);
                }
            else {
                URI = xmlOldParseExternalID(ctxt, &literal, 1);
                if (URI) {
                    if ((ctxt->sax != NULL) && (ctxt->sax->entityDecl != NULL))
                        ctxt->sax->entityDecl(ctxt->userData, name,
                                    XML_EXTERNAL_PARAMETER_ENTITY,
                                    literal, URI, NULL);
                }
            }
        } else {
            if ((CUR == '"') || (CUR == '\'')) {
                value = xmlOldParseEntityValue(ctxt, &orig);
                if ((ctxt->sax != NULL) && (ctxt->sax->entityDecl != NULL))
                    ctxt->sax->entityDecl(ctxt->userData, name,
                                XML_INTERNAL_GENERAL_ENTITY,
                                NULL, NULL, value);
            } else {
                URI = xmlOldParseExternalID(ctxt, &literal, 1);
                if ((CUR != '>') && (!IS_BLANK(CUR))) {
                    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                        ctxt->sax->error(ctxt->userData,
                            "Space required before 'NDATA'\n");
                    ctxt->errNo = XML_ERR_SPACE_REQUIRED;
                    ctxt->wellFormed = 0;
                }
                SKIP_BLANKS;
                if ((CUR == 'N') && (NXT(1) == 'D') &&
                    (NXT(2) == 'A') && (NXT(3) == 'T') &&
                    (NXT(4) == 'A')) {
                    SKIP(5);
                    if (!IS_BLANK(CUR)) {
                        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                            ctxt->sax->error(ctxt->userData,
                                "Space required after 'NDATA'\n");
                        ctxt->errNo = XML_ERR_SPACE_REQUIRED;
                        ctxt->wellFormed = 0;
                    }
                    SKIP_BLANKS;
                    ndata = xmlOldParseName(ctxt);
                    if ((ctxt->sax != NULL) &&
                        (ctxt->sax->unparsedEntityDecl != NULL))
                        ctxt->sax->unparsedEntityDecl(ctxt->userData, name,
                                    literal, URI, ndata);
                } else {
                    if ((ctxt->sax != NULL) && (ctxt->sax->entityDecl != NULL))
                        ctxt->sax->entityDecl(ctxt->userData, name,
                                    XML_EXTERNAL_GENERAL_PARSED_ENTITY,
                                    literal, URI, NULL);
                }
            }
        }
        SKIP_BLANKS;
        if (CUR != '>') {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData, 
                    "xmlParseEntityDecl: entity %s not terminated\n", name);
            ctxt->errNo = XML_ERR_ENTITY_NOT_FINISHED;
            ctxt->wellFormed = 0;
        } else
            NEXT;
        if (orig != NULL) {
            /*
             * Ugly mechanism to save the raw entity value.
             */
            xmlEntityPtr cur = NULL;

            if (isParameter) {
                if ((ctxt->sax != NULL) &&
                    (ctxt->sax->getParameterEntity != NULL))
                    cur = ctxt->sax->getParameterEntity(ctxt->userData, name);
            } else {
                if ((ctxt->sax != NULL) &&
                    (ctxt->sax->getEntity != NULL))
                    cur = ctxt->sax->getEntity(ctxt->userData, name);
            }
            if (cur != NULL) {
                if (cur->orig != NULL)
                    xmlFree(orig);
                else
                    cur->orig = orig;
            } else
                xmlFree(orig);
        }
        if (name != NULL) xmlFree(name);
        if (value != NULL) xmlFree(value);
        if (URI != NULL) xmlFree(URI);
        if (literal != NULL) xmlFree(literal);
        if (ndata != NULL) xmlFree(ndata);
    }
}

/**
 * xmlOldParseDefaultDecl:
 * @ctxt:  an XML parser context
 * @value:  Receive a possible fixed default value for the attribute
 *
 * Parse an attribute default declaration
 *
 * [60] DefaultDecl ::= '#REQUIRED' | '#IMPLIED' | (('#FIXED' S)? AttValue)
 *
 * [ VC: Required Attribute ]
 * if the default declaration is the keyword #REQUIRED, then the
 * attribute must be specified for all elements of the type in the
 * attribute-list declaration.
 *
 * [ VC: Attribute Default Legal ]
 * The declared default value must meet the lexical constraints of
 * the declared attribute type c.f. xmlValidateAttributeDecl()
 *
 * [ VC: Fixed Attribute Default ]
 * if an attribute has a default value declared with the #FIXED
 * keyword, instances of that attribute must match the default value. 
 *
 * [ WFC: No < in Attribute Values ]
 * handled in xmlOldParseAttValue()
 *
 * returns: XML_ATTRIBUTE_NONE, XML_ATTRIBUTE_REQUIRED, XML_ATTRIBUTE_IMPLIED
 *          or XML_ATTRIBUTE_FIXED. 
 */

static int
xmlOldParseDefaultDecl(xmlParserCtxtPtr ctxt, xmlChar **value) {
    int val;
    xmlChar *ret;

    *value = NULL;
    if ((CUR == '#') && (NXT(1) == 'R') &&
        (NXT(2) == 'E') && (NXT(3) == 'Q') &&
        (NXT(4) == 'U') && (NXT(5) == 'I') &&
        (NXT(6) == 'R') && (NXT(7) == 'E') &&
        (NXT(8) == 'D')) {
        SKIP(9);
        return(XML_ATTRIBUTE_REQUIRED);
    }
    if ((CUR == '#') && (NXT(1) == 'I') &&
        (NXT(2) == 'M') && (NXT(3) == 'P') &&
        (NXT(4) == 'L') && (NXT(5) == 'I') &&
        (NXT(6) == 'E') && (NXT(7) == 'D')) {
        SKIP(8);
        return(XML_ATTRIBUTE_IMPLIED);
    }
    val = XML_ATTRIBUTE_NONE;
    if ((CUR == '#') && (NXT(1) == 'F') &&
        (NXT(2) == 'I') && (NXT(3) == 'X') &&
        (NXT(4) == 'E') && (NXT(5) == 'D')) {
        SKIP(6);
        val = XML_ATTRIBUTE_FIXED;
        if (!IS_BLANK(CUR)) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
                                 "Space required after '#FIXED'\n");
            ctxt->errNo = XML_ERR_SPACE_REQUIRED;
            ctxt->wellFormed = 0;
        }
        SKIP_BLANKS;
    }
    ret = xmlOldParseAttValue(ctxt);
    ctxt->instate = XML_PARSER_DTD;
    if (ret == NULL) {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
               "Attribute default value declaration error\n");
        ctxt->wellFormed = 0;
    } else
        *value = ret;
    return(val);
}

/**
 * xmlOldParseNotationType:
 * @ctxt:  an XML parser context
 *
 * parse an Notation attribute type.
 *
 * Note: the leading 'NOTATION' S part has already being parsed...
 *
 * [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'
 *
 * [ VC: Notation Attributes ]
 * Values of this type must match one of the notation names included
 * in the declaration; all notation names in the declaration must be declared. 
 *
 * Returns: the notation attribute tree built while parsing
 */

static xmlEnumerationPtr
xmlOldParseNotationType(xmlParserCtxtPtr ctxt) {
    xmlChar *name;
    xmlEnumerationPtr ret = NULL, last = NULL, cur;

    if (CUR != '(') {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
                             "'(' required to start 'NOTATION'\n");
        ctxt->errNo = XML_ERR_NOTATION_NOT_STARTED;
        ctxt->wellFormed = 0;
        return(NULL);
    }
    SHRINK;
    do {
        NEXT;
        SKIP_BLANKS;
        name = xmlOldParseName(ctxt);
        if (name == NULL) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData, 
                                 "Name expected in NOTATION declaration\n");
            ctxt->errNo = XML_ERR_NAME_REQUIRED;
            ctxt->wellFormed = 0;
            return(ret);
        }
        cur = xmlCreateEnumeration(name);
        xmlFree(name);
        if (cur == NULL) return(ret);
        if (last == NULL) ret = last = cur;
        else {
            last->next = cur;
            last = cur;
        }
        SKIP_BLANKS;
    } while (CUR == '|');
    if (CUR != ')') {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
                             "')' required to finish NOTATION declaration\n");
        ctxt->errNo = XML_ERR_NOTATION_NOT_FINISHED;
        ctxt->wellFormed = 0;
        return(ret);
    }
    NEXT;
    return(ret);
}

/**
 * xmlOldParseEnumerationType:
 * @ctxt:  an XML parser context
 *
 * parse an Enumeration attribute type.
 *
 * [59] Enumeration ::= '(' S? Nmtoken (S? '|' S? Nmtoken)* S? ')'
 *
 * [ VC: Enumeration ]
 * Values of this type must match one of the Nmtoken tokens in
 * the declaration
 *
 * Returns: the enumeration attribute tree built while parsing
 */

static xmlEnumerationPtr
xmlOldParseEnumerationType(xmlParserCtxtPtr ctxt) {
    xmlChar *name;
    xmlEnumerationPtr ret = NULL, last = NULL, cur;

    if (CUR != '(') {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
                             "'(' required to start ATTLIST enumeration\n");
        ctxt->errNo = XML_ERR_ATTLIST_NOT_STARTED;
        ctxt->wellFormed = 0;
        return(NULL);
    }
    SHRINK;
    do {
        NEXT;
        SKIP_BLANKS;
        name = xmlOldParseNmtoken(ctxt);
        if (name == NULL) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData, 
                                 "NmToken expected in ATTLIST enumeration\n");
            ctxt->errNo = XML_ERR_NMTOKEN_REQUIRED;
            ctxt->wellFormed = 0;
            return(ret);
        }
        cur = xmlCreateEnumeration(name);
        xmlFree(name);
        if (cur == NULL) return(ret);
        if (last == NULL) ret = last = cur;
        else {
            last->next = cur;
            last = cur;
        }
        SKIP_BLANKS;
    } while (CUR == '|');
    if (CUR != ')') {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
                             "')' required to finish ATTLIST enumeration\n");
        ctxt->errNo = XML_ERR_ATTLIST_NOT_FINISHED;
        ctxt->wellFormed = 0;
        return(ret);
    }
    NEXT;
    return(ret);
}

/**
 * xmlOldParseEnumeratedType:
 * @ctxt:  an XML parser context
 * @tree:  the enumeration tree built while parsing
 *
 * parse an Enumerated attribute type.
 *
 * [57] EnumeratedType ::= NotationType | Enumeration
 *
 * [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'
 *
 *
 * Returns: XML_ATTRIBUTE_ENUMERATION or XML_ATTRIBUTE_NOTATION
 */

static int
xmlOldParseEnumeratedType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
    if ((CUR == 'N') && (NXT(1) == 'O') &&
        (NXT(2) == 'T') && (NXT(3) == 'A') &&
        (NXT(4) == 'T') && (NXT(5) == 'I') &&
        (NXT(6) == 'O') && (NXT(7) == 'N')) {
        SKIP(8);
        if (!IS_BLANK(CUR)) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
                                 "Space required after 'NOTATION'\n");
            ctxt->errNo = XML_ERR_SPACE_REQUIRED;
            ctxt->wellFormed = 0;
            return(0);
        }
        SKIP_BLANKS;
        *tree = xmlOldParseNotationType(ctxt);
        if (*tree == NULL) return(0);
        return(XML_ATTRIBUTE_NOTATION);
    }
    *tree = xmlOldParseEnumerationType(ctxt);
    if (*tree == NULL) return(0);
    return(XML_ATTRIBUTE_ENUMERATION);
}

/**
 * xmlOldParseAttributeType:
 * @ctxt:  an XML parser context
 * @tree:  the enumeration tree built while parsing
 *
 * parse the Attribute list def for an element
 *
 * [54] AttType ::= StringType | TokenizedType | EnumeratedType
 *
 * [55] StringType ::= 'CDATA'
 *
 * [56] TokenizedType ::= 'ID' | 'IDREF' | 'IDREFS' | 'ENTITY' |
 *                        'ENTITIES' | 'NMTOKEN' | 'NMTOKENS'
 *
 * Validity constraints for attribute values syntax are checked in
 * xmlValidateAttributeValue()
 *
 * [ VC: ID ]
 * Values of type ID must match the Name production. A name must not
 * appear more than once in an XML document as a value of this type;
 * i.e., ID values must uniquely identify the elements which bear them.
 *
 * [ VC: One ID per Element Type ]
 * No element type may have more than one ID attribute specified.
 *
 * [ VC: ID Attribute Default ]
 * An ID attribute must have a declared default of #IMPLIED or #REQUIRED.
 *
 * [ VC: IDREF ]
 * Values of type IDREF must match the Name production, and values
 * of type IDREFS must match Names; each IDREF Name must match the value
 * of an ID attribute on some element in the XML document; i.e. IDREF
 * values must match the value of some ID attribute.
 *
 * [ VC: Entity Name ]
 * Values of type ENTITY must match the Name production, values
 * of type ENTITIES must match Names; each Entity Name must match the
 * name of an unparsed entity declared in the DTD.  
 *
 * [ VC: Name Token ]
 * Values of type NMTOKEN must match the Nmtoken production; values
 * of type NMTOKENS must match Nmtokens. 
 *
 * Returns the attribute type
 */
static int 
xmlOldParseAttributeType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
    SHRINK;
    if ((CUR == 'C') && (NXT(1) == 'D') &&
        (NXT(2) == 'A') && (NXT(3) == 'T') &&
        (NXT(4) == 'A')) {
        SKIP(5);
        return(XML_ATTRIBUTE_CDATA);
     } else if ((CUR == 'I') && (NXT(1) == 'D') &&
        (NXT(2) == 'R') && (NXT(3) == 'E') &&
        (NXT(4) == 'F') && (NXT(5) == 'S')) {
        SKIP(6);
        return(XML_ATTRIBUTE_IDREFS);
     } else if ((CUR == 'I') && (NXT(1) == 'D') &&
        (NXT(2) == 'R') && (NXT(3) == 'E') &&
        (NXT(4) == 'F')) {
        SKIP(5);
        return(XML_ATTRIBUTE_IDREF);
     } else if ((CUR == 'I') && (NXT(1) == 'D')) {
        SKIP(2);
        return(XML_ATTRIBUTE_ID);
     } else if ((CUR == 'E') && (NXT(1) == 'N') &&
        (NXT(2) == 'T') && (NXT(3) == 'I') &&
        (NXT(4) == 'T') && (NXT(5) == 'Y')) {
        SKIP(6);
        return(XML_ATTRIBUTE_ENTITY);
     } else if ((CUR == 'E') && (NXT(1) == 'N') &&
        (NXT(2) == 'T') && (NXT(3) == 'I') &&
        (NXT(4) == 'T') && (NXT(5) == 'I') &&
        (NXT(6) == 'E') && (NXT(7) == 'S')) {
        SKIP(8);
        return(XML_ATTRIBUTE_ENTITIES);
     } else if ((CUR == 'N') && (NXT(1) == 'M') &&
        (NXT(2) == 'T') && (NXT(3) == 'O') &&
        (NXT(4) == 'K') && (NXT(5) == 'E') &&
        (NXT(6) == 'N') && (NXT(7) == 'S')) {
        SKIP(8);
        return(XML_ATTRIBUTE_NMTOKENS);
     } else if ((CUR == 'N') && (NXT(1) == 'M') &&
        (NXT(2) == 'T') && (NXT(3) == 'O') &&
        (NXT(4) == 'K') && (NXT(5) == 'E') &&
        (NXT(6) == 'N')) {
        SKIP(7);
        return(XML_ATTRIBUTE_NMTOKEN);
     }
     return(xmlOldParseEnumeratedType(ctxt, tree));
}

/**
 * xmlOldParseAttributeListDecl:
 * @ctxt:  an XML parser context
 *
 * : parse the Attribute list def for an element
 *
 * [52] AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>'
 *
 * [53] AttDef ::= S Name S AttType S DefaultDecl
 *
 */
static void
xmlOldParseAttributeListDecl(xmlParserCtxtPtr ctxt) {
    xmlChar *elemName;
    xmlChar *attrName;
    xmlEnumerationPtr tree;

    if ((CUR == '<') && (NXT(1) == '!') &&
        (NXT(2) == 'A') && (NXT(3) == 'T') &&
        (NXT(4) == 'T') && (NXT(5) == 'L') &&
        (NXT(6) == 'I') && (NXT(7) == 'S') &&
        (NXT(8) == 'T')) {
        SKIP(9);
        if (!IS_BLANK(CUR)) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
                                 "Space required after '<!ATTLIST'\n");
            ctxt->errNo = XML_ERR_SPACE_REQUIRED;
            ctxt->wellFormed = 0;
        }
        SKIP_BLANKS;
        elemName = xmlOldParseName(ctxt);
        if (elemName == NULL) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
                                 "ATTLIST: no name for Element\n");
            ctxt->errNo = XML_ERR_NAME_REQUIRED;
            ctxt->wellFormed = 0;
            return;
        }
        SKIP_BLANKS;
        while (CUR != '>') {
            const xmlChar *check = CUR_PTR;
            int type;
            int def;
            xmlChar *defaultValue = NULL;

            tree = NULL;
            attrName = xmlOldParseName(ctxt);
            if (attrName == NULL) {
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData,
                                     "ATTLIST: no name for Attribute\n");
                ctxt->errNo = XML_ERR_NAME_REQUIRED;
                ctxt->wellFormed = 0;
                break;
            }
            GROW;
            if (!IS_BLANK(CUR)) {
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData, 
                        "Space required after the attribute name\n");
                ctxt->errNo = XML_ERR_SPACE_REQUIRED;
                ctxt->wellFormed = 0;
                break;
            }
            SKIP_BLANKS;

            type = xmlOldParseAttributeType(ctxt, &tree);
            if (type <= 0) break;

            GROW;
            if (!IS_BLANK(CUR)) {
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData, 
                        "Space required after the attribute type\n");
                ctxt->errNo = XML_ERR_SPACE_REQUIRED;
                ctxt->wellFormed = 0;
                break;
            }
            SKIP_BLANKS;

            def = xmlOldParseDefaultDecl(ctxt, &defaultValue);
            if (def <= 0) break;

            GROW;
            if (CUR != '>') {
                if (!IS_BLANK(CUR)) {
                    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                        ctxt->sax->error(ctxt->userData, 
                        "Space required after the attribute default value\n");
                    ctxt->errNo = XML_ERR_SPACE_REQUIRED;
                    ctxt->wellFormed = 0;
                    break;
                }
                SKIP_BLANKS;
            }
            if (check == CUR_PTR) {
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData, 
                    "xmlParseAttributeListDecl: detected internal error\n");
                ctxt->errNo = XML_ERR_INTERNAL_ERROR;
                break;
            }
            if ((ctxt->sax != NULL) && (ctxt->sax->attributeDecl != NULL))
                ctxt->sax->attributeDecl(ctxt->userData, elemName, attrName,
                                type, def, defaultValue, tree);
            if (attrName != NULL)
                xmlFree(attrName);
            if (defaultValue != NULL)
                xmlFree(defaultValue);
            GROW;
        }
        if (CUR == '>')
            NEXT;

        xmlFree(elemName);
    }
}

/**
 * xmlOldParseElementMixedContentDecl:
 * @ctxt:  an XML parser context
 *
 * parse the declaration for a Mixed Element content
 * The leading '(' and spaces have been skipped in xmlOldParseElementContentDecl
 * 
 * [51] Mixed ::= '(' S? '#PCDATA' (S? '|' S? Name)* S? ')*' |
 *                '(' S? '#PCDATA' S? ')'
 *
 * [ VC: Proper Group/PE Nesting ] applies to [51] too (see [49])
 *
 * [ VC: No Duplicate Types ]
 * The same name must not appear more than once in a single
 * mixed-content declaration. 
 *
 * returns: the list of the xmlElementContentPtr describing the element choices
 */
static xmlElementContentPtr
xmlOldParseElementMixedContentDecl(xmlParserCtxtPtr ctxt) {
    xmlElementContentPtr ret = NULL, cur = NULL, n;
    xmlChar *elem = NULL;

    GROW;
    if ((CUR == '#') && (NXT(1) == 'P') &&
        (NXT(2) == 'C') && (NXT(3) == 'D') &&
        (NXT(4) == 'A') && (NXT(5) == 'T') &&
        (NXT(6) == 'A')) {
        SKIP(7);
        SKIP_BLANKS;
        SHRINK;
        if (CUR == ')') {
            NEXT;
            ret = xmlNewElementContent(NULL, XML_ELEMENT_CONTENT_PCDATA);
            if (CUR == '*') {
                ret->ocur = XML_ELEMENT_CONTENT_MULT;
                NEXT;
            }
            return(ret);
        }
        if ((CUR == '(') || (CUR == '|')) {
            ret = cur = xmlNewElementContent(NULL, XML_ELEMENT_CONTENT_PCDATA);
            if (ret == NULL) return(NULL);
        }
        while (CUR == '|') {
            NEXT;
            if (elem == NULL) {
                ret = xmlNewElementContent(NULL, XML_ELEMENT_CONTENT_OR);
                if (ret == NULL) return(NULL);
                ret->c1 = cur;
                cur = ret;
            } else {
                n = xmlNewElementContent(NULL, XML_ELEMENT_CONTENT_OR);
                if (n == NULL) return(NULL);
                n->c1 = xmlNewElementContent(elem, XML_ELEMENT_CONTENT_ELEMENT);
                cur->c2 = n;
                cur = n;
                xmlFree(elem);
            }
            SKIP_BLANKS;
            elem = xmlOldParseName(ctxt);
            if (elem == NULL) {
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData, 
                        "xmlParseElementMixedContentDecl : Name expected\n");
                ctxt->errNo = XML_ERR_NAME_REQUIRED;
                ctxt->wellFormed = 0;
                xmlFreeElementContent(cur);
                return(NULL);
            }
            SKIP_BLANKS;
            GROW;
        }
        if ((CUR == ')') && (NXT(1) == '*')) {
            if (elem != NULL) {
                cur->c2 = xmlNewElementContent(elem,
                                               XML_ELEMENT_CONTENT_ELEMENT);
                xmlFree(elem);
            }
            ret->ocur = XML_ELEMENT_CONTENT_MULT;
            SKIP(2);
        } else {
            if (elem != NULL) xmlFree(elem);
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData, 
                    "xmlParseElementMixedContentDecl : '|' or ')*' expected\n");
            ctxt->errNo = XML_ERR_MIXED_NOT_STARTED;
            ctxt->wellFormed = 0;
            xmlFreeElementContent(ret);
            return(NULL);
        }

    } else {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData, 
                "xmlParseElementMixedContentDecl : '#PCDATA' expected\n");
        ctxt->errNo = XML_ERR_PCDATA_REQUIRED;
        ctxt->wellFormed = 0;
    }
    return(ret);
}

/**
 * xmlOldParseElementChildrenContentDecl:
 * @ctxt:  an XML parser context
 *
 * parse the declaration for a Mixed Element content
 * The leading '(' and spaces have been skipped in xmlOldParseElementContentDecl
 * 
 *
 * [47] children ::= (choice | seq) ('?' | '*' | '+')?
 *
 * [48] cp ::= (Name | choice | seq) ('?' | '*' | '+')?
 *
 * [49] choice ::= '(' S? cp ( S? '|' S? cp )* S? ')'
 *
 * [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')'
 *
 * [ VC: Proper Group/PE Nesting ] applies to [49] and [50]
 * TODO Parameter-entity replacement text must be properly nested
 *      with parenthetized groups. That is to say, if either of the
 *      opening or closing parentheses in a choice, seq, or Mixed
 *      construct is contained in the replacement text for a parameter
 *      entity, both must be contained in the same replacement text. For
 *      interoperability, if a parameter-entity reference appears in a
 *      choice, seq, or Mixed construct, its replacement text should not
 *      be empty, and neither the first nor last non-blank character of
 *      the replacement text should be a connector (| or ,).
 *
 * returns: the tree of xmlElementContentPtr describing the element 
 *          hierarchy.
 */
static xmlElementContentPtr
xmlOldParseElementChildrenContentDecl(xmlParserCtxtPtr ctxt) {
    xmlElementContentPtr ret = NULL, cur = NULL, last = NULL, op = NULL;
    xmlChar *elem;
    xmlChar type = 0;

    SKIP_BLANKS;
    GROW;
    if (CUR == '(') {
        /* Recurse on first child */
        NEXT;
        SKIP_BLANKS;
        cur = ret = xmlOldParseElementChildrenContentDecl(ctxt);
        SKIP_BLANKS;
        GROW;
    } else {
        elem = xmlOldParseName(ctxt);
        if (elem == NULL) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData, 
                "xmlParseElementChildrenContentDecl : Name or '(' expected\n");
            ctxt->errNo = XML_ERR_ELEMCONTENT_NOT_STARTED;
            ctxt->wellFormed = 0;
            return(NULL);
        }
        cur = ret = xmlNewElementContent(elem, XML_ELEMENT_CONTENT_ELEMENT);
        GROW;
        if (CUR == '?') {
            cur->ocur = XML_ELEMENT_CONTENT_OPT;
            NEXT;
        } else if (CUR == '*') {
            cur->ocur = XML_ELEMENT_CONTENT_MULT;
            NEXT;
        } else if (CUR == '+') {
            cur->ocur = XML_ELEMENT_CONTENT_PLUS;
            NEXT;
        } else {
            cur->ocur = XML_ELEMENT_CONTENT_ONCE;
        }
        xmlFree(elem);
        GROW;
    }
    SKIP_BLANKS;
    SHRINK;
    while (CUR != ')') {
        /*
         * Each loop we parse one separator and one element.
         */
        if (CUR == ',') {
            if (type == 0) type = CUR;

            /*
             * Detect "Name | Name , Name" error
             */
            else if (type != CUR) {
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData, 
                    "xmlParseElementChildrenContentDecl : '%c' expected\n",
                    type);
                ctxt->errNo = XML_ERR_SEPARATOR_REQUIRED;
                ctxt->wellFormed = 0;
                xmlFreeElementContent(ret);
                return(NULL);
            }
            NEXT;

            op = xmlNewElementContent(NULL, XML_ELEMENT_CONTENT_SEQ);
            if (op == NULL) {
                xmlFreeElementContent(ret);
                return(NULL);
            }
            if (last == NULL) {
                op->c1 = ret;
                ret = cur = op;
            } else {
                cur->c2 = op;
                op->c1 = last;
                cur =op;
                last = NULL;
            }
        } else if (CUR == '|') {
            if (type == 0) type = CUR;

            /*
             * Detect "Name , Name | Name" error
             */
            else if (type != CUR) {
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData, 
                    "xmlParseElementChildrenContentDecl : '%c' expected\n",
                    type);
                ctxt->errNo = XML_ERR_SEPARATOR_REQUIRED;
                ctxt->wellFormed = 0;
                xmlFreeElementContent(ret);
                return(NULL);
            }
            NEXT;

            op = xmlNewElementContent(NULL, XML_ELEMENT_CONTENT_OR);
            if (op == NULL) {
                xmlFreeElementContent(ret);
                return(NULL);
            }
            if (last == NULL) {
                op->c1 = ret;
                ret = cur = op;
            } else {
                cur->c2 = op;
                op->c1 = last;
                cur =op;
                last = NULL;
            }
        } else {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData, 
            "xmlParseElementChildrenContentDecl : ',' '|' or ')' expected\n");
            ctxt->wellFormed = 0;
            ctxt->errNo = XML_ERR_ELEMCONTENT_NOT_FINISHED;
            xmlFreeElementContent(ret);
            return(NULL);
        }
        GROW;
        SKIP_BLANKS;
        GROW;
        if (CUR == '(') {
            /* Recurse on second child */
            NEXT;
            SKIP_BLANKS;
            last = xmlOldParseElementChildrenContentDecl(ctxt);
            SKIP_BLANKS;
        } else {
            elem = xmlOldParseName(ctxt);
            if (elem == NULL) {
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData, 
                "xmlParseElementChildrenContentDecl : Name or '(' expected\n");
                ctxt->errNo = XML_ERR_ELEMCONTENT_NOT_STARTED;
                ctxt->wellFormed = 0;
                return(NULL);
            }
            last = xmlNewElementContent(elem, XML_ELEMENT_CONTENT_ELEMENT);
            xmlFree(elem);
            if (CUR == '?') {
                last->ocur = XML_ELEMENT_CONTENT_OPT;
                NEXT;
            } else if (CUR == '*') {
                last->ocur = XML_ELEMENT_CONTENT_MULT;
                NEXT;
            } else if (CUR == '+') {
                last->ocur = XML_ELEMENT_CONTENT_PLUS;
                NEXT;
            } else {
                last->ocur = XML_ELEMENT_CONTENT_ONCE;
            }
        }
        SKIP_BLANKS;
        GROW;
    }
    if ((cur != NULL) && (last != NULL)) {
        cur->c2 = last;
    }
    NEXT;
    if (CUR == '?') {
        ret->ocur = XML_ELEMENT_CONTENT_OPT;
        NEXT;
    } else if (CUR == '*') {
        ret->ocur = XML_ELEMENT_CONTENT_MULT;
        NEXT;
    } else if (CUR == '+') {
        ret->ocur = XML_ELEMENT_CONTENT_PLUS;
        NEXT;
    }
    return(ret);
}

/**
 * xmlOldParseElementContentDecl:
 * @ctxt:  an XML parser context
 * @name:  the name of the element being defined.
 * @result:  the Element Content pointer will be stored here if any
 *
 * parse the declaration for an Element content either Mixed or Children,
 * the cases EMPTY and ANY are handled directly in xmlOldParseElementDecl
 * 
 * [46] contentspec ::= 'EMPTY' | 'ANY' | Mixed | children
 *
 * returns: the type of element content XML_ELEMENT_TYPE_xxx
 */

static int
xmlOldParseElementContentDecl(xmlParserCtxtPtr ctxt, xmlChar *name,
                           xmlElementContentPtr *result) {

    xmlElementContentPtr tree = NULL;
    int res;

    *result = NULL;

    if (CUR != '(') {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData, 
                "xmlParseElementContentDecl : '(' expected\n");
        ctxt->errNo = XML_ERR_ELEMCONTENT_NOT_STARTED;
        ctxt->wellFormed = 0;
        return(-1);
    }
    NEXT;
    GROW;
    SKIP_BLANKS;
    if ((CUR == '#') && (NXT(1) == 'P') &&
        (NXT(2) == 'C') && (NXT(3) == 'D') &&
        (NXT(4) == 'A') && (NXT(5) == 'T') &&
        (NXT(6) == 'A')) {
        tree = xmlOldParseElementMixedContentDecl(ctxt);
        res = XML_ELEMENT_TYPE_MIXED;
    } else {
        tree = xmlOldParseElementChildrenContentDecl(ctxt);
        res = XML_ELEMENT_TYPE_ELEMENT;
    }
    SKIP_BLANKS;
    /****************************
    if (CUR != ')') {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData, 
                "xmlParseElementContentDecl : ')' expected\n");
        ctxt->wellFormed = 0;
        return(-1);
    }
     ****************************/
    *result = tree;
    return(res);
}

/**
 * xmlOldParseElementDecl:
 * @ctxt:  an XML parser context
 *
 * parse an Element declaration.
 *
 * [45] elementdecl ::= '<!ELEMENT' S Name S contentspec S? '>'
 *
 * [ VC: Unique Element Type Declaration ]
 * No element type may be declared more than once
 *
 * Returns the type of the element, or -1 in case of error
 */
static int
xmlOldParseElementDecl(xmlParserCtxtPtr ctxt) {
    xmlChar *name;
    int ret = -1;
    xmlElementContentPtr content  = NULL;

    GROW;
    if ((CUR == '<') && (NXT(1) == '!') &&
        (NXT(2) == 'E') && (NXT(3) == 'L') &&
        (NXT(4) == 'E') && (NXT(5) == 'M') &&
        (NXT(6) == 'E') && (NXT(7) == 'N') &&
        (NXT(8) == 'T')) {
        SKIP(9);
        if (!IS_BLANK(CUR)) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData, 
                    "Space required after 'ELEMENT'\n");
            ctxt->errNo = XML_ERR_SPACE_REQUIRED;
            ctxt->wellFormed = 0;
        }
        SKIP_BLANKS;
        name = xmlOldParseName(ctxt);
        if (name == NULL) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
                   "xmlParseElementDecl: no name for Element\n");
            ctxt->errNo = XML_ERR_NAME_REQUIRED;
            ctxt->wellFormed = 0;
            return(-1);
        }
        if (!IS_BLANK(CUR)) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData, 
                    "Space required after the element name\n");
            ctxt->errNo = XML_ERR_SPACE_REQUIRED;
            ctxt->wellFormed = 0;
        }
        SKIP_BLANKS;
        if ((CUR == 'E') && (NXT(1) == 'M') &&
            (NXT(2) == 'P') && (NXT(3) == 'T') &&
            (NXT(4) == 'Y')) {
            SKIP(5);
            /*
             * Element must always be empty.
             */
            ret = XML_ELEMENT_TYPE_EMPTY;
        } else if ((CUR == 'A') && (NXT(1) == 'N') &&
                   (NXT(2) == 'Y')) {
            SKIP(3);
            /*
             * Element is a generic container.
             */
            ret = XML_ELEMENT_TYPE_ANY;
        } else if (CUR == '(') {
            ret = xmlOldParseElementContentDecl(ctxt, name, &content);
        } else {
            /*
             * [ WFC: PEs in Internal Subset ] error handling.
             */
            if ((CUR == '%') && (ctxt->external == 0) &&
                (ctxt->inputNr == 1)) {
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData, 
          "PEReference: forbidden within markup decl in internal subset\n");
                ctxt->errNo = XML_ERR_PEREF_IN_INT_SUBSET;
            } else {
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData, 
                      "xmlParseElementDecl: 'EMPTY', 'ANY' or '(' expected\n");
                ctxt->errNo = XML_ERR_ELEMCONTENT_NOT_STARTED;
            }
            ctxt->wellFormed = 0;
            if (name != NULL) xmlFree(name);
            return(-1);
        }

        SKIP_BLANKS;
        /*
         * Pop-up of finished entities.
         */
        while ((CUR == 0) && (ctxt->inputNr > 1))
            xmlOldPopInput(ctxt);
        SKIP_BLANKS;

        if (CUR != '>') {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData, 
                  "xmlParseElementDecl: expected '>' at the end\n");
            ctxt->errNo = XML_ERR_GT_REQUIRED;
            ctxt->wellFormed = 0;
        } else {
            NEXT;
            if ((ctxt->sax != NULL) && (ctxt->sax->elementDecl != NULL))
                ctxt->sax->elementDecl(ctxt->userData, name, ret,
                                       content);
        }
        if (content != NULL) {
            xmlFreeElementContent(content);
        }
        if (name != NULL) {
            xmlFree(name);
        }
    }
    return(ret);
}

/**
 * xmlOldParseMarkupDecl:
 * @ctxt:  an XML parser context
 * 
 * parse Markup declarations
 *
 * [29] markupdecl ::= elementdecl | AttlistDecl | EntityDecl |
 *                     NotationDecl | PI | Comment
 *
 * [ VC: Proper Declaration/PE Nesting ]
 * TODO Parameter-entity replacement text must be properly nested with
 * markup declarations. That is to say, if either the first character
 * or the last character of a markup declaration (markupdecl above) is
 * contained in the replacement text for a parameter-entity reference,
 * both must be contained in the same replacement text.
 *
 * [ WFC: PEs in Internal Subset ]
 * In the internal DTD subset, parameter-entity references can occur
 * only where markup declarations can occur, not within markup declarations.
 * (This does not apply to references that occur in external parameter
 * entities or to the external subset.) 
 */
static void
xmlOldParseMarkupDecl(xmlParserCtxtPtr ctxt) {
    GROW;
    xmlOldParseElementDecl(ctxt);
    xmlOldParseAttributeListDecl(ctxt);
    xmlOldParseEntityDecl(ctxt);
    xmlOldParseNotationDecl(ctxt);
    xmlOldParsePI(ctxt);
    xmlOldParseComment(ctxt);
    /*
     * This is only for internal subset. On external entities,
     * the replacement is done before parsing stage
     */
    if ((ctxt->external == 0) && (ctxt->inputNr == 1))
        xmlOldParsePEReference(ctxt);
    ctxt->instate = XML_PARSER_DTD;
}

/**
 * xmlOldParseTextDecl:
 * @ctxt:  an XML parser context
 * 
 * parse an XML declaration header for external entities
 *
 * [77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>'
 *
 * Returns the only valuable info for an external parsed entity, the encoding
 */

static xmlChar *
xmlOldParseTextDecl(xmlParserCtxtPtr ctxt) {
    xmlChar *version;
    xmlChar *encoding = NULL;

    /*
     * We know that '<?xml' is here.
     */
    SKIP(5);

    if (!IS_BLANK(CUR)) {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
                             "Space needed after '<?xml'\n");
        ctxt->errNo = XML_ERR_SPACE_REQUIRED;
        ctxt->wellFormed = 0;
    }
    SKIP_BLANKS;

    /*
     * We may have the VersionInfo here.
     */
    version = xmlOldParseVersionInfo(ctxt);
    if (version == NULL)
        version = xmlCharStrdup(XML_DEFAULT_VERSION);
    ctxt->version = xmlStrdup(version);
    xmlFree(version);

    /*
     * We must have the encoding declaration
     */
    if (!IS_BLANK(CUR)) {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData, "Space needed here\n");
        ctxt->errNo = XML_ERR_SPACE_REQUIRED;
        ctxt->wellFormed = 0;
    }
    encoding = xmlOldParseEncodingDecl(ctxt);

    SKIP_BLANKS;
    if ((CUR == '?') && (NXT(1) == '>')) {
        SKIP(2);
    } else if (CUR == '>') {
        /* Deprecated old WD ... */
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
                             "XML declaration must end-up with '?>'\n");
        ctxt->errNo = XML_ERR_XMLDECL_NOT_FINISHED;
        ctxt->wellFormed = 0;
        NEXT;
    } else {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
                             "parsing XML declaration: '?>' expected\n");
        ctxt->errNo = XML_ERR_XMLDECL_NOT_FINISHED;
        ctxt->wellFormed = 0;
        MOVETO_ENDTAG(CUR_PTR);
        NEXT;
    }
    return(encoding);
}

/*
 * xmlOldParseConditionalSections
 * @ctxt:  an XML parser context
 *
 * TODO : Conditionnal section are not yet supported !
 *
 * [61] conditionalSect ::= includeSect | ignoreSect 
 * [62] includeSect ::= '<![' S? 'INCLUDE' S? '[' extSubsetDecl ']]>' 
 * [63] ignoreSect ::= '<![' S? 'IGNORE' S? '[' ignoreSectContents* ']]>'
 * [64] ignoreSectContents ::= Ignore ('<![' ignoreSectContents ']]>' Ignore)*
 * [65] Ignore ::= Char* - (Char* ('<![' | ']]>') Char*)
 */

static void
xmlOldParseConditionalSections(xmlParserCtxtPtr ctxt) {
    if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
        ctxt->sax->warning(ctxt->userData,
                           "XML conditional section not supported\n");
    /*
     * Skip up to the end of the conditionnal section.
     */
    while ((CUR != 0) && ((CUR != ']') || (NXT(1) != ']') || (NXT(2) != '>'))) {
        NEXT;
        /*
         * Pop-up of finished entities.
         */
        while ((CUR == 0) && (ctxt->inputNr > 1))
            xmlOldPopInput(ctxt);

        if (CUR == 0)
            GROW;
    }

    if (CUR == 0)
        SHRINK;

    if (CUR == 0) {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
                "XML conditional section not closed\n");
        ctxt->errNo = XML_ERR_CONDSEC_NOT_FINISHED;
        ctxt->wellFormed = 0;
    } else {
        SKIP(3);
    }
}

/**
 * xmlOldParseExternalSubset:
 * @ctxt:  an XML parser context
 * @ExternalID: the external identifier
 * @SystemID: the system identifier (or URL)
 * 
 * parse Markup declarations from an external subset
 *
 * [30] extSubset ::= textDecl? extSubsetDecl
 *
 * [31] extSubsetDecl ::= (markupdecl | conditionalSect | PEReference | S) *
 */
void
xmlOldParseExternalSubset(xmlParserCtxtPtr ctxt, const xmlChar *ExternalID,
                       const xmlChar *SystemID) {
    GROW;
    if ((CUR == '<') && (NXT(1) == '?') &&
        (NXT(2) == 'x') && (NXT(3) == 'm') &&
        (NXT(4) == 'l')) {
        xmlChar *decl;

        decl = xmlOldParseTextDecl(ctxt);
        if (decl != NULL)
            xmlFree(decl);
    }
    if (ctxt->myDoc == NULL) {
        ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
    }
    if ((ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset == NULL))
        xmlCreateIntSubset(ctxt->myDoc, NULL, ExternalID, SystemID);

    ctxt->instate = XML_PARSER_DTD;
    ctxt->external = 1;
    while (((CUR == '<') && (NXT(1) == '?')) ||
           ((CUR == '<') && (NXT(1) == '!')) ||
           IS_BLANK(CUR)) {
        const xmlChar *check = CUR_PTR;
        int cons = ctxt->input->consumed;

        if ((CUR == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
            xmlOldParseConditionalSections(ctxt);
        } else if (IS_BLANK(CUR)) {
            NEXT;
        } else if (CUR == '%') {
            xmlOldParsePEReference(ctxt);
        } else
            xmlOldParseMarkupDecl(ctxt);

        /*
         * Pop-up of finished entities.
         */
        while ((CUR == 0) && (ctxt->inputNr > 1))
            xmlOldPopInput(ctxt);

        if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
                    "Content error in the external subset\n");
            ctxt->wellFormed = 0;
            ctxt->errNo = XML_ERR_EXT_SUBSET_NOT_FINISHED;
            break;
        }
    }
    
    if (CUR != 0) {
        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
            ctxt->sax->error(ctxt->userData,
                "Extra content at the end of the document\n");
        ctxt->errNo = XML_ERR_EXT_SUBSET_NOT_FINISHED;
        ctxt->wellFormed = 0;
    }

}

/**
 * xmlOldParseReference:
 * @ctxt:  an XML parser context
 * 
 * parse and handle entity references in content, depending on the SAX
 * interface, this may end-up in a call to character() if this is a
 * CharRef, a predefined entity, if there is no reference() callback.
 * or if the parser was asked to switch to that mode.
 *
 * [67] Reference ::= EntityRef | CharRef
 */
static void
xmlOldParseReference(xmlParserCtxtPtr ctxt) {
    xmlEntityPtr ent;
    xmlChar *val;
    if (CUR != '&') return;
#if 0
    if (ctxt->inputNr > 1) {
        xmlChar cur[2] = { '&' , 0 } ;

        if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL))
            ctxt->sax->characters(ctxt->userData, cur, 1);
        if (ctxt->token == '&')
            ctxt->token = 0;
        else {
            SKIP(1);
        }
        return;
    }
#endif
    if (NXT(1) == '#') {
        xmlChar out[2];
        int val = xmlOldParseCharRef(ctxt);
        /* invalid for UTF-8 variable encoding !!!!! */
        out[0] = val;
        out[1] = 0;
        if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL))
            ctxt->sax->characters(ctxt->userData, out, 1);
    } else {
        ent = xmlOldParseEntityRef(ctxt);
        if (ent == NULL) return;
        if ((ent->name != NULL) && 
            (ent->type != XML_INTERNAL_PREDEFINED_ENTITY)) {
            if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
                (ctxt->replaceEntities == 0)) {
                /*
                 * Create a node.
                 */
                ctxt->sax->reference(ctxt->userData, ent->name);
                return;
            } else if (ctxt->replaceEntities) {
                xmlParserInputPtr input;

                input = xmlOldNewEntityInputStream(ctxt, ent);
                xmlOldPushInput(ctxt, input);
                return;
            }
        }
        val = ent->content;
        if (val == NULL) return;
        /*
         * inline the entity.
         */
        if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL))
            ctxt->sax->characters(ctxt->userData, val, xmlStrlen(val));
    }
}

/**
 * xmlOldParseEntityRef:
 * @ctxt:  an XML parser context
 *
 * parse ENTITY references declarations
 *
 * [68] EntityRef ::= '&' Name ';'
 *
 * [ WFC: Entity Declared ]
 * In a document without any DTD, a document with only an internal DTD
 * subset which contains no parameter entity references, or a document
 * with "standalone='yes'", the Name given in the entity reference
 * must match that in an entity declaration, except that well-formed
 * documents need not declare any of the following entities: amp, lt,
 * gt, apos, quot.  The declaration of a parameter entity must precede
 * any reference to it.  Similarly, the declaration of a general entity
 * must precede any reference to it which appears in a default value in an
 * attribute-list declaration. Note that if entities are declared in the
 * external subset or in external parameter entities, a non-validating
 * processor is not obligated to read and process their declarations;
 * for such documents, the rule that an entity must be declared is a
 * well-formedness constraint only if standalone='yes'.
 *
 * [ WFC: Parsed Entity ]
 * An entity reference must not contain the name of an unparsed entity
 *
 * Returns the xmlEntityPtr if found, or NULL otherwise.
 */
static xmlEntityPtr
xmlOldParseEntityRef(xmlParserCtxtPtr ctxt) {
    xmlChar *name;
    xmlEntityPtr ent = NULL;

    GROW;
    
    if (CUR == '&') {
        NEXT;
        name = xmlOldParseName(ctxt);
        if (name == NULL) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
                                 "xmlParseEntityRef: no name\n");
            ctxt->errNo = XML_ERR_NAME_REQUIRED;
            ctxt->wellFormed = 0;
        } else {
            if (CUR == ';') {
                NEXT;
                /*
                 * Ask first SAX for entity resolution, otherwise try the
                 * predefined set.
                 */
                if (ctxt->sax != NULL) {
                    if (ctxt->sax->getEntity != NULL)
                        ent = ctxt->sax->getEntity(ctxt->userData, name);
                    if (ent == NULL)
                        ent = xmlGetPredefinedEntity(name);
                }
                /*
                 * [ WFC: Entity Declared ]
                 * In a document without any DTD, a document with only an
                 * internal DTD subset which contains no parameter entity
                 * references, or a document with "standalone='yes'", the
                 * Name given in the entity reference must match that in an
                 * entity declaration, except that well-formed documents
                 * need not declare any of the following entities: amp, lt,
                 * gt, apos, quot.
                 * The declaration of a parameter entity must precede any
                 * reference to it.
                 * Similarly, the declaration of a general entity must
                 * precede any reference to it which appears in a default
                 * value in an attribute-list declaration. Note that if
                 * entities are declared in the external subset or in
                 * external parameter entities, a non-validating processor
                 * is not obligated to read and process their declarations;
                 * for such documents, the rule that an entity must be
                 * declared is a well-formedness constraint only if
                 * standalone='yes'. 
                 */
                if (ent == NULL) {
                    if ((ctxt->standalone == 1) ||
                        ((ctxt->hasExternalSubset == 0) &&
                         (ctxt->hasPErefs == 0))) {
                        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                            ctxt->sax->error(ctxt->userData, 
                                 "Entity '%s' not defined\n", name);
                        ctxt->errNo = XML_ERR_UNDECLARED_ENTITY;
                        ctxt->wellFormed = 0;
                    } else {
                        if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
                            ctxt->sax->warning(ctxt->userData, 
                                 "Entity '%s' not defined\n", name);
                        ctxt->errNo = XML_WAR_UNDECLARED_ENTITY;
                    }
                }

                /*
                 * [ WFC: Parsed Entity ]
                 * An entity reference must not contain the name of an
                 * unparsed entity
                 */
                else if (ent->type == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
                    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                        ctxt->sax->error(ctxt->userData, 
                             "Entity reference to unparsed entity %s\n", name);
                    ctxt->errNo = XML_ERR_UNPARSED_ENTITY;
                    ctxt->wellFormed = 0;
                }

                /*
                 * [ WFC: No External Entity References ]
                 * Attribute values cannot contain direct or indirect
                 * entity references to external entities.
                 */
                else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
                         (ent->type == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
                    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                        ctxt->sax->error(ctxt->userData, 
                     "Attribute references external entity '%s'\n", name);
                    ctxt->errNo = XML_ERR_ENTITY_IS_EXTERNAL;
                    ctxt->wellFormed = 0;
                }
                /*
                 * [ WFC: No < in Attribute Values ]
                 * The replacement text of any entity referred to directly or
                 * indirectly in an attribute value (other than "&lt;") must
                 * not contain a <. 
                 */
                else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
                         (ent != NULL) &&
                         (xmlStrcmp(ent->name, BAD_CAST "lt")) &&
                         (ent->content != NULL) &&
                         (xmlStrchr(ent->content, '<'))) {
                    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                        ctxt->sax->error(ctxt->userData, 
         "'<' in entity '%s' is not allowed in attributes values\n", name);
                    ctxt->errNo = XML_ERR_LT_IN_ATTRIBUTE;
                    ctxt->wellFormed = 0;
                }

                /*
                 * Internal check, no parameter entities here ...
                 */
                else {
                    switch (ent->type) {
                        case XML_INTERNAL_PARAMETER_ENTITY:
                        case XML_EXTERNAL_PARAMETER_ENTITY:
                        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                            ctxt->sax->error(ctxt->userData, 
                     "Attempt to reference the parameter entity '%s'\n", name);
                        ctxt->errNo = XML_ERR_ENTITY_IS_PARAMETER;
                        ctxt->wellFormed = 0;
                        break;
                    }
                }

                /*
                 * [ WFC: No Recursion ]
                 * TODO A parsed entity must not contain a recursive reference
                 * to itself, either directly or indirectly. 
                 */

            } else {
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData,
                                     "xmlParseEntityRef: expecting ';'\n");
                ctxt->errNo = XML_ERR_ENTITYREF_SEMICOL_MISSING;
                ctxt->wellFormed = 0;
            }
            xmlFree(name);
        }
    }
    return(ent);
}
/**
 * xmlOldParseStringEntityRef:
 * @ctxt:  an XML parser context
 * @str:  a pointer to an index in the string
 *
 * parse ENTITY references declarations, but this version parses it from
 * a string value.
 *
 * [68] EntityRef ::= '&' Name ';'
 *
 * [ WFC: Entity Declared ]
 * In a document without any DTD, a document with only an internal DTD
 * subset which contains no parameter entity references, or a document
 * with "standalone='yes'", the Name given in the entity reference
 * must match that in an entity declaration, except that well-formed
 * documents need not declare any of the following entities: amp, lt,
 * gt, apos, quot.  The declaration of a parameter entity must precede
 * any reference to it.  Similarly, the declaration of a general entity
 * must precede any reference to it which appears in a default value in an
 * attribute-list declaration. Note that if entities are declared in the
 * external subset or in external parameter entities, a non-validating
 * processor is not obligated to read and process their declarations;
 * for such documents, the rule that an entity must be declared is a
 * well-formedness constraint only if standalone='yes'.
 *
 * [ WFC: Parsed Entity ]
 * An entity reference must not contain the name of an unparsed entity
 *
 * Returns the xmlEntityPtr if found, or NULL otherwise. The str pointer
 * is updated to the current location in the string.
 */
static xmlEntityPtr
xmlOldParseStringEntityRef(xmlParserCtxtPtr ctxt, const xmlChar ** str) {
    xmlChar *name;
    const xmlChar *ptr;
    xmlChar cur;
    xmlEntityPtr ent = NULL;

    GROW;
    
    if ((str == NULL) || (*str == NULL)) return(NULL); /* !!! */
    ptr = *str;
    cur = *ptr;
    if (cur == '&') {
        ptr++;
        cur = *ptr;
        name = xmlOldParseStringName(ctxt, &ptr);
        if (name == NULL) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
                                 "xmlParseEntityRef: no name\n");
            ctxt->errNo = XML_ERR_NAME_REQUIRED;
            ctxt->wellFormed = 0;
        } else {
            if (CUR == ';') {
                NEXT;
                /*
                 * Ask first SAX for entity resolution, otherwise try the
                 * predefined set.
                 */
                if (ctxt->sax != NULL) {
                    if (ctxt->sax->getEntity != NULL)
                        ent = ctxt->sax->getEntity(ctxt->userData, name);
                    if (ent == NULL)
                        ent = xmlGetPredefinedEntity(name);
                }
                /*
                 * [ WFC: Entity Declared ]
                 * In a document without any DTD, a document with only an
                 * internal DTD subset which contains no parameter entity
                 * references, or a document with "standalone='yes'", the
                 * Name given in the entity reference must match that in an
                 * entity declaration, except that well-formed documents
                 * need not declare any of the following entities: amp, lt,
                 * gt, apos, quot.
                 * The declaration of a parameter entity must precede any
                 * reference to it.
                 * Similarly, the declaration of a general entity must
                 * precede any reference to it which appears in a default
                 * value in an attribute-list declaration. Note that if
                 * entities are declared in the external subset or in
                 * external parameter entities, a non-validating processor
                 * is not obligated to read and process their declarations;
                 * for such documents, the rule that an entity must be
                 * declared is a well-formedness constraint only if
                 * standalone='yes'. 
                 */
                if (ent == NULL) {
                    if ((ctxt->standalone == 1) ||
                        ((ctxt->hasExternalSubset == 0) &&
                         (ctxt->hasPErefs == 0))) {
                        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                            ctxt->sax->error(ctxt->userData, 
                                 "Entity '%s' not defined\n", name);
                        ctxt->errNo = XML_ERR_UNDECLARED_ENTITY;
                        ctxt->wellFormed = 0;
                    } else {
                        if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
                            ctxt->sax->warning(ctxt->userData, 
                                 "Entity '%s' not defined\n", name);
                        ctxt->errNo = XML_WAR_UNDECLARED_ENTITY;
                    }
                }

                /*
                 * [ WFC: Parsed Entity ]
                 * An entity reference must not contain the name of an
                 * unparsed entity
                 */
                else if (ent->type == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
                    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                        ctxt->sax->error(ctxt->userData, 
                             "Entity reference to unparsed entity %s\n", name);
                    ctxt->errNo = XML_ERR_UNPARSED_ENTITY;
                    ctxt->wellFormed = 0;
                }

                /*
                 * [ WFC: No External Entity References ]
                 * Attribute values cannot contain direct or indirect
                 * entity references to external entities.
                 */
                else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
                         (ent->type == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
                    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                        ctxt->sax->error(ctxt->userData, 
                     "Attribute references external entity '%s'\n", name);
                    ctxt->errNo = XML_ERR_ENTITY_IS_EXTERNAL;
                    ctxt->wellFormed = 0;
                }
                /*
                 * [ WFC: No < in Attribute Values ]
                 * The replacement text of any entity referred to directly or
                 * indirectly in an attribute value (other than "&lt;") must
                 * not contain a <. 
                 */
                else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
                         (ent != NULL) &&
                         (xmlStrcmp(ent->name, BAD_CAST "lt")) &&
                         (ent->content != NULL) &&
                         (xmlStrchr(ent->content, '<'))) {
                    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                        ctxt->sax->error(ctxt->userData, 
         "'<' in entity '%s' is not allowed in attributes values\n", name);
                    ctxt->errNo = XML_ERR_LT_IN_ATTRIBUTE;
                    ctxt->wellFormed = 0;
                }

                /*
                 * Internal check, no parameter entities here ...
                 */
                else {
                    switch (ent->type) {
                        case XML_INTERNAL_PARAMETER_ENTITY:
                        case XML_EXTERNAL_PARAMETER_ENTITY:
                        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                            ctxt->sax->error(ctxt->userData, 
                     "Attempt to reference the parameter entity '%s'\n", name);
                        ctxt->errNo = XML_ERR_ENTITY_IS_PARAMETER;
                        ctxt->wellFormed = 0;
                        break;
                    }
                }

                /*
                 * [ WFC: No Recursion ]
                 * TODO A parsed entity must not contain a recursive reference
                 * to itself, either directly or indirectly. 
                 */

            } else {
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData,
                                     "xmlParseEntityRef: expecting ';'\n");
                ctxt->errNo = XML_ERR_ENTITYREF_SEMICOL_MISSING;
                ctxt->wellFormed = 0;
            }
            xmlFree(name);
        }
    }
    return(ent);
}

/**
 * xmlOldParsePEReference:
 * @ctxt:  an XML parser context
 *
 * parse PEReference declarations
 * The entity content is handled directly by pushing it's content as
 * a new input stream.
 *
 * [69] PEReference ::= '%' Name ';'
 *
 * [ WFC: No Recursion ]
 * TODO A parsed entity must not contain a recursive
 * reference to itself, either directly or indirectly. 
 *
 * [ WFC: Entity Declared ]
 * In a document without any DTD, a document with only an internal DTD
 * subset which contains no parameter entity references, or a document
 * with "standalone='yes'", ...  ... The declaration of a parameter
 * entity must precede any reference to it...
 *
 * [ VC: Entity Declared ]
 * In a document with an external subset or external parameter entities
 * with "standalone='no'", ...  ... The declaration of a parameter entity
 * must precede any reference to it...
 *
 * [ WFC: In DTD ]
 * Parameter-entity references may only appear in the DTD.
 * NOTE: misleading but this is handled.
 */
static void
xmlOldParsePEReference(xmlParserCtxtPtr ctxt) {
    xmlChar *name;
    xmlEntityPtr entity = NULL;
    xmlParserInputPtr input;

    if (CUR == '%') {
        NEXT;
        name = xmlOldParseName(ctxt);
        if (name == NULL) {
            if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                ctxt->sax->error(ctxt->userData,
                                 "xmlParsePEReference: no name\n");
            ctxt->errNo = XML_ERR_NAME_REQUIRED;
            ctxt->wellFormed = 0;
        } else {
            if (CUR == ';') {
                NEXT;
                if ((ctxt->sax != NULL) &&
                    (ctxt->sax->getParameterEntity != NULL))
                    entity = ctxt->sax->getParameterEntity(ctxt->userData,
                                                           name);
                if (entity == NULL) {
                    /*
                     * [ WFC: Entity Declared ]
                     * In a document without any DTD, a document with only an
                     * internal DTD subset which contains no parameter entity
                     * references, or a document with "standalone='yes'", ...
                     * ... The declaration of a parameter entity must precede
                     * any reference to it...
                     */
                    if ((ctxt->standalone == 1) ||
                        ((ctxt->hasExternalSubset == 0) &&
                         (ctxt->hasPErefs == 0))) {
                        if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                            ctxt->sax->error(ctxt->userData,
                             "PEReference: %%%s; not found\n", name);
                        ctxt->errNo = XML_ERR_UNDECLARED_ENTITY;
                        ctxt->wellFormed = 0;
                    } else {
                        /*
                         * [ VC: Entity Declared ]
                         * In a document with an external subset or external
                         * parameter entities with "standalone='no'", ...
                         * ... The declaration of a parameter entity must precede
                         * any reference to it...
                         */
                        if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
                            ctxt->sax->warning(ctxt->userData,
                             "PEReference: %%%s; not found\n", name);
                        ctxt->valid = 0;
                    }
                } else {
                    /*
                     * Internal checking in case the entity quest barfed
                     */
                    if ((entity->type != XML_INTERNAL_PARAMETER_ENTITY) &&
                        (entity->type != XML_EXTERNAL_PARAMETER_ENTITY)) {
                        if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
                            ctxt->sax->warning(ctxt->userData,
                         "Internal: %%%s; is not a parameter entity\n", name);
                    } else {
                        input = xmlOldNewEntityInputStream(ctxt, entity);
                        xmlOldPushInput(ctxt, input);
                    }
                }
                ctxt->hasPErefs = 1;
            } else {
                if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
                    ctxt->sax->error(ctxt->userData,
                                     "xmlParsePEReference: expecting ';'\n");
                ctxt->errNo = XML_ERR_ENTITYREF_SEMICOL_MISSING;
                ctxt->wellFormed = 0;
            }
            xmlFree(name);
        }
    }
}

/**
 * xmlOldParseStringPEReference:
 * @ctxt:  an XML parser context
 * @str:  a pointer to an index in the string
 *
 * parse PEReference declarations
 *
 * [69] PEReference ::= '%' Name ';'
 *
 * [ WFC: No Recursion ]
 * TODO A parsed entity must not contain a recursive
 * reference to itself, either directly or indirectly. 
 *
 * [ WFC: Entity Declared ]
 * In a document without any DTD, a document with only an internal DTD
 *