parserInternals.h File Reference

#include <libxml/xmlversion.h>
#include <libxml/parser.h>
#include <libxml/HTMLparser.h>
#include <libxml/chvalid.h>
#include <libxml/SAX2.h>

Include dependency graph for parserInternals.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	XML_MAX_TEXT_LENGTH   10000000
#define	XML_MAX_HUGE_LENGTH   1000000000
#define	XML_MAX_NAME_LENGTH   50000
#define	XML_MAX_DICTIONARY_LIMIT   10000000
#define	XML_MAX_LOOKUP_LIMIT   10000000
#define	XML_MAX_NAMELEN   100
#define	INPUT_CHUNK   250
#define	IS_BYTE_CHAR(c)   xmlIsChar_ch(c)
#define	IS_CHAR(c)   xmlIsCharQ(c)
#define	IS_CHAR_CH(c)   xmlIsChar_ch(c)
#define	IS_BLANK(c)   xmlIsBlankQ(c)
#define	IS_BLANK_CH(c)   xmlIsBlank_ch(c)
#define	IS_BASECHAR(c)   xmlIsBaseCharQ(c)
#define	IS_DIGIT(c)   xmlIsDigitQ(c)
#define	IS_DIGIT_CH(c)   xmlIsDigit_ch(c)
#define	IS_COMBINING(c)   xmlIsCombiningQ(c)
#define	IS_COMBINING_CH(c)   0
#define	IS_EXTENDER(c)   xmlIsExtenderQ(c)
#define	IS_EXTENDER_CH(c)   xmlIsExtender_ch(c)
#define	IS_IDEOGRAPHIC(c)   xmlIsIdeographicQ(c)
#define	IS_LETTER(c)   (IS_BASECHAR(c) || IS_IDEOGRAPHIC(c))
#define	IS_LETTER_CH(c)   xmlIsBaseChar_ch(c)
#define	IS_ASCII_LETTER(c)
#define	IS_ASCII_DIGIT(c)   ((0x30 <= (c)) && ((c) <= 0x39))
#define	IS_PUBIDCHAR(c)   xmlIsPubidCharQ(c)
#define	IS_PUBIDCHAR_CH(c)   xmlIsPubidChar_ch(c)
#define	XML_SUBSTITUTE_NONE   0
#define	XML_SUBSTITUTE_REF   1
#define	XML_SUBSTITUTE_PEREF   2
#define	XML_SUBSTITUTE_BOTH   3

