parserInternals.h File Reference

#include <libxml/xmlversion.h>
#include <libxml/parser.h>
#include <libxml/HTMLparser.h>
#include <libxml/chvalid.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_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	SKIP_EOL(p)
#define	MOVETO_ENDTAG(p)   while ((*p) && (*(p) != '>')) (p)++
#define	MOVETO_STARTTAG(p)   while ((*p) && (*(p) != '<')) (p)++
#define	XML_SUBSTITUTE_NONE   0
#define	XML_SUBSTITUTE_REF   1
#define	XML_SUBSTITUTE_PEREF   2
#define	XML_SUBSTITUTE_BOTH   3

Functions
XMLPUBFUN int XMLCALL	xmlIsLetter (int c)
XMLPUBFUN xmlParserCtxtPtr XMLCALL	xmlCreateFileParserCtxt (const char *filename)
XMLPUBFUN xmlParserCtxtPtr XMLCALL	xmlCreateURLParserCtxt (const char *filename, int options)
XMLPUBFUN xmlParserCtxtPtr XMLCALL	xmlCreateMemoryParserCtxt (const char *buffer, int size)
XMLPUBFUN xmlParserCtxtPtr XMLCALL	xmlCreateEntityParserCtxt (const xmlChar *URL, const xmlChar *ID, const xmlChar *base)
XMLPUBFUN int XMLCALL	xmlSwitchEncoding (xmlParserCtxtPtr ctxt, xmlCharEncoding enc)
XMLPUBFUN int XMLCALL	xmlSwitchToEncoding (xmlParserCtxtPtr ctxt, xmlCharEncodingHandlerPtr handler)
XML_DEPRECATED XMLPUBFUN int XMLCALL	xmlSwitchInputEncoding (xmlParserCtxtPtr ctxt, xmlParserInputPtr input, xmlCharEncodingHandlerPtr handler)
XMLPUBFUN xmlParserInputPtr XMLCALL	xmlNewStringInputStream (xmlParserCtxtPtr ctxt, const xmlChar *buffer)
XMLPUBFUN xmlParserInputPtr XMLCALL	xmlNewEntityInputStream (xmlParserCtxtPtr ctxt, xmlEntityPtr entity)
XMLPUBFUN int XMLCALL	xmlPushInput (xmlParserCtxtPtr ctxt, xmlParserInputPtr input)
XMLPUBFUN xmlChar XMLCALL	xmlPopInput (xmlParserCtxtPtr ctxt)
XMLPUBFUN void XMLCALL	xmlFreeInputStream (xmlParserInputPtr input)
XMLPUBFUN xmlParserInputPtr XMLCALL	xmlNewInputFromFile (xmlParserCtxtPtr ctxt, const char *filename)
XMLPUBFUN xmlParserInputPtr XMLCALL	xmlNewInputStream (xmlParserCtxtPtr ctxt)
XMLPUBFUN xmlChar *XMLCALL	xmlSplitQName (xmlParserCtxtPtr ctxt, const xmlChar *name, xmlChar **prefix)
XMLPUBFUN const xmlChar *XMLCALL	xmlParseName (xmlParserCtxtPtr ctxt)
XMLPUBFUN xmlChar *XMLCALL	xmlParseNmtoken (xmlParserCtxtPtr ctxt)
XMLPUBFUN xmlChar *XMLCALL	xmlParseEntityValue (xmlParserCtxtPtr ctxt, xmlChar **orig)
XMLPUBFUN xmlChar *XMLCALL	xmlParseAttValue (xmlParserCtxtPtr ctxt)
XMLPUBFUN xmlChar *XMLCALL	xmlParseSystemLiteral (xmlParserCtxtPtr ctxt)
XMLPUBFUN xmlChar *XMLCALL	xmlParsePubidLiteral (xmlParserCtxtPtr ctxt)
XMLPUBFUN void XMLCALL	xmlParseCharData (xmlParserCtxtPtr ctxt, int cdata)
XMLPUBFUN xmlChar *XMLCALL	xmlParseExternalID (xmlParserCtxtPtr ctxt, xmlChar **publicID, int strict)
XMLPUBFUN void XMLCALL	xmlParseComment (xmlParserCtxtPtr ctxt)
XMLPUBFUN const xmlChar *XMLCALL	xmlParsePITarget (xmlParserCtxtPtr ctxt)
XMLPUBFUN void XMLCALL	xmlParsePI (xmlParserCtxtPtr ctxt)
XMLPUBFUN void XMLCALL	xmlParseNotationDecl (xmlParserCtxtPtr ctxt)
XMLPUBFUN void XMLCALL	xmlParseEntityDecl (xmlParserCtxtPtr ctxt)
XMLPUBFUN int XMLCALL	xmlParseDefaultDecl (xmlParserCtxtPtr ctxt, xmlChar **value)
XMLPUBFUN xmlEnumerationPtr XMLCALL	xmlParseNotationType (xmlParserCtxtPtr ctxt)
XMLPUBFUN xmlEnumerationPtr XMLCALL	xmlParseEnumerationType (xmlParserCtxtPtr ctxt)
XMLPUBFUN int XMLCALL	xmlParseEnumeratedType (xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree)
XMLPUBFUN int XMLCALL	xmlParseAttributeType (xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree)
XMLPUBFUN void XMLCALL	xmlParseAttributeListDecl (xmlParserCtxtPtr ctxt)
XMLPUBFUN xmlElementContentPtr XMLCALL	xmlParseElementMixedContentDecl (xmlParserCtxtPtr ctxt, int inputchk)
XMLPUBFUN xmlElementContentPtr XMLCALL	xmlParseElementChildrenContentDecl (xmlParserCtxtPtr ctxt, int inputchk)
XMLPUBFUN int XMLCALL	xmlParseElementContentDecl (xmlParserCtxtPtr ctxt, const xmlChar *name, xmlElementContentPtr *result)
XMLPUBFUN int XMLCALL	xmlParseElementDecl (xmlParserCtxtPtr ctxt)
XMLPUBFUN void XMLCALL	xmlParseMarkupDecl (xmlParserCtxtPtr ctxt)
XMLPUBFUN int XMLCALL	xmlParseCharRef (xmlParserCtxtPtr ctxt)
XMLPUBFUN xmlEntityPtr XMLCALL	xmlParseEntityRef (xmlParserCtxtPtr ctxt)
XMLPUBFUN void XMLCALL	xmlParseReference (xmlParserCtxtPtr ctxt)
XMLPUBFUN void XMLCALL	xmlParsePEReference (xmlParserCtxtPtr ctxt)
XMLPUBFUN void XMLCALL	xmlParseDocTypeDecl (xmlParserCtxtPtr ctxt)
XMLPUBFUN void XMLCALL	xmlParseCDSect (xmlParserCtxtPtr ctxt)
XMLPUBFUN void XMLCALL	xmlParseContent (xmlParserCtxtPtr ctxt)
XMLPUBFUN void XMLCALL	xmlParseElement (xmlParserCtxtPtr ctxt)
XMLPUBFUN xmlChar *XMLCALL	xmlParseVersionNum (xmlParserCtxtPtr ctxt)
XMLPUBFUN xmlChar *XMLCALL	xmlParseVersionInfo (xmlParserCtxtPtr ctxt)
XMLPUBFUN xmlChar *XMLCALL	xmlParseEncName (xmlParserCtxtPtr ctxt)
XMLPUBFUN const xmlChar *XMLCALL	xmlParseEncodingDecl (xmlParserCtxtPtr ctxt)
XMLPUBFUN int XMLCALL	xmlParseSDDecl (xmlParserCtxtPtr ctxt)
XMLPUBFUN void XMLCALL	xmlParseXMLDecl (xmlParserCtxtPtr ctxt)
XMLPUBFUN void XMLCALL	xmlParseTextDecl (xmlParserCtxtPtr ctxt)
XMLPUBFUN void XMLCALL	xmlParseMisc (xmlParserCtxtPtr ctxt)
XMLPUBFUN void XMLCALL	xmlParseExternalSubset (xmlParserCtxtPtr ctxt, const xmlChar *ExternalID, const xmlChar *SystemID)
XMLPUBFUN xmlChar *XMLCALL	xmlStringDecodeEntities (xmlParserCtxtPtr ctxt, const xmlChar *str, int what, xmlChar end, xmlChar end2, xmlChar end3)
XMLPUBFUN xmlChar *XMLCALL	xmlStringLenDecodeEntities (xmlParserCtxtPtr ctxt, const xmlChar *str, int len, int what, xmlChar end, xmlChar end2, xmlChar end3)
XMLPUBFUN int XMLCALL	nodePush (xmlParserCtxtPtr ctxt, xmlNodePtr value)
XMLPUBFUN xmlNodePtr XMLCALL	nodePop (xmlParserCtxtPtr ctxt)
XMLPUBFUN int XMLCALL	inputPush (xmlParserCtxtPtr ctxt, xmlParserInputPtr value)
XMLPUBFUN xmlParserInputPtr XMLCALL	inputPop (xmlParserCtxtPtr ctxt)
XMLPUBFUN const xmlChar *XMLCALL	namePop (xmlParserCtxtPtr ctxt)
XMLPUBFUN int XMLCALL	namePush (xmlParserCtxtPtr ctxt, const xmlChar *value)
XMLPUBFUN int XMLCALL	xmlSkipBlankChars (xmlParserCtxtPtr ctxt)
XMLPUBFUN int XMLCALL	xmlStringCurrentChar (xmlParserCtxtPtr ctxt, const xmlChar *cur, int *len)
XMLPUBFUN void XMLCALL	xmlParserHandlePEReference (xmlParserCtxtPtr ctxt)
XMLPUBFUN int XMLCALL	xmlCheckLanguageID (const xmlChar *lang)
XMLPUBFUN int XMLCALL	xmlCurrentChar (xmlParserCtxtPtr ctxt, int *len)
XMLPUBFUN int XMLCALL	xmlCopyCharMultiByte (xmlChar *out, int val)
XMLPUBFUN int XMLCALL	xmlCopyChar (int len, xmlChar *out, int val)
XMLPUBFUN void XMLCALL	xmlNextChar (xmlParserCtxtPtr ctxt)
XMLPUBFUN void XMLCALL	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 89 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 260 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 250 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 153 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 135 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 143 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 105 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 117 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 125 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 181 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 189 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 163 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 171 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 202 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 210 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 221 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 232 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 241 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 271 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 279 of file parserInternals.h.

