/*

 * parser.c : an XML 1.0 parser, namespaces and validity support are mostly

 *            implemented on top of the SAX interfaces

 *

 * References:

 *   The XML specification:

 *     http://www.w3.org/TR/REC-xml

 *   Original 1.0 version:

 *     http://www.w3.org/TR/1998/REC-xml-19980210

 *   XML second edition working draft

 *     http://www.w3.org/TR/2000/WD-xml-2e-20000814

 *

 * Okay this is a big file, the parser core is around 7000 lines, then it

 * is followed by the progressive parser top routines, then the various

 * high level APIs to call the parser and a few miscellaneous functions.

 * A number of helper functions and deprecated ones have been moved to

 * parserInternals.c to reduce this file size.

 * As much as possible the functions are associated with their relative

 * production in the XML specification. A few productions defining the

 * different ranges of character are actually implanted either in

 * parserInternals.h or parserInternals.c

 * The DOM tree build is realized from the default SAX callbacks in

 * the module SAX.c.

 * The routines doing the validation checks are in valid.c and called either

 * from the SAX callbacks or as standalone functions using a preparsed

 * document.

 *

 * See Copyright for the status of this software.

 *

 * daniel@veillard.com

 */

#pragma warning(disable: 4127 4132)

#define IN_LIBXML

#include "XmlEnglibxml.h"

#if defined(WIN32) && !defined (__CYGWIN__)

#define XML_DIR_SEP '\\'

#else

#define XML_DIR_SEP '/'

#endif

#include <stdlib.h>

#include <string.h>

#include <stdarg.h>

#include "Libxml2_globals.h"

#include "Libxml2_parserInternals.h"

#include "Libxml2_uri.h"

#ifdef LIBXML_CATALOG_ENABLED

#include <catalog.h>

#endif

#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

#define SAX2 1

#define XML_PARSER_BIG_BUFFER_SIZE 300

#define XML_PARSER_BUFFER_SIZE 100

#define SAX_COMPAT_MODE BAD_CAST "SAX compatibility mode document"

/* DEPR void xmlParserHandleReference(xmlParserCtxtPtr ctxt); */

xmlEntityPtr xmlParseStringPEReference(xmlParserCtxtPtr ctxt,

                                       const xmlChar **str);

static xmlParserErrors

xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt,

                  xmlSAXHandlerPtr sax,

              void *user_data, int depth, const xmlChar *URL,

              const xmlChar *ID, xmlNodePtr *list);

#ifdef LIBXML_LEGACY_ENABLED

static void

xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode,

                      xmlNodePtr lastNode);

#endif /* LIBXML_LEGACY_ENABLED */

static xmlParserErrors

xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt,

              const xmlChar *string, void *user_data, xmlNodePtr *lst);

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

 *                                  *

 *      Some factorized error routines              *

 *                                  *

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

/**

 * xmlErrAttributeDup:

 * @ctxt:  an XML parser context

 * @prefix:  the attribute prefix

 * @localname:  the attribute localname

 *

 * Handle a redefinition of attribute error

 */

static void

xmlErrAttributeDup(xmlParserCtxtPtr ctxt, const xmlChar * prefix,

                   const xmlChar * localname)

{

    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&

        (ctxt->instate == XML_PARSER_EOF))

        return;

    ctxt->errNo = XML_ERR_ATTRIBUTE_REDEFINED;

    if (prefix == NULL)

        __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,

                        ctxt->errNo, XML_ERR_FATAL, NULL, 0,

                        (const char *) localname, NULL, NULL, 0, 0,

                        EMBED_ERRTXT("Attribute %s redefined\n"), localname);

    else

        __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,

                        ctxt->errNo, XML_ERR_FATAL, NULL, 0,

                        (const char *) prefix, (const char *) localname,

                        NULL, 0, 0, EMBED_ERRTXT("Attribute %s:%s redefined\n"), prefix,

                        localname);

    ctxt->wellFormed = 0;

    if (ctxt->recovery == 0)

        ctxt->disableSAX = 1;

}

/**

 * xmlFatalErr:

 * @ctxt:  an XML parser context

 * @error:  the error number

 * @extra:  extra information string

 *

 * Handle a fatal parser error, i.e. violating Well-Formedness constraints

 */

static void

xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info)