Functions
XMLPUBFUN int	xmlIsLetter (int c)
XMLPUBFUN xmlParserCtxtPtr	xmlCreateFileParserCtxt (const char *filename)
XMLPUBFUN xmlParserCtxtPtr	xmlCreateURLParserCtxt (const char *filename, int options)
XMLPUBFUN xmlParserCtxtPtr	xmlCreateMemoryParserCtxt (const char *buffer, int size)
XMLPUBFUN xmlParserCtxtPtr	xmlCreateEntityParserCtxt (const xmlChar *URL, const xmlChar *ID, const xmlChar *base)
XMLPUBFUN int	xmlSwitchEncoding (xmlParserCtxtPtr ctxt, xmlCharEncoding enc)
XMLPUBFUN int	xmlSwitchToEncoding (xmlParserCtxtPtr ctxt, xmlCharEncodingHandlerPtr handler)
XML_DEPRECATED XMLPUBFUN int	xmlSwitchInputEncoding (xmlParserCtxtPtr ctxt, xmlParserInputPtr input, xmlCharEncodingHandlerPtr handler)
XMLPUBFUN xmlParserInputPtr	xmlNewStringInputStream (xmlParserCtxtPtr ctxt, const xmlChar *buffer)
XML_DEPRECATED XMLPUBFUN xmlParserInputPtr	xmlNewEntityInputStream (xmlParserCtxtPtr ctxt, xmlEntityPtr entity)
XMLPUBFUN int	xmlPushInput (xmlParserCtxtPtr ctxt, xmlParserInputPtr input)
XMLPUBFUN xmlChar	xmlPopInput (xmlParserCtxtPtr ctxt)
XMLPUBFUN void	xmlFreeInputStream (xmlParserInputPtr input)
XMLPUBFUN xmlParserInputPtr	xmlNewInputFromFile (xmlParserCtxtPtr ctxt, const char *filename)
XMLPUBFUN xmlParserInputPtr	xmlNewInputStream (xmlParserCtxtPtr ctxt)
XMLPUBFUN xmlChar *	xmlSplitQName (xmlParserCtxtPtr ctxt, const xmlChar *name, xmlChar **prefix)
XML_DEPRECATED XMLPUBFUN const xmlChar *	xmlParseName (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN xmlChar *	xmlParseNmtoken (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN xmlChar *	xmlParseEntityValue (xmlParserCtxtPtr ctxt, xmlChar **orig)
XML_DEPRECATED XMLPUBFUN xmlChar *	xmlParseAttValue (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN xmlChar *	xmlParseSystemLiteral (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN xmlChar *	xmlParsePubidLiteral (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN void	xmlParseCharData (xmlParserCtxtPtr ctxt, int cdata)
XML_DEPRECATED XMLPUBFUN xmlChar *	xmlParseExternalID (xmlParserCtxtPtr ctxt, xmlChar **publicID, int strict)
XML_DEPRECATED XMLPUBFUN void	xmlParseComment (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN const xmlChar *	xmlParsePITarget (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN void	xmlParsePI (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN void	xmlParseNotationDecl (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN void	xmlParseEntityDecl (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN int	xmlParseDefaultDecl (xmlParserCtxtPtr ctxt, xmlChar **value)
XML_DEPRECATED XMLPUBFUN xmlEnumerationPtr	xmlParseNotationType (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN xmlEnumerationPtr	xmlParseEnumerationType (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN int	xmlParseEnumeratedType (xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree)
XML_DEPRECATED XMLPUBFUN int	xmlParseAttributeType (xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree)
XML_DEPRECATED XMLPUBFUN void	xmlParseAttributeListDecl (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN xmlElementContentPtr	xmlParseElementMixedContentDecl (xmlParserCtxtPtr ctxt, int inputchk)
XML_DEPRECATED XMLPUBFUN xmlElementContentPtr	xmlParseElementChildrenContentDecl (xmlParserCtxtPtr ctxt, int inputchk)
XML_DEPRECATED XMLPUBFUN int	xmlParseElementContentDecl (xmlParserCtxtPtr ctxt, const xmlChar *name, xmlElementContentPtr *result)
XML_DEPRECATED XMLPUBFUN int	xmlParseElementDecl (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN void	xmlParseMarkupDecl (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN int	xmlParseCharRef (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN xmlEntityPtr	xmlParseEntityRef (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN void	xmlParseReference (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN void	xmlParsePEReference (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN void	xmlParseDocTypeDecl (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN void	xmlParseCDSect (xmlParserCtxtPtr ctxt)
XMLPUBFUN void	xmlParseContent (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN void	xmlParseElement (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN xmlChar *	xmlParseVersionNum (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN xmlChar *	xmlParseVersionInfo (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN xmlChar *	xmlParseEncName (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN const xmlChar *	xmlParseEncodingDecl (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN int	xmlParseSDDecl (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN void	xmlParseXMLDecl (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN void	xmlParseTextDecl (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN void	xmlParseMisc (xmlParserCtxtPtr ctxt)
XMLPUBFUN void	xmlParseExternalSubset (xmlParserCtxtPtr ctxt, const xmlChar *ExternalID, const xmlChar *SystemID)
XML_DEPRECATED XMLPUBFUN xmlChar *	xmlStringDecodeEntities (xmlParserCtxtPtr ctxt, const xmlChar *str, int what, xmlChar end, xmlChar end2, xmlChar end3)
XML_DEPRECATED XMLPUBFUN xmlChar *	xmlStringLenDecodeEntities (xmlParserCtxtPtr ctxt, const xmlChar *str, int len, int what, xmlChar end, xmlChar end2, xmlChar end3)
XML_DEPRECATED XMLPUBFUN int	nodePush (xmlParserCtxtPtr ctxt, xmlNodePtr value)
XML_DEPRECATED XMLPUBFUN xmlNodePtr	nodePop (xmlParserCtxtPtr ctxt)
XMLPUBFUN int	inputPush (xmlParserCtxtPtr ctxt, xmlParserInputPtr value)
XMLPUBFUN xmlParserInputPtr	inputPop (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN const xmlChar *	namePop (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN int	namePush (xmlParserCtxtPtr ctxt, const xmlChar *value)
XML_DEPRECATED XMLPUBFUN int	xmlSkipBlankChars (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN int	xmlStringCurrentChar (xmlParserCtxtPtr ctxt, const xmlChar *cur, int *len)
XML_DEPRECATED XMLPUBFUN void	xmlParserHandlePEReference (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN int	xmlCheckLanguageID (const xmlChar *lang)
XML_DEPRECATED XMLPUBFUN int	xmlCurrentChar (xmlParserCtxtPtr ctxt, int *len)
XMLPUBFUN int	xmlCopyCharMultiByte (xmlChar *out, int val)
XMLPUBFUN int	xmlCopyChar (int len, xmlChar *out, int val)
XML_DEPRECATED XMLPUBFUN void	xmlNextChar (xmlParserCtxtPtr ctxt)
XML_DEPRECATED XMLPUBFUN void	xmlParserInputShrink (xmlParserInputPtr in)

Variables
XMLPUBVAR unsigned int	xmlParserMaxDepth
XMLPUBVAR const xmlChar	xmlStringText []
XMLPUBVAR const xmlChar	xmlStringTextNoenc []
XMLPUBVAR const xmlChar	xmlStringComment []

Macro Definition Documentation

INPUT_CHUNK

#define INPUT_CHUNK   250

INPUT_CHUNK:

The parser tries to always have that amount of input ready. One of the point is providing context when reporting errors.

Definition at line 97 of file parserInternals.h.

IS_ASCII_DIGIT

#define IS_ASCII_DIGIT

(

c

)

((0x30 <= (c)) && ((c) <= 0x39))

IS_ASCII_DIGIT: : an xmlChar value

Macro to check [0-9]

Definition at line 268 of file parserInternals.h.

IS_ASCII_LETTER

#define IS_ASCII_LETTER

(

c

)

Value:

                 (((0x41 <= (c)) && ((c) <= 0x5a)) || \
                 ((0x61 <= (c)) && ((c) <= 0x7a)))

IS_ASCII_LETTER: : an xmlChar value

Macro to check [a-zA-Z]

Definition at line 258 of file parserInternals.h.

IS_BASECHAR

#define IS_BASECHAR

(

c

)

xmlIsBaseCharQ(c)

IS_BASECHAR: : an UNICODE value (int)

Macro to check the following production in the XML spec:

[85] BaseChar ::= ... long list see REC ...

Definition at line 161 of file parserInternals.h.

IS_BLANK

#define IS_BLANK

(

c

)

xmlIsBlankQ(c)

IS_BLANK: : an UNICODE value (int)

Macro to check the following production in the XML spec:

[3] S ::= (#x20 | x9 | #xD | #xA)+

Definition at line 143 of file parserInternals.h.

IS_BLANK_CH

#define IS_BLANK_CH

(

c

)

xmlIsBlank_ch(c)

IS_BLANK_CH: : an xmlChar value (normally unsigned char)

Behaviour same as IS_BLANK

Definition at line 151 of file parserInternals.h.

IS_BYTE_CHAR

#define IS_BYTE_CHAR

(

c

)

xmlIsChar_ch(c)

IS_BYTE_CHAR: : an byte value (int)

Macro to check the following production in the XML spec:

[2] Char ::= x9 | #xA | #xD | [#x20...] any byte character in the accepted range

Definition at line 113 of file parserInternals.h.

IS_CHAR

#define IS_CHAR

(

c

)

xmlIsCharQ(c)

IS_CHAR: : an UNICODE value (int)

Macro to check the following production in the XML spec:

[2] Char ::= x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF] any Unicode character, excluding the surrogate blocks, FFFE, and FFFF.

Definition at line 125 of file parserInternals.h.

IS_CHAR_CH

#define IS_CHAR_CH

(

c

)

xmlIsChar_ch(c)

IS_CHAR_CH: : an xmlChar (usually an unsigned char)

Behaves like IS_CHAR on single-byte value

Definition at line 133 of file parserInternals.h.

IS_COMBINING

#define IS_COMBINING

(

c

)

xmlIsCombiningQ(c)

IS_COMBINING: : an UNICODE value (int)

Macro to check the following production in the XML spec:

[87] CombiningChar ::= ... long list see REC ...

Definition at line 189 of file parserInternals.h.

IS_COMBINING_CH

#define IS_COMBINING_CH

(

c

)

0

IS_COMBINING_CH: : an xmlChar (usually an unsigned char)

Always false (all combining chars > 0xff)

Definition at line 197 of file parserInternals.h.

IS_DIGIT

#define IS_DIGIT

(

c

)

xmlIsDigitQ(c)

IS_DIGIT: : an UNICODE value (int)

Macro to check the following production in the XML spec:

[88] Digit ::= ... long list see REC ...

Definition at line 171 of file parserInternals.h.

IS_DIGIT_CH

#define IS_DIGIT_CH

(

c

)

xmlIsDigit_ch(c)

IS_DIGIT_CH: : an xmlChar value (usually an unsigned char)

Behaves like IS_DIGIT but with a single byte argument

Definition at line 179 of file parserInternals.h.

IS_EXTENDER

#define IS_EXTENDER

(

c

)

xmlIsExtenderQ(c)

IS_EXTENDER: : an UNICODE value (int)

Macro to check the following production in the XML spec:

[89] Extender ::= #x00B7 | #x02D0 | #x02D1 | #x0387 | #x0640 | #x0E46 | #x0EC6 | #x3005 | [#x3031-#x3035] | [#x309D-#x309E] | [#x30FC-#x30FE]

Definition at line 210 of file parserInternals.h.

IS_EXTENDER_CH

#define IS_EXTENDER_CH

(

c

)

xmlIsExtender_ch(c)

IS_EXTENDER_CH: : an xmlChar value (usually an unsigned char)

Behaves like IS_EXTENDER but with a single-byte argument

Definition at line 218 of file parserInternals.h.

IS_IDEOGRAPHIC

#define IS_IDEOGRAPHIC

(

c

)

xmlIsIdeographicQ(c)

IS_IDEOGRAPHIC: : an UNICODE value (int)

Macro to check the following production in the XML spec:

[86] Ideographic ::= [#x4E00-#x9FA5] | #x3007 | [#x3021-#x3029]

Definition at line 229 of file parserInternals.h.

IS_LETTER

#define IS_LETTER

(

c

)

(IS_BASECHAR(c) || IS_IDEOGRAPHIC(c))

IS_LETTER: : an UNICODE value (int)

Macro to check the following production in the XML spec:

[84] Letter ::= BaseChar | Ideographic

Definition at line 240 of file parserInternals.h.

IS_LETTER_CH

#define IS_LETTER_CH

(

c

)

xmlIsBaseChar_ch(c)

IS_LETTER_CH: : an xmlChar value (normally unsigned char)

Macro behaves like IS_LETTER, but only check base chars

Definition at line 249 of file parserInternals.h.

IS_PUBIDCHAR

#define IS_PUBIDCHAR

(

c

)

xmlIsPubidCharQ(c)

IS_PUBIDCHAR: : an UNICODE value (int)

Macro to check the following production in the XML spec:

[13] PubidChar ::= #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#$_%]

Definition at line 279 of file parserInternals.h.

IS_PUBIDCHAR_CH

#define IS_PUBIDCHAR_CH

(

c

)

xmlIsPubidChar_ch(c)

IS_PUBIDCHAR_CH: : an xmlChar value (normally unsigned char)

Same as IS_PUBIDCHAR but for single-byte value

Definition at line 287 of file parserInternals.h.

XML_MAX_DICTIONARY_LIMIT

#define XML_MAX_DICTIONARY_LIMIT   10000000

XML_MAX_DICTIONARY_LIMIT:

Maximum size allowed by the parser for a dictionary by default This is not a limitation of the parser but a safety boundary feature, use XML_PARSE_HUGE option to override it. Introduced in 2.9.0

Definition at line 71 of file parserInternals.h.

XML_MAX_HUGE_LENGTH

#define XML_MAX_HUGE_LENGTH   1000000000

XML_MAX_HUGE_LENGTH:

Maximum size allowed when XML_PARSE_HUGE is set.

Definition at line 49 of file parserInternals.h.

XML_MAX_LOOKUP_LIMIT

#define XML_MAX_LOOKUP_LIMIT   10000000

XML_MAX_LOOKUP_LIMIT:

Maximum size allowed by the parser for ahead lookup This is an upper boundary enforced by the parser to avoid bad behaviour on "unfriendly' content Introduced in 2.9.0

Definition at line 81 of file parserInternals.h.

XML_MAX_NAME_LENGTH

#define XML_MAX_NAME_LENGTH   50000

XML_MAX_NAME_LENGTH:

Maximum size allowed for a markup identifier. This is not a limitation of the parser but a safety boundary feature, use XML_PARSE_HUGE option to override it. Note that with the use of parsing dictionaries overriding the limit may result in more runtime memory usage in face of "unfriendly' content Introduced in 2.9.0

Definition at line 61 of file parserInternals.h.

XML_MAX_NAMELEN

#define XML_MAX_NAMELEN   100

XML_MAX_NAMELEN:

Identifiers can be longer, but this will be more costly at runtime.

Definition at line 89 of file parserInternals.h.

XML_MAX_TEXT_LENGTH

#define XML_MAX_TEXT_LENGTH   10000000

XML_MAX_TEXT_LENGTH:

Maximum size allowed for a single text node when building a tree. This is not a limitation of the parser but a safety boundary feature, use XML_PARSE_HUGE option to override it. Introduced in 2.9.0

Definition at line 42 of file parserInternals.h.

XML_SUBSTITUTE_BOTH

#define XML_SUBSTITUTE_BOTH   3

XML_SUBSTITUTE_BOTH:

Both general and parameter entities need to be substituted.

Definition at line 533 of file parserInternals.h.

XML_SUBSTITUTE_NONE

#define XML_SUBSTITUTE_NONE   0

XML_SUBSTITUTE_NONE:

If no entities need to be substituted.

Definition at line 515 of file parserInternals.h.

XML_SUBSTITUTE_PEREF

#define XML_SUBSTITUTE_PEREF   2

XML_SUBSTITUTE_PEREF:

Whether parameter entities need to be substituted.

Definition at line 527 of file parserInternals.h.

XML_SUBSTITUTE_REF

#define XML_SUBSTITUTE_REF   1

XML_SUBSTITUTE_REF:

Whether general entities need to be substituted.

Definition at line 521 of file parserInternals.h.

Function Documentation

inputPop()

XMLPUBFUN xmlParserInputPtr inputPop

(

xmlParserCtxtPtr

ctxt

)

inputPop: @ctxt: an XML parser context

Pops the top parser input from the input stack

Returns the input just removed

Definition at line 1927 of file parser.c.

{
    xmlParserInputPtr ret;
 
    if (ctxt == NULL)
        return(NULL);
    if (ctxt->inputNr <= 0)
        return (NULL);
    ctxt->inputNr--;
    if (ctxt->inputNr > 0)
        ctxt->input = ctxt->inputTab[ctxt->inputNr - 1];
    else
        ctxt->input = NULL;
    ret = ctxt->inputTab[ctxt->inputNr];
    ctxt->inputTab[ctxt->inputNr] = NULL;
    return (ret);
}

Referenced by xmlCtxtReset(), xmlFreeParserCtxt(), xmlHaltParser(), xmlInitSAXParserCtxt(), xmlLoadEntityContent(), xmlPopInput(), and xmlPushInput().

inputPush()

XMLPUBFUN int inputPush	(	xmlParserCtxtPtr	ctxt,
		xmlParserInputPtr	value
	)

inputPush: @ctxt: an XML parser context @value: the parser input

Pushes a new parser input on top of the input stack

Returns -1 in case of error, the index in the stack otherwise

Definition at line 1897 of file parser.c.

{
    if ((ctxt == NULL) || (value == NULL))
        return(-1);
    if (ctxt->inputNr >= ctxt->inputMax) {
        size_t newSize = ctxt->inputMax * 2;
        xmlParserInputPtr *tmp;
 
        tmp = (xmlParserInputPtr *) xmlRealloc(ctxt->inputTab,
                                               newSize * sizeof(*tmp));
        if (tmp == NULL) {
            xmlErrMemory(ctxt, NULL);
            return (-1);
        }
        ctxt->inputTab = tmp;
        ctxt->inputMax = newSize;
    }
    ctxt->inputTab[ctxt->inputNr] = value;
    ctxt->input = value;
    return (ctxt->inputNr++);
}

Referenced by xmlCreateDocParserCtxt(), xmlCreateEntityParserCtxtInternal(), xmlCreateIOParserCtxt(), xmlCreateMemoryParserCtxt(), xmlCreateURLParserCtxt(), xmlCtxtReadDoc(), xmlCtxtReadFd(), xmlCtxtReadFile(), xmlCtxtReadIO(), xmlCtxtReadMemory(), xmlCtxtResetPush(), xmlLoadEntityContent(), xmlPushInput(), xmlReadFd(), xmlReadIO(), xslt_doc_default_loader(), and xsltDocDefaultLoaderFunc().

namePop()

XML_DEPRECATED XMLPUBFUN const xmlChar * namePop

(

xmlParserCtxtPtr

ctxt

)

namePop: @ctxt: an XML parser context

DEPRECATED: Internal function, do not use.

Pops the top element name from the name stack

Returns the name just removed

Definition at line 2143 of file parser.c.

{
    const xmlChar *ret;
 
    if ((ctxt == NULL) || (ctxt->nameNr <= 0))
        return (NULL);
    ctxt->nameNr--;
    if (ctxt->nameNr > 0)
        ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
    else
        ctxt->name = NULL;
    ret = ctxt->nameTab[ctxt->nameNr];
    ctxt->nameTab[ctxt->nameNr] = NULL;
    return (ret);
}

Referenced by xmlParseElementEnd(), and xmlParseElementStart().

namePush()

XML_DEPRECATED XMLPUBFUN int namePush	(	xmlParserCtxtPtr	ctxt,
		const xmlChar *	value
	)

namePush: @ctxt: an XML parser context @value: the element name

DEPRECATED: Internal function, do not use.

Pushes a new element name on top of the name stack

Returns -1 in case of error, the index in the stack otherwise

Definition at line 2109 of file parser.c.

{
    if (ctxt == NULL) return (-1);
 
    if (ctxt->nameNr >= ctxt->nameMax) {
        const xmlChar * *tmp;
        tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab,
                                    ctxt->nameMax * 2 *
                                    sizeof(ctxt->nameTab[0]));
        if (tmp == NULL) {
        goto mem_error;
        }
    ctxt->nameTab = tmp;
        ctxt->nameMax *= 2;
    }
    ctxt->nameTab[ctxt->nameNr] = value;
    ctxt->name = value;
    return (ctxt->nameNr++);
mem_error:
    xmlErrMemory(ctxt, NULL);
    return (-1);
}

nodePop()

XML_DEPRECATED XMLPUBFUN xmlNodePtr nodePop

(

xmlParserCtxtPtr

ctxt

)

nodePop: @ctxt: an XML parser context

DEPRECATED: Internal function, do not use.

Pops the top element node from the node stack

Returns the node just removed

Definition at line 1996 of file parser.c.

{
    xmlNodePtr ret;
 
    if (ctxt == NULL) return(NULL);
    if (ctxt->nodeNr <= 0)
        return (NULL);
    ctxt->nodeNr--;
    if (ctxt->nodeNr > 0)
        ctxt->node = ctxt->nodeTab[ctxt->nodeNr - 1];
    else
        ctxt->node = NULL;
    ret = ctxt->nodeTab[ctxt->nodeNr];
    ctxt->nodeTab[ctxt->nodeNr] = NULL;
    return (ret);
}

Referenced by xmlParseElementStart(), and xmlSAX2EndElementNs().

nodePush()

XML_DEPRECATED XMLPUBFUN int nodePush	(	xmlParserCtxtPtr	ctxt,
		xmlNodePtr	value
	)

nodePush: @ctxt: an XML parser context @value: the element node

DEPRECATED: Internal function, do not use.

Pushes a new element node on top of the node stack

Returns -1 in case of error, the index in the stack otherwise

Definition at line 1956 of file parser.c.

{
    if (ctxt == NULL) return(0);
    if (ctxt->nodeNr >= ctxt->nodeMax) {
        xmlNodePtr *tmp;
 
    tmp = (xmlNodePtr *) xmlRealloc(ctxt->nodeTab,
                                      ctxt->nodeMax * 2 *
                                      sizeof(ctxt->nodeTab[0]));
        if (tmp == NULL) {
            xmlErrMemory(ctxt, NULL);
            return (-1);
        }
        ctxt->nodeTab = tmp;
    ctxt->nodeMax *= 2;
    }
    if ((((unsigned int) ctxt->nodeNr) > xmlParserMaxDepth) &&
        ((ctxt->options & XML_PARSE_HUGE) == 0)) {
    xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
         "Excessive depth in document: %d use XML_PARSE_HUGE option\n",
              xmlParserMaxDepth);
    xmlHaltParser(ctxt);
    return(-1);
    }
    ctxt->nodeTab[ctxt->nodeNr] = value;
    ctxt->node = value;
    return (ctxt->nodeNr++);
}

Referenced by xmlParseBalancedChunkMemoryInternal(), xmlParseExternalEntityPrivate(), xmlParseInNodeContext(), and xmlSAX2StartElementNs().

xmlCheckLanguageID()

XML_DEPRECATED XMLPUBFUN int xmlCheckLanguageID

(

const xmlChar *

lang

)

xmlCheckLanguageID: @lang: pointer to the string value

DEPRECATED: Internal function, do not use.

Checks that the value conforms to the LanguageID production:

NOTE: this is somewhat deprecated, those productions were removed from the XML Second edition.

[33] LanguageID ::= Langcode ('-' Subcode)* [34] Langcode ::= ISO639Code | IanaCode | UserCode [35] ISO639Code ::= ([a-z] | [A-Z]) ([a-z] | [A-Z]) [36] IanaCode ::= ('i' | 'I') '-' ([a-z] | [A-Z])+ [37] UserCode ::= ('x' | 'X') '-' ([a-z] | [A-Z])+ [38] Subcode ::= ([a-z] | [A-Z])+

The current REC reference the successors of RFC 1766, currently 5646

http://www.rfc-editor.org/rfc/rfc5646.txt langtag = language ["-" script] ["-" region] *("-" variant) *("-" extension) ["-" privateuse] language = 2*3ALPHA ; shortest ISO 639 code ["-" extlang] ; sometimes followed by ; extended language subtags / 4ALPHA ; or reserved for future use / 5*8ALPHA ; or registered language subtag

extlang = 3ALPHA ; selected ISO 639 codes *2("-" 3ALPHA) ; permanently reserved

script = 4ALPHA ; ISO 15924 code

region = 2ALPHA ; ISO 3166-1 code / 3DIGIT ; UN M.49 code

variant = 5*8alphanum ; registered variants / (DIGIT 3alphanum)

extension = singleton 1*("-" (2*8alphanum))

                                ; Single alphanumerics
                                ; "x" reserved for private use

singleton = DIGIT ; 0 - 9 / x41-57 ; A - W / x59-5A ; Y - Z / x61-77 ; a - w / x79-7A ; y - z

it sounds right to still allow Irregular i-xxx IANA and user codes too The parser below doesn't try to cope with extension or privateuse that could be added but that's not interoperable anyway

Returns 1 if correct 0 otherwise

Definition at line 1261 of file parser.c.

{
    const xmlChar *cur = lang, *nxt;
 
    if (cur == NULL)
        return (0);
    if (((cur[0] == 'i') && (cur[1] == '-')) ||
        ((cur[0] == 'I') && (cur[1] == '-')) ||
        ((cur[0] == 'x') && (cur[1] == '-')) ||
        ((cur[0] == 'X') && (cur[1] == '-'))) {
        /*
         * Still allow IANA code and user code which were coming
         * from the previous version of the XML-1.0 specification
         * it's deprecated but we should not fail
         */
        cur += 2;
        while (((cur[0] >= 'A') && (cur[0] <= 'Z')) ||
               ((cur[0] >= 'a') && (cur[0] <= 'z')))
            cur++;
        return(cur[0] == 0);
    }
    nxt = cur;
    while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
           ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
           nxt++;
    if (nxt - cur >= 4) {
        /*
         * Reserved
         */
        if ((nxt - cur > 8) || (nxt[0] != 0))
            return(0);
        return(1);
    }
    if (nxt - cur < 2)
        return(0);
    /* we got an ISO 639 code */
    if (nxt[0] == 0)
        return(1);
    if (nxt[0] != '-')
        return(0);
 
    nxt++;
    cur = nxt;
    /* now we can have extlang or script or region or variant */
    if ((nxt[0] >= '0') && (nxt[0] <= '9'))
        goto region_m49;
 
    while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
           ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
           nxt++;
    if (nxt - cur == 4)
        goto script;
    if (nxt - cur == 2)
        goto region;
    if ((nxt - cur >= 5) && (nxt - cur <= 8))
        goto variant;
    if (nxt - cur != 3)
        return(0);
    /* we parsed an extlang */
    if (nxt[0] == 0)
        return(1);
    if (nxt[0] != '-')
        return(0);
 
    nxt++;
    cur = nxt;
    /* now we can have script or region or variant */
    if ((nxt[0] >= '0') && (nxt[0] <= '9'))
        goto region_m49;
 
    while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
           ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
           nxt++;
    if (nxt - cur == 2)
        goto region;
    if ((nxt - cur >= 5) && (nxt - cur <= 8))
        goto variant;
    if (nxt - cur != 4)
        return(0);
    /* we parsed a script */
script:
    if (nxt[0] == 0)
        return(1);
    if (nxt[0] != '-')
        return(0);
 
    nxt++;
    cur = nxt;
    /* now we can have region or variant */
    if ((nxt[0] >= '0') && (nxt[0] <= '9'))
        goto region_m49;
 
    while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
           ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
           nxt++;
 
    if ((nxt - cur >= 5) && (nxt - cur <= 8))
        goto variant;
    if (nxt - cur != 2)
        return(0);
    /* we parsed a region */
region:
    if (nxt[0] == 0)
        return(1);
    if (nxt[0] != '-')
        return(0);
 
    nxt++;
    cur = nxt;
    /* now we can just have a variant */
    while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
           ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
           nxt++;
 
    if ((nxt - cur < 5) || (nxt - cur > 8))
        return(0);
 
    /* we parsed a variant */
variant:
    if (nxt[0] == 0)
        return(1);
    if (nxt[0] != '-')
        return(0);
    /* extensions and private use subtags not checked */
    return (1);
 
region_m49:
    if (((nxt[1] >= '0') && (nxt[1] <= '9')) &&
        ((nxt[2] >= '0') && (nxt[2] <= '9'))) {
        nxt += 3;
        goto region;
    }
    return(0);
}

Referenced by xmlParseAttribute2().

xmlCopyChar()

XMLPUBFUN int xmlCopyChar	(	int len	ATTRIBUTE_UNUSED,
		xmlChar *	out,
		int	val
	)

xmlCopyChar: @len: Ignored, compatibility @out: pointer to an array of xmlChar @val: the char value

append the char value in the array

Returns the number of xmlChar written

Definition at line 1057 of file parserInternals.c.

                                                             {
    if ((out == NULL) || (val < 0)) return(0);
    /* the len parameter is ignored */
    if  (val >= 0x80) {
    return(xmlCopyCharMultiByte (out, val));
    }
    *out = val;
    return 1;
}

Referenced by xmlParseAttValueComplex().

xmlCopyCharMultiByte()

XMLPUBFUN int xmlCopyCharMultiByte	(	xmlChar *	out,
		int	val
	)

xmlCopyCharMultiByte: @out: pointer to an array of xmlChar @val: the char value

append the char value in the array

Returns the number of xmlChar written

Definition at line 1014 of file parserInternals.c.

                                            {
    if ((out == NULL) || (val < 0)) return(0);
    /*
     * We are supposed to handle UTF8, check it's valid
     * From rfc2044: encoding of the Unicode values on UTF-8:
     *
     * UCS-4 range (hex.)           UTF-8 octet sequence (binary)
     * 0000 0000-0000 007F   0xxxxxxx
     * 0000 0080-0000 07FF   110xxxxx 10xxxxxx
     * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx
     */
    if  (val >= 0x80) {
    xmlChar *savedout = out;
    int bits;
    if (val <   0x800) { *out++= (val >>  6) | 0xC0;  bits=  0; }
    else if (val < 0x10000) { *out++= (val >> 12) | 0xE0;  bits=  6;}
    else if (val < 0x110000)  { *out++= (val >> 18) | 0xF0;  bits=  12; }
    else {
        xmlErrEncodingInt(NULL, XML_ERR_INVALID_CHAR,
            "Internal error, xmlCopyCharMultiByte 0x%X out of bound\n",
                  val);
        return(0);
    }
    for ( ; bits >= 0; bits-= 6)
        *out++= ((val >> bits) & 0x3F) | 0x80 ;
    return (out - savedout);
    }
    *out = val;
    return 1;
}

Referenced by xmlCopyChar(), and xsltNumberFormatDecimal().

xmlCreateEntityParserCtxt()

XMLPUBFUN xmlParserCtxtPtr xmlCreateEntityParserCtxt	(	const xmlChar *	URL,
		const xmlChar *	ID,
		const xmlChar *	base
	)

xmlCreateEntityParserCtxt: @URL: the entity URL @ID: the entity PUBLIC ID @base: a possible base for the target URI

Create a parser context for an external entity Automatic support for ZLIB/Compress compressed document is provided by default if found at compile-time.

Returns the new parser context or NULL

Definition at line 13670 of file parser.c.

                                           {
    return xmlCreateEntityParserCtxtInternal(NULL, NULL, URL, ID, base, NULL);
 
}

xmlCreateFileParserCtxt()

XMLPUBFUN xmlParserCtxtPtr xmlCreateFileParserCtxt

(

const char *

filename

)

Parser context.

xmlCreateFileParserCtxt: @filename: the filename

Create a parser context for a file content. Automatic support for ZLIB/Compress compressed document is provided by default if found at compile-time.

Returns the new parser context or NULL

Definition at line 13736 of file parser.c.

{
    return(xmlCreateURLParserCtxt(filename, 0));
}

xmlCreateMemoryParserCtxt()

XMLPUBFUN xmlParserCtxtPtr xmlCreateMemoryParserCtxt	(	const char *	buffer,
		int	size
	)

xmlCreateMemoryParserCtxt: @buffer: a pointer to a char array @size: the size of the array

Create a parser context for an XML in-memory document.

Returns the new parser context or NULL

Definition at line 13996 of file parser.c.

                                                        {
    xmlParserCtxtPtr ctxt;
    xmlParserInputPtr input;
    xmlParserInputBufferPtr buf;
 
    if (buffer == NULL)
    return(NULL);
    if (size <= 0)
    return(NULL);
 
    ctxt = xmlNewParserCtxt();
    if (ctxt == NULL)
    return(NULL);
 
    buf = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
    if (buf == NULL) {
    xmlFreeParserCtxt(ctxt);
    return(NULL);
    }
 
    input = xmlNewInputStream(ctxt);
    if (input == NULL) {
    xmlFreeParserInputBuffer(buf);
    xmlFreeParserCtxt(ctxt);
    return(NULL);
    }
 
    input->filename = NULL;
    input->buf = buf;
    xmlBufResetInput(input->buf->buffer, input);
 
    inputPush(ctxt, input);
    return(ctxt);
}

Referenced by doparse(), internal_parseBuffer(), xmlParseInNodeContext(), and xmlReadMemory().

xmlCreateURLParserCtxt()

XMLPUBFUN xmlParserCtxtPtr xmlCreateURLParserCtxt	(	const char *	filename,
		int	options
	)

xmlCreateURLParserCtxt: @filename: the filename or URL @options: a combination of xmlParserOption

Create a parser context for a file or URL content. Automatic support for ZLIB/Compress compressed document is provided by default if found at compile-time and for file accesses

Returns the new parser context or NULL

Definition at line 13694 of file parser.c.

{
    xmlParserCtxtPtr ctxt;
    xmlParserInputPtr inputStream;
    char *directory = NULL;
 
    ctxt = xmlNewParserCtxt();
    if (ctxt == NULL) {
    xmlErrMemory(NULL, "cannot allocate parser context");
    return(NULL);
    }
 
    if (options)
    xmlCtxtUseOptionsInternal(ctxt, options);
    ctxt->linenumbers = 1;
 
    inputStream = xmlLoadExternalEntity(filename, NULL, ctxt);
    if (inputStream == NULL) {
    xmlFreeParserCtxt(ctxt);
    return(NULL);
    }
 
    inputPush(ctxt, inputStream);
    if ((ctxt->directory == NULL) && (directory == NULL))
        directory = xmlParserGetDirectory(filename);
    if ((ctxt->directory == NULL) && (directory != NULL))
        ctxt->directory = directory;
 
    return(ctxt);
}

Referenced by xmlCreateFileParserCtxt(), and xmlReadFile().

xmlCurrentChar()

XML_DEPRECATED XMLPUBFUN int xmlCurrentChar	(	xmlParserCtxtPtr	ctxt,
		int *	len
	)

xmlCurrentChar: @ctxt: the XML parser context @len: pointer to the length of the char read

DEPRECATED: Internal function, do not use.

The current char value, if using UTF-8 this may actually span multiple bytes in the input buffer. Implement the end of line normalization: 2.11 End-of-Line Handling Wherever an external parsed entity or the literal entity value of an internal parsed entity contains either the literal two-character sequence "#xD#xA" or a standalone literal #xD, an XML processor must pass to the application the single character #xA. This behavior can conveniently be produced by normalizing all line breaks to #xA on input, before parsing.)

Returns the current char value and its length

Definition at line 833 of file parserInternals.c.

                                                {
    const unsigned char *cur;
    size_t avail;
    int c;
 
    if ((ctxt == NULL) || (len == NULL) || (ctxt->input == NULL)) return(0);
    if (ctxt->instate == XML_PARSER_EOF)
    return(0);
 
    avail = ctxt->input->end - ctxt->input->cur;
 
    if (avail < INPUT_CHUNK) {
        xmlParserGrow(ctxt);
        if (ctxt->instate == XML_PARSER_EOF)
            return(0);
        avail = ctxt->input->end - ctxt->input->cur;
    }
 
    cur = ctxt->input->cur;
    c = *cur;
 
    if (c < 0x80) {
    /* 1-byte code */
        if (c < 0x20) {
            /*
             *   2.11 End-of-Line Handling
             *   the literal two-character sequence "#xD#xA" or a standalone
             *   literal #xD, an XML processor must pass to the application
             *   the single character #xA.
             */
            if (c == '\r') {
                /*
                 * TODO: This function shouldn't change the 'cur' pointer
                 * as side effect, but the NEXTL macro in parser.c relies
                 * on this behavior when incrementing line numbers.
                 */
                if (cur[1] == '\n')
                    ctxt->input->cur++;
                *len = 1;
                c = '\n';
            } else if (c == 0) {
                if (ctxt->input->cur >= ctxt->input->end) {
                    *len = 0;
                } else {
                    *len = 1;
                    /*
                     * TODO: Null bytes should be handled by callers,
                     * but this can be tricky.
                     */
                    xmlErrEncodingInt(ctxt, XML_ERR_INVALID_CHAR,
                            "Char 0x0 out of allowed range\n", c);
                }
            } else {
                *len = 1;
            }
        } else {
            *len = 1;
        }
 
        return(c);
    } else {
        int val;
 
        if (avail < 2)
            goto incomplete_sequence;
        if ((cur[1] & 0xc0) != 0x80)
            goto encoding_error;
 
        if (c < 0xe0) {
            /* 2-byte code */
            if (c < 0xc2)
                goto encoding_error;
            val = (c & 0x1f) << 6;
            val |= cur[1] & 0x3f;
            *len = 2;
        } else {
            if (avail < 3)
                goto incomplete_sequence;
            if ((cur[2] & 0xc0) != 0x80)
                goto encoding_error;
 
            if (c < 0xf0) {
                /* 3-byte code */
                val = (c & 0xf) << 12;
                val |= (cur[1] & 0x3f) << 6;
                val |= cur[2] & 0x3f;
                if ((val < 0x800) || ((val >= 0xd800) && (val < 0xe000)))
                    goto encoding_error;
                *len = 3;
            } else {
                if (avail < 4)
                    goto incomplete_sequence;
                if ((cur[3] & 0xc0) != 0x80)
                    goto encoding_error;
 
                /* 4-byte code */
                val = (c & 0x0f) << 18;
                val |= (cur[1] & 0x3f) << 12;
                val |= (cur[2] & 0x3f) << 6;
                val |= cur[3] & 0x3f;
                if ((val < 0x10000) || (val >= 0x110000))
                    goto encoding_error;
                *len = 4;
            }
        }
 
        return(val);
    }
 
encoding_error:
    /* Only report the first error */
    if ((ctxt->input->flags & XML_INPUT_ENCODING_ERROR) == 0) {
        if (ctxt->input->end - ctxt->input->cur < 4) {
            __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
                         "Input is not proper UTF-8, indicate encoding !\n",
                         NULL, NULL);
        } else {
            char buffer[150];
 
            snprintf(&buffer[0], 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
                            ctxt->input->cur[0], ctxt->input->cur[1],
                            ctxt->input->cur[2], ctxt->input->cur[3]);
            __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
                         "Input is not proper UTF-8, indicate encoding !\n%s",
                         BAD_CAST buffer, NULL);
        }
        ctxt->input->flags |= XML_INPUT_ENCODING_ERROR;
    }
    *len = 1;
    return(0xFFFD); /* U+FFFD Replacement Character */
 
incomplete_sequence:
    /*
     * An encoding problem may arise from a truncated input buffer
     * splitting a character in the middle. In that case do not raise
     * an error but return 0. This should only happen when push parsing
     * char data.
     */
    *len = 0;
    return(0);
}

xmlFreeInputStream()

XMLPUBFUN void xmlFreeInputStream

(

xmlParserInputPtr

input

)

xmlFreeInputStream: @input: an xmlParserInputPtr

Free up an input stream.

Definition at line 1519 of file parserInternals.c.

                                            {
    if (input == NULL) return;
 
    if (input->filename != NULL) xmlFree((char *) input->filename);
    if (input->directory != NULL) xmlFree((char *) input->directory);
    if (input->version != NULL) xmlFree((char *) input->version);
    if ((input->free != NULL) && (input->base != NULL))
        input->free((xmlChar *) input->base);
    if (input->buf != NULL)
        xmlFreeParserInputBuffer(input->buf);
    xmlFree(input);
}

Referenced by xmlCtxtReset(), xmlFreeParserCtxt(), xmlHaltParser(), xmlInitSAXParserCtxt(), xmlLoadEntityContent(), xmlParsePEReference(), xmlPopInput(), xmlPushInput(), and xmlSAX2ExternalSubset().

xmlIsLetter()

XMLPUBFUN int xmlIsLetter

(

int

c

)

xmlIsLetter: : an unicode character (int)

Check whether the character is allowed by the production [84] Letter ::= BaseChar | Ideographic

Returns 0 if not, non-zero otherwise

Definition at line 440 of file parserInternals.c.

                   {
    return(IS_BASECHAR(c) || IS_IDEOGRAPHIC(c));
}

xmlNewEntityInputStream()

XML_DEPRECATED XMLPUBFUN xmlParserInputPtr xmlNewEntityInputStream	(	xmlParserCtxtPtr	ctxt,
		xmlEntityPtr	entity
	)

xmlNewEntityInputStream: @ctxt: an XML parser context @entity: an Entity pointer

DEPRECATED: Internal function, do not use.

Create a new input stream based on an xmlEntityPtr

Returns the new input stream or NULL

Definition at line 1615 of file parserInternals.c.

                                                                    {
    xmlParserInputPtr input;
 
    if (entity == NULL) {
        xmlErrInternal(ctxt, "xmlNewEntityInputStream entity = NULL\n",
                   NULL);
    return(NULL);
    }
    if (xmlParserDebugEntities)
    xmlGenericError(xmlGenericErrorContext,
        "new input from entity: %s\n", entity->name);
    if (entity->content == NULL) {
    switch (entity->etype) {
            case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
            xmlErrInternal(ctxt, "Cannot parse entity %s\n",
                       entity->name);
                break;
            case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
            case XML_EXTERNAL_PARAMETER_ENTITY:
        input = xmlLoadExternalEntity((char *) entity->URI,
               (char *) entity->ExternalID, ctxt);
                if (input != NULL)
                    input->entity = entity;
                return(input);
            case XML_INTERNAL_GENERAL_ENTITY:
            xmlErrInternal(ctxt,
              "Internal entity %s without content !\n",
                       entity->name);
                break;
            case XML_INTERNAL_PARAMETER_ENTITY:
            xmlErrInternal(ctxt,
              "Internal parameter entity %s without content !\n",
                       entity->name);
                break;
            case XML_INTERNAL_PREDEFINED_ENTITY:
            xmlErrInternal(ctxt,
              "Predefined entity %s without content !\n",
                       entity->name);
                break;
    }
    return(NULL);
    }
    input = xmlNewInputStream(ctxt);
    if (input == NULL) {
    return(NULL);
    }
    if (entity->URI != NULL)
    input->filename = (char *) xmlStrdup((xmlChar *) entity->URI);
    input->base = entity->content;
    if (entity->length == 0)
        entity->length = xmlStrlen(entity->content);
    input->cur = entity->content;
    input->length = entity->length;
    input->end = &entity->content[input->length];
    input->entity = entity;
    return(input);
}

Referenced by xmlParsePEReference().

xmlNewInputFromFile()

XMLPUBFUN xmlParserInputPtr xmlNewInputFromFile	(	xmlParserCtxtPtr	ctxt,
		const char *	filename
	)

xmlNewInputFromFile: @ctxt: an XML parser context @filename: the filename to use as entity

Create a new input stream based on a file or an URL.

Returns the new input stream or NULL in case of error

Definition at line 1720 of file parserInternals.c.

                                                                 {
    xmlParserInputBufferPtr buf;
    xmlParserInputPtr inputStream;
    char *directory = NULL;
    xmlChar *URI = NULL;
 
    if (xmlParserDebugEntities)
    xmlGenericError(xmlGenericErrorContext,
        "new input from file: %s\n", filename);
    if (ctxt == NULL) return(NULL);
    buf = xmlParserInputBufferCreateFilename(filename, XML_CHAR_ENCODING_NONE);
    if (buf == NULL) {
    if (filename == NULL)
        __xmlLoaderErr(ctxt,
                       "failed to load external entity: NULL filename \n",
               NULL);
    else
        __xmlLoaderErr(ctxt, "failed to load external entity \"%s\"\n",
               (const char *) filename);
    return(NULL);
    }
 
    inputStream = xmlNewInputStream(ctxt);
    if (inputStream == NULL) {
    xmlFreeParserInputBuffer(buf);
    return(NULL);
    }
 
    inputStream->buf = buf;
    inputStream = xmlCheckHTTPInput(ctxt, inputStream);
    if (inputStream == NULL)
        return(NULL);
 
    if (inputStream->filename == NULL)
    URI = xmlStrdup((xmlChar *) filename);
    else
    URI = xmlStrdup((xmlChar *) inputStream->filename);
    directory = xmlParserGetDirectory((const char *) URI);
    if (inputStream->filename != NULL) xmlFree((char *)inputStream->filename);
    inputStream->filename = (char *) xmlCanonicPath((const xmlChar *) URI);
    if (URI != NULL) xmlFree((char *) URI);
    inputStream->directory = directory;
 
    xmlBufResetInput(inputStream->buf->buffer, inputStream);
    if ((ctxt->directory == NULL) && (directory != NULL))
        ctxt->directory = (char *) xmlStrdup((const xmlChar *) directory);
    return(inputStream);
}

xmlNewInputStream()

XMLPUBFUN xmlParserInputPtr xmlNewInputStream

(

xmlParserCtxtPtr

ctxt

)

xmlNewInputStream: @ctxt: an XML parser context

Create a new input stream structure.

Returns the new input stream or NULL

Definition at line 1541 of file parserInternals.c.

                                         {
    xmlParserInputPtr input;
 
    input = (xmlParserInputPtr) xmlMalloc(sizeof(xmlParserInput));
    if (input == NULL) {
        xmlErrMemory(ctxt,  "couldn't allocate a new input stream\n");
    return(NULL);
    }
    memset(input, 0, sizeof(xmlParserInput));
    input->line = 1;
    input->col = 1;
 
    /*
     * If the context is NULL the id cannot be initialized, but that
     * should not happen while parsing which is the situation where
     * the id is actually needed.
     */
    if (ctxt != NULL) {
        if (input->id >= INT_MAX) {
            xmlErrMemory(ctxt, "Input ID overflow\n");
            return(NULL);
        }
        input->id = ctxt->input_id++;
    }
 
    return(input);
}

Referenced by xmlCreateDocParserCtxt(), xmlCreateMemoryParserCtxt(), xmlCtxtResetPush(), xmlNewEntityInputStream(), xmlNewInputFromFile(), xmlNewIOInputStream(), and xmlNewStringInputStream().

xmlNewStringInputStream()

XMLPUBFUN xmlParserInputPtr xmlNewStringInputStream	(	xmlParserCtxtPtr	ctxt,
		const xmlChar *	buffer
	)

Input Streams.

xmlNewStringInputStream: @ctxt: an XML parser context @buffer: an memory buffer

Create a new input stream based on a memory buffer. Returns the new input stream

Definition at line 1682 of file parserInternals.c.

                                                                      {
    xmlParserInputPtr input;
    xmlParserInputBufferPtr buf;
 
    if (buffer == NULL) {
        xmlErrInternal(ctxt, "xmlNewStringInputStream string = NULL\n",
                   NULL);
    return(NULL);
    }
    if (xmlParserDebugEntities)
    xmlGenericError(xmlGenericErrorContext,
        "new fixed input: %.30s\n", buffer);
    buf = xmlParserInputBufferCreateString(buffer);
    if (buf == NULL) {
    xmlErrMemory(ctxt, NULL);
        return(NULL);
    }
    input = xmlNewInputStream(ctxt);
    if (input == NULL) {
        xmlErrMemory(ctxt,  "couldn't allocate a new input stream\n");
    xmlFreeParserInputBuffer(buf);
    return(NULL);
    }
    input->buf = buf;
    xmlBufResetInput(input->buf->buffer, input);
    return(input);
}

Referenced by external_entity_loader().

xmlNextChar()

XML_DEPRECATED XMLPUBFUN void xmlNextChar

(

xmlParserCtxtPtr

ctxt

)

xmlNextChar: @ctxt: the XML parser context

DEPRECATED: Internal function, do not use.

Skip to the next char input char.

Definition at line 709 of file parserInternals.c.

{
    const unsigned char *cur;
    size_t avail;
    int c;
 
    if ((ctxt == NULL) || (ctxt->instate == XML_PARSER_EOF) ||
        (ctxt->input == NULL))
        return;
 
    avail = ctxt->input->end - ctxt->input->cur;
 
    if (avail < INPUT_CHUNK) {
        xmlParserGrow(ctxt);
        if ((ctxt->instate == XML_PARSER_EOF) ||
            (ctxt->input->cur >= ctxt->input->end))
            return;
        avail = ctxt->input->end - ctxt->input->cur;
    }
 
    cur = ctxt->input->cur;
    c = *cur;
 
    if (c < 0x80) {
        if (c == '\n') {
            ctxt->input->cur++;
            ctxt->input->line++;
            ctxt->input->col = 1;
        } else if (c == '\r') {
            /*
             *   2.11 End-of-Line Handling
             *   the literal two-character sequence "#xD#xA" or a standalone
             *   literal #xD, an XML processor must pass to the application
             *   the single character #xA.
             */
            ctxt->input->cur += ((cur[1] == '\n') ? 2 : 1);
            ctxt->input->line++;
            ctxt->input->col = 1;
            return;
        } else {
            ctxt->input->cur++;
            ctxt->input->col++;
        }
    } else {
        ctxt->input->col++;
 
        if ((avail < 2) || (cur[1] & 0xc0) != 0x80)
            goto encoding_error;
 
        if (c < 0xe0) {
            /* 2-byte code */
            if (c < 0xc2)
                goto encoding_error;
            ctxt->input->cur += 2;
        } else {
            unsigned int val = (c << 8) | cur[1];
 
            if ((avail < 3) || (cur[2] & 0xc0) != 0x80)
                goto encoding_error;
 
            if (c < 0xf0) {
                /* 3-byte code */
                if ((val < 0xe0a0) || ((val >= 0xeda0) && (val < 0xee00)))
                    goto encoding_error;
                ctxt->input->cur += 3;
            } else {
                if ((avail < 4) || ((cur[3] & 0xc0) != 0x80))
                    goto encoding_error;
 
                /* 4-byte code */
                if ((val < 0xf090) || (val >= 0xf490))
                    goto encoding_error;
                ctxt->input->cur += 4;
            }
        }
    }
 
    return;
 
encoding_error:
    /* Only report the first error */
    if ((ctxt->input->flags & XML_INPUT_ENCODING_ERROR) == 0) {
        if ((ctxt == NULL) || (ctxt->input == NULL) ||
            (ctxt->input->end - ctxt->input->cur < 4)) {
            __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
                         "Input is not proper UTF-8, indicate encoding !\n",
                         NULL, NULL);
        } else {
            char buffer[150];
 
            snprintf(buffer, 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
                            ctxt->input->cur[0], ctxt->input->cur[1],
                            ctxt->input->cur[2], ctxt->input->cur[3]);
            __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
                         "Input is not proper UTF-8, indicate encoding !\n%s",
                         BAD_CAST buffer, NULL);
        }
        ctxt->input->flags |= XML_INPUT_ENCODING_ERROR;
    }
    ctxt->input->cur++;
    return;
}

xmlParseAttributeListDecl()

XML_DEPRECATED XMLPUBFUN void xmlParseAttributeListDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseAttributeListDecl: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

Parse an attribute list declaration for an element. Always consumes '<!'.

[52] AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>'

[53] AttDef ::= S Name S AttType S DefaultDecl

Definition at line 6130 of file parser.c.

                                                 {
    const xmlChar *elemName;
    const xmlChar *attrName;
    xmlEnumerationPtr tree;
 
    if ((CUR != '<') || (NXT(1) != '!'))
        return;
    SKIP(2);
 
    if (CMP7(CUR_PTR, 'A', 'T', 'T', 'L', 'I', 'S', 'T')) {
    int inputid = ctxt->input->id;
 
    SKIP(7);
    if (SKIP_BLANKS == 0) {
        xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
                         "Space required after '<!ATTLIST'\n");
    }
        elemName = xmlParseName(ctxt);
    if (elemName == NULL) {
        xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
               "ATTLIST: no name for Element\n");
        return;
    }
    SKIP_BLANKS;
    GROW;
    while ((RAW != '>') && (ctxt->instate != XML_PARSER_EOF)) {
        int type;
        int def;
        xmlChar *defaultValue = NULL;
 
        GROW;
            tree = NULL;
        attrName = xmlParseName(ctxt);
        if (attrName == NULL) {
        xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
                   "ATTLIST: no name for Attribute\n");
        break;
        }
        GROW;
        if (SKIP_BLANKS == 0) {
        xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
                "Space required after the attribute name\n");
        break;
        }
 
        type = xmlParseAttributeType(ctxt, &tree);
        if (type <= 0) {
            break;
        }
 
        GROW;
        if (SKIP_BLANKS == 0) {
        xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
                   "Space required after the attribute type\n");
            if (tree != NULL)
            xmlFreeEnumeration(tree);
        break;
        }
 
        def = xmlParseDefaultDecl(ctxt, &defaultValue);
        if (def <= 0) {
                if (defaultValue != NULL)
            xmlFree(defaultValue);
            if (tree != NULL)
            xmlFreeEnumeration(tree);
            break;
        }
        if ((type != XML_ATTRIBUTE_CDATA) && (defaultValue != NULL))
            xmlAttrNormalizeSpace(defaultValue, defaultValue);
 
        GROW;
            if (RAW != '>') {
        if (SKIP_BLANKS == 0) {
            xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
            "Space required after the attribute default value\n");
            if (defaultValue != NULL)
            xmlFree(defaultValue);
            if (tree != NULL)
            xmlFreeEnumeration(tree);
            break;
        }
        }
        if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
        (ctxt->sax->attributeDecl != NULL))
        ctxt->sax->attributeDecl(ctxt->userData, elemName, attrName,
                            type, def, defaultValue, tree);
        else if (tree != NULL)
        xmlFreeEnumeration(tree);
 
        if ((ctxt->sax2) && (defaultValue != NULL) &&
            (def != XML_ATTRIBUTE_IMPLIED) &&
        (def != XML_ATTRIBUTE_REQUIRED)) {
        xmlAddDefAttrs(ctxt, elemName, attrName, defaultValue);
        }
        if (ctxt->sax2) {
        xmlAddSpecialAttr(ctxt, elemName, attrName, type);
        }
        if (defaultValue != NULL)
            xmlFree(defaultValue);
        GROW;
    }
    if (RAW == '>') {
        if (inputid != ctxt->input->id) {
        xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
                               "Attribute list declaration doesn't start and"
                               " stop in the same entity\n");
        }
        NEXT;
    }
    }
}

Referenced by xmlParseMarkupDecl().

xmlParseAttributeType()

XML_DEPRECATED XMLPUBFUN int xmlParseAttributeType	(	xmlParserCtxtPtr	ctxt,
		xmlEnumerationPtr *	tree
	)

xmlParseAttributeType: @ctxt: an XML parser context @tree: the enumeration tree built while parsing

DEPRECATED: Internal function, don't use.

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

Definition at line 6087 of file parser.c.

                                                                      {
    if (CMP5(CUR_PTR, 'C', 'D', 'A', 'T', 'A')) {
    SKIP(5);
    return(XML_ATTRIBUTE_CDATA);
     } else if (CMP6(CUR_PTR, 'I', 'D', 'R', 'E', 'F', 'S')) {
    SKIP(6);
    return(XML_ATTRIBUTE_IDREFS);
     } else if (CMP5(CUR_PTR, 'I', 'D', 'R', 'E', 'F')) {
    SKIP(5);
    return(XML_ATTRIBUTE_IDREF);
     } else if ((RAW == 'I') && (NXT(1) == 'D')) {
        SKIP(2);
    return(XML_ATTRIBUTE_ID);
     } else if (CMP6(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'Y')) {
    SKIP(6);
    return(XML_ATTRIBUTE_ENTITY);
     } else if (CMP8(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'I', 'E', 'S')) {
    SKIP(8);
    return(XML_ATTRIBUTE_ENTITIES);
     } else if (CMP8(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N', 'S')) {
    SKIP(8);
    return(XML_ATTRIBUTE_NMTOKENS);
     } else if (CMP7(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N')) {
    SKIP(7);
    return(XML_ATTRIBUTE_NMTOKEN);
     }
     return(xmlParseEnumeratedType(ctxt, tree));
}

Referenced by xmlParseAttributeListDecl().

xmlParseAttValue()

XML_DEPRECATED XMLPUBFUN xmlChar * xmlParseAttValue

(

xmlParserCtxtPtr

ctxt

)

xmlParseAttValue: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

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.

Definition at line 4342 of file parser.c.

                                        {
    if ((ctxt == NULL) || (ctxt->input == NULL)) return(NULL);
    return(xmlParseAttValueInternal(ctxt, NULL, NULL, 0));
}

Referenced by xmlParseDefaultDecl().

xmlParseCDSect()

XML_DEPRECATED XMLPUBFUN void xmlParseCDSect

(

xmlParserCtxtPtr

ctxt

)

xmlParseCDSect: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

Parse escaped pure raw content. Always consumes '<!['.

[18] CDSect ::= CDStart CData CDEnd

[19] CDStart ::= ''

[20] Data ::= (Char* - (Char* '' Char*))

[21] CDEnd ::= ']]>'

Definition at line 10117 of file parser.c.

                                      {
    xmlChar *buf = NULL;
    int len = 0;
    int size = XML_PARSER_BUFFER_SIZE;
    int r, rl;
    int s, sl;
    int cur, l;
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
                    XML_MAX_HUGE_LENGTH :
                    XML_MAX_TEXT_LENGTH;
 
    if ((CUR != '<') || (NXT(1) != '!') || (NXT(2) != '['))
        return;
    SKIP(3);
 
    if (!CMP6(CUR_PTR, 'C', 'D', 'A', 'T', 'A', '['))
        return;
    SKIP(6);
 
    ctxt->instate = XML_PARSER_CDATA_SECTION;
    r = CUR_CHAR(rl);
    if (!IS_CHAR(r)) {
    xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
        goto out;
    }
    NEXTL(rl);
    s = CUR_CHAR(sl);
    if (!IS_CHAR(s)) {
    xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
        goto out;
    }
    NEXTL(sl);
    cur = CUR_CHAR(l);
    buf = (xmlChar *) xmlMallocAtomic(size);
    if (buf == NULL) {
    xmlErrMemory(ctxt, NULL);
        goto out;
    }
    while (IS_CHAR(cur) &&
           ((r != ']') || (s != ']') || (cur != '>'))) {
    if (len + 5 >= size) {
        xmlChar *tmp;
 
        tmp = (xmlChar *) xmlRealloc(buf, size * 2);
        if (tmp == NULL) {
        xmlErrMemory(ctxt, NULL);
                goto out;
        }
        buf = tmp;
        size *= 2;
    }
    COPY_BUF(buf, len, r);
        if (len > maxLength) {
            xmlFatalErrMsg(ctxt, XML_ERR_CDATA_NOT_FINISHED,
                           "CData section too big found\n");
            goto out;
        }
    r = s;
    rl = sl;
    s = cur;
    sl = l;
    NEXTL(l);
    cur = CUR_CHAR(l);
    }
    buf[len] = 0;
    if (ctxt->instate == XML_PARSER_EOF) {
        xmlFree(buf);
        return;
    }
    if (cur != '>') {
    xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED,
                         "CData section not finished\n%.50s\n", buf);
        goto out;
    }
    NEXTL(l);
 
    /*
     * OK the buffer is to be consumed as cdata.
     */
    if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
    if (ctxt->sax->cdataBlock != NULL)
        ctxt->sax->cdataBlock(ctxt->userData, buf, len);
    else if (ctxt->sax->characters != NULL)
        ctxt->sax->characters(ctxt->userData, buf, len);
    }
 
out:
    if (ctxt->instate != XML_PARSER_EOF)
        ctxt->instate = XML_PARSER_CONTENT;
    xmlFree(buf);
}

Referenced by xmlParseContentInternal().

xmlParseCharData()

XML_DEPRECATED XMLPUBFUN void xmlParseCharData	(	xmlParserCtxtPtr	ctxt,
		int	cdata
	)

xmlParseCharRef()

XML_DEPRECATED XMLPUBFUN int xmlParseCharRef

(

xmlParserCtxtPtr

ctxt

)

xmlParseCharRef: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

Parse a numeric character reference. Always consumes '&'.

[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

Definition at line 2493 of file parser.c.

                                       {
    int val = 0;
    int count = 0;
 
    /*
     * Using RAW/CUR/NEXT is okay since we are working on ASCII range here
     */
    if ((RAW == '&') && (NXT(1) == '#') &&
        (NXT(2) == 'x')) {
    SKIP(3);
    GROW;
    while (RAW != ';') { /* loop blocked by count */
        if (count++ > 20) {
        count = 0;
        GROW;
                if (ctxt->instate == XML_PARSER_EOF)
                    return(0);
        }
        if ((RAW >= '0') && (RAW <= '9'))
            val = val * 16 + (CUR - '0');
        else if ((RAW >= 'a') && (RAW <= 'f') && (count < 20))
            val = val * 16 + (CUR - 'a') + 10;
        else if ((RAW >= 'A') && (RAW <= 'F') && (count < 20))
            val = val * 16 + (CUR - 'A') + 10;
        else {
        xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
        val = 0;
        break;
        }
        if (val > 0x110000)
            val = 0x110000;
 
        NEXT;
        count++;
    }
    if (RAW == ';') {
        /* on purpose to avoid reentrancy problems with NEXT and SKIP */
        ctxt->input->col++;
        ctxt->input->cur++;
    }
    } else if  ((RAW == '&') && (NXT(1) == '#')) {
    SKIP(2);
    GROW;
    while (RAW != ';') { /* loop blocked by count */
        if (count++ > 20) {
        count = 0;
        GROW;
                if (ctxt->instate == XML_PARSER_EOF)
                    return(0);
        }
        if ((RAW >= '0') && (RAW <= '9'))
            val = val * 10 + (CUR - '0');
        else {
        xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
        val = 0;
        break;
        }
        if (val > 0x110000)
            val = 0x110000;
 
        NEXT;
        count++;
    }
    if (RAW == ';') {
        /* on purpose to avoid reentrancy problems with NEXT and SKIP */
        ctxt->input->col++;
        ctxt->input->cur++;
    }
    } else {
        if (RAW == '&')
            SKIP(1);
        xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
    }
 
    /*
     * [ WFC: Legal Character ]
     * Characters referred to using character references must match the
     * production for Char.
     */
    if (val >= 0x110000) {
        xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
                "xmlParseCharRef: character reference out of bounds\n",
            val);
    } else if (IS_CHAR(val)) {
        return(val);
    } else {
        xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
                          "xmlParseCharRef: invalid xmlChar value %d\n",
                      val);
    }
    return(0);
}

Referenced by xmlParseAttValueComplex(), and xmlParseReference().

xmlParseComment()

XML_DEPRECATED XMLPUBFUN void xmlParseComment

(

xmlParserCtxtPtr

ctxt

)

xmlParseComment: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

Parse an XML (SGML) comment. Always consumes '<!'.

The spec says that "For compatibility, the string "–" (double-hyphen) must not occur within comments. "

[15] Comment ::= ''

Definition at line 5034 of file parser.c.

                                       {
    xmlChar *buf = NULL;
    size_t size = XML_PARSER_BUFFER_SIZE;
    size_t len = 0;
    size_t maxLength = (ctxt->options & XML_PARSE_HUGE) ?
                       XML_MAX_HUGE_LENGTH :
                       XML_MAX_TEXT_LENGTH;
    xmlParserInputState state;
    const xmlChar *in;
    size_t nbchar = 0;
    int ccol;
    int inputid;
 
    /*
     * Check that there is a comment right here.
     */
    if ((RAW != '<') || (NXT(1) != '!'))
        return;
    SKIP(2);
    if ((RAW != '-') || (NXT(1) != '-'))
        return;
    state = ctxt->instate;
    ctxt->instate = XML_PARSER_COMMENT;
    inputid = ctxt->input->id;
    SKIP(2);
    GROW;
 
    /*
     * Accelerated common case where input don't need to be
     * modified before passing it to the handler.
     */
    in = ctxt->input->cur;
    do {
    if (*in == 0xA) {
        do {
        ctxt->input->line++; ctxt->input->col = 1;
        in++;
        } while (*in == 0xA);
    }
get_more:
        ccol = ctxt->input->col;
    while (((*in > '-') && (*in <= 0x7F)) ||
           ((*in >= 0x20) && (*in < '-')) ||
           (*in == 0x09)) {
            in++;
            ccol++;
    }
    ctxt->input->col = ccol;
    if (*in == 0xA) {
        do {
        ctxt->input->line++; ctxt->input->col = 1;
        in++;
        } while (*in == 0xA);
        goto get_more;
    }
    nbchar = in - ctxt->input->cur;
    /*
     * save current set of data
     */
    if (nbchar > 0) {
            if (buf == NULL) {
                if ((*in == '-') && (in[1] == '-'))
                    size = nbchar + 1;
                else
                    size = XML_PARSER_BUFFER_SIZE + nbchar;
                buf = (xmlChar *) xmlMallocAtomic(size);
                if (buf == NULL) {
                    xmlErrMemory(ctxt, NULL);
                    ctxt->instate = state;
                    return;
                }
                len = 0;
            } else if (len + nbchar + 1 >= size) {
                xmlChar *new_buf;
                size  += len + nbchar + XML_PARSER_BUFFER_SIZE;
                new_buf = (xmlChar *) xmlRealloc(buf, size);
                if (new_buf == NULL) {
                    xmlFree (buf);
                    xmlErrMemory(ctxt, NULL);
                    ctxt->instate = state;
                    return;
                }
                buf = new_buf;
            }
            memcpy(&buf[len], ctxt->input->cur, nbchar);
            len += nbchar;
            buf[len] = 0;
    }
        if (len > maxLength) {
            xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
                         "Comment too big found", NULL);
            xmlFree (buf);
            return;
        }
    ctxt->input->cur = in;
    if (*in == 0xA) {
        in++;
        ctxt->input->line++; ctxt->input->col = 1;
    }
    if (*in == 0xD) {
        in++;
        if (*in == 0xA) {
        ctxt->input->cur = in;
        in++;
        ctxt->input->line++; ctxt->input->col = 1;
        goto get_more;
        }
        in--;
    }
    SHRINK;
    GROW;
        if (ctxt->instate == XML_PARSER_EOF) {
            xmlFree(buf);
            return;
        }
    in = ctxt->input->cur;
    if (*in == '-') {
        if (in[1] == '-') {
            if (in[2] == '>') {
            if (ctxt->input->id != inputid) {
            xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
                           "comment doesn't start and stop in the"
                                       " same entity\n");
            }
            SKIP(3);
            if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
                (!ctxt->disableSAX)) {
            if (buf != NULL)
                ctxt->sax->comment(ctxt->userData, buf);
            else
                ctxt->sax->comment(ctxt->userData, BAD_CAST "");
            }
            if (buf != NULL)
                xmlFree(buf);
            if (ctxt->instate != XML_PARSER_EOF)
            ctxt->instate = state;
            return;
        }
        if (buf != NULL) {
            xmlFatalErrMsgStr(ctxt, XML_ERR_HYPHEN_IN_COMMENT,
                              "Double hyphen within comment: "
                                      "<!--%.50s\n",
                      buf);
        } else
            xmlFatalErrMsgStr(ctxt, XML_ERR_HYPHEN_IN_COMMENT,
                              "Double hyphen within comment\n", NULL);
                if (ctxt->instate == XML_PARSER_EOF) {
                    xmlFree(buf);
                    return;
                }
        in++;
        ctxt->input->col++;
        }
        in++;
        ctxt->input->col++;
        goto get_more;
    }
    } while (((*in >= 0x20) && (*in <= 0x7F)) || (*in == 0x09) || (*in == 0x0a));
    xmlParseCommentComplex(ctxt, buf, len, size);
    ctxt->instate = state;
    return;
}

Referenced by xmlParseContentInternal(), xmlParseMarkupDecl(), and xmlParseMisc().

xmlParseContent()

XMLPUBFUN void xmlParseContent

(

xmlParserCtxtPtr

ctxt

)

xmlParseContent: @ctxt: an XML parser context

Parse a content sequence. Stops at EOF or '</'.

[43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*

Definition at line 10294 of file parser.c.

                                       {
    int nameNr = ctxt->nameNr;
 
    xmlParseContentInternal(ctxt);
 
    if ((ctxt->instate != XML_PARSER_EOF) &&
        (ctxt->errNo == XML_ERR_OK) &&
        (ctxt->nameNr > nameNr)) {
        const xmlChar *name = ctxt->nameTab[ctxt->nameNr - 1];
        int line = ctxt->pushTab[ctxt->nameNr - 1].line;
        xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NOT_FINISHED,
                "Premature end of data in tag %s line %d\n",
        name, line, NULL);
    }
}

Referenced by xmlParseBalancedChunkMemoryInternal(), xmlParseExternalEntityPrivate(), xmlParseExtParsedEnt(), and xmlParseInNodeContext().

xmlParseDefaultDecl()

XML_DEPRECATED XMLPUBFUN int xmlParseDefaultDecl	(	xmlParserCtxtPtr	ctxt,
		xmlChar **	value
	)

xmlParseDefaultDecl: @ctxt: an XML parser context @value: Receive a possible fixed default value for the attribute

DEPRECATED: Internal function, don't use.

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 xmlParseAttValue()

returns: XML_ATTRIBUTE_NONE, XML_ATTRIBUTE_REQUIRED, XML_ATTRIBUTE_IMPLIED or XML_ATTRIBUTE_FIXED.

Definition at line 5829 of file parser.c.

                                                            {
    int val;
    xmlChar *ret;
 
    *value = NULL;
    if (CMP9(CUR_PTR, '#', 'R', 'E', 'Q', 'U', 'I', 'R', 'E', 'D')) {
    SKIP(9);
    return(XML_ATTRIBUTE_REQUIRED);
    }
    if (CMP8(CUR_PTR, '#', 'I', 'M', 'P', 'L', 'I', 'E', 'D')) {
    SKIP(8);
    return(XML_ATTRIBUTE_IMPLIED);
    }
    val = XML_ATTRIBUTE_NONE;
    if (CMP6(CUR_PTR, '#', 'F', 'I', 'X', 'E', 'D')) {
    SKIP(6);
    val = XML_ATTRIBUTE_FIXED;
    if (SKIP_BLANKS == 0) {
        xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
               "Space required after '#FIXED'\n");
    }
    }
    ret = xmlParseAttValue(ctxt);
    ctxt->instate = XML_PARSER_DTD;
    if (ret == NULL) {
    xmlFatalErrMsg(ctxt, (xmlParserErrors)ctxt->errNo,
               "Attribute default value declaration error\n");
    } else
        *value = ret;
    return(val);
}

Referenced by xmlParseAttributeListDecl().

xmlParseDocTypeDecl()

XML_DEPRECATED XMLPUBFUN void xmlParseDocTypeDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseDocTypeDecl: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse a DOCTYPE declaration

[28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S? ('[' (markupdecl | PEReference | S)* ']' S?)? '>'

[ VC: Root Element Type ] The Name in the document type declaration must match the element type of the root element.

Definition at line 8466 of file parser.c.

                                           {
    const xmlChar *name = NULL;
    xmlChar *ExternalID = NULL;
    xmlChar *URI = NULL;
 
    /*
     * We know that '<!DOCTYPE' has been detected.
     */
    SKIP(9);
 
    SKIP_BLANKS;
 
    /*
     * Parse the DOCTYPE name.
     */
    name = xmlParseName(ctxt);
    if (name == NULL) {
    xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
               "xmlParseDocTypeDecl : no DOCTYPE name !\n");
    }
    ctxt->intSubName = name;
 
    SKIP_BLANKS;
 
    /*
     * Check for SystemID and ExternalID
     */
    URI = xmlParseExternalID(ctxt, &ExternalID, 1);
 
    if ((URI != NULL) || (ExternalID != NULL)) {
        ctxt->hasExternalSubset = 1;
    }
    ctxt->extSubURI = URI;
    ctxt->extSubSystem = ExternalID;
 
    SKIP_BLANKS;
 
    /*
     * Create and update the internal subset.
     */
    if ((ctxt->sax != NULL) && (ctxt->sax->internalSubset != NULL) &&
    (!ctxt->disableSAX))
    ctxt->sax->internalSubset(ctxt->userData, name, ExternalID, URI);
    if (ctxt->instate == XML_PARSER_EOF)
    return;
 
    /*
     * Is there any internal subset declarations ?
     * they are handled separately in xmlParseInternalSubset()
     */
    if (RAW == '[')
    return;
 
    /*
     * We should be at the end of the DOCTYPE declaration.
     */
    if (RAW != '>') {
    xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
    }
    NEXT;
}

Referenced by xmlParseDocument().

xmlParseElement()

XML_DEPRECATED XMLPUBFUN void xmlParseElement

(

xmlParserCtxtPtr

ctxt

)

xmlParseElement: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse an XML element

[39] element ::= EmptyElemTag | STag content ETag

[ WFC: Element Type Match ] The Name in an element's end-tag must match the element type in the start-tag.

Definition at line 10327 of file parser.c.

                                       {
    if (xmlParseElementStart(ctxt) != 0)
        return;
 
    xmlParseContentInternal(ctxt);
    if (ctxt->instate == XML_PARSER_EOF)
    return;
 
    if (ctxt->input->cur >= ctxt->input->end) {
        if (ctxt->errNo == XML_ERR_OK) {
            const xmlChar *name = ctxt->nameTab[ctxt->nameNr - 1];
            int line = ctxt->pushTab[ctxt->nameNr - 1].line;
            xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NOT_FINISHED,
                    "Premature end of data in tag %s line %d\n",
                    name, line, NULL);
        }
        return;
    }
 
    xmlParseElementEnd(ctxt);
}

Referenced by xmlParseDocument().

xmlParseElementChildrenContentDecl()

XML_DEPRECATED XMLPUBFUN xmlElementContentPtr xmlParseElementChildrenContentDecl	(	xmlParserCtxtPtr	ctxt,
		int	inputchk
	)

xmlParseElementChildrenContentDecl: @ctxt: an XML parser context @inputchk: the input used for the current entity, needed for boundary checks

DEPRECATED: Internal function, don't use.

parse the declaration for a Mixed Element content The leading '(' and spaces have been skipped in xmlParseElementContentDecl

[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 parenthesized 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.

Definition at line 6693 of file parser.c.

                                                                        {
    /* stub left for API/ABI compat */
    return(xmlParseElementChildrenContentDeclPriv(ctxt, inputchk, 1));
}

xmlParseElementContentDecl()

XML_DEPRECATED XMLPUBFUN int xmlParseElementContentDecl	(	xmlParserCtxtPtr	ctxt,
		const xmlChar *	name,
		xmlElementContentPtr *	result
	)

Definition at line 6715 of file parser.c.

                                                         {
 
    xmlElementContentPtr tree = NULL;
    int inputid = ctxt->input->id;
    int res;
 
    *result = NULL;
 
    if (RAW != '(') {
    xmlFatalErrMsgStr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
        "xmlParseElementContentDecl : %s '(' expected\n", name);
    return(-1);
    }
    NEXT;
    GROW;
    if (ctxt->instate == XML_PARSER_EOF)
        return(-1);
    SKIP_BLANKS;
    if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
        tree = xmlParseElementMixedContentDecl(ctxt, inputid);
    res = XML_ELEMENT_TYPE_MIXED;
    } else {
        tree = xmlParseElementChildrenContentDeclPriv(ctxt, inputid, 1);
    res = XML_ELEMENT_TYPE_ELEMENT;
    }
    SKIP_BLANKS;
    *result = tree;
    return(res);
}

Referenced by xmlParseElementDecl().

xmlParseElementDecl()

XML_DEPRECATED XMLPUBFUN int xmlParseElementDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseElementDecl: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

Parse an element declaration. Always consumes '<!'.

[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

Definition at line 6762 of file parser.c.

                                           {
    const xmlChar *name;
    int ret = -1;
    xmlElementContentPtr content  = NULL;
 
    if ((CUR != '<') || (NXT(1) != '!'))
        return(ret);
    SKIP(2);
 
    /* GROW; done in the caller */
    if (CMP7(CUR_PTR, 'E', 'L', 'E', 'M', 'E', 'N', 'T')) {
    int inputid = ctxt->input->id;
 
    SKIP(7);
    if (SKIP_BLANKS == 0) {
        xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
                   "Space required after 'ELEMENT'\n");
        return(-1);
    }
        name = xmlParseName(ctxt);
    if (name == NULL) {
        xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
               "xmlParseElementDecl: no name for Element\n");
        return(-1);
    }
    if (SKIP_BLANKS == 0) {
        xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
               "Space required after the element name\n");
    }
    if (CMP5(CUR_PTR, 'E', 'M', 'P', 'T', 'Y')) {
        SKIP(5);
        /*
         * Element must always be empty.
         */
        ret = XML_ELEMENT_TYPE_EMPTY;
    } else if ((RAW == 'A') && (NXT(1) == 'N') &&
               (NXT(2) == 'Y')) {
        SKIP(3);
        /*
         * Element is a generic container.
         */
        ret = XML_ELEMENT_TYPE_ANY;
    } else if (RAW == '(') {
        ret = xmlParseElementContentDecl(ctxt, name, &content);
    } else {
        /*
         * [ WFC: PEs in Internal Subset ] error handling.
         */
        if ((RAW == '%') && (ctxt->external == 0) &&
            (ctxt->inputNr == 1)) {
        xmlFatalErrMsg(ctxt, XML_ERR_PEREF_IN_INT_SUBSET,
      "PEReference: forbidden within markup decl in internal subset\n");
        } else {
        xmlFatalErrMsg(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
              "xmlParseElementDecl: 'EMPTY', 'ANY' or '(' expected\n");
            }
        return(-1);
    }
 
    SKIP_BLANKS;
 
    if (RAW != '>') {
        xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
        if (content != NULL) {
        xmlFreeDocElementContent(ctxt->myDoc, content);
        }
    } else {
        if (inputid != ctxt->input->id) {
        xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
                               "Element declaration doesn't start and stop in"
                               " the same entity\n");
        }
 
        NEXT;
        if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
        (ctxt->sax->elementDecl != NULL)) {
        if (content != NULL)
            content->parent = NULL;
            ctxt->sax->elementDecl(ctxt->userData, name, ret,
                               content);
        if ((content != NULL) && (content->parent == NULL)) {
            /*
             * this is a trick: if xmlAddElementDecl is called,
             * instead of copying the full tree it is plugged directly
             * if called from the parser. Avoid duplicating the
             * interfaces or change the API/ABI
             */
            xmlFreeDocElementContent(ctxt->myDoc, content);
        }
        } else if (content != NULL) {
        xmlFreeDocElementContent(ctxt->myDoc, content);
        }
    }
    }
    return(ret);
}

Referenced by xmlParseMarkupDecl().

xmlParseElementMixedContentDecl()

XML_DEPRECATED XMLPUBFUN xmlElementContentPtr xmlParseElementMixedContentDecl	(	xmlParserCtxtPtr	ctxt,
		int	inputchk
	)

xmlParseElementMixedContentDecl: @ctxt: an XML parser context @inputchk: the input used for the current entity, needed for boundary checks

DEPRECATED: Internal function, don't use.

parse the declaration for a Mixed Element content The leading '(' and spaces have been skipped in xmlParseElementContentDecl

[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

Definition at line 6264 of file parser.c.

                                                                     {
    xmlElementContentPtr ret = NULL, cur = NULL, n;
    const xmlChar *elem = NULL;
 
    GROW;
    if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
    SKIP(7);
    SKIP_BLANKS;
    if (RAW == ')') {
        if (ctxt->input->id != inputchk) {
        xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
                               "Element content declaration doesn't start and"
                               " stop in the same entity\n");
        }
        NEXT;
        ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
        if (ret == NULL)
            return(NULL);
        if (RAW == '*') {
        ret->ocur = XML_ELEMENT_CONTENT_MULT;
        NEXT;
        }
        return(ret);
    }
    if ((RAW == '(') || (RAW == '|')) {
        ret = cur = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
        if (ret == NULL) return(NULL);
    }
    while ((RAW == '|') && (ctxt->instate != XML_PARSER_EOF)) {
        NEXT;
        if (elem == NULL) {
            ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
        if (ret == NULL) {
            xmlFreeDocElementContent(ctxt->myDoc, cur);
                    return(NULL);
                }
        ret->c1 = cur;
        if (cur != NULL)
            cur->parent = ret;
        cur = ret;
        } else {
            n = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
        if (n == NULL) {
            xmlFreeDocElementContent(ctxt->myDoc, ret);
                    return(NULL);
                }
        n->c1 = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
        if (n->c1 != NULL)
            n->c1->parent = n;
            cur->c2 = n;
        if (n != NULL)
            n->parent = cur;
        cur = n;
        }
        SKIP_BLANKS;
        elem = xmlParseName(ctxt);
        if (elem == NULL) {
        xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
            "xmlParseElementMixedContentDecl : Name expected\n");
        xmlFreeDocElementContent(ctxt->myDoc, ret);
        return(NULL);
        }
        SKIP_BLANKS;
        GROW;
    }
    if ((RAW == ')') && (NXT(1) == '*')) {
        if (elem != NULL) {
        cur->c2 = xmlNewDocElementContent(ctxt->myDoc, elem,
                                       XML_ELEMENT_CONTENT_ELEMENT);
        if (cur->c2 != NULL)
            cur->c2->parent = cur;
            }
            if (ret != NULL)
                ret->ocur = XML_ELEMENT_CONTENT_MULT;
        if (ctxt->input->id != inputchk) {
        xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
                               "Element content declaration doesn't start and"
                               " stop in the same entity\n");
        }
        SKIP(2);
    } else {
        xmlFreeDocElementContent(ctxt->myDoc, ret);
        xmlFatalErr(ctxt, XML_ERR_MIXED_NOT_STARTED, NULL);
        return(NULL);
    }
 
    } else {
    xmlFatalErr(ctxt, XML_ERR_PCDATA_REQUIRED, NULL);
    }
    return(ret);
}

Referenced by xmlParseElementContentDecl().

xmlParseEncName()

XML_DEPRECATED XMLPUBFUN xmlChar * xmlParseEncName

(

xmlParserCtxtPtr

ctxt

)

xmlParseEncName: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse the XML encoding name

[81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')*

Returns the encoding name value or NULL

Definition at line 10643 of file parser.c.

                                       {
    xmlChar *buf = NULL;
    int len = 0;
    int size = 10;
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
                    XML_MAX_TEXT_LENGTH :
                    XML_MAX_NAME_LENGTH;
    xmlChar cur;
 
    cur = CUR;
    if (((cur >= 'a') && (cur <= 'z')) ||
        ((cur >= 'A') && (cur <= 'Z'))) {
    buf = (xmlChar *) xmlMallocAtomic(size);
    if (buf == NULL) {
        xmlErrMemory(ctxt, NULL);
        return(NULL);
    }
 
    buf[len++] = cur;
    NEXT;
    cur = CUR;
    while (((cur >= 'a') && (cur <= 'z')) ||
           ((cur >= 'A') && (cur <= 'Z')) ||
           ((cur >= '0') && (cur <= '9')) ||
           (cur == '.') || (cur == '_') ||
           (cur == '-')) {
        if (len + 1 >= size) {
            xmlChar *tmp;
 
        size *= 2;
        tmp = (xmlChar *) xmlRealloc(buf, size);
        if (tmp == NULL) {
            xmlErrMemory(ctxt, NULL);
            xmlFree(buf);
            return(NULL);
        }
        buf = tmp;
        }
        buf[len++] = cur;
            if (len > maxLength) {
                xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "EncName");
                xmlFree(buf);
                return(NULL);
            }
        NEXT;
        cur = CUR;
        }
    buf[len] = 0;
    } else {
    xmlFatalErr(ctxt, XML_ERR_ENCODING_NAME, NULL);
    }
    return(buf);
}

Referenced by xmlParseEncodingDecl().

xmlParseEncodingDecl()

XML_DEPRECATED XMLPUBFUN const xmlChar * xmlParseEncodingDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseEncodingDecl: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse the XML encoding declaration

[80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' | "'" EncName "'")

this setups the conversion filters.

Returns the encoding value or NULL

Definition at line 10713 of file parser.c.

                                            {
    xmlChar *encoding = NULL;
 
    SKIP_BLANKS;
    if (CMP8(CUR_PTR, 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g') == 0)
        return(NULL);
 
    SKIP(8);
    SKIP_BLANKS;
    if (RAW != '=') {
        xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
        return(NULL);
    }
    NEXT;
    SKIP_BLANKS;
    if (RAW == '"') {
        NEXT;
        encoding = xmlParseEncName(ctxt);
        if (RAW != '"') {
            xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
            xmlFree((xmlChar *) encoding);
            return(NULL);
        } else
            NEXT;
    } else if (RAW == '\''){
        NEXT;
        encoding = xmlParseEncName(ctxt);
        if (RAW != '\'') {
            xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
            xmlFree((xmlChar *) encoding);
            return(NULL);
        } else
            NEXT;
    } else {
        xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
    }
 
    if (encoding == NULL)
        return(NULL);
 
    xmlSetDeclaredEncoding(ctxt, encoding);
 
    return(ctxt->encoding);
}

Referenced by xmlParseTextDecl(), and xmlParseXMLDecl().

xmlParseEntityDecl()

XML_DEPRECATED XMLPUBFUN void xmlParseEntityDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseEntityDecl: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

Parse an entity declaration. Always consumes '<!'.

[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.

Definition at line 5551 of file parser.c.

                                          {
    const xmlChar *name = NULL;
    xmlChar *value = NULL;
    xmlChar *URI = NULL, *literal = NULL;
    const xmlChar *ndata = NULL;
    int isParameter = 0;
    xmlChar *orig = NULL;
 
    if ((CUR != '<') || (NXT(1) != '!'))
        return;
    SKIP(2);
 
    /* GROW; done in the caller */
    if (CMP6(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'Y')) {
    int inputid = ctxt->input->id;
    SKIP(6);
    if (SKIP_BLANKS == 0) {
        xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
               "Space required after '<!ENTITY'\n");
    }
 
    if (RAW == '%') {
        NEXT;
        if (SKIP_BLANKS == 0) {
        xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
                   "Space required after '%%'\n");
        }
        isParameter = 1;
    }
 
        name = xmlParseName(ctxt);
    if (name == NULL) {
        xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
                       "xmlParseEntityDecl: no name\n");
            return;
    }
    if (xmlStrchr(name, ':') != NULL) {
        xmlNsErr(ctxt, XML_NS_ERR_COLON,
             "colons are forbidden from entities names '%s'\n",
             name, NULL, NULL);
    }
    if (SKIP_BLANKS == 0) {
        xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
               "Space required after the entity name\n");
    }
 
    ctxt->instate = XML_PARSER_ENTITY_DECL;
    /*
     * handle the various case of definitions...
     */
    if (isParameter) {
        if ((RAW == '"') || (RAW == '\'')) {
            value = xmlParseEntityValue(ctxt, &orig);
        if (value) {
            if ((ctxt->sax != NULL) &&
            (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
            ctxt->sax->entityDecl(ctxt->userData, name,
                            XML_INTERNAL_PARAMETER_ENTITY,
                    NULL, NULL, value);
        }
        } else {
            URI = xmlParseExternalID(ctxt, &literal, 1);
        if ((URI == NULL) && (literal == NULL)) {
            xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
        }
        if (URI) {
            xmlURIPtr uri;
 
            uri = xmlParseURI((const char *) URI);
            if (uri == NULL) {
                xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
                     "Invalid URI: %s\n", URI);
            /*
             * This really ought to be a well formedness error
             * but the XML Core WG decided otherwise c.f. issue
             * E26 of the XML erratas.
             */
            } else {
            if (uri->fragment != NULL) {
                /*
                 * Okay this is foolish to block those but not
                 * invalid URIs.
                 */
                xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
            } else {
                if ((ctxt->sax != NULL) &&
                (!ctxt->disableSAX) &&
                (ctxt->sax->entityDecl != NULL))
                ctxt->sax->entityDecl(ctxt->userData, name,
                        XML_EXTERNAL_PARAMETER_ENTITY,
                        literal, URI, NULL);
            }
            xmlFreeURI(uri);
            }
        }
        }
    } else {
        if ((RAW == '"') || (RAW == '\'')) {
            value = xmlParseEntityValue(ctxt, &orig);
        if ((ctxt->sax != NULL) &&
            (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
            ctxt->sax->entityDecl(ctxt->userData, name,
                XML_INTERNAL_GENERAL_ENTITY,
                NULL, NULL, value);
        /*
         * For expat compatibility in SAX mode.
         */
        if ((ctxt->myDoc == NULL) ||
            (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
            if (ctxt->myDoc == NULL) {
            ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
            if (ctxt->myDoc == NULL) {
                xmlErrMemory(ctxt, "New Doc failed");
                goto done;
            }
            ctxt->myDoc->properties = XML_DOC_INTERNAL;
            }
            if (ctxt->myDoc->intSubset == NULL)
            ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
                        BAD_CAST "fake", NULL, NULL);
 
            xmlSAX2EntityDecl(ctxt, name, XML_INTERNAL_GENERAL_ENTITY,
                          NULL, NULL, value);
        }
        } else {
            URI = xmlParseExternalID(ctxt, &literal, 1);
        if ((URI == NULL) && (literal == NULL)) {
            xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
        }
        if (URI) {
            xmlURIPtr uri;
 
            uri = xmlParseURI((const char *)URI);
            if (uri == NULL) {
                xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
                     "Invalid URI: %s\n", URI);
            /*
             * This really ought to be a well formedness error
             * but the XML Core WG decided otherwise c.f. issue
             * E26 of the XML erratas.
             */
            } else {
            if (uri->fragment != NULL) {
                /*
                 * Okay this is foolish to block those but not
                 * invalid URIs.
                 */
                xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
            }
            xmlFreeURI(uri);
            }
        }
        if ((RAW != '>') && (SKIP_BLANKS == 0)) {
            xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
                   "Space required before 'NDATA'\n");
        }
        if (CMP5(CUR_PTR, 'N', 'D', 'A', 'T', 'A')) {
            SKIP(5);
            if (SKIP_BLANKS == 0) {
            xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
                       "Space required after 'NDATA'\n");
            }
            ndata = xmlParseName(ctxt);
            if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
                (ctxt->sax->unparsedEntityDecl != NULL))
            ctxt->sax->unparsedEntityDecl(ctxt->userData, name,
                    literal, URI, ndata);
        } else {
            if ((ctxt->sax != NULL) &&
                (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
            ctxt->sax->entityDecl(ctxt->userData, name,
                    XML_EXTERNAL_GENERAL_PARSED_ENTITY,
                    literal, URI, NULL);
            /*
             * For expat compatibility in SAX mode.
             * assuming the entity replacement was asked for
             */
            if ((ctxt->replaceEntities != 0) &&
            ((ctxt->myDoc == NULL) ||
            (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE)))) {
            if (ctxt->myDoc == NULL) {
                ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
                if (ctxt->myDoc == NULL) {
                    xmlErrMemory(ctxt, "New Doc failed");
                goto done;
                }
                ctxt->myDoc->properties = XML_DOC_INTERNAL;
            }
 
            if (ctxt->myDoc->intSubset == NULL)
                ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
                        BAD_CAST "fake", NULL, NULL);
            xmlSAX2EntityDecl(ctxt, name,
                          XML_EXTERNAL_GENERAL_PARSED_ENTITY,
                          literal, URI, NULL);
            }
        }
        }
    }
    if (ctxt->instate == XML_PARSER_EOF)
        goto done;
    SKIP_BLANKS;
    if (RAW != '>') {
        xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_NOT_FINISHED,
                "xmlParseEntityDecl: entity %s not terminated\n", name);
        xmlHaltParser(ctxt);
    } else {
        if (inputid != ctxt->input->id) {
        xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
                           "Entity declaration doesn't start and stop in"
                               " the same entity\n");
        }
        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) && (ctxt->userData==ctxt)) {
            cur = xmlSAX2GetEntity(ctxt, name);
        }
        }
            if ((cur != NULL) && (cur->orig == NULL)) {
        cur->orig = orig;
                orig = NULL;
        }
    }
 
done:
    if (value != NULL) xmlFree(value);
    if (URI != NULL) xmlFree(URI);
    if (literal != NULL) xmlFree(literal);
        if (orig != NULL) xmlFree(orig);
    }
}