MOVETO_ENDTAG

#define MOVETO_ENDTAG

(

p

)

while ((*p) && (*(p) != '>')) (p)++

MOVETO_ENDTAG: : and UTF8 string pointer

Skips to the next '>' char.

Definition at line 297 of file parserInternals.h.

MOVETO_STARTTAG

#define MOVETO_STARTTAG

(

p

)

while ((*p) && (*(p) != '<')) (p)++

MOVETO_STARTTAG: : and UTF8 string pointer

Skips to the next '<' char.

Definition at line 306 of file parserInternals.h.

SKIP_EOL

#define SKIP_EOL

(

p

)

Value:

if (*(p) == 0x13) { p++ ; if (*(p) == 0x10) p++; }          \
    if (*(p) == 0x10) { p++ ; if (*(p) == 0x13) p++; }

SKIP_EOL: : and UTF8 string pointer

Skips the end of line chars.

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 63 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 73 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 53 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 81 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 41 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 520 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 502 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 514 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 508 of file parserInternals.h.

Function Documentation

inputPop()

XMLPUBFUN xmlParserInputPtr XMLCALL 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 1774 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(), xmlInitParserCtxt(), xmlPopInput(), and xmlPushInput().

inputPush()

XMLPUBFUN int XMLCALL 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 1745 of file parser.c.

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

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