{

    const char *errmsg;

    if ((ctxt != NULL) && (ctxt->disableSAX != 0) && (ctxt->instate == XML_PARSER_EOF))

        return;

    switch (error) {

        case XML_ERR_INVALID_HEX_CHARREF:

            errmsg = EMBED_ERRTXT("CharRef: invalid hexadecimal value\n");

            break;

        case XML_ERR_INVALID_DEC_CHARREF:

            errmsg = EMBED_ERRTXT("CharRef: invalid decimal value\n");

            break;

        case XML_ERR_INVALID_CHARREF:

            errmsg = EMBED_ERRTXT("CharRef: invalid value\n");

            break;

        case XML_ERR_INTERNAL_ERROR:

            errmsg = EMBED_ERRTXT("internal error");

            break;

        case XML_ERR_PEREF_AT_EOF:

            errmsg = EMBED_ERRTXT("PEReference at end of document\n");

            break;

        case XML_ERR_PEREF_IN_PROLOG:

            errmsg = EMBED_ERRTXT("PEReference in prolog\n");

            break;

        case XML_ERR_PEREF_IN_EPILOG:

            errmsg = EMBED_ERRTXT("PEReference in epilog\n");

            break;

        case XML_ERR_PEREF_NO_NAME:

            errmsg = EMBED_ERRTXT("PEReference: no name\n");

            break;

        case XML_ERR_PEREF_SEMICOL_MISSING:

            errmsg = EMBED_ERRTXT("PEReference: expecting ';'\n");

            break;

        case XML_ERR_ENTITY_LOOP:

            errmsg = EMBED_ERRTXT("Detected an entity reference loop\n");

            break;

        case XML_ERR_ENTITY_NOT_STARTED:

            errmsg = EMBED_ERRTXT("EntityValue: \" or ' expected\n");

            break;

        case XML_ERR_ENTITY_PE_INTERNAL:

            errmsg = EMBED_ERRTXT("PEReferences forbidden in internal subset\n");

            break;

        case XML_ERR_ENTITY_NOT_FINISHED:

            errmsg = EMBED_ERRTXT("EntityValue: \" or ' expected\n");

            break;

        case XML_ERR_ATTRIBUTE_NOT_STARTED:

            errmsg = EMBED_ERRTXT("AttValue: \" or ' expected\n");

            break;

        case XML_ERR_LT_IN_ATTRIBUTE:

            errmsg = EMBED_ERRTXT("Unescaped '<' not allowed in attributes values\n");

            break;

        case XML_ERR_LITERAL_NOT_STARTED:

            errmsg = EMBED_ERRTXT("SystemLiteral \" or ' expected\n");

            break;

        case XML_ERR_LITERAL_NOT_FINISHED:

            errmsg = EMBED_ERRTXT("Unfinished System or Public ID \" or ' expected\n");

            break;

        case XML_ERR_MISPLACED_CDATA_END:

            errmsg = EMBED_ERRTXT("Sequence ']]>' not allowed in content\n");

            break;

        case XML_ERR_URI_REQUIRED:

            errmsg = EMBED_ERRTXT("SYSTEM or PUBLIC, the URI is missing\n");

            break;

        case XML_ERR_PUBID_REQUIRED:

            errmsg = EMBED_ERRTXT("PUBLIC, the Public Identifier is missing\n");

            break;

        case XML_ERR_HYPHEN_IN_COMMENT:

            errmsg = EMBED_ERRTXT("Comment must not contain '--' (double-hyphen)\n");

            break;

        case XML_ERR_PI_NOT_STARTED:

            errmsg = EMBED_ERRTXT("xmlParsePI : no target name\n");

            break;

        case XML_ERR_RESERVED_XML_NAME:

            errmsg = EMBED_ERRTXT("Invalid PI name\n");

            break;

        case XML_ERR_NOTATION_NOT_STARTED:

            errmsg = EMBED_ERRTXT("NOTATION: Name expected here\n");

            break;

        case XML_ERR_NOTATION_NOT_FINISHED:

            errmsg = EMBED_ERRTXT("'>' required to close NOTATION declaration\n");

            break;

        case XML_ERR_VALUE_REQUIRED:

            errmsg = EMBED_ERRTXT("Entity value required\n");

            break;

        case XML_ERR_URI_FRAGMENT:

            errmsg = EMBED_ERRTXT("Fragment not allowed");

            break;

        case XML_ERR_ATTLIST_NOT_STARTED:

            errmsg = EMBED_ERRTXT("'(' required to start ATTLIST enumeration\n");

            break;

        case XML_ERR_NMTOKEN_REQUIRED:

            errmsg = EMBED_ERRTXT("NmToken expected in ATTLIST enumeration\n");

            break;

        case XML_ERR_ATTLIST_NOT_FINISHED:

            errmsg = EMBED_ERRTXT("')' required to finish ATTLIST enumeration\n");

            break;

        case XML_ERR_MIXED_NOT_STARTED:

            errmsg = EMBED_ERRTXT("MixedContentDecl : '|' or ')*' expected\n");

            break;

        case XML_ERR_PCDATA_REQUIRED:

            errmsg = EMBED_ERRTXT("MixedContentDecl : '#PCDATA' expected\n");

            break;

        case XML_ERR_ELEMCONTENT_NOT_STARTED:

            errmsg = EMBED_ERRTXT("ContentDecl : Name or '(' expected\n");

            break;

        case XML_ERR_ELEMCONTENT_NOT_FINISHED:

            errmsg = EMBED_ERRTXT("ContentDecl : ',' '|' or ')' expected\n");

            break;

        case XML_ERR_PEREF_IN_INT_SUBSET:

            errmsg =

                EMBED_ERRTXT("PEReference: forbidden within markup decl in internal subset\n");

            break;

        case XML_ERR_GT_REQUIRED:

            errmsg =EMBED_ERRTXT("expected '>'\n");

            break;

        case XML_ERR_CONDSEC_INVALID:

            errmsg = EMBED_ERRTXT("XML conditional section '[' expected\n");

            break;

        case XML_ERR_EXT_SUBSET_NOT_FINISHED:

            errmsg = EMBED_ERRTXT("Content error in the external subset\n");

            break;

        case XML_ERR_CONDSEC_INVALID_KEYWORD:

            errmsg =

                EMBED_ERRTXT("conditional section INCLUDE or IGNORE keyword expected\n");

            break;

        case XML_ERR_CONDSEC_NOT_FINISHED:

            errmsg = EMBED_ERRTXT("XML conditional section not closed\n");

            break;

        case XML_ERR_XMLDECL_NOT_STARTED:

            errmsg = EMBED_ERRTXT("Text declaration '<?xml' required\n");

            break;

        case XML_ERR_XMLDECL_NOT_FINISHED:

            errmsg = EMBED_ERRTXT("parsing XML declaration: '?>' expected\n");

            break;

        case XML_ERR_EXT_ENTITY_STANDALONE:

            errmsg = EMBED_ERRTXT("external parsed entities cannot be standalone\n");

            break;

        case XML_ERR_ENTITYREF_SEMICOL_MISSING:

            errmsg = EMBED_ERRTXT("EntityRef: expecting ';'\n");

            break;

        case XML_ERR_DOCTYPE_NOT_FINISHED:

            errmsg = EMBED_ERRTXT("DOCTYPE improperly terminated\n");

            break;

        case XML_ERR_LTSLASH_REQUIRED:

            errmsg = EMBED_ERRTXT("EndTag: '</' not found\n");

            break;

        case XML_ERR_EQUAL_REQUIRED:

            errmsg = EMBED_ERRTXT("expected '='\n");

            break;

        case XML_ERR_STRING_NOT_CLOSED:

            errmsg = EMBED_ERRTXT("String not closed expecting \" or '\n");

            break;

        case XML_ERR_STRING_NOT_STARTED:

            errmsg = EMBED_ERRTXT("String not started expecting ' or \"\n");

            break;

        case XML_ERR_ENCODING_NAME:

            errmsg = EMBED_ERRTXT("Invalid XML encoding name\n");

            break;

        case XML_ERR_STANDALONE_VALUE:

            errmsg = EMBED_ERRTXT("standalone accepts only 'yes' or 'no'\n");

            break;

        case XML_ERR_DOCUMENT_EMPTY:

            errmsg = EMBED_ERRTXT("Document is empty\n");

            break;

        case XML_ERR_DOCUMENT_END:

            errmsg = EMBED_ERRTXT("Extra content at the end of the document\n");

            break;

        case XML_ERR_NOT_WELL_BALANCED:

            errmsg = EMBED_ERRTXT("chunk is not well balanced\n");

            break;

        case XML_ERR_EXTRA_CONTENT:

            errmsg = EMBED_ERRTXT("extra content at the end of well balanced chunk\n");

            break;

        case XML_ERR_VERSION_MISSING:

            errmsg = EMBED_ERRTXT("Malformed declaration expecting version\n");

            break;

        case XML_ERR_STACK_LOW:

            errmsg = EMBED_ERRTXT("Thread's stack has reached critical level\n");

            break;            

#if 0

        case:

            errmsg = "\n";

            break;

#endif

        default:

            errmsg = EMBED_ERRTXT("Unregistered error message\n");

    }

    ctxt->errNo = error;

    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,

                    XML_ERR_FATAL, NULL, 0, info, NULL, NULL, 0, 0, errmsg,

                    info);

    ctxt->wellFormed = 0;

    if (ctxt->recovery == 0)

        ctxt->disableSAX = 1;

}