Referenced by xmlParseMarkupDecl().

xmlParseEntityRef()

XML_DEPRECATED XMLPUBFUN xmlEntityPtr xmlParseEntityRef

(

xmlParserCtxtPtr

ctxt

)

xmlParseEntityRef: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

Parse an entitiy reference. Always consumes '&'.

[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.

Definition at line 7683 of file parser.c.

                                         {
    const xmlChar *name;
    xmlEntityPtr ent = NULL;
 
    GROW;
    if (ctxt->instate == XML_PARSER_EOF)
        return(NULL);
 
    if (RAW != '&')
        return(NULL);
    NEXT;
    name = xmlParseName(ctxt);
    if (name == NULL) {
    xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
               "xmlParseEntityRef: no name\n");
        return(NULL);
    }
    if (RAW != ';') {
    xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
    return(NULL);
    }
    NEXT;
 
    /*
     * Predefined entities override any extra definition
     */
    if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
        ent = xmlGetPredefinedEntity(name);
        if (ent != NULL)
            return(ent);
    }
 
    /*
     * Ask first SAX for entity resolution, otherwise try the
     * entities which may have stored in the parser context.
     */
    if (ctxt->sax != NULL) {
    if (ctxt->sax->getEntity != NULL)
        ent = ctxt->sax->getEntity(ctxt->userData, name);
    if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
        (ctxt->options & XML_PARSE_OLDSAX))
        ent = xmlGetPredefinedEntity(name);
    if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
        (ctxt->userData==ctxt)) {
        ent = xmlSAX2GetEntity(ctxt, name);
    }
    }
    if (ctxt->instate == XML_PARSER_EOF)
    return(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
     * 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))) {
        xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
             "Entity '%s' not defined\n", name);
    } else {
        xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
             "Entity '%s' not defined\n", name);
        if ((ctxt->inSubset == 0) &&
        (ctxt->sax != NULL) &&
                (ctxt->disableSAX == 0) &&
        (ctxt->sax->reference != NULL)) {
        ctxt->sax->reference(ctxt->userData, name);
        }
    }
    ctxt->valid = 0;
    }
 
    /*
     * [ WFC: Parsed Entity ]
     * An entity reference must not contain the name of an
     * unparsed entity
     */
    else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
    xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
         "Entity reference to unparsed entity %s\n", name);
    }
 
    /*
     * [ 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->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
    xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
         "Attribute references external entity '%s'\n", name);
    }
    /*
     * [ 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->etype != XML_INTERNAL_PREDEFINED_ENTITY)) {
    if ((ent->flags & XML_ENT_CHECKED_LT) == 0) {
            if ((ent->content != NULL) && (xmlStrchr(ent->content, '<')))
                ent->flags |= XML_ENT_CONTAINS_LT;
            ent->flags |= XML_ENT_CHECKED_LT;
        }
        if (ent->flags & XML_ENT_CONTAINS_LT)
            xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
                    "'<' in entity '%s' is not allowed in attributes "
                    "values\n", name);
    }
 
    /*
     * Internal check, no parameter entities here ...
     */
    else {
    switch (ent->etype) {
        case XML_INTERNAL_PARAMETER_ENTITY:
        case XML_EXTERNAL_PARAMETER_ENTITY:
        xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
         "Attempt to reference the parameter entity '%s'\n",
                  name);
        break;
        default:
        break;
    }
    }
 
    /*
     * [ WFC: No Recursion ]
     * A parsed entity must not contain a recursive reference
     * to itself, either directly or indirectly.
     * Done somewhere else
     */
    return(ent);
}