namePop()

XMLPUBFUN const xmlChar* XMLCALL namePop

(

xmlParserCtxtPtr

ctxt

)

namePop: @ctxt: an XML parser context

Pops the top element name from the name stack

Returns the name just removed

Definition at line 1981 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()

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

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

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

XMLPUBFUN xmlNodePtr XMLCALL nodePop

(

xmlParserCtxtPtr

ctxt

)

nodePop: @ctxt: an XML parser context

Pops the top element node from the node stack

Returns the node just removed

Definition at line 1839 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()

XMLPUBFUN int XMLCALL nodePush	(	xmlParserCtxtPtr	ctxt,
		xmlNodePtr	value
	)

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

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

XMLPUBFUN int XMLCALL xmlCheckLanguageID

(

const xmlChar *

lang

)

xmlCheckLanguageID: @lang: pointer to the string value

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 1474 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 XMLCALL 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 852 of file parserInternals.c.

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

Referenced by xmlParseAttValueComplex().

xmlCopyCharMultiByte()

XMLPUBFUN int XMLCALL 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 809 of file parserInternals.c.

                                            {
    if (out == NULL) 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 = (xmlChar) val;
    return 1;
}

Referenced by xmlCopyChar(), and xsltNumberFormatDecimal().

xmlCreateEntityParserCtxt()

XMLPUBFUN xmlParserCtxtPtr XMLCALL 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 14027 of file parser.c.

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

}

xmlCreateFileParserCtxt()

XMLPUBFUN xmlParserCtxtPtr XMLCALL 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 14093 of file parser.c.

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

xmlCreateMemoryParserCtxt()

XMLPUBFUN xmlParserCtxtPtr XMLCALL 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 14339 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);

    /* TODO: xmlParserInputBufferCreateStatic, requires some serious changes */
    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 xmlCreateDocParserCtxt(), xmlParseBalancedChunkMemoryInternal(), xmlParseInNodeContext(), and xmlReadMemory().

xmlCreateURLParserCtxt()

XMLPUBFUN xmlParserCtxtPtr XMLCALL 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 14051 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, NULL);
    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()

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

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

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 542 of file parserInternals.c.

                                                {
    if ((ctxt == NULL) || (len == NULL) || (ctxt->input == NULL)) return(0);
    if (ctxt->instate == XML_PARSER_EOF)
    return(0);

    if ((*ctxt->input->cur >= 0x20) && (*ctxt->input->cur <= 0x7F)) {
        *len = 1;
        return((int) *ctxt->input->cur);
    }
    if (ctxt->charset == XML_CHAR_ENCODING_UTF8) {
    /*
     * 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
     *
     * Check for the 0x110000 limit too
     */
    const unsigned char *cur = ctxt->input->cur;
    unsigned char c;
    unsigned int val;

    c = *cur;
    if (c & 0x80) {
        if (((c & 0x40) == 0) || (c == 0xC0))
        goto encoding_error;
        if (cur[1] == 0) {
        xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
                cur = ctxt->input->cur;
            }
        if ((cur[1] & 0xc0) != 0x80)
        goto encoding_error;
        if ((c & 0xe0) == 0xe0) {
        if (cur[2] == 0) {
            xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
                    cur = ctxt->input->cur;
                }
        if ((cur[2] & 0xc0) != 0x80)
            goto encoding_error;
        if ((c & 0xf0) == 0xf0) {
            if (cur[3] == 0) {
            xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
                        cur = ctxt->input->cur;
                    }
            if (((c & 0xf8) != 0xf0) ||
            ((cur[3] & 0xc0) != 0x80))
            goto encoding_error;
            /* 4-byte code */
            *len = 4;
            val = (cur[0] & 0x7) << 18;
            val |= (cur[1] & 0x3f) << 12;
            val |= (cur[2] & 0x3f) << 6;
            val |= cur[3] & 0x3f;
            if (val < 0x10000)
            goto encoding_error;
        } else {
          /* 3-byte code */
            *len = 3;
            val = (cur[0] & 0xf) << 12;
            val |= (cur[1] & 0x3f) << 6;
            val |= cur[2] & 0x3f;
            if (val < 0x800)
            goto encoding_error;
        }
        } else {
          /* 2-byte code */
        *len = 2;
        val = (cur[0] & 0x1f) << 6;
        val |= cur[1] & 0x3f;
        if (val < 0x80)
            goto encoding_error;
        }
        if (!IS_CHAR(val)) {
            xmlErrEncodingInt(ctxt, XML_ERR_INVALID_CHAR,
                  "Char 0x%X out of allowed range\n", val);
        }
        return(val);
    } else {
        /* 1-byte code */
        *len = 1;
        if (*ctxt->input->cur == 0)
        xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
        if ((*ctxt->input->cur == 0) &&
            (ctxt->input->end > ctxt->input->cur)) {
            xmlErrEncodingInt(ctxt, XML_ERR_INVALID_CHAR,
                  "Char 0x0 out of allowed range\n", 0);
        }
        if (*ctxt->input->cur == 0xD) {
        if (ctxt->input->cur[1] == 0xA) {
            ctxt->input->cur++;
        }
        return(0xA);
        }
        return((int) *ctxt->input->cur);
    }
    }
    /*
     * Assume it's a fixed length encoding (1) with
     * a compatible encoding for the ASCII set, since
     * XML constructs only use < 128 chars
     */
    *len = 1;
    if (*ctxt->input->cur == 0xD) {
    if (ctxt->input->cur[1] == 0xA) {
        ctxt->input->cur++;
    }
    return(0xA);
    }
    return((int) *ctxt->input->cur);
encoding_error:
    /*
     * 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 to indicate an end of stream problem
     */
    if (ctxt->input->end - ctxt->input->cur < 4) {
    *len = 0;
    return(0);
    }

    /*
     * If we detect an UTF8 error that probably mean that the
     * input encoding didn't get properly advertised in the
     * declaration header. Report the error and switch the encoding
     * to ISO-Latin-1 (if you don't like this policy, just declare the
     * encoding !)
     */
    {
        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->charset = XML_CHAR_ENCODING_8859_1;
    *len = 1;
    return((int) *ctxt->input->cur);
}

xmlFreeInputStream()

XMLPUBFUN void XMLCALL xmlFreeInputStream

(

xmlParserInputPtr

input

)

xmlFreeInputStream: @input: an xmlParserInputPtr

Free up an input stream.

Definition at line 1192 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->encoding != NULL) xmlFree((char *) input->encoding);
    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(), xmlInitParserCtxt(), xmlLoadEntityContent(), xmlParsePEReference(), xmlPopInput(), xmlPushInput(), and xmlSAX2ExternalSubset().