/**

 * xmlFatalErrMsg:

 * @ctxt:  an XML parser context

 * @error:  the error number

 * @msg:  the error message

 *

 * Handle a fatal parser error, i.e. violating Well-Formedness constraints

 */

static void

xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,

               const char *msg)

{

    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&

        (ctxt->instate == XML_PARSER_EOF))

    return;

    ctxt->errNo = error;

    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,

                    XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0, msg);

    ctxt->wellFormed = 0;

    if (ctxt->recovery == 0)

        ctxt->disableSAX = 1;

}

/**

 * xmlWarningMsg:

 * @ctxt:  an XML parser context

 * @error:  the error number

 * @msg:  the error message

 * @str1:  extra data

 * @str2:  extra data

 *

 * Handle a warning.

 */

static void

xmlWarningMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,

              const char *msg, const xmlChar *str1, const xmlChar *str2)

{

    xmlStructuredErrorFunc schannel = NULL;

    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&

        (ctxt->instate == XML_PARSER_EOF))

    return;

    ctxt->errNo = error;

    if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))

        schannel = ctxt->sax->serror;

    __xmlRaiseError(schannel,

                    (ctxt->sax) ? ctxt->sax->warning : NULL,

                    ctxt->userData,

                    ctxt, NULL, XML_FROM_PARSER, error,

                    XML_ERR_WARNING, NULL, 0,

            (const char *) str1, (const char *) str2, NULL, 0, 0,

            msg, (const char *) str1, (const char *) str2);

}