Referenced by xmlParseAttValueComplex(), and xmlParseReference().

xmlParseEntityValue()

XML_DEPRECATED XMLPUBFUN xmlChar * xmlParseEntityValue	(	xmlParserCtxtPtr	ctxt,
		xmlChar **	orig
	)

xmlParseEntityValue: @ctxt: an XML parser context @orig: if non-NULL store a copy of the original entity value

DEPRECATED: Internal function, don't use.

parse a value for ENTITY declarations

[9] EntityValue ::= '"' ([^%&"] | PEReference | Reference)* '"' | "'" ([^%&'] | PEReference | Reference)* "'"

Returns the EntityValue parsed with reference substituted or NULL

Definition at line 3906 of file parser.c.

                                                           {
    xmlChar *buf = NULL;
    int len = 0;
    int size = XML_PARSER_BUFFER_SIZE;
    int c, l;
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
                    XML_MAX_HUGE_LENGTH :
                    XML_MAX_TEXT_LENGTH;
    xmlChar stop;
    xmlChar *ret = NULL;
    const xmlChar *cur = NULL;
    xmlParserInputPtr input;
 
    if (RAW == '"') stop = '"';
    else if (RAW == '\'') stop = '\'';
    else {
    xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_STARTED, NULL);
    return(NULL);
    }
    buf = (xmlChar *) xmlMallocAtomic(size);
    if (buf == NULL) {
    xmlErrMemory(ctxt, NULL);
    return(NULL);
    }
 
    /*
     * The content of the entity definition is copied in a buffer.
     */
 
    ctxt->instate = XML_PARSER_ENTITY_VALUE;
    input = ctxt->input;
    GROW;
    if (ctxt->instate == XML_PARSER_EOF)
        goto error;
    NEXT;
    c = CUR_CHAR(l);
    /*
     * 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) || /* checked */
        (ctxt->input != input))) && (ctxt->instate != XML_PARSER_EOF)) {
    if (len + 5 >= size) {
        xmlChar *tmp;
 
        size *= 2;
        tmp = (xmlChar *) xmlRealloc(buf, size);
        if (tmp == NULL) {
        xmlErrMemory(ctxt, NULL);
                goto error;
        }
        buf = tmp;
    }
    COPY_BUF(buf, len, c);
    NEXTL(l);
 
    GROW;
    c = CUR_CHAR(l);
    if (c == 0) {
        GROW;
        c = CUR_CHAR(l);
    }
 
        if (len > maxLength) {
            xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_NOT_FINISHED,
                           "entity value too long\n");
            goto error;
        }
    }
    buf[len] = 0;
    if (ctxt->instate == XML_PARSER_EOF)
        goto error;
    if (c != stop) {
        xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_FINISHED, NULL);
        goto error;
    }
    NEXT;
 
    /*
     * Raise problem w.r.t. '&' and '%' being used in non-entities
     * reference constructs. Note Charref will be handled in
     * xmlStringDecodeEntities()
     */
    cur = buf;
    while (*cur != 0) { /* non input consuming */
    if ((*cur == '%') || ((*cur == '&') && (cur[1] != '#'))) {
        xmlChar *name;
        xmlChar tmp = *cur;
            int nameOk = 0;
 
        cur++;
        name = xmlParseStringName(ctxt, &cur);
            if (name != NULL) {
                nameOk = 1;
                xmlFree(name);
            }
            if ((nameOk == 0) || (*cur != ';')) {
        xmlFatalErrMsgInt(ctxt, XML_ERR_ENTITY_CHAR_ERROR,
        "EntityValue: '%c' forbidden except for entities references\n",
                              tmp);
                goto error;
        }
        if ((tmp == '%') && (ctxt->inSubset == 1) &&
        (ctxt->inputNr == 1)) {
        xmlFatalErr(ctxt, XML_ERR_ENTITY_PE_INTERNAL, NULL);
                goto error;
        }
        if (*cur == 0)
            break;
    }
    cur++;
    }
 
    /*
     * Then PEReference entities are substituted.
     *
     * 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 here.
     */
    ++ctxt->depth;
    ret = xmlStringDecodeEntitiesInt(ctxt, buf, len, XML_SUBSTITUTE_PEREF,
                                     0, 0, 0, /* check */ 1);
    --ctxt->depth;
 
    if (orig != NULL) {
        *orig = buf;
        buf = NULL;
    }
 