xmlIsLetter()

XMLPUBFUN int XMLCALL 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 213 of file parserInternals.c.

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

xmlNewEntityInputStream()

XMLPUBFUN xmlParserInputPtr XMLCALL xmlNewEntityInputStream	(	xmlParserCtxtPtr	ctxt,
		xmlEntityPtr	entity
	)

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

Create a new input stream based on an xmlEntityPtr

Returns the new input stream or NULL

Definition at line 1283 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:
        return(xmlLoadExternalEntity((char *) entity->URI,
               (char *) entity->ExternalID, ctxt));
            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];
    return(input);
}

Referenced by xmlLoadEntityContent(), and xmlParsePEReference().

xmlNewInputFromFile()

XMLPUBFUN xmlParserInputPtr XMLCALL 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 1379 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 XMLCALL 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 1215 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;
    input->standalone = -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)
        input->id = ctxt->input_id++;

    return(input);
}

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

xmlNewStringInputStream()

XMLPUBFUN xmlParserInputPtr XMLCALL 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 1346 of file parserInternals.c.

                                                                      {
    xmlParserInputPtr input;

    if (buffer == NULL) {
        xmlErrInternal(ctxt, "xmlNewStringInputStream string = NULL\n",
                   NULL);
    return(NULL);
    }
    if (xmlParserDebugEntities)
    xmlGenericError(xmlGenericErrorContext,
        "new fixed input: %.30s\n", buffer);
    input = xmlNewInputStream(ctxt);
    if (input == NULL) {
        xmlErrMemory(ctxt,  "couldn't allocate a new input stream\n");
    return(NULL);
    }
    input->base = buffer;
    input->cur = buffer;
    input->length = xmlStrlen(buffer);
    input->end = &buffer[input->length];
    return(input);
}

xmlNextChar()

XMLPUBFUN void XMLCALL xmlNextChar

(

xmlParserCtxtPtr

ctxt

)

xmlNextChar: @ctxt: the XML parser context

Skip to the next char input char.

Definition at line 380 of file parserInternals.c.