/**

 * xmlValidityError:

 * @ctxt:  an XML parser context

 * @error:  the error number

 * @msg:  the error message

 * @str1:  extra data

 *

 * Handle a validity error.

 */

static void

xmlValidityError(xmlParserCtxtPtr ctxt, xmlParserErrors error,

              const char *msg, const xmlChar *str1)

{

    xmlStructuredErrorFunc schannel = NULL;

    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&

        (ctxt->instate == XML_PARSER_EOF))

    return;

    ctxt->errNo = error;

    if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))

        schannel = ctxt->sax->serror;

    __xmlRaiseError(schannel,

                    ctxt->vctxt.error, ctxt->vctxt.userData,

                    ctxt, NULL, XML_FROM_DTD, error,

                    XML_ERR_ERROR, NULL, 0, (const char *) str1,

            NULL, NULL, 0, 0,

            msg, (const char *) str1);

    ctxt->valid = 0;

}

/**

 * xmlFatalErrMsgInt:

 * @ctxt:  an XML parser context

 * @error:  the error number

 * @msg:  the error message

 * @val:  an integer value

 *

 * Handle a fatal parser error, i.e. violating Well-Formedness constraints

 */

static void

xmlFatalErrMsgInt(xmlParserCtxtPtr ctxt, xmlParserErrors error,

                  const char *msg, int val)

{

    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&

        (ctxt->instate == XML_PARSER_EOF))

    return;

    ctxt->errNo = error;

    __xmlRaiseError(NULL, NULL, NULL,

                    ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,

                    NULL, 0, NULL, NULL, NULL, val, 0, msg, val);

    ctxt->wellFormed = 0;

    if (ctxt->recovery == 0)

        ctxt->disableSAX = 1;

}

/**

 * xmlFatalErrMsgStrIntStr:

 * @ctxt:  an XML parser context

 * @error:  the error number

 * @msg:  the error message

 * @str1:  an string info

 * @val:  an integer value

 * @str2:  an string info

 *

 * Handle a fatal parser error, i.e. violating Well-Formedness constraints

 */

static void

xmlFatalErrMsgStrIntStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,

                  const char *msg, const xmlChar *str1, int val,

          const xmlChar *str2)

{

    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&

        (ctxt->instate == XML_PARSER_EOF))

    return;

    ctxt->errNo = error;

    __xmlRaiseError(NULL, NULL, NULL,

                    ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,

                    NULL, 0, (const char *) str1, (const char *) str2,

            NULL, val, 0, msg, str1, val, str2);

    ctxt->wellFormed = 0;

    if (ctxt->recovery == 0)

        ctxt->disableSAX = 1;

}

/**

 * xmlFatalErrMsgStr:

 * @ctxt:  an XML parser context

 * @error:  the error number

 * @msg:  the error message

 * @val:  a string value

 *

 * Handle a fatal parser error, i.e. violating Well-Formedness constraints

 */

static void

xmlFatalErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,

                  const char *msg, const xmlChar * val)

{

    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&

        (ctxt->instate == XML_PARSER_EOF))

    return;

    ctxt->errNo = error;

    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,

                    XML_FROM_PARSER, error, XML_ERR_FATAL,

                    NULL, 0, (const char *) val, NULL, NULL, 0, 0, msg,

                    val);

    ctxt->wellFormed = 0;

    if (ctxt->recovery == 0)

        ctxt->disableSAX = 1;

}

/**

 * xmlErrMsgStr:

 * @ctxt:  an XML parser context

 * @error:  the error number

 * @msg:  the error message

 * @val:  a string value

 *

 * Handle a non fatal parser error

 */

static void

xmlErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,

                  const char *msg, const xmlChar * val)

{

    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&

        (ctxt->instate == XML_PARSER_EOF))

    return;

    ctxt->errNo = error;

    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,

                    XML_FROM_PARSER, error, XML_ERR_ERROR,