error:
    if (buf != NULL)
        xmlFree(buf);
    return(ret);
}

Referenced by xmlParseEntityDecl().

xmlParseEnumeratedType()

XML_DEPRECATED XMLPUBFUN int xmlParseEnumeratedType	(	xmlParserCtxtPtr	ctxt,
		xmlEnumerationPtr *	tree
	)

xmlParseEnumeratedType: @ctxt: an XML parser context @tree: the enumeration tree built while parsing

DEPRECATED: Internal function, don't use.

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

Definition at line 6022 of file parser.c.

                                                                       {
    if (CMP8(CUR_PTR, 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) {
    SKIP(8);
    if (SKIP_BLANKS == 0) {
        xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
               "Space required after 'NOTATION'\n");
        return(0);
    }
    *tree = xmlParseNotationType(ctxt);
    if (*tree == NULL) return(0);
    return(XML_ATTRIBUTE_NOTATION);
    }
    *tree = xmlParseEnumerationType(ctxt);
    if (*tree == NULL) return(0);
    return(XML_ATTRIBUTE_ENUMERATION);
}

Referenced by xmlParseAttributeType().

xmlParseEnumerationType()

XML_DEPRECATED XMLPUBFUN xmlEnumerationPtr xmlParseEnumerationType

(

xmlParserCtxtPtr

ctxt

)

xmlParseEnumerationType: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

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

Definition at line 5952 of file parser.c.

                                               {
    xmlChar *name;
    xmlEnumerationPtr ret = NULL, last = NULL, cur, tmp;
 
    if (RAW != '(') {
    xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_STARTED, NULL);
    return(NULL);
    }
    do {
        NEXT;
    SKIP_BLANKS;
        name = xmlParseNmtoken(ctxt);
    if (name == NULL) {
        xmlFatalErr(ctxt, XML_ERR_NMTOKEN_REQUIRED, NULL);
        return(ret);
    }
    tmp = ret;
    while (tmp != NULL) {
        if (xmlStrEqual(name, tmp->name)) {
        xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
      "standalone: attribute enumeration value token %s duplicated\n",
                 name, NULL);
        if (!xmlDictOwns(ctxt->dict, name))
            xmlFree(name);
        break;
        }
        tmp = tmp->next;
    }
    if (tmp == NULL) {
        cur = xmlCreateEnumeration(name);
        if (!xmlDictOwns(ctxt->dict, name))
        xmlFree(name);
        if (cur == NULL) {
                xmlFreeEnumeration(ret);
                return(NULL);
            }
        if (last == NULL) ret = last = cur;
        else {
        last->next = cur;
        last = cur;
        }
    }
    SKIP_BLANKS;
    } while (RAW == '|');
    if (RAW != ')') {
    xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_FINISHED, NULL);
    return(ret);
    }
    NEXT;
    return(ret);
}

Referenced by xmlParseEnumeratedType().

xmlParseExternalID()

XML_DEPRECATED XMLPUBFUN xmlChar * xmlParseExternalID	(	xmlParserCtxtPtr	ctxt,
		xmlChar **	publicID,
		int	strict
	)

xmlParseExternalID: @ctxt: an XML parser context @publicID: a xmlChar** receiving PubidLiteral @strict: indicate whether we should restrict parsing to only production [75], see NOTE below

DEPRECATED: Internal function, don't use.

Parse an External ID or a Public ID

NOTE: Productions [75] and [83] interact 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.

Definition at line 4840 of file parser.c.

                                                                          {
    xmlChar *URI = NULL;
 
    *publicID = NULL;
    if (CMP6(CUR_PTR, 'S', 'Y', 'S', 'T', 'E', 'M')) {
        SKIP(6);
    if (SKIP_BLANKS == 0) {
        xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
                       "Space required after 'SYSTEM'\n");
    }
    URI = xmlParseSystemLiteral(ctxt);
    if (URI == NULL) {
        xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
        }
    } else if (CMP6(CUR_PTR, 'P', 'U', 'B', 'L', 'I', 'C')) {
        SKIP(6);
    if (SKIP_BLANKS == 0) {
        xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
            "Space required after 'PUBLIC'\n");
    }
    *publicID = xmlParsePubidLiteral(ctxt);
    if (*publicID == NULL) {
        xmlFatalErr(ctxt, XML_ERR_PUBID_REQUIRED, NULL);
    }
    if (strict) {
        /*
         * We don't handle [83] so "S SystemLiteral" is required.
         */
        if (SKIP_BLANKS == 0) {
        xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
            "Space required after the Public Identifier\n");
        }
    } else {
        /*
         * We handle [83] so we return immediately, if
         * "S SystemLiteral" is not detected. We skip blanks if no
             * system literal was found, but this is harmless since we must
             * be at the end of a NotationDecl.
         */
        if (SKIP_BLANKS == 0) return(NULL);
        if ((CUR != '\'') && (CUR != '"')) return(NULL);
    }
    URI = xmlParseSystemLiteral(ctxt);
    if (URI == NULL) {
        xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
        }
    }
    return(URI);
}

Referenced by xmlParseDocTypeDecl(), xmlParseEntityDecl(), and xmlParseNotationDecl().

xmlParseExternalSubset()

XMLPUBFUN void xmlParseExternalSubset	(	xmlParserCtxtPtr	ctxt,
		const xmlChar *	ExternalID,
		const xmlChar *	SystemID
	)

xmlParseExternalSubset: @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) *

Definition at line 7160 of file parser.c.

                                                {
    xmlDetectSAX2(ctxt);
 
    xmlDetectEncoding(ctxt);
 
    if (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) {
    xmlParseTextDecl(ctxt);
    if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
        /*
         * The XML REC instructs us to stop parsing right here
         */
        xmlHaltParser(ctxt);
        return;
    }
    }
    if (ctxt->myDoc == NULL) {
        ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
    if (ctxt->myDoc == NULL) {
        xmlErrMemory(ctxt, "New Doc failed");
        return;
    }
    ctxt->myDoc->properties = XML_DOC_INTERNAL;
    }
    if ((ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset == NULL))
        xmlCreateIntSubset(ctxt->myDoc, NULL, ExternalID, SystemID);
 
    ctxt->instate = XML_PARSER_DTD;
    ctxt->external = 1;
    SKIP_BLANKS;
    while ((ctxt->instate != XML_PARSER_EOF) && (RAW != 0)) {
    GROW;
        if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
            xmlParseConditionalSections(ctxt);
        } else if ((RAW == '<') && ((NXT(1) == '!') || (NXT(1) == '?'))) {
            xmlParseMarkupDecl(ctxt);
        } else {
            xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
            xmlHaltParser(ctxt);
            return;
        }
        SKIP_BLANKS;
        SHRINK;
    }
 
    if (RAW != 0) {
    xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
    }
 
}

Referenced by xmlSAX2ExternalSubset().

xmlParseMarkupDecl()

XML_DEPRECATED XMLPUBFUN void xmlParseMarkupDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseMarkupDecl: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

Parse markup declarations. Always consumes '<!' or '<?'.

[29] markupdecl ::= elementdecl | AttlistDecl | EntityDecl | NotationDecl | PI | Comment

[ VC: Proper Declaration/PE Nesting ] 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.)

Definition at line 7020 of file parser.c.

                                          {
    GROW;
    if (CUR == '<') {
        if (NXT(1) == '!') {
        switch (NXT(2)) {
            case 'E':
            if (NXT(3) == 'L')
            xmlParseElementDecl(ctxt);
            else if (NXT(3) == 'N')
            xmlParseEntityDecl(ctxt);
                    else
                        SKIP(2);
            break;
            case 'A':
            xmlParseAttributeListDecl(ctxt);
            break;
            case 'N':
            xmlParseNotationDecl(ctxt);
            break;
            case '-':
            xmlParseComment(ctxt);
            break;
        default:
            /* there is an error but it will be detected later */
                    SKIP(2);
            break;
        }
    } else if (NXT(1) == '?') {
        xmlParsePI(ctxt);
    }
    }
 
    /*
     * detect requirement to exit there and act accordingly
     * and avoid having instate overridden later on
     */
    if (ctxt->instate == XML_PARSER_EOF)
        return;
 
    ctxt->instate = XML_PARSER_DTD;
}

Referenced by xmlParseConditionalSections(), xmlParseExternalSubset(), and xmlParseInternalSubset().

xmlParseMisc()

XML_DEPRECATED XMLPUBFUN void xmlParseMisc

(

xmlParserCtxtPtr

ctxt

)

xmlParseMisc: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse an XML Misc* optional field.