{
    if ((ctxt == NULL) || (ctxt->instate == XML_PARSER_EOF) ||
        (ctxt->input == NULL))
        return;

    if (!(VALID_CTXT(ctxt))) {
        xmlErrInternal(ctxt, "Parser input data memory error\n", NULL);
    ctxt->errNo = XML_ERR_INTERNAL_ERROR;
        xmlStopParser(ctxt);
    return;
    }

    if ((*ctxt->input->cur == 0) &&
        (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) {
        return;
    }

    if (ctxt->charset == XML_CHAR_ENCODING_UTF8) {
        const unsigned char *cur;
        unsigned char c;

        /*
         *   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 (*(ctxt->input->cur) == '\n') {
            ctxt->input->line++; ctxt->input->col = 1;
        } else
            ctxt->input->col++;

        /*
         * 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
         *
         * Check for the 0x110000 limit too
         */
        cur = ctxt->input->cur;

        c = *cur;
        if (c & 0x80) {
            if (c == 0xC0)
            goto encoding_error;
            if (cur[1] == 0) {
                xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
                cur = ctxt->input->cur;
            }
            if ((cur[1] & 0xc0) != 0x80)
                goto encoding_error;
            if ((c & 0xe0) == 0xe0) {
                unsigned int val;

                if (cur[2] == 0) {
                    xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
                    cur = ctxt->input->cur;
                }
                if ((cur[2] & 0xc0) != 0x80)
                    goto encoding_error;
                if ((c & 0xf0) == 0xf0) {
                    if (cur[3] == 0) {
                        xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
                        cur = ctxt->input->cur;
                    }
                    if (((c & 0xf8) != 0xf0) ||
                        ((cur[3] & 0xc0) != 0x80))
                        goto encoding_error;
                    /* 4-byte code */
                    ctxt->input->cur += 4;
                    val = (cur[0] & 0x7) << 18;
                    val |= (cur[1] & 0x3f) << 12;
                    val |= (cur[2] & 0x3f) << 6;
                    val |= cur[3] & 0x3f;
                } else {
                    /* 3-byte code */
                    ctxt->input->cur += 3;
                    val = (cur[0] & 0xf) << 12;
                    val |= (cur[1] & 0x3f) << 6;
                    val |= cur[2] & 0x3f;
                }
                if (((val > 0xd7ff) && (val < 0xe000)) ||
                    ((val > 0xfffd) && (val < 0x10000)) ||
                    (val >= 0x110000)) {
        xmlErrEncodingInt(ctxt, XML_ERR_INVALID_CHAR,
                  "Char 0x%X out of allowed range\n",
                  val);
                }
            } else
                /* 2-byte code */
                ctxt->input->cur += 2;
        } else
            /* 1-byte code */
            ctxt->input->cur++;
    } else {
        /*
         * Assume it's a fixed length encoding (1) with
         * a compatible encoding for the ASCII set, since
         * XML constructs only use < 128 chars
         */

        if (*(ctxt->input->cur) == '\n') {
            ctxt->input->line++; ctxt->input->col = 1;
        } else
            ctxt->input->col++;
        ctxt->input->cur++;
    }
    if (*ctxt->input->cur == 0)
        xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
    return;
encoding_error:
    /*
     * If we detect an UTF8 error that probably mean that the
     * input encoding didn't get properly advertised in the
     * declaration header. Report the error and switch the encoding
     * to ISO-Latin-1 (if you don't like this policy, just declare the
     * encoding !)
     */
    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->charset = XML_CHAR_ENCODING_8859_1;
    ctxt->input->cur++;
    return;
}

xmlParseAttributeListDecl()

XMLPUBFUN void XMLCALL xmlParseAttributeListDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseAttributeListDecl: @ctxt: an XML parser context

: parse the Attribute list def for an element

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

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

Definition at line 5976 of file parser.c.

                                                 {
    const xmlChar *elemName;
    const xmlChar *attrName;
    xmlEnumerationPtr tree;

    if (CMP9(CUR_PTR, '<', '!', 'A', 'T', 'T', 'L', 'I', 'S', 'T')) {
    int inputid = ctxt->input->id;

    SKIP(9);
    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()

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

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

parse the Attribute list def for an element

[54] AttType ::= StringType | TokenizedType | EnumeratedType

[55] StringType ::= 'CDATA'

[56] TokenizedType ::= 'ID' | 'IDREF' | 'IDREFS' | 'ENTITY' | 'ENTITIES' | 'NMTOKEN' | 'NMTOKENS'

Validity constraints for attribute values syntax are checked in xmlValidateAttributeValue()

[ VC: ID ] Values of type ID must match the Name production. A name must not appear more than once in an XML document as a value of this type; i.e., ID values must uniquely identify the elements which bear them.

[ VC: One ID per Element Type ] No element type may have more than one ID attribute specified.

[ VC: ID Attribute Default ] An ID attribute must have a declared default of #IMPLIED or #REQUIRED.

[ VC: IDREF ] Values of type IDREF must match the Name production, and values of type IDREFS must match Names; each IDREF Name must match the value of an ID attribute on some element in the XML document; i.e. IDREF values must match the value of some ID attribute.

[ VC: Entity Name ] Values of type ENTITY must match the Name production, values of type ENTITIES must match Names; each Entity Name must match the name of an unparsed entity declared in the DTD.

[ VC: Name Token ] Values of type NMTOKEN must match the Nmtoken production; values of type NMTOKENS must match Nmtokens.

Returns the attribute type

Definition at line 5934 of file parser.c.

                                                                      {
    SHRINK;
    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()

XMLPUBFUN xmlChar* XMLCALL xmlParseAttValue

(

xmlParserCtxtPtr

ctxt

)

xmlParseAttValue: @ctxt: an XML parser context

parse a value for an attribute Note: the parser won't do substitution of entities here, this will be handled later in xmlStringGetNodeList

[10] AttValue ::= '"' ([^<&"] | Reference)* '"' | "'" ([^<&'] | Reference)* "'"

3.3.3 Attribute-Value Normalization: Before the value of an attribute is passed to the application or checked for validity, the XML processor must normalize it as follows:

• a character reference is processed by appending the referenced character to the attribute value
• an entity reference is processed by recursively processing the replacement text of the entity
• a whitespace character (#x20, #xD, #xA, #x9) is processed by appending #x20 to the normalized value, except that only a single #x20 is appended for a "#xD#xA" sequence that is part of an external parsed entity or the literal entity value of an internal parsed entity
• other characters are processed by appending them to the normalized value If the declared value is not CDATA, then the XML processor must further process the normalized attribute value by discarding any leading and trailing space (#x20) characters, and by replacing sequences of space (#x20) characters by a single space (#x20) character. All attributes for which no declaration has been read should be treated by a non-validating parser as if declared CDATA.

Returns the AttValue parsed or NULL. The value has to be freed by the caller.

Definition at line 4182 of file parser.c.

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

Referenced by xmlParseDefaultDecl().

xmlParseCDSect()

XMLPUBFUN void XMLCALL xmlParseCDSect

(

xmlParserCtxtPtr

ctxt

)

xmlParseCDSect: @ctxt: an XML parser context

Parse escaped pure raw content.

[18] CDSect ::= CDStart CData CDEnd

[19] CDStart ::= ''

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

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

Definition at line 9765 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 count = 0;
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
                    XML_MAX_HUGE_LENGTH :
                    XML_MAX_TEXT_LENGTH;

    /* Check 2.6.0 was NXT(0) not RAW */
    if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) {
    SKIP(9);
    } else
        return;

    ctxt->instate = XML_PARSER_CDATA_SECTION;
    r = CUR_CHAR(rl);
    if (!IS_CHAR(r)) {
    xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
    ctxt->instate = XML_PARSER_CONTENT;
        return;
    }
    NEXTL(rl);
    s = CUR_CHAR(sl);
    if (!IS_CHAR(s)) {
    xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
    ctxt->instate = XML_PARSER_CONTENT;
        return;
    }
    NEXTL(sl);
    cur = CUR_CHAR(l);
    buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
    if (buf == NULL) {
    xmlErrMemory(ctxt, NULL);
    return;
    }
    while (IS_CHAR(cur) &&
           ((r != ']') || (s != ']') || (cur != '>'))) {
    if (len + 5 >= size) {
        xmlChar *tmp;

        tmp = (xmlChar *) xmlRealloc(buf, size * 2 * sizeof(xmlChar));
        if (tmp == NULL) {
            xmlFree(buf);
        xmlErrMemory(ctxt, NULL);
        return;
        }
        buf = tmp;
        size *= 2;
    }
    COPY_BUF(rl,buf,len,r);
    r = s;
    rl = sl;
    s = cur;
    sl = l;
    count++;
    if (count > 50) {
        SHRINK;
        GROW;
            if (ctxt->instate == XML_PARSER_EOF) {
        xmlFree(buf);
        return;
            }
        count = 0;
    }
    NEXTL(l);
    cur = CUR_CHAR(l);
        if (len > maxLength) {
            xmlFatalErrMsg(ctxt, XML_ERR_CDATA_NOT_FINISHED,
                           "CData section too big found\n");
            xmlFree(buf);
            return;
        }
    }
    buf[len] = 0;
    ctxt->instate = XML_PARSER_CONTENT;
    if (cur != '>') {
    xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED,
                         "CData section not finished\n%.50s\n", buf);
    xmlFree(buf);
        return;
    }
    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);
    }
    xmlFree(buf);
}

Referenced by xmlParseContentInternal().

xmlParseCharData()

XMLPUBFUN void XMLCALL xmlParseCharData	(	xmlParserCtxtPtr	ctxt,
		int	cdata
	)

xmlParseCharData: @ctxt: an XML parser context @cdata: int indicating whether we are within a CDATA section

parse a CharData section. if we are within a CDATA section ']]>' marks an end of section.

The right angle bracket (>) may be represented using the string "&gt;", and must, for compatibility, be escaped using "&gt;" or a character reference when it appears in the string "]]>" in content, when that string is not marking the end of a CDATA section.

[14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)

Definition at line 4425 of file parser.c.

                                                   {
    const xmlChar *in;
    int nbchar = 0;
    int line = ctxt->input->line;
    int col = ctxt->input->col;
    int ccol;

    SHRINK;
    GROW;
    /*
     * Accelerated common case where input don't need to be
     * modified before passing it to the handler.
     */
    if (!cdata) {
    in = ctxt->input->cur;
    do {
get_more_space:
        while (*in == 0x20) { in++; ctxt->input->col++; }
        if (*in == 0xA) {
        do {
            ctxt->input->line++; ctxt->input->col = 1;
            in++;
        } while (*in == 0xA);
        goto get_more_space;
        }
        if (*in == '<') {
        nbchar = in - ctxt->input->cur;
        if (nbchar > 0) {
            const xmlChar *tmp = ctxt->input->cur;
            ctxt->input->cur = in;

            if ((ctxt->sax != NULL) &&
                (ctxt->sax->ignorableWhitespace !=
                 ctxt->sax->characters)) {
            if (areBlanks(ctxt, tmp, nbchar, 1)) {
                if (ctxt->sax->ignorableWhitespace != NULL)
                ctxt->sax->ignorableWhitespace(ctxt->userData,
                               tmp, nbchar);
            } else {
                if (ctxt->sax->characters != NULL)
                ctxt->sax->characters(ctxt->userData,
                              tmp, nbchar);
                if (*ctxt->space == -1)
                    *ctxt->space = -2;
            }
            } else if ((ctxt->sax != NULL) &&
                       (ctxt->sax->characters != NULL)) {
            ctxt->sax->characters(ctxt->userData,
                          tmp, nbchar);
            }
        }
        return;
        }

get_more:
            ccol = ctxt->input->col;
        while (test_char_data[*in]) {
        in++;
        ccol++;
        }
        ctxt->input->col = ccol;
        if (*in == 0xA) {
        do {
            ctxt->input->line++; ctxt->input->col = 1;
            in++;
        } while (*in == 0xA);
        goto get_more;
        }
        if (*in == ']') {
        if ((in[1] == ']') && (in[2] == '>')) {
            xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
            ctxt->input->cur = in + 1;
            return;
        }
        in++;
        ctxt->input->col++;
        goto get_more;
        }
        nbchar = in - ctxt->input->cur;
        if (nbchar > 0) {
        if ((ctxt->sax != NULL) &&
            (ctxt->sax->ignorableWhitespace !=
             ctxt->sax->characters) &&
            (IS_BLANK_CH(*ctxt->input->cur))) {
            const xmlChar *tmp = ctxt->input->cur;
            ctxt->input->cur = in;

            if (areBlanks(ctxt, tmp, nbchar, 0)) {
                if (ctxt->sax->ignorableWhitespace != NULL)
                ctxt->sax->ignorableWhitespace(ctxt->userData,
                               tmp, nbchar);
            } else {
                if (ctxt->sax->characters != NULL)
                ctxt->sax->characters(ctxt->userData,
                          tmp, nbchar);
            if (*ctxt->space == -1)
                *ctxt->space = -2;
            }
                    line = ctxt->input->line;
                    col = ctxt->input->col;
        } else if (ctxt->sax != NULL) {
            if (ctxt->sax->characters != NULL)
            ctxt->sax->characters(ctxt->userData,
                          ctxt->input->cur, nbchar);
                    line = ctxt->input->line;
                    col = ctxt->input->col;
        }
                /* something really bad happened in the SAX callback */
                if (ctxt->instate != XML_PARSER_CONTENT)
                    return;
        }
        ctxt->input->cur = in;
        if (*in == 0xD) {
        in++;
        if (*in == 0xA) {
            ctxt->input->cur = in;
            in++;
            ctxt->input->line++; ctxt->input->col = 1;
            continue; /* while */
        }
        in--;
        }
        if (*in == '<') {
        return;
        }
        if (*in == '&') {
        return;
        }
        SHRINK;
        GROW;
            if (ctxt->instate == XML_PARSER_EOF)
        return;
        in = ctxt->input->cur;
    } while (((*in >= 0x20) && (*in <= 0x7F)) || (*in == 0x09) || (*in == 0x0a));
    nbchar = 0;
    }
    ctxt->input->line = line;
    ctxt->input->col = col;
    xmlParseCharDataComplex(ctxt, cdata);
}

Referenced by xmlParseContentInternal().

xmlParseCharRef()

XMLPUBFUN int XMLCALL xmlParseCharRef

(

xmlParserCtxtPtr

ctxt

)

xmlParseCharRef: @ctxt: an XML parser context

parse Reference declarations

[66] CharRef ::= '&#' [0-9]+ ';' | '&x' [0-9a-fA-F]+ ';'

[ WFC: Legal Character ] Characters referred to using character references must match the production for Char.

Returns the value parsed (as an int), 0 in case of error

Definition at line 2332 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 {
        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()

XMLPUBFUN void XMLCALL xmlParseComment

(

xmlParserCtxtPtr

ctxt

)

xmlParseComment: @ctxt: an XML parser context

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

[15] Comment ::= ''

Definition at line 4888 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) != '!') ||
        (NXT(2) != '-') || (NXT(3) != '-')) return;
    state = ctxt->instate;
    ctxt->instate = XML_PARSER_COMMENT;
    inputid = ctxt->input->id;
    SKIP(4);
    SHRINK;
    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 ((ctxt->sax != NULL) &&
        (ctxt->sax->comment != NULL)) {
        if (buf == NULL) {
            if ((*in == '-') && (in[1] == '-'))
                size = nbchar + 1;
            else
                size = XML_PARSER_BUFFER_SIZE + nbchar;
            buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
            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 * sizeof(xmlChar));
            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 XMLCALL 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 9958 of file parser.c.

                                       {
    int nameNr = ctxt->nameNr;

    xmlParseContentInternal(ctxt);

    if ((ctxt->instate != XML_PARSER_EOF) && (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()

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

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

Parse an attribute default declaration

[60] DefaultDecl ::= '#REQUIRED' | '#IMPLIED' | (('FIXED' S)? AttValue)

[ VC: Required Attribute ] if the default declaration is the keyword #REQUIRED, then the attribute must be specified for all elements of the type in the attribute-list declaration.

[ VC: Attribute Default Legal ] The declared default value must meet the lexical constraints of the declared attribute type c.f. xmlValidateAttributeDecl()

[ VC: Fixed Attribute Default ] if an attribute has a default value declared with the FIXED keyword, instances of that attribute must match the default value.

[ WFC: No < in Attribute Values ] handled in xmlParseAttValue()

returns: XML_ATTRIBUTE_NONE, XML_ATTRIBUTE_REQUIRED, XML_ATTRIBUTE_IMPLIED or XML_ATTRIBUTE_FIXED.

Definition at line 5682 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()

XMLPUBFUN void XMLCALL xmlParseDocTypeDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseDocTypeDecl: @ctxt: an XML parser context

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

XMLPUBFUN void XMLCALL xmlParseElement

(

xmlParserCtxtPtr

ctxt

)

xmlParseElement: @ctxt: an XML parser context

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 9987 of file parser.c.

                                       {
    if (xmlParseElementStart(ctxt) != 0)
        return;

    xmlParseContentInternal(ctxt);
    if (ctxt->instate == XML_PARSER_EOF)
    return;

    if (CUR == 0) {
        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()

XMLPUBFUN xmlElementContentPtr XMLCALL xmlParseElementChildrenContentDecl	(	xmlParserCtxtPtr	ctxt,
		int	inputchk
	)

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

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 6533 of file parser.c.

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

xmlParseElementContentDecl()

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

Definition at line 6553 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()

XMLPUBFUN int XMLCALL xmlParseElementDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseElementDecl: @ctxt: an XML parser context

parse an Element declaration.

[45] elementdecl ::= '<!ELEMENT' S Name S contentspec S? '>'

[ VC: Unique Element Type Declaration ] No element type may be declared more than once

Returns the type of the element, or -1 in case of error

Definition at line 6598 of file parser.c.

                                           {
    const xmlChar *name;
    int ret = -1;
    xmlElementContentPtr content  = NULL;

    /* GROW; done in the caller */
    if (CMP9(CUR_PTR, '<', '!', 'E', 'L', 'E', 'M', 'E', 'N', 'T')) {
    int inputid = ctxt->input->id;

    SKIP(9);
    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()

XMLPUBFUN xmlElementContentPtr XMLCALL xmlParseElementMixedContentDecl	(	xmlParserCtxtPtr	ctxt,
		int	inputchk
	)

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

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 6104 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;
    SHRINK;
    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()

XMLPUBFUN xmlChar* XMLCALL xmlParseEncName

(

xmlParserCtxtPtr

ctxt

)

xmlParseEncName: @ctxt: an XML parser context

parse the XML encoding name

[81] EncName ::= A-Za-z*

Returns the encoding name value or NULL

Definition at line 10293 of file parser.c.

                                       {
    xmlChar *buf = NULL;
    int len = 0;
    int size = 10;
    xmlChar cur;

    cur = CUR;
    if (((cur >= 'a') && (cur <= 'z')) ||
        ((cur >= 'A') && (cur <= 'Z'))) {
    buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
    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 * sizeof(xmlChar));
        if (tmp == NULL) {
            xmlErrMemory(ctxt, NULL);
            xmlFree(buf);
            return(NULL);
        }
        buf = tmp;
        }
        buf[len++] = cur;
        NEXT;
        cur = CUR;
        if (cur == 0) {
            SHRINK;
        GROW;
        cur = CUR;
        }
        }
    buf[len] = 0;
    } else {
    xmlFatalErr(ctxt, XML_ERR_ENCODING_NAME, NULL);
    }
    return(buf);
}

Referenced by xmlParseEncodingDecl().

xmlParseEncodingDecl()

XMLPUBFUN const xmlChar* XMLCALL xmlParseEncodingDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseEncodingDecl: @ctxt: an XML parser context

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 10358 of file parser.c.

                                            {
    xmlChar *encoding = NULL;

    SKIP_BLANKS;
    if (CMP8(CUR_PTR, 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g')) {
    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);
    }

        /*
         * Non standard parsing, allowing the user to ignore encoding
         */
        if (ctxt->options & XML_PARSE_IGNORE_ENC) {
        xmlFree((xmlChar *) encoding);
            return(NULL);
    }

    /*
     * UTF-16 encoding switch has already taken place at this stage,
     * more over the little-endian/big-endian selection is already done
     */
        if ((encoding != NULL) &&
        ((!xmlStrcasecmp(encoding, BAD_CAST "UTF-16")) ||
         (!xmlStrcasecmp(encoding, BAD_CAST "UTF16")))) {
        /*
         * If no encoding was passed to the parser, that we are
         * using UTF-16 and no decoder is present i.e. the
         * document is apparently UTF-8 compatible, then raise an
         * encoding mismatch fatal error
         */
        if ((ctxt->encoding == NULL) &&
            (ctxt->input->buf != NULL) &&
            (ctxt->input->buf->encoder == NULL)) {
        xmlFatalErrMsg(ctxt, XML_ERR_INVALID_ENCODING,
          "Document labelled UTF-16 but has UTF-8 content\n");
        }
        if (ctxt->encoding != NULL)
        xmlFree((xmlChar *) ctxt->encoding);
        ctxt->encoding = encoding;
    }
    /*
     * UTF-8 encoding is handled natively
     */
        else if ((encoding != NULL) &&
        ((!xmlStrcasecmp(encoding, BAD_CAST "UTF-8")) ||
         (!xmlStrcasecmp(encoding, BAD_CAST "UTF8")))) {
        if (ctxt->encoding != NULL)
        xmlFree((xmlChar *) ctxt->encoding);
        ctxt->encoding = encoding;
    }
    else if (encoding != NULL) {
        xmlCharEncodingHandlerPtr handler;

        if (ctxt->input->encoding != NULL)
        xmlFree((xmlChar *) ctxt->input->encoding);
        ctxt->input->encoding = encoding;

            handler = xmlFindCharEncodingHandler((const char *) encoding);
        if (handler != NULL) {
        if (xmlSwitchToEncoding(ctxt, handler) < 0) {
            /* failed to convert */
            ctxt->errNo = XML_ERR_UNSUPPORTED_ENCODING;
            return(NULL);
        }
        } else {
        xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
            "Unsupported encoding %s\n", encoding);
        return(NULL);
        }
    }
    }
    return(encoding);
}

Referenced by xmlParseTextDecl(), and xmlParseXMLDecl().

xmlParseEntityDecl()

XMLPUBFUN void XMLCALL xmlParseEntityDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseEntityDecl: @ctxt: an XML parser context

parse <!ENTITY declarations

[70] EntityDecl ::= GEDecl | PEDecl

[71] GEDecl ::= '<!ENTITY' S Name S EntityDef S? '>'

[72] PEDecl ::= '<!ENTITY' S '' S Name S PEDef S? '>'

[73] EntityDef ::= EntityValue | (ExternalID NDataDecl?)

[74] PEDef ::= EntityValue | ExternalID

[76] NDataDecl ::= S 'NDATA' S Name

[ VC: Notation Declared ] The Name must match the declared name of a notation.

Definition at line 5409 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;

    /* GROW; done in the caller */
    if (CMP8(CUR_PTR, '<', '!', 'E', 'N', 'T', 'I', 'T', 'Y')) {
    int inputid = ctxt->input->id;
    SHRINK;
    SKIP(8);
    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");
                return;
            }
            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");
                return;
                }
                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()

XMLPUBFUN xmlEntityPtr XMLCALL xmlParseEntityRef

(