[27] Misc ::= Comment | PI | S

Definition at line 10979 of file parser.c.

                                    {
    while (ctxt->instate != XML_PARSER_EOF) {
        SKIP_BLANKS;
        GROW;
        if ((RAW == '<') && (NXT(1) == '?')) {
        xmlParsePI(ctxt);
        } else if (CMP4(CUR_PTR, '<', '!', '-', '-')) {
        xmlParseComment(ctxt);
        } else {
            break;
        }
    }
}

Referenced by xmlParseDocument().

xmlParseName()

XML_DEPRECATED XMLPUBFUN const xmlChar * xmlParseName

(

xmlParserCtxtPtr

ctxt

)

Generic production rules.

xmlParseName: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse an XML name.

[4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' | CombiningChar | Extender

[5] Name ::= (Letter | '_' | ':') (NameChar)*

[6] Names ::= Name (#x20 Name)*

Returns the Name parsed or NULL

Definition at line 3529 of file parser.c.

                                    {
    const xmlChar *in;
    const xmlChar *ret;
    size_t count = 0;
    size_t maxLength = (ctxt->options & XML_PARSE_HUGE) ?
                       XML_MAX_TEXT_LENGTH :
                       XML_MAX_NAME_LENGTH;
 
    GROW;
    if (ctxt->instate == XML_PARSER_EOF)
        return(NULL);
 
    /*
     * Accelerator for simple ASCII names
     */
    in = ctxt->input->cur;
    if (((*in >= 0x61) && (*in <= 0x7A)) ||
    ((*in >= 0x41) && (*in <= 0x5A)) ||
    (*in == '_') || (*in == ':')) {
    in++;
    while (((*in >= 0x61) && (*in <= 0x7A)) ||
           ((*in >= 0x41) && (*in <= 0x5A)) ||
           ((*in >= 0x30) && (*in <= 0x39)) ||
           (*in == '_') || (*in == '-') ||
           (*in == ':') || (*in == '.'))
        in++;
    if ((*in > 0) && (*in < 0x80)) {
        count = in - ctxt->input->cur;
            if (count > maxLength) {
                xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Name");
                return(NULL);
            }
        ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
        ctxt->input->cur = in;
        ctxt->input->col += count;
        if (ret == NULL)
            xmlErrMemory(ctxt, NULL);
        return(ret);
    }
    }
    /* accelerator for special cases */
    return(xmlParseNameComplex(ctxt));
}

Referenced by xmlParseAttributeListDecl(), xmlParseDocTypeDecl(), xmlParseElementChildrenContentDeclPriv(), xmlParseElementDecl(), xmlParseElementMixedContentDecl(), xmlParseEntityDecl(), xmlParseEntityRef(), xmlParseNameAndCompare(), xmlParseNotationDecl(), xmlParseNotationType(), xmlParsePEReference(), and xmlParsePITarget().

xmlParseNmtoken()

XML_DEPRECATED XMLPUBFUN xmlChar * xmlParseNmtoken

(

xmlParserCtxtPtr

ctxt

)

xmlParseNmtoken: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse an XML Nmtoken.

[7] Nmtoken ::= (NameChar)+

[8] Nmtokens ::= Nmtoken (#x20 Nmtoken)*

Returns the Nmtoken parsed or NULL

Definition at line 3821 of file parser.c.

                                       {
    xmlChar buf[XML_MAX_NAMELEN + 5];
    int len = 0, l;
    int c;
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
                    XML_MAX_TEXT_LENGTH :
                    XML_MAX_NAME_LENGTH;
 
    c = CUR_CHAR(l);
 
    while (xmlIsNameChar(ctxt, c)) {
    COPY_BUF(buf, len, c);
    NEXTL(l);
    c = CUR_CHAR(l);
    if (len >= XML_MAX_NAMELEN) {
        /*
         * Okay someone managed to make a huge token, so he's ready to pay
         * for the processing speed.
         */
        xmlChar *buffer;
        int max = len * 2;
 
        buffer = (xmlChar *) xmlMallocAtomic(max);
        if (buffer == NULL) {
            xmlErrMemory(ctxt, NULL);
        return(NULL);
        }
        memcpy(buffer, buf, len);
        while (xmlIsNameChar(ctxt, c)) {
        if (len + 10 > max) {
            xmlChar *tmp;
 
            max *= 2;
            tmp = (xmlChar *) xmlRealloc(buffer, max);
            if (tmp == NULL) {
            xmlErrMemory(ctxt, NULL);
            xmlFree(buffer);
            return(NULL);
            }
            buffer = tmp;
        }
        COPY_BUF(buffer, len, c);
                if (len > maxLength) {
                    xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NmToken");
                    xmlFree(buffer);
                    return(NULL);
                }
        NEXTL(l);
        c = CUR_CHAR(l);
        }
        buffer[len] = 0;
            if (ctxt->instate == XML_PARSER_EOF) {
                xmlFree(buffer);
                return(NULL);
            }
        return(buffer);
    }
    }
    if (ctxt->instate == XML_PARSER_EOF)
        return(NULL);
    if (len == 0)
        return(NULL);
    if (len > maxLength) {
        xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NmToken");
        return(NULL);
    }
    return(xmlStrndup(buf, len));
}

Referenced by xmlParseEnumerationType(), and xmlParseQNameHashed().

xmlParseNotationDecl()

XML_DEPRECATED XMLPUBFUN void xmlParseNotationDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseNotationDecl: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

Parse a notation declaration. Always consumes '<!'.

[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 xmlParseExternalID().

Definition at line 5468 of file parser.c.

                                            {
    const xmlChar *name;
    xmlChar *Pubid;
    xmlChar *Systemid;
 
    if ((CUR != '<') || (NXT(1) != '!'))
        return;
    SKIP(2);
 
    if (CMP8(CUR_PTR, 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) {
    int inputid = ctxt->input->id;
    SKIP(8);
    if (SKIP_BLANKS == 0) {
        xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
               "Space required after '<!NOTATION'\n");
        return;
    }
 
        name = xmlParseName(ctxt);
    if (name == NULL) {
        xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
        return;
    }
    if (xmlStrchr(name, ':') != NULL) {
        xmlNsErr(ctxt, XML_NS_ERR_COLON,
             "colons are forbidden from notation names '%s'\n",
             name, NULL, NULL);
    }
    if (SKIP_BLANKS == 0) {
        xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
             "Space required after the NOTATION name'\n");
        return;
    }
 
    /*
     * Parse the IDs.
     */
    Systemid = xmlParseExternalID(ctxt, &Pubid, 0);
    SKIP_BLANKS;
 
    if (RAW == '>') {
        if (inputid != ctxt->input->id) {
        xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
                           "Notation declaration doesn't start and stop"
                               " in the same entity\n");
        }
        NEXT;
        if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
        (ctxt->sax->notationDecl != NULL))
        ctxt->sax->notationDecl(ctxt->userData, name, Pubid, Systemid);
    } else {
        xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
    }
    if (Systemid != NULL) xmlFree(Systemid);
    if (Pubid != NULL) xmlFree(Pubid);
    }
}

Referenced by xmlParseMarkupDecl().

xmlParseNotationType()

XML_DEPRECATED XMLPUBFUN xmlEnumerationPtr xmlParseNotationType

(

xmlParserCtxtPtr

ctxt

)

xmlParseNotationType: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

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

Definition at line 5881 of file parser.c.

                                            {
    const xmlChar *name;
    xmlEnumerationPtr ret = NULL, last = NULL, cur, tmp;
 
    if (RAW != '(') {
    xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
    return(NULL);
    }
    do {
        NEXT;
    SKIP_BLANKS;
        name = xmlParseName(ctxt);
    if (name == NULL) {
        xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
               "Name expected in NOTATION declaration\n");
            xmlFreeEnumeration(ret);
        return(NULL);
    }
    tmp = ret;
    while (tmp != NULL) {
        if (xmlStrEqual(name, tmp->name)) {
        xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
      "standalone: attribute notation value token %s duplicated\n",
                 name, NULL);
        if (!xmlDictOwns(ctxt->dict, name))
            xmlFree((xmlChar *) name);
        break;
        }
        tmp = tmp->next;
    }
    if (tmp == NULL) {
        cur = xmlCreateEnumeration(name);
        if (cur == NULL) {
                xmlFreeEnumeration(ret);
                return(NULL);
            }
        if (last == NULL) ret = last = cur;
        else {
        last->next = cur;
        last = cur;
        }
    }
    SKIP_BLANKS;
    } while (RAW == '|');
    if (RAW != ')') {
    xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
        xmlFreeEnumeration(ret);
    return(NULL);
    }
    NEXT;
    return(ret);
}

Referenced by xmlParseEnumeratedType().

xmlParsePEReference()

XML_DEPRECATED XMLPUBFUN void xmlParsePEReference

(

xmlParserCtxtPtr

ctxt

)

xmlParsePEReference: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

Parse a parameter entity reference. Always consumes ''.

The entity content is handled directly by pushing it's content as a new input stream.

[69] PEReference ::= '' Name ';'

[ WFC: No Recursion ] 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.

Definition at line 8063 of file parser.c.

{
    const xmlChar *name;
    xmlEntityPtr entity = NULL;
    xmlParserInputPtr input;
 
    if (RAW != '%')
        return;
    NEXT;
    name = xmlParseName(ctxt);
    if (name == NULL) {
    xmlFatalErrMsg(ctxt, XML_ERR_PEREF_NO_NAME, "PEReference: no name\n");
    return;
    }
    if (xmlParserDebugEntities)
    xmlGenericError(xmlGenericErrorContext,
        "PEReference: %s\n", name);
    if (RAW != ';') {
    xmlFatalErr(ctxt, XML_ERR_PEREF_SEMICOL_MISSING, NULL);
        return;
    }
 
    NEXT;
 
    /*
     * Request the entity from SAX
     */
    if ((ctxt->sax != NULL) &&
    (ctxt->sax->getParameterEntity != NULL))
    entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
    if (ctxt->instate == XML_PARSER_EOF)
    return;
    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))) {
        xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
                  "PEReference: %%%s; not found\n",
                  name);
    } 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->validate) && (ctxt->vctxt.error != NULL)) {
                xmlValidityError(ctxt, XML_WAR_UNDECLARED_ENTITY,
                                 "PEReference: %%%s; not found\n",
                                 name, NULL);
            } else
                xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
                              "PEReference: %%%s; not found\n",
                              name, NULL);
            ctxt->valid = 0;
    }
    } else {
    /*
     * Internal checking in case the entity quest barfed
     */
    if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
        (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
        xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
          "Internal: %%%s; is not a parameter entity\n",
              name, NULL);
    } else {
            unsigned long parentConsumed;
            xmlEntityPtr oldEnt;
 
        if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
            ((ctxt->options & XML_PARSE_NOENT) == 0) &&
        ((ctxt->options & XML_PARSE_DTDVALID) == 0) &&
        ((ctxt->options & XML_PARSE_DTDLOAD) == 0) &&
        ((ctxt->options & XML_PARSE_DTDATTR) == 0) &&
        (ctxt->replaceEntities == 0) &&
        (ctxt->validate == 0))
        return;
 
            if (entity->flags & XML_ENT_EXPANDING) {
                xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
                xmlHaltParser(ctxt);
                return;
            }
 
            /* Must be computed from old input before pushing new input. */
            parentConsumed = ctxt->input->parentConsumed;
            oldEnt = ctxt->input->entity;
            if ((oldEnt == NULL) ||
                ((oldEnt->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
                 ((oldEnt->flags & XML_ENT_PARSED) == 0))) {
                xmlSaturatedAdd(&parentConsumed, ctxt->input->consumed);
                xmlSaturatedAddSizeT(&parentConsumed,
                                     ctxt->input->cur - ctxt->input->base);
            }
 
        input = xmlNewEntityInputStream(ctxt, entity);
        if (xmlPushInput(ctxt, input) < 0) {
                xmlFreeInputStream(input);
        return;
            }
 
            entity->flags |= XML_ENT_EXPANDING;
 
            input->parentConsumed = parentConsumed;
 
        if (entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) {
                xmlDetectEncoding(ctxt);
 
                if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) &&
                    (IS_BLANK_CH(NXT(5)))) {
                    xmlParseTextDecl(ctxt);
                }
            }
    }
    }
    ctxt->hasPErefs = 1;
}

Referenced by xmlParseInternalSubset(), xmlParserHandlePEReference(), and xmlSkipBlankChars().

xmlParsePI()

XML_DEPRECATED XMLPUBFUN void xmlParsePI

(

xmlParserCtxtPtr

ctxt

)

xmlParsePI: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse an XML Processing Instruction.

[16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>'

The processing is transferred to SAX once parsed.

Definition at line 5322 of file parser.c.

                                  {
    xmlChar *buf = NULL;
    size_t len = 0;
    size_t size = XML_PARSER_BUFFER_SIZE;
    size_t maxLength = (ctxt->options & XML_PARSE_HUGE) ?
                       XML_MAX_HUGE_LENGTH :
                       XML_MAX_TEXT_LENGTH;
    int cur, l;
    const xmlChar *target;
    xmlParserInputState state;
 
    if ((RAW == '<') && (NXT(1) == '?')) {
    int inputid = ctxt->input->id;
    state = ctxt->instate;
        ctxt->instate = XML_PARSER_PI;
    /*
     * this is a Processing Instruction.
     */
    SKIP(2);
 
    /*
     * Parse the target name and check for special support like
     * namespace.
     */
        target = xmlParsePITarget(ctxt);
    if (target != NULL) {
        if ((RAW == '?') && (NXT(1) == '>')) {
        if (inputid != ctxt->input->id) {
            xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
                               "PI declaration doesn't start and stop in"
                                   " the same entity\n");
        }
        SKIP(2);
 
        /*
         * SAX: PI detected.
         */
        if ((ctxt->sax) && (!ctxt->disableSAX) &&
            (ctxt->sax->processingInstruction != NULL))
            ctxt->sax->processingInstruction(ctxt->userData,
                                             target, NULL);
        if (ctxt->instate != XML_PARSER_EOF)
            ctxt->instate = state;
        return;
        }
        buf = (xmlChar *) xmlMallocAtomic(size);
        if (buf == NULL) {
        xmlErrMemory(ctxt, NULL);
        ctxt->instate = state;
        return;
        }
        if (SKIP_BLANKS == 0) {
        xmlFatalErrMsgStr(ctxt, XML_ERR_SPACE_REQUIRED,
              "ParsePI: PI %s space expected\n", target);
        }
        cur = CUR_CHAR(l);
        while (IS_CHAR(cur) && /* checked */
           ((cur != '?') || (NXT(1) != '>'))) {
        if (len + 5 >= size) {
            xmlChar *tmp;
                    size_t new_size = size * 2;
            tmp = (xmlChar *) xmlRealloc(buf, new_size);
            if (tmp == NULL) {
            xmlErrMemory(ctxt, NULL);
            xmlFree(buf);
            ctxt->instate = state;
            return;
            }
            buf = tmp;
                    size = new_size;
        }
        COPY_BUF(buf, len, cur);
                if (len > maxLength) {
                    xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
                                      "PI %s too big found", target);
                    xmlFree(buf);
                    ctxt->instate = state;
                    return;
                }
        NEXTL(l);
        cur = CUR_CHAR(l);
        }
        buf[len] = 0;
            if (ctxt->instate == XML_PARSER_EOF) {
                xmlFree(buf);
                return;
            }
        if (cur != '?') {
        xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
              "ParsePI: PI %s never end ...\n", target);
        } else {
        if (inputid != ctxt->input->id) {
            xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
                               "PI declaration doesn't start and stop in"
                                   " the same entity\n");
        }
        SKIP(2);
 
#ifdef LIBXML_CATALOG_ENABLED
        if (((state == XML_PARSER_MISC) ||
                 (state == XML_PARSER_START)) &&
            (xmlStrEqual(target, XML_CATALOG_PI))) {
            xmlCatalogAllow allow = xmlCatalogGetDefaults();
            if ((allow == XML_CATA_ALLOW_DOCUMENT) ||
            (allow == XML_CATA_ALLOW_ALL))
            xmlParseCatalogPI(ctxt, buf);
        }
#endif
 
 
        /*
         * SAX: PI detected.
         */
        if ((ctxt->sax) && (!ctxt->disableSAX) &&
            (ctxt->sax->processingInstruction != NULL))
            ctxt->sax->processingInstruction(ctxt->userData,
                                             target, buf);
        }
        xmlFree(buf);
    } else {
        xmlFatalErr(ctxt, XML_ERR_PI_NOT_STARTED, NULL);
    }
    if (ctxt->instate != XML_PARSER_EOF)
        ctxt->instate = state;
    }
}

Referenced by xmlParseContentInternal(), xmlParseMarkupDecl(), and xmlParseMisc().

xmlParsePITarget()

XML_DEPRECATED XMLPUBFUN const xmlChar * xmlParsePITarget

(

xmlParserCtxtPtr

ctxt

)

xmlParsePITarget: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse the name of a PI

[17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l'))

Returns the PITarget name or NULL

Definition at line 5212 of file parser.c.

                                        {
    const xmlChar *name;
 
    name = xmlParseName(ctxt);
    if ((name != NULL) &&
        ((name[0] == 'x') || (name[0] == 'X')) &&
        ((name[1] == 'm') || (name[1] == 'M')) &&
        ((name[2] == 'l') || (name[2] == 'L'))) {
    int i;
    if ((name[0] == 'x') && (name[1] == 'm') &&
        (name[2] == 'l') && (name[3] == 0)) {
        xmlFatalErrMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
         "XML declaration allowed only at the start of the document\n");
        return(name);
    } else if (name[3] == 0) {
        xmlFatalErr(ctxt, XML_ERR_RESERVED_XML_NAME, NULL);
        return(name);
    }
    for (i = 0;;i++) {
        if (xmlW3CPIs[i] == NULL) break;
        if (xmlStrEqual(name, (const xmlChar *)xmlW3CPIs[i]))
            return(name);
    }
    xmlWarningMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
              "xmlParsePITarget: invalid name prefix 'xml'\n",
              NULL, NULL);
    }
    if ((name != NULL) && (xmlStrchr(name, ':') != NULL)) {
    xmlNsErr(ctxt, XML_NS_ERR_COLON,
         "colons are forbidden from PI names '%s'\n", name, NULL, NULL);
    }
    return(name);
}

Referenced by xmlParsePI().

xmlParsePubidLiteral()

XML_DEPRECATED XMLPUBFUN xmlChar * xmlParsePubidLiteral

(

xmlParserCtxtPtr

ctxt

)

xmlParsePubidLiteral: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse an XML public literal

[12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'"

Returns the PubidLiteral parsed or NULL.

Definition at line 4442 of file parser.c.

                                            {
    xmlChar *buf = NULL;
    int len = 0;
    int size = XML_PARSER_BUFFER_SIZE;
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
                    XML_MAX_TEXT_LENGTH :
                    XML_MAX_NAME_LENGTH;
    xmlChar cur;
    xmlChar stop;
    xmlParserInputState oldstate = ctxt->instate;
 
    if (RAW == '"') {
        NEXT;
    stop = '"';
    } else if (RAW == '\'') {
        NEXT;
    stop = '\'';
    } else {
    xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
    return(NULL);
    }
    buf = (xmlChar *) xmlMallocAtomic(size);
    if (buf == NULL) {
    xmlErrMemory(ctxt, NULL);
    return(NULL);
    }
    ctxt->instate = XML_PARSER_PUBLIC_LITERAL;
    cur = CUR;
    while ((IS_PUBIDCHAR_CH(cur)) && (cur != stop)) { /* checked */
    if (len + 1 >= size) {
        xmlChar *tmp;
 
        size *= 2;
        tmp = (xmlChar *) xmlRealloc(buf, size);
        if (tmp == NULL) {
        xmlErrMemory(ctxt, NULL);
        xmlFree(buf);
        return(NULL);
        }
        buf = tmp;
    }
    buf[len++] = cur;
        if (len > maxLength) {
            xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Public ID");
            xmlFree(buf);
            return(NULL);
        }
    NEXT;
    cur = CUR;
    }
    buf[len] = 0;
    if (ctxt->instate == XML_PARSER_EOF) {
        xmlFree(buf);
        return(NULL);
    }
    if (cur != stop) {
    xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
    } else {
    NEXTL(1);
    }
    ctxt->instate = oldstate;
    return(buf);
}

Referenced by xmlParseExternalID().

xmlParseReference()

XML_DEPRECATED XMLPUBFUN void xmlParseReference

(

xmlParserCtxtPtr

ctxt

)

xmlParseReference: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

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.

Always consumes '&'.

[67] Reference ::= EntityRef | CharRef

Definition at line 7227 of file parser.c.

                                         {
    xmlEntityPtr ent;
    xmlChar *val;
    int was_checked;
    xmlNodePtr list = NULL;
    xmlParserErrors ret = XML_ERR_OK;
 
 
    if (RAW != '&')
        return;
 
    /*
     * Simple case of a CharRef
     */
    if (NXT(1) == '#') {
    int i = 0;
    xmlChar out[16];
    int value = xmlParseCharRef(ctxt);
 
    if (value == 0)
        return;
 
        /*
         * Just encode the value in UTF-8
         */
        COPY_BUF(out, i, value);
        out[i] = 0;
        if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
            (!ctxt->disableSAX))
            ctxt->sax->characters(ctxt->userData, out, i);
    return;
    }
 
    /*
     * We are seeing an entity reference
     */
    ent = xmlParseEntityRef(ctxt);
    if (ent == NULL) return;
    if (!ctxt->wellFormed)
    return;
    was_checked = ent->flags & XML_ENT_PARSED;
 
    /* special case of predefined entities */
    if ((ent->name == NULL) ||
        (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
    val = ent->content;
    if (val == NULL) return;
    /*
     * inline the entity.
     */
    if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
        (!ctxt->disableSAX))
        ctxt->sax->characters(ctxt->userData, val, xmlStrlen(val));
    return;
    }
 
    /*
     * The first reference to the entity trigger a parsing phase
     * where the ent->children is filled with the result from
     * the parsing.
     * Note: external parsed entities will not be loaded, it is not
     * required for a non-validating parser, unless the parsing option
     * of validating, or substituting entities were given. Doing so is
     * far more secure as the parser will only process data coming from
     * the document entity by default.
     *
     * FIXME: This doesn't work correctly since entities can be
     * expanded with different namespace declarations in scope.
     * For example:
     *
     * <!DOCTYPE doc [
     *   <!ENTITY ent "<ns:elem/>">
     * ]>
     * <doc>
     *   <decl1 xmlns:ns="urn:ns1">
     *     &ent;
     *   </decl1>
     *   <decl2 xmlns:ns="urn:ns2">
     *     &ent;
     *   </decl2>
     * </doc>
     *
     * Proposed fix:
     *
     * - Remove the ent->owner optimization which tries to avoid the
     *   initial copy of the entity. Always make entities own the
     *   subtree.
     * - Ignore current namespace declarations when parsing the
     *   entity. If a prefix can't be resolved, don't report an error
     *   but mark it as unresolved.
     * - Try to resolve these prefixes when expanding the entity.
     *   This will require a specialized version of xmlStaticCopyNode
     *   which can also make use of the namespace hash table to avoid
     *   quadratic behavior.
     *
     * Alternatively, we could simply reparse the entity on each
     * expansion like we already do with custom SAX callbacks.
     * External entity content should be cached in this case.
     */
    if (((ent->flags & XML_ENT_PARSED) == 0) &&
        ((ent->etype != XML_EXTERNAL_GENERAL_PARSED_ENTITY) ||
         (ctxt->options & (XML_PARSE_NOENT | XML_PARSE_DTDVALID)))) {
    unsigned long oldsizeentcopy = ctxt->sizeentcopy;
 
    /*
     * This is a bit hackish but this seems the best
     * way to make sure both SAX and DOM entity support
     * behaves okay.
     */
    void *user_data;
    if (ctxt->userData == ctxt)
        user_data = NULL;
    else
        user_data = ctxt->userData;
 
        /* Avoid overflow as much as possible */
        ctxt->sizeentcopy = 0;
 
        if (ent->flags & XML_ENT_EXPANDING) {
            xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
            xmlHaltParser(ctxt);
            return;
        }
 
        ent->flags |= XML_ENT_EXPANDING;
 
    /*
     * Check that this entity is well formed
     * 4.3.2: An internal general parsed entity is well-formed
     * if its replacement text matches the production labeled
     * content.
     */
    if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
        ctxt->depth++;
        ret = xmlParseBalancedChunkMemoryInternal(ctxt, ent->content,
                                                  user_data, &list);
        ctxt->depth--;
 
    } else if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
        ctxt->depth++;
        ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt, ctxt->sax,
                                       user_data, ctxt->depth, ent->URI,
                       ent->ExternalID, &list);
        ctxt->depth--;
    } else {
        ret = XML_ERR_ENTITY_PE_INTERNAL;
        xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
             "invalid entity type found\n", NULL);
    }
 
        ent->flags &= ~XML_ENT_EXPANDING;
        ent->flags |= XML_ENT_PARSED | XML_ENT_CHECKED;
        ent->expandedSize = ctxt->sizeentcopy;
    if (ret == XML_ERR_ENTITY_LOOP) {
            xmlHaltParser(ctxt);
        xmlFreeNodeList(list);
        return;
    }
    if (xmlParserEntityCheck(ctxt, oldsizeentcopy)) {
        xmlFreeNodeList(list);
        return;
    }
 
    if ((ret == XML_ERR_OK) && (list != NULL)) {
            ent->children = list;
            /*
             * Prune it directly in the generated document
             * except for single text nodes.
             */
            if ((ctxt->replaceEntities == 0) ||
                (ctxt->parseMode == XML_PARSE_READER) ||
                ((list->type == XML_TEXT_NODE) &&
                 (list->next == NULL))) {
                ent->owner = 1;
                while (list != NULL) {
                    list->parent = (xmlNodePtr) ent;
                    if (list->doc != ent->doc)
                        xmlSetTreeDoc(list, ent->doc);
                    if (list->next == NULL)
                        ent->last = list;
                    list = list->next;
                }
                list = NULL;
            } else {
                ent->owner = 0;
                while (list != NULL) {
                    list->parent = (xmlNodePtr) ctxt->node;
                    list->doc = ctxt->myDoc;
                    if (list->next == NULL)
                        ent->last = list;
                    list = list->next;
                }
                list = ent->children;
#ifdef LIBXML_LEGACY_ENABLED
                if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
                    xmlAddEntityReference(ent, list, NULL);
#endif /* LIBXML_LEGACY_ENABLED */
            }
    } else if ((ret != XML_ERR_OK) &&
           (ret != XML_WAR_UNDECLARED_ENTITY)) {
        xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
             "Entity '%s' failed to parse\n", ent->name);
            if (ent->content != NULL)
                ent->content[0] = 0;
    } else if (list != NULL) {
        xmlFreeNodeList(list);
        list = NULL;
    }
 
        /* Prevent entity from being parsed and expanded twice (Bug 760367). */
        was_checked = 0;
    }
 
    /*
     * Now that the entity content has been gathered
     * provide it to the application, this can take different forms based
     * on the parsing modes.
     */
    if (ent->children == NULL) {
    /*
     * Probably running in SAX mode and the callbacks don't
     * build the entity content. So unless we already went
     * though parsing for first checking go though the entity
     * content to generate callbacks associated to the entity
     */
    if (was_checked != 0) {
        void *user_data;
        /*
         * This is a bit hackish but this seems the best
         * way to make sure both SAX and DOM entity support
         * behaves okay.
         */
        if (ctxt->userData == ctxt)
        user_data = NULL;
        else
        user_data = ctxt->userData;
 
        if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
        ctxt->depth++;
        ret = xmlParseBalancedChunkMemoryInternal(ctxt,
                   ent->content, user_data, NULL);
        ctxt->depth--;
        } else if (ent->etype ==
               XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
            unsigned long oldsizeentities = ctxt->sizeentities;
 
        ctxt->depth++;
        ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt,
               ctxt->sax, user_data, ctxt->depth,
               ent->URI, ent->ExternalID, NULL);
        ctxt->depth--;
 
                /* Undo the change to sizeentities */
                ctxt->sizeentities = oldsizeentities;
        } else {
        ret = XML_ERR_ENTITY_PE_INTERNAL;
        xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
                 "invalid entity type found\n", NULL);
        }
        if (ret == XML_ERR_ENTITY_LOOP) {
        xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
        return;
        }
            if (xmlParserEntityCheck(ctxt, 0))
                return;
    }
    if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
        (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
        /*
         * Entity reference callback comes second, it's somewhat
         * superfluous but a compatibility to historical behaviour
         */
        ctxt->sax->reference(ctxt->userData, ent->name);
    }
    return;
    }
 
    /*
     * We also check for amplification if entities aren't substituted.
     * They might be expanded later.
     */
    if ((was_checked != 0) &&
        (xmlParserEntityCheck(ctxt, ent->expandedSize)))
        return;
 
    /*
     * If we didn't get any children for the entity being built
     */
    if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
    (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
    /*
     * Create a node.
     */
    ctxt->sax->reference(ctxt->userData, ent->name);
    return;
    }
 
    if (ctxt->replaceEntities)  {
    /*
     * There is a problem on the handling of _private for entities
     * (bug 155816): Should we copy the content of the field from
     * the entity (possibly overwriting some value set by the user
     * when a copy is created), should we leave it alone, or should
     * we try to take care of different situations?  The problem
     * is exacerbated by the usage of this field by the xmlReader.
     * To fix this bug, we look at _private on the created node
     * and, if it's NULL, we copy in whatever was in the entity.
     * If it's not NULL we leave it alone.  This is somewhat of a
     * hack - maybe we should have further tests to determine
     * what to do.
     */
    if (ctxt->node != NULL) {
        /*
         * Seems we are generating the DOM content, do
         * a simple tree copy for all references except the first
         * In the first occurrence list contains the replacement.
         */
        if (((list == NULL) && (ent->owner == 0)) ||
        (ctxt->parseMode == XML_PARSE_READER)) {
        xmlNodePtr nw = NULL, cur, firstChild = NULL;
 
        /*
         * when operating on a reader, the entities definitions
         * are always owning the entities subtree.
        if (ctxt->parseMode == XML_PARSE_READER)
            ent->owner = 1;
         */
 
        cur = ent->children;
        while (cur != NULL) {
            nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
            if (nw != NULL) {
            if (nw->_private == NULL)
                nw->_private = cur->_private;
            if (firstChild == NULL){
                firstChild = nw;
            }
            nw = xmlAddChild(ctxt->node, nw);
            }
            if (cur == ent->last) {
            /*
             * needed to detect some strange empty
             * node cases in the reader tests
             */
            if ((ctxt->parseMode == XML_PARSE_READER) &&
                (nw != NULL) &&
                (nw->type == XML_ELEMENT_NODE) &&
                (nw->children == NULL))
                nw->extra = 1;
 
            break;
            }
            cur = cur->next;
        }
#ifdef LIBXML_LEGACY_ENABLED
        if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
          xmlAddEntityReference(ent, firstChild, nw);
#endif /* LIBXML_LEGACY_ENABLED */
        } else if ((list == NULL) || (ctxt->inputNr > 0)) {
        xmlNodePtr nw = NULL, cur, next, last,
               firstChild = NULL;
 
        /*
         * Copy the entity child list and make it the new
         * entity child list. The goal is to make sure any
         * ID or REF referenced will be the one from the
         * document content and not the entity copy.
         */
        cur = ent->children;
        ent->children = NULL;
        last = ent->last;
        ent->last = NULL;
        while (cur != NULL) {
            next = cur->next;
            cur->next = NULL;
            cur->parent = NULL;
            nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
            if (nw != NULL) {
            if (nw->_private == NULL)
                nw->_private = cur->_private;
            if (firstChild == NULL){
                firstChild = cur;
            }
            xmlAddChild((xmlNodePtr) ent, nw);
            }
            xmlAddChild(ctxt->node, cur);
            if (cur == last)
            break;
            cur = next;
        }
        if (ent->owner == 0)
            ent->owner = 1;
#ifdef LIBXML_LEGACY_ENABLED
        if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
          xmlAddEntityReference(ent, firstChild, nw);
#endif /* LIBXML_LEGACY_ENABLED */
        } else {
        const xmlChar *nbktext;
 
        /*
         * the name change is to avoid coalescing of the
         * node with a possible previous text one which
         * would make ent->children a dangling pointer
         */
        nbktext = xmlDictLookup(ctxt->dict, BAD_CAST "nbktext",
                    -1);
        if (ent->children->type == XML_TEXT_NODE)
            ent->children->name = nbktext;
        if ((ent->last != ent->children) &&
            (ent->last->type == XML_TEXT_NODE))
            ent->last->name = nbktext;
        xmlAddChildList(ctxt->node, ent->children);
        }
 
        /*
         * This is to avoid a nasty side effect, see
         * characters() in SAX.c
         */
        ctxt->nodemem = 0;
        ctxt->nodelen = 0;
        return;
    }
    }
}

Referenced by xmlParseContentInternal().

xmlParserHandlePEReference()

XML_DEPRECATED XMLPUBFUN void xmlParserHandlePEReference

(

xmlParserCtxtPtr

ctxt

)

xmlParserHandlePEReference: @ctxt: the parser context

DEPRECATED: Internal function, do not use.

[69] PEReference ::= '' Name ';'

[ WFC: No Recursion ] 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 Parameter Entity reference within DTDs

Definition at line 2715 of file parser.c.

                                                  {
    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:
        xmlFatalErr(ctxt, XML_ERR_PEREF_AT_EOF, NULL);
        return;
        case XML_PARSER_PROLOG:
    case XML_PARSER_START:
    case XML_PARSER_XML_DECL:
    case XML_PARSER_MISC:
        xmlFatalErr(ctxt, XML_ERR_PEREF_IN_PROLOG, NULL);
        return;
    case XML_PARSER_ENTITY_DECL:
        case XML_PARSER_CONTENT:
        case XML_PARSER_ATTRIBUTE_VALUE:
        case XML_PARSER_PI:
    case XML_PARSER_SYSTEM_LITERAL:
    case XML_PARSER_PUBLIC_LITERAL:
        /* we just ignore it there */
        return;
        case XML_PARSER_EPILOG:
        xmlFatalErr(ctxt, XML_ERR_PEREF_IN_EPILOG, NULL);
        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 xmlStringDecodeEntities
         */
        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 xmlParseMarkupDecl
         */
        if ((ctxt->external == 0) && (ctxt->inputNr == 1))
        return;
        if (IS_BLANK_CH(NXT(1)) || NXT(1) == 0)
        return;
            break;
        case XML_PARSER_IGNORE:
            return;
    }
 
    xmlParsePEReference(ctxt);
}

xmlParserInputShrink()

XML_DEPRECATED XMLPUBFUN void xmlParserInputShrink

(

xmlParserInputPtr

in

)

xmlParserInputShrink: @in: an XML parser input

DEPRECATED: Don't use.

This function removes used input for the parser.

Definition at line 650 of file parserInternals.c.

                                           {
    size_t used;
    size_t ret;
 
    if (in == NULL) return;
    if (in->buf == NULL) return;
    if (in->base == NULL) return;
    if (in->cur == NULL) return;
    if (in->buf->buffer == NULL) return;
 
    used = in->cur - in->base;
    /*
     * Do not shrink on large buffers whose only a tiny fraction
     * was consumed
     */
    if (used > INPUT_CHUNK) {
    ret = xmlBufShrink(in->buf->buffer, used - LINE_LEN);
    if (ret > 0) {
            used -= ret;
            if ((ret > ULONG_MAX) ||
                (in->consumed > ULONG_MAX - (unsigned long)ret))
                in->consumed = ULONG_MAX;
            else
                in->consumed += ret;
    }
    }
 
    if (xmlBufUse(in->buf->buffer) <= INPUT_CHUNK) {
        xmlParserInputBufferRead(in->buf, 2 * INPUT_CHUNK);
    }
 
    in->base = xmlBufContent(in->buf->buffer);
    if (in->base == NULL) {
        /* TODO: raise error */
        in->base = BAD_CAST "";
        in->cur = in->base;
        in->end = in->base;
        return;
    }
    in->cur = in->base + used;
    in->end = xmlBufEnd(in->buf->buffer);
}

xmlParseSDDecl()

XML_DEPRECATED XMLPUBFUN int xmlParseSDDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseSDDecl: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse the XML standalone declaration

[32] SDDecl ::= S 'standalone' Eq (("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no')'"'))

[ VC: Standalone Document Declaration ] TODO The standalone document declaration must have the value "no" if any external markup declarations contain declarations of:

• attributes with default values, if elements to which these attributes apply appear in the document without specifications of values for these attributes, or
• entities (other than amp, lt, gt, apos, quot), if references to those entities appear in the document, or
• attributes with values subject to normalization, where the attribute appears in the document with a value which will change as a result of normalization, or
• element types with element content, if white space occurs directly within any instance of those types.

Returns: 1 if standalone="yes" 0 if standalone="no" -2 if standalone attribute is missing or invalid (A standalone value of -2 means that the XML declaration was found, but no value was specified for the standalone attribute).

Definition at line 10792 of file parser.c.

                                      {
    int standalone = -2;
 
    SKIP_BLANKS;
    if (CMP10(CUR_PTR, 's', 't', 'a', 'n', 'd', 'a', 'l', 'o', 'n', 'e')) {
    SKIP(10);
        SKIP_BLANKS;
    if (RAW != '=') {
        xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
        return(standalone);
        }
    NEXT;
    SKIP_BLANKS;
        if (RAW == '\''){
        NEXT;
        if ((RAW == 'n') && (NXT(1) == 'o')) {
            standalone = 0;
                SKIP(2);
        } else if ((RAW == 'y') && (NXT(1) == 'e') &&
                   (NXT(2) == 's')) {
            standalone = 1;
        SKIP(3);
            } else {
        xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
        }
        if (RAW != '\'') {
        xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
        } else
            NEXT;
    } else if (RAW == '"'){
        NEXT;
        if ((RAW == 'n') && (NXT(1) == 'o')) {
            standalone = 0;
        SKIP(2);
        } else if ((RAW == 'y') && (NXT(1) == 'e') &&
                   (NXT(2) == 's')) {
            standalone = 1;
                SKIP(3);
            } else {
        xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
        }
        if (RAW != '"') {
        xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
        } else
            NEXT;
    } else {
        xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
        }
    }
    return(standalone);
}

Referenced by xmlParseXMLDecl().

xmlParseSystemLiteral()

XML_DEPRECATED XMLPUBFUN xmlChar * xmlParseSystemLiteral

(

xmlParserCtxtPtr

ctxt

)

xmlParseSystemLiteral: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse an XML Literal

[11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'")

Returns the SystemLiteral parsed or NULL

Definition at line 4361 of file parser.c.

                                             {
    xmlChar *buf = NULL;
    int len = 0;
    int size = XML_PARSER_BUFFER_SIZE;
    int cur, l;
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
                    XML_MAX_TEXT_LENGTH :
                    XML_MAX_NAME_LENGTH;
    xmlChar stop;
    int state = ctxt->instate;
 
    if (RAW == '"') {
        NEXT;
    stop = '"';
    } else if (RAW == '\'') {
        NEXT;
    stop = '\'';
    } else {
    xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
    return(NULL);
    }
 
    buf = (xmlChar *) xmlMallocAtomic(size);
    if (buf == NULL) {
        xmlErrMemory(ctxt, NULL);
    return(NULL);
    }
    ctxt->instate = XML_PARSER_SYSTEM_LITERAL;
    cur = CUR_CHAR(l);
    while ((IS_CHAR(cur)) && (cur != stop)) { /* checked */
    if (len + 5 >= size) {
        xmlChar *tmp;
 
        size *= 2;
        tmp = (xmlChar *) xmlRealloc(buf, size);
        if (tmp == NULL) {
            xmlFree(buf);
        xmlErrMemory(ctxt, NULL);
        ctxt->instate = (xmlParserInputState) state;
        return(NULL);
        }
        buf = tmp;
    }
    COPY_BUF(buf, len, cur);
        if (len > maxLength) {
            xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "SystemLiteral");
            xmlFree(buf);
            ctxt->instate = (xmlParserInputState) state;
            return(NULL);
        }
    NEXTL(l);
    cur = CUR_CHAR(l);
    }
    buf[len] = 0;
    if (ctxt->instate == XML_PARSER_EOF) {
        xmlFree(buf);
        return(NULL);
    }
    ctxt->instate = (xmlParserInputState) state;
    if (!IS_CHAR(cur)) {
    xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
    } else {
    NEXT;
    }
    return(buf);
}

Referenced by xmlParseExternalID().

xmlParseTextDecl()

XML_DEPRECATED XMLPUBFUN void xmlParseTextDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseTextDecl: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse an XML declaration header for external entities

[77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>'

Definition at line 7074 of file parser.c.

                                        {
    xmlChar *version;
    int oldstate;
 
    /*
     * We know that '<?xml' is here.
     */
    if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
    SKIP(5);
    } else {
    xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_STARTED, NULL);
    return;
    }
 
    /* Avoid expansion of parameter entities when skipping blanks. */
    oldstate = ctxt->instate;
    ctxt->instate = XML_PARSER_START;
 
    if (SKIP_BLANKS == 0) {
    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
               "Space needed after '<?xml'\n");
    }
 
    /*
     * We may have the VersionInfo here.
     */
    version = xmlParseVersionInfo(ctxt);
    if (version == NULL)
    version = xmlCharStrdup(XML_DEFAULT_VERSION);
    else {
    if (SKIP_BLANKS == 0) {
        xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
                   "Space needed here\n");
    }
    }
    ctxt->input->version = version;
 
    /*
     * We must have the encoding declaration
     */
    xmlParseEncodingDecl(ctxt);
    if (ctxt->instate == XML_PARSER_EOF)
        return;
    if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
    /*
     * The XML REC instructs us to stop parsing right here
     */
        ctxt->instate = oldstate;
        return;
    }
 
    SKIP_BLANKS;
    if ((RAW == '?') && (NXT(1) == '>')) {
        SKIP(2);
    } else if (RAW == '>') {
        /* Deprecated old WD ... */
    xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
    NEXT;
    } else {
        int c;
 
    xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
        while ((c = CUR) != 0) {
            NEXT;
            if (c == '>')
                break;
        }
    }
 
    if (ctxt->instate != XML_PARSER_EOF)
        ctxt->instate = oldstate;
}

Referenced by xmlLoadEntityContent(), xmlParseExternalEntityPrivate(), xmlParseExternalSubset(), and xmlParsePEReference().

xmlParseVersionInfo()

XML_DEPRECATED XMLPUBFUN xmlChar * xmlParseVersionInfo

(

xmlParserCtxtPtr

ctxt

)

xmlParseVersionInfo: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse the XML version.

[24] VersionInfo ::= S 'version' Eq (' VersionNum ' | " VersionNum ")

[25] Eq ::= S? '=' S?

Returns the version string, e.g. "1.0"

Definition at line 10597 of file parser.c.

                                           {
    xmlChar *version = NULL;
 
    if (CMP7(CUR_PTR, 'v', 'e', 'r', 's', 'i', 'o', 'n')) {
    SKIP(7);
    SKIP_BLANKS;
    if (RAW != '=') {
        xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
        return(NULL);
        }
    NEXT;
    SKIP_BLANKS;
    if (RAW == '"') {
        NEXT;
        version = xmlParseVersionNum(ctxt);
        if (RAW != '"') {
        xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
        } else
            NEXT;
    } else if (RAW == '\''){
        NEXT;
        version = xmlParseVersionNum(ctxt);
        if (RAW != '\'') {
        xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
        } else
            NEXT;
    } else {
        xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
    }
    }
    return(version);
}

Referenced by xmlParseTextDecl(), and xmlParseXMLDecl().

xmlParseVersionNum()

XML_DEPRECATED XMLPUBFUN xmlChar * xmlParseVersionNum

(

xmlParserCtxtPtr

ctxt

)

xmlParseVersionNum: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse the XML version value.

[26] VersionNum ::= '1.' [0-9]+

In practice allow [0-9].[0-9]+ at that level

Returns the string giving the XML version number, or NULL

Definition at line 10534 of file parser.c.

                                          {
    xmlChar *buf = NULL;
    int len = 0;
    int size = 10;
    xmlChar cur;
 
    buf = (xmlChar *) xmlMallocAtomic(size);
    if (buf == NULL) {
    xmlErrMemory(ctxt, NULL);
    return(NULL);
    }
    cur = CUR;
    if (!((cur >= '0') && (cur <= '9'))) {
    xmlFree(buf);
    return(NULL);
    }
    buf[len++] = cur;
    NEXT;
    cur=CUR;
    if (cur != '.') {
    xmlFree(buf);
    return(NULL);
    }
    buf[len++] = cur;
    NEXT;
    cur=CUR;
    while ((cur >= '0') && (cur <= '9')) {
    if (len + 1 >= size) {
        xmlChar *tmp;
 
        size *= 2;
        tmp = (xmlChar *) xmlRealloc(buf, size);
        if (tmp == NULL) {
            xmlFree(buf);
        xmlErrMemory(ctxt, NULL);
        return(NULL);
        }
        buf = tmp;
    }
    buf[len++] = cur;
    NEXT;
    cur=CUR;
    }
    buf[len] = 0;
    return(buf);
}

Referenced by xmlParseVersionInfo().

xmlParseXMLDecl()

XML_DEPRECATED XMLPUBFUN void xmlParseXMLDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseXMLDecl: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse an XML declaration header

[23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'

Definition at line 10856 of file parser.c.

                                       {
    xmlChar *version;
 
    /*
     * This value for standalone indicates that the document has an
     * XML declaration but it does not have a standalone attribute.
     * It will be overwritten later if a standalone attribute is found.
     */
 
    ctxt->standalone = -2;
 
    /*
     * We know that '<?xml' is here.
     */
    SKIP(5);
 
    if (!IS_BLANK_CH(RAW)) {
    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
                   "Blank needed after '<?xml'\n");
    }
    SKIP_BLANKS;
 
    /*
     * We must have the VersionInfo here.
     */
    version = xmlParseVersionInfo(ctxt);
    if (version == NULL) {
    xmlFatalErr(ctxt, XML_ERR_VERSION_MISSING, NULL);
    } else {
    if (!xmlStrEqual(version, (const xmlChar *) XML_DEFAULT_VERSION)) {
        /*
         * Changed here for XML-1.0 5th edition
         */
        if (ctxt->options & XML_PARSE_OLD10) {
        xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
                      "Unsupported version '%s'\n",
                      version);
        } else {
            if ((version[0] == '1') && ((version[1] == '.'))) {
            xmlWarningMsg(ctxt, XML_WAR_UNKNOWN_VERSION,
                          "Unsupported version '%s'\n",
                  version, NULL);
        } else {
            xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
                      "Unsupported version '%s'\n",
                      version);
        }
        }
    }
    if (ctxt->version != NULL)
        xmlFree((void *) ctxt->version);
    ctxt->version = version;
    }
 
    /*
     * We may have the encoding declaration
     */
    if (!IS_BLANK_CH(RAW)) {
        if ((RAW == '?') && (NXT(1) == '>')) {
        SKIP(2);
        return;
    }
    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
    }
    xmlParseEncodingDecl(ctxt);
    if ((ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) ||
         (ctxt->instate == XML_PARSER_EOF)) {
    /*
     * The XML REC instructs us to stop parsing right here
     */
        return;
    }
 
    /*
     * We may have the standalone status.
     */
    if ((ctxt->encoding != NULL) && (!IS_BLANK_CH(RAW))) {
        if ((RAW == '?') && (NXT(1) == '>')) {
        SKIP(2);
        return;
    }
    xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
    }
 
    /*
     * We can grow the input buffer freely at that point
     */
    GROW;
 
    SKIP_BLANKS;
    ctxt->standalone = xmlParseSDDecl(ctxt);
 
    SKIP_BLANKS;
    if ((RAW == '?') && (NXT(1) == '>')) {
        SKIP(2);
    } else if (RAW == '>') {
        /* Deprecated old WD ... */
    xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
    NEXT;
    } else {
        int c;
 
    xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
        while ((c = CUR) != 0) {
            NEXT;
            if (c == '>')
                break;
        }
    }
}

Referenced by xmlParseDocument(), and xmlParseExtParsedEnt().

xmlPopInput()

XMLPUBFUN xmlChar xmlPopInput

(

xmlParserCtxtPtr

ctxt

)

xmlPopInput: @ctxt: an XML parser context

xmlPopInput: 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

Definition at line 2419 of file parser.c.

                                   {
    xmlParserInputPtr input;
 
    if ((ctxt == NULL) || (ctxt->inputNr <= 1)) return(0);
    if (xmlParserDebugEntities)
    xmlGenericError(xmlGenericErrorContext,
        "Popping input %d\n", ctxt->inputNr);
    if ((ctxt->inputNr > 1) && (ctxt->inSubset == 0) &&
        (ctxt->instate != XML_PARSER_EOF))
        xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
                    "Unfinished entity outside the DTD");
    input = inputPop(ctxt);
    if (input->entity != NULL)
        input->entity->flags &= ~XML_ENT_EXPANDING;
    xmlFreeInputStream(input);
    if (*ctxt->input->cur == 0)
        xmlParserGrow(ctxt);
    return(CUR);
}

Referenced by xmlSAX2ExternalSubset(), and xmlSkipBlankChars().

xmlPushInput()

XMLPUBFUN int xmlPushInput	(	xmlParserCtxtPtr	ctxt,
		xmlParserInputPtr	input
	)

xmlPushInput: @ctxt: an XML parser context @input: an XML parser input fragment (entity, XML fragment ...).

xmlPushInput: switch to a new input stream which is stacked on top of the previous one(s). Returns -1 in case of error or the index in the input stack

Definition at line 2449 of file parser.c.

                                                             {
    int ret;
    if (input == NULL) return(-1);
 
    if (xmlParserDebugEntities) {
    if ((ctxt->input != NULL) && (ctxt->input->filename))
        xmlGenericError(xmlGenericErrorContext,
            "%s(%d): ", ctxt->input->filename,
            ctxt->input->line);
    xmlGenericError(xmlGenericErrorContext,
        "Pushing input %d : %.30s\n", ctxt->inputNr+1, input->cur);
    }
    if (((ctxt->inputNr > 40) && ((ctxt->options & XML_PARSE_HUGE) == 0)) ||
        (ctxt->inputNr > 100)) {
        xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
        while (ctxt->inputNr > 1)
            xmlFreeInputStream(inputPop(ctxt));
    return(-1);
    }
    ret = inputPush(ctxt, input);
    if (ctxt->instate == XML_PARSER_EOF)
        return(-1);
    GROW;
    return(ret);
}

Referenced by xmlParsePEReference(), and xmlSAX2ExternalSubset().

xmlSkipBlankChars()

XML_DEPRECATED XMLPUBFUN int xmlSkipBlankChars

(

xmlParserCtxtPtr

ctxt

)

xmlSkipBlankChars: @ctxt: the XML parser context

DEPRECATED: Internal function, do not use.

skip all blanks character found at that point in the input streams. It pops up finished entities in the process if allowable at that point.

Returns the number of space chars skipped

Definition at line 2316 of file parser.c.

                                         {
    int res = 0;
 
    /*
     * It's Okay to use CUR/NEXT here since all the blanks are on
     * the ASCII range.
     */
    if (((ctxt->inputNr == 1) && (ctxt->instate != XML_PARSER_DTD)) ||
        (ctxt->instate == XML_PARSER_START)) {
    const xmlChar *cur;
    /*
     * if we are in the document content, go really fast
     */
    cur = ctxt->input->cur;
    while (IS_BLANK_CH(*cur)) {
        if (*cur == '\n') {
        ctxt->input->line++; ctxt->input->col = 1;
        } else {
        ctxt->input->col++;
        }
        cur++;
        if (res < INT_MAX)
        res++;
        if (*cur == 0) {
        ctxt->input->cur = cur;
        xmlParserGrow(ctxt);
        cur = ctxt->input->cur;
        }
    }
    ctxt->input->cur = cur;
    } else {
        int expandPE = ((ctxt->external != 0) || (ctxt->inputNr != 1));
 
    while (ctxt->instate != XML_PARSER_EOF) {
            if (IS_BLANK_CH(CUR)) { /* CHECKED tstblanks.xml */
        NEXT;
        } else if (CUR == '%') {
                /*
                 * Need to handle support of entities branching here
                 */
            if ((expandPE == 0) || (IS_BLANK_CH(NXT(1))) || (NXT(1) == 0))
                    break;
            xmlParsePEReference(ctxt);
            } else if (CUR == 0) {
                unsigned long consumed;
                xmlEntityPtr ent;
 
                if (ctxt->inputNr <= 1)
                    break;
 
                consumed = ctxt->input->consumed;
                xmlSaturatedAddSizeT(&consumed,
                                     ctxt->input->cur - ctxt->input->base);
 
                /*
                 * Add to sizeentities when parsing an external entity
                 * for the first time.
                 */
                ent = ctxt->input->entity;
                if ((ent->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
                    ((ent->flags & XML_ENT_PARSED) == 0)) {
                    ent->flags |= XML_ENT_PARSED;
 
                    xmlSaturatedAdd(&ctxt->sizeentities, consumed);
                }
 
                xmlParserEntityCheck(ctxt, consumed);
 
                xmlPopInput(ctxt);
            } else {
                break;
            }
 
            /*
             * Also increase the counter when entering or exiting a PERef.
             * The spec says: "When a parameter-entity reference is recognized
             * in the DTD and included, its replacement text MUST be enlarged
             * by the attachment of one leading and one following space (#x20)
             * character."
             */
        if (res < INT_MAX)
        res++;
        }
    }
    return(res);
}

xmlSplitQName()

XMLPUBFUN xmlChar * xmlSplitQName	(	xmlParserCtxtPtr	ctxt,
		const xmlChar *	name,
		xmlChar **	prefix
	)

Namespaces.

Definition at line 3157 of file parser.c.

                                                                            {
    xmlChar buf[XML_MAX_NAMELEN + 5];
    xmlChar *buffer = NULL;
    int len = 0;
    int max = XML_MAX_NAMELEN;
    xmlChar *ret = NULL;
    const xmlChar *cur = name;
    int c;
 
    if (prefix == NULL) return(NULL);
    *prefix = NULL;
 
    if (cur == NULL) return(NULL);
 
#ifndef XML_XML_NAMESPACE
    /* xml: prefix is not really a namespace */
    if ((cur[0] == 'x') && (cur[1] == 'm') &&
        (cur[2] == 'l') && (cur[3] == ':'))
    return(xmlStrdup(name));
#endif
 
    /* nasty but well=formed */
    if (cur[0] == ':')
    return(xmlStrdup(name));
 
    c = *cur++;
    while ((c != 0) && (c != ':') && (len < max)) { /* tested bigname.xml */
    buf[len++] = c;
    c = *cur++;
    }
    if (len >= max) {
    /*
     * Okay someone managed to make a huge name, so he's ready to pay
     * for the processing speed.
     */
    max = len * 2;
 
    buffer = (xmlChar *) xmlMallocAtomic(max);
    if (buffer == NULL) {
        xmlErrMemory(ctxt, NULL);
        return(NULL);
    }
    memcpy(buffer, buf, len);
    while ((c != 0) && (c != ':')) { /* tested bigname.xml */
        if (len + 10 > max) {
            xmlChar *tmp;
 
        max *= 2;
        tmp = (xmlChar *) xmlRealloc(buffer, max);
        if (tmp == NULL) {
            xmlFree(buffer);
            xmlErrMemory(ctxt, NULL);
            return(NULL);
        }
        buffer = tmp;
        }
        buffer[len++] = c;
        c = *cur++;
    }
    buffer[len] = 0;
    }
 
    if ((c == ':') && (*cur == 0)) {
        if (buffer != NULL)
        xmlFree(buffer);
    *prefix = NULL;
    return(xmlStrdup(name));
    }
 
    if (buffer == NULL)
    ret = xmlStrndup(buf, len);
    else {
    ret = buffer;
    buffer = NULL;
    max = XML_MAX_NAMELEN;
    }
 
 
    if (c == ':') {
    c = *cur;
        *prefix = ret;
    if (c == 0) {
        return(xmlStrndup(BAD_CAST "", 0));
    }
    len = 0;
 
    /*
     * Check that the first character is proper to start
     * a new name
     */
    if (!(((c >= 0x61) && (c <= 0x7A)) ||
          ((c >= 0x41) && (c <= 0x5A)) ||
          (c == '_') || (c == ':'))) {
        int l;
        int first = CUR_SCHAR(cur, l);
 
        if (!IS_LETTER(first) && (first != '_')) {
        xmlFatalErrMsgStr(ctxt, XML_NS_ERR_QNAME,
                "Name %s is not XML Namespace compliant\n",
                  name);
        }
    }
    cur++;
 
    while ((c != 0) && (len < max)) { /* tested bigname2.xml */
        buf[len++] = c;
        c = *cur++;
    }
    if (len >= max) {
        /*
         * Okay someone managed to make a huge name, so he's ready to pay
         * for the processing speed.
         */
        max = len * 2;
 
        buffer = (xmlChar *) xmlMallocAtomic(max);
        if (buffer == NULL) {
            xmlErrMemory(ctxt, NULL);
        return(NULL);
        }
        memcpy(buffer, buf, len);
        while (c != 0) { /* tested bigname2.xml */
        if (len + 10 > max) {
            xmlChar *tmp;
 
            max *= 2;
            tmp = (xmlChar *) xmlRealloc(buffer, max);
            if (tmp == NULL) {
            xmlErrMemory(ctxt, NULL);
            xmlFree(buffer);
            return(NULL);
            }
            buffer = tmp;
        }
        buffer[len++] = c;
        c = *cur++;
        }
        buffer[len] = 0;
    }
 
    if (buffer == NULL)
        ret = xmlStrndup(buf, len);
    else {
        ret = buffer;
    }
    }
 
    return(ret);
}

Referenced by xmlSAX2AttributeDecl().

xmlStringCurrentChar()

XML_DEPRECATED XMLPUBFUN int xmlStringCurrentChar	(	xmlParserCtxtPtr ctxt	ATTRIBUTE_UNUSED,
		const xmlChar *	cur,
		int *	len
	)

xmlStringCurrentChar: @ctxt: the XML parser context @cur: pointer to the beginning of the char @len: pointer to the length of the char read

DEPRECATED: Internal function, do not use.

The current char value, if using UTF-8 this may actually span multiple bytes in the input buffer.

Returns the current char value and its length

Definition at line 990 of file parserInternals.c.

                                                   {
    int c;
 
    if ((cur == NULL) || (len == NULL))
        return(0);
 
    /* cur is zero-terminated, so we can lie about its length. */
    *len = 4;
    c = xmlGetUTF8Char(cur, len);
 
    return((c < 0) ? 0 : c);
}

xmlStringDecodeEntities()

XML_DEPRECATED XMLPUBFUN xmlChar * xmlStringDecodeEntities	(	xmlParserCtxtPtr	ctxt,
		const xmlChar *	str,
		int	what,
		xmlChar	end,
		xmlChar	end2,
		xmlChar	end3
	)

xmlStringDecodeEntities: @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

DEPRECATED: Internal function, don't use.

Takes a entity string content and process to do the adequate substitutions.

[67] Reference ::= EntityRef | CharRef

[69] PEReference ::= '' Name ';'

Returns A newly allocated string with the substitution done. The caller must deallocate it !

Definition at line 3050 of file parser.c.

                                                          {
    if ((ctxt == NULL) || (str == NULL)) return(NULL);
    return(xmlStringDecodeEntitiesInt(ctxt, str, xmlStrlen(str), what,
                                      end, end2, end3, 0));
}

xmlStringLenDecodeEntities()

XML_DEPRECATED XMLPUBFUN xmlChar * xmlStringLenDecodeEntities	(	xmlParserCtxtPtr	ctxt,
		const xmlChar *	str,
		int	len,
		int	what,
		xmlChar	end,
		xmlChar	end2,
		xmlChar	end3
	)

xmlStringLenDecodeEntities: @ctxt: the parser context @str: the input string @len: the string length @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

DEPRECATED: Internal function, don't use.

Takes a entity string content and process to do the adequate substitutions.

[67] Reference ::= EntityRef | CharRef

[69] PEReference ::= '' Name ';'

Returns A newly allocated string with the substitution done. The caller must deallocate it !

Definition at line 3020 of file parser.c.

                                         {
    if ((ctxt == NULL) || (str == NULL) || (len < 0))
        return(NULL);
    return(xmlStringDecodeEntitiesInt(ctxt, str, len, what,
                                      end, end2, end3, 0));
}

xmlSwitchEncoding()

XMLPUBFUN int xmlSwitchEncoding	(	xmlParserCtxtPtr	ctxt,
		xmlCharEncoding	enc
	)

xmlSwitchEncoding: @ctxt: the parser context @enc: the encoding value (number)

Use encoding specified by enum to decode input data.

This function can be used to enforce the encoding of chunks passed to xmlParseChunk.

Returns 0 in case of success, -1 otherwise

Definition at line 1146 of file parserInternals.c.

{
    xmlCharEncodingHandlerPtr handler = NULL;
    int check = 1;
    int ret;
 
    if ((ctxt == NULL) || (ctxt->input == NULL))
        return(-1);
 
    switch (enc) {
    case XML_CHAR_ENCODING_NONE:
    case XML_CHAR_ENCODING_UTF8:
        case XML_CHAR_ENCODING_ASCII:
            check = 0;
            break;
        case XML_CHAR_ENCODING_EBCDIC:
            handler = xmlDetectEBCDIC(ctxt->input);
            break;
        default:
            handler = xmlGetCharEncodingHandler(enc);
            break;
    }
 
    if ((check) && (handler == NULL)) {
        const char *name = xmlGetCharEncodingName(enc);
 
        __xmlErrEncoding(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
                "encoding not supported: %s\n",
                BAD_CAST (name ? name : "<null>"), NULL);
        /*
         * TODO: We could recover from errors in external entities
         * if we didn't stop the parser. But most callers of this
         * function don't check the return value.
         */
        xmlStopParser(ctxt);
        return(-1);
    }
 
    ret = xmlSwitchInputEncoding(ctxt, ctxt->input, handler);
 
    if ((ret >= 0) && (enc == XML_CHAR_ENCODING_NONE)) {
        ctxt->input->flags &= ~XML_INPUT_HAS_ENCODING;
    }
 
    return(ret);
}

Referenced by doparse(), internal_parseBuffer(), xmlDetectEncoding(), and xmlNewIOInputStream().

xmlSwitchInputEncoding()

XML_DEPRECATED XMLPUBFUN int xmlSwitchInputEncoding	(	xmlParserCtxtPtr	ctxt,
		xmlParserInputPtr	input,
		xmlCharEncodingHandlerPtr	handler
	)

xmlSwitchInputEncoding: @ctxt: the parser context @input: the input stream @handler: the encoding handler

DEPRECATED: Internal function, don't use.

Use encoding handler to decode input data.

Returns 0 in case of success, -1 otherwise

Definition at line 1206 of file parserInternals.c.

{
    int nbchars;
    xmlParserInputBufferPtr in;
 
    if ((input == NULL) || (input->buf == NULL)) {
        xmlCharEncCloseFunc(handler);
    return (-1);
    }
    in = input->buf;
 
    input->flags |= XML_INPUT_HAS_ENCODING;
 
    /*
     * UTF-8 requires no encoding handler.
     */
    if ((handler != NULL) &&
        (xmlStrcasecmp(BAD_CAST handler->name, BAD_CAST "UTF-8") == 0)) {
        xmlCharEncCloseFunc(handler);
        handler = NULL;
    }
 
    if (in->encoder == handler)
        return (0);
 
    if (in->encoder != NULL) {
        /*
         * Switching encodings during parsing is a really bad idea,
         * but Chromium can switch between ISO-8859-1 and UTF-16 before
         * separate calls to xmlParseChunk.
         *
         * TODO: We should check whether the "raw" input buffer is empty and
         * convert the old content using the old encoder.
         */
 
        xmlCharEncCloseFunc(in->encoder);
        in->encoder = handler;
        return (0);
    }
 
    in->encoder = handler;
 
    /*
     * Is there already some content down the pipe to convert ?
     */
    if (xmlBufIsEmpty(in->buffer) == 0) {
        size_t processed;
 
        /*
         * Shrink the current input buffer.
         * Move it as the raw buffer and create a new input buffer
         */
        processed = input->cur - input->base;
        xmlBufShrink(in->buffer, processed);
        input->consumed += processed;
        in->raw = in->buffer;
        in->buffer = xmlBufCreate();
        in->rawconsumed = processed;
 
        nbchars = xmlCharEncInput(in);
        xmlBufResetInput(in->buffer, input);
        if (nbchars < 0) {
            /* TODO: This could be an out of memory or an encoding error. */
            xmlErrInternal(ctxt,
                           "switching encoding: encoder error\n",
                           NULL);
            xmlHaltParser(ctxt);
            return (-1);
        }
    }
    return (0);
}

Referenced by xmlSwitchEncoding(), and xmlSwitchToEncoding().

xmlSwitchToEncoding()

XMLPUBFUN int xmlSwitchToEncoding	(	xmlParserCtxtPtr	ctxt,
		xmlCharEncodingHandlerPtr	handler
	)

xmlSwitchToEncoding: @ctxt: the parser context @handler: the encoding handler

Use encoding handler to decode input data.

This function can be used to enforce the encoding of chunks passed to xmlParseChunk.

Returns 0 in case of success, -1 otherwise

Definition at line 1293 of file parserInternals.c.

{
    if (ctxt == NULL)
        return(-1);
    return(xmlSwitchInputEncoding(ctxt, ctxt->input, handler));
}

Referenced by xmlCtxtResetPush(), xmlDoRead(), xmlParseInNodeContext(), and xmlSetDeclaredEncoding().

Variable Documentation

xmlParserMaxDepth

XMLPUBVAR unsigned int xmlParserMaxDepth

xmlParserMaxDepth:

arbitrary depth limit for the XML documents that we allow to process. This is not a limitation of the parser but a safety boundary feature, use XML_PARSE_HUGE option to override it.

Definition at line 32 of file parserInternals.h.

xmlStringComment

XMLPUBVAR const xmlChar xmlStringComment[]

Definition at line 294 of file parserInternals.h.

xmlStringText

XMLPUBVAR const xmlChar xmlStringText[]

Global variables used for predefined strings.

Definition at line 292 of file parserInternals.h.

Referenced by xmlSAX2Text(), xmlSAX2TextNode(), and xsltCopyTextString().

xmlStringTextNoenc

XMLPUBVAR const xmlChar xmlStringTextNoenc[]

Definition at line 293 of file parserInternals.h.

Referenced by xsltApplySequenceConstructor(), xsltAttribute(), xsltCopyText(), xsltCopyTextString(), xsltCopyTree(), xsltParseTemplateContent(), and xsltText().