parser.c File Reference

#include "libxml.h"
#include <stdlib.h>
#include <limits.h>
#include <string.h>
#include <stdarg.h>
#include <stddef.h>
#include <ctype.h>
#include <libxml/xmlmemory.h>
#include <libxml/threads.h>
#include <libxml/globals.h>
#include <libxml/tree.h>
#include <libxml/parser.h>
#include <libxml/parserInternals.h>
#include <libxml/valid.h>
#include <libxml/entities.h>
#include <libxml/xmlerror.h>
#include <libxml/encoding.h>
#include <libxml/xmlIO.h>
#include <libxml/uri.h>
#include "buf.h"
#include "enc.h"

Include dependency graph for parser.c:

Go to the source code of this file.

Classes
struct	_xmlStartTag
struct	_xmlDefAttrs

Macros
#define	IN_LIBXML
#define	XML_DIR_SEP   '/'
#define	XML_MAX_HUGE_LENGTH   1000000000
#define	XML_PARSER_BIG_ENTITY   1000
#define	XML_PARSER_LOT_ENTITY   5000
#define	XML_PARSER_NON_LINEAR   10
#define	SAX2   1
#define	XML_PARSER_BIG_BUFFER_SIZE   300
#define	XML_PARSER_BUFFER_SIZE   100
#define	SAX_COMPAT_MODE   BAD_CAST "SAX compatibility mode document"
#define	XML_PARSER_CHUNK_SIZE   100
#define	RAW   (*ctxt->input->cur)
#define	CUR   (*ctxt->input->cur)
#define	NXT(val)   ctxt->input->cur[(val)]
#define	CUR_PTR   ctxt->input->cur
#define	BASE_PTR   ctxt->input->base
#define	CMP4(s, c1, c2, c3, c4)
#define	CMP5(s, c1, c2, c3, c4, c5)    ( CMP4( s, c1, c2, c3, c4 ) && ((unsigned char *) s)[ 4 ] == c5 )
#define	CMP6(s, c1, c2, c3, c4, c5, c6)    ( CMP5( s, c1, c2, c3, c4, c5 ) && ((unsigned char *) s)[ 5 ] == c6 )
#define	CMP7(s, c1, c2, c3, c4, c5, c6, c7)    ( CMP6( s, c1, c2, c3, c4, c5, c6 ) && ((unsigned char *) s)[ 6 ] == c7 )
#define	CMP8(s, c1, c2, c3, c4, c5, c6, c7, c8)    ( CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) && ((unsigned char *) s)[ 7 ] == c8 )
#define	CMP9(s, c1, c2, c3, c4, c5, c6, c7, c8, c9)
#define	CMP10(s, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10)
#define	SKIP(val)
#define	SKIPL(val)
#define	SHRINK
#define	GROW
#define	SKIP_BLANKS   xmlSkipBlankChars(ctxt)
#define	NEXT   xmlNextChar(ctxt)
#define	NEXT1
#define	NEXTL(l)
#define	CUR_CHAR(l)   xmlCurrentChar(ctxt, &l)
#define	CUR_SCHAR(s, l)   xmlStringCurrentChar(ctxt, s, &l)
#define	COPY_BUF(l, b, i, v)
#define	CUR_CONSUMED    (ctxt->input->consumed + (ctxt->input->cur - ctxt->input->base))
#define	growBuffer(buffer, n)

Typedefs
typedef struct _xmlDefAttrs	xmlDefAttrs
typedef xmlDefAttrs *	xmlDefAttrsPtr

Functions
static void	xmlFatalErr (xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info)
static int	xmlParserEntityCheck (xmlParserCtxtPtr ctxt, size_t size, xmlEntityPtr ent, size_t replacement)
static void	xmlErrAttributeDup (xmlParserCtxtPtr ctxt, const xmlChar *prefix, const xmlChar *localname)
static void	LIBXML_ATTR_FORMAT (3, 0)
int	xmlHasFeature (xmlFeature feature)
static void	xmlDetectSAX2 (xmlParserCtxtPtr ctxt)
static xmlChar *	xmlAttrNormalizeSpace (const xmlChar *src, xmlChar *dst)
static const xmlChar *	xmlAttrNormalizeSpace2 (xmlParserCtxtPtr ctxt, xmlChar *src, int *len)
static void	xmlAddDefAttrs (xmlParserCtxtPtr ctxt, const xmlChar *fullname, const xmlChar *fullattr, const xmlChar *value)
static void	xmlAddSpecialAttr (xmlParserCtxtPtr ctxt, const xmlChar *fullname, const xmlChar *fullattr, int type)
static void	xmlCleanSpecialAttrCallback (void *payload, void *data, const xmlChar *fullname, const xmlChar *fullattr, const xmlChar *unused ATTRIBUTE_UNUSED)
static void	xmlCleanSpecialAttr (xmlParserCtxtPtr ctxt)
int	xmlCheckLanguageID (const xmlChar *lang)
static int	nsPush (xmlParserCtxtPtr ctxt, const xmlChar *prefix, const xmlChar *URL)
static int	nsPop (xmlParserCtxtPtr ctxt, int nr)
static int	xmlCtxtGrowAttrs (xmlParserCtxtPtr ctxt, int nr)
int	inputPush (xmlParserCtxtPtr ctxt, xmlParserInputPtr value)
xmlParserInputPtr	inputPop (xmlParserCtxtPtr ctxt)
int	nodePush (xmlParserCtxtPtr ctxt, xmlNodePtr value)
xmlNodePtr	nodePop (xmlParserCtxtPtr ctxt)
static int	nameNsPush (xmlParserCtxtPtr ctxt, const xmlChar *value, const xmlChar *prefix, const xmlChar *URI, int line, int nsNr)
int	namePush (xmlParserCtxtPtr ctxt, const xmlChar *value)
const xmlChar *	namePop (xmlParserCtxtPtr ctxt)
static int	spacePush (xmlParserCtxtPtr ctxt, int val)
static int	spacePop (xmlParserCtxtPtr ctxt)
static void	xmlSHRINK (xmlParserCtxtPtr ctxt)
static void	xmlGROW (xmlParserCtxtPtr ctxt)
int	xmlSkipBlankChars (xmlParserCtxtPtr ctxt)
xmlChar	xmlPopInput (xmlParserCtxtPtr ctxt)
int	xmlPushInput (xmlParserCtxtPtr ctxt, xmlParserInputPtr input)
int	xmlParseCharRef (xmlParserCtxtPtr ctxt)
static int	xmlParseStringCharRef (xmlParserCtxtPtr ctxt, const xmlChar **str)
void	xmlParserHandlePEReference (xmlParserCtxtPtr ctxt)
xmlChar *	xmlStringLenDecodeEntities (xmlParserCtxtPtr ctxt, const xmlChar *str, int len, int what, xmlChar end, xmlChar end2, xmlChar end3)
xmlChar *	xmlStringDecodeEntities (xmlParserCtxtPtr ctxt, const xmlChar *str, int what, xmlChar end, xmlChar end2, xmlChar end3)
static int	areBlanks (xmlParserCtxtPtr ctxt, const xmlChar *str, int len, int blank_chars)
: the name of the element being defined.
xmlParseElementContentDecl: @ctxt: an XML parser context Returns : the Element Content pointer will be stored here if any parse the declaration for an Element content either Mixed or Children, the cases EMPTY and ANY are handled directly in xmlParseElementDecl [46] contentspec ::= 'EMPTY' | 'ANY' | Mixed | children returns: the type of element content XML_ELEMENT_TYPE_xxx
static xmlEntityPtr	xmlParseStringPEReference (xmlParserCtxtPtr ctxt, const xmlChar **str)
static int	xmlLoadEntityContent (xmlParserCtxtPtr ctxt, xmlEntityPtr entity)
static xmlEntityPtr	xmlParseStringEntityRef (xmlParserCtxtPtr ctxt, const xmlChar **str)
int	xmlParseElementContentDecl (xmlParserCtxtPtr ctxt, const xmlChar *name, xmlElementContentPtr *result)
int	xmlParseElementDecl (xmlParserCtxtPtr ctxt)
static void	xmlParseConditionalSections (xmlParserCtxtPtr ctxt)
void	xmlParseMarkupDecl (xmlParserCtxtPtr ctxt)
void	xmlParseTextDecl (xmlParserCtxtPtr ctxt)
void	xmlParseExternalSubset (xmlParserCtxtPtr ctxt, const xmlChar *ExternalID, const xmlChar *SystemID)
void	xmlParseReference (xmlParserCtxtPtr ctxt)
xmlEntityPtr	xmlParseEntityRef (xmlParserCtxtPtr ctxt)
void	xmlParsePEReference (xmlParserCtxtPtr ctxt)
void	xmlParseDocTypeDecl (xmlParserCtxtPtr ctxt)
static void	xmlParseInternalSubset (xmlParserCtxtPtr ctxt)
static const xmlChar *	xmlGetNamespace (xmlParserCtxtPtr ctxt, const xmlChar *prefix)
static const xmlChar *	xmlParseQName (xmlParserCtxtPtr ctxt, const xmlChar **prefix)

Variables
unsigned int	xmlParserMaxDepth = 256
static const char *const	xmlW3CPIs []

: the localname
xmlParseQNameAndCompare: @ctxt: an XML parser context @prefix: the prefix, if any. parse an XML name and compares for match (specialized for endtag parsing) Returns NULL for an illegal name, (xmlChar*) 1 for success and the name for mismatch
#define	GROW_PARSE_ATT_VALUE_INTERNAL(ctxt, in, start, end)
#define	DICT_FREE(str)
static int	xmlParserInitialized = 0
static xmlParserCtxtPtr	xmlCreateEntityParserCtxtInternal (const xmlChar *URL, const xmlChar *ID, const xmlChar *base, xmlParserCtxtPtr pctx)
static void	xmlHaltParser (xmlParserCtxtPtr ctxt)
static int	xmlParseElementStart (xmlParserCtxtPtr ctxt)
static void	xmlParseElementEnd (xmlParserCtxtPtr ctxt)
static xmlParserErrors	xmlParseExternalEntityPrivate (xmlDocPtr doc, xmlParserCtxtPtr oldctxt, xmlSAXHandlerPtr sax, void *user_data, int depth, const xmlChar *URL, const xmlChar *ID, xmlNodePtr *list)
static int	xmlCtxtUseOptionsInternal (xmlParserCtxtPtr ctxt, int options, const char *encoding)
static xmlParserErrors	xmlParseBalancedChunkMemoryInternal (xmlParserCtxtPtr oldctxt, const xmlChar *string, void *user_data, xmlNodePtr *lst)
static const xmlChar *	xmlParseQNameAndCompare (xmlParserCtxtPtr ctxt, xmlChar const *name, xmlChar const *prefix)
static const xmlChar *	xmlParseAttribute2 (xmlParserCtxtPtr ctxt, const xmlChar *pref, const xmlChar *elem, const xmlChar **prefix, xmlChar **value, int *len, int *alloc)
static const xmlChar *	xmlParseStartTag2 (xmlParserCtxtPtr ctxt, const xmlChar **pref, const xmlChar **URI, int *tlen)
static void	xmlParseEndTag2 (xmlParserCtxtPtr ctxt, const xmlStartTag *tag)
void	xmlParseCDSect (xmlParserCtxtPtr ctxt)
static void	xmlParseContentInternal (xmlParserCtxtPtr ctxt)
void	xmlParseContent (xmlParserCtxtPtr ctxt)
void	xmlParseElement (xmlParserCtxtPtr ctxt)
xmlChar *	xmlParseVersionNum (xmlParserCtxtPtr ctxt)
xmlChar *	xmlParseVersionInfo (xmlParserCtxtPtr ctxt)
xmlChar *	xmlParseEncName (xmlParserCtxtPtr ctxt)
const xmlChar *	xmlParseEncodingDecl (xmlParserCtxtPtr ctxt)
int	xmlParseSDDecl (xmlParserCtxtPtr ctxt)
void	xmlParseXMLDecl (xmlParserCtxtPtr ctxt)
void	xmlParseMisc (xmlParserCtxtPtr ctxt)
int	xmlParseDocument (xmlParserCtxtPtr ctxt)
int	xmlParseExtParsedEnt (xmlParserCtxtPtr ctxt)
void	xmlStopParser (xmlParserCtxtPtr ctxt)
xmlParserCtxtPtr	xmlCreateIOParserCtxt (xmlSAXHandlerPtr sax, void *user_data, xmlInputReadCallback ioread, xmlInputCloseCallback ioclose, void *ioctx, xmlCharEncoding enc)
int	xmlParseCtxtExternalEntity (xmlParserCtxtPtr ctx, const xmlChar *URL, const xmlChar *ID, xmlNodePtr *lst)
xmlParserErrors	xmlParseInNodeContext (xmlNodePtr node, const char *data, int datalen, int options, xmlNodePtr *lst)
xmlParserCtxtPtr	xmlCreateEntityParserCtxt (const xmlChar *URL, const xmlChar *ID, const xmlChar *base)
xmlParserCtxtPtr	xmlCreateURLParserCtxt (const char *filename, int options)
xmlParserCtxtPtr	xmlCreateFileParserCtxt (const char *filename)
xmlParserCtxtPtr	xmlCreateMemoryParserCtxt (const char *buffer, int size)
xmlParserCtxtPtr	xmlCreateDocParserCtxt (const xmlChar *cur)
void XMLCDECL	xmlGenericErrorDefaultFunc (void *ctx, const char *msg,...)
void	xmlInitParser (void)
void	xmlCleanupParser (void)
void	xmlCtxtReset (xmlParserCtxtPtr ctxt)
int	xmlCtxtResetPush (xmlParserCtxtPtr ctxt, const char *chunk, int size, const char *filename, const char *encoding)
int	xmlCtxtUseOptions (xmlParserCtxtPtr ctxt, int options)
static xmlDocPtr	xmlDoRead (xmlParserCtxtPtr ctxt, const char *URL, const char *encoding, int options, int reuse)
xmlDocPtr	xmlReadDoc (const xmlChar *cur, const char *URL, const char *encoding, int options)
xmlDocPtr	xmlReadFile (const char *filename, const char *encoding, int options)
xmlDocPtr	xmlReadMemory (const char *buffer, int size, const char *URL, const char *encoding, int options)
xmlDocPtr	xmlReadFd (int fd, const char *URL, const char *encoding, int options)
xmlDocPtr	xmlReadIO (xmlInputReadCallback ioread, xmlInputCloseCallback ioclose, void *ioctx, const char *URL, const char *encoding, int options)
xmlDocPtr	xmlCtxtReadDoc (xmlParserCtxtPtr ctxt, const xmlChar *cur, const char *URL, const char *encoding, int options)
xmlDocPtr	xmlCtxtReadFile (xmlParserCtxtPtr ctxt, const char *filename, const char *encoding, int options)
xmlDocPtr	xmlCtxtReadMemory (xmlParserCtxtPtr ctxt, const char *buffer, int size, const char *URL, const char *encoding, int options)
xmlDocPtr	xmlCtxtReadFd (xmlParserCtxtPtr ctxt, int fd, const char *URL, const char *encoding, int options)
xmlDocPtr	xmlCtxtReadIO (xmlParserCtxtPtr ctxt, xmlInputReadCallback ioread, xmlInputCloseCallback ioclose, void *ioctx, const char *URL, const char *encoding, int options)

: an XML parser context
xmlSplitQName: @ctxt: an XML parser context @prefix: a xmlChar ** parse an UTF8 encoded XML qualified name string [NS 5] QName ::= (Prefix ':')? LocalPart [NS 6] Prefix ::= NCName [NS 7] LocalPart ::= NCName Returns the local part, and prefix is updated to get the Prefix if any.
static const unsigned char	test_char_data [256]
xmlChar *	xmlSplitQName (xmlParserCtxtPtr ctxt, const xmlChar *name, xmlChar **prefix)
static int	xmlIsNameStartChar (xmlParserCtxtPtr ctxt, int c)
static int	xmlIsNameChar (xmlParserCtxtPtr ctxt, int c)
static xmlChar *	xmlParseAttValueInternal (xmlParserCtxtPtr ctxt, int *len, int *alloc, int normalize)
static const xmlChar *	xmlParseNameComplex (xmlParserCtxtPtr ctxt)
const xmlChar *	xmlParseName (xmlParserCtxtPtr ctxt)
static const xmlChar *	xmlParseNCNameComplex (xmlParserCtxtPtr ctxt)
static const xmlChar *	xmlParseNCName (xmlParserCtxtPtr ctxt)
static const xmlChar *	xmlParseNameAndCompare (xmlParserCtxtPtr ctxt, xmlChar const *other)
static xmlChar *	xmlParseStringName (xmlParserCtxtPtr ctxt, const xmlChar **str)
xmlChar *	xmlParseNmtoken (xmlParserCtxtPtr ctxt)
xmlChar *	xmlParseEntityValue (xmlParserCtxtPtr ctxt, xmlChar **orig)
static xmlChar *	xmlParseAttValueComplex (xmlParserCtxtPtr ctxt, int *attlen, int normalize)
xmlChar *	xmlParseAttValue (xmlParserCtxtPtr ctxt)
xmlChar *	xmlParseSystemLiteral (xmlParserCtxtPtr ctxt)
xmlChar *	xmlParsePubidLiteral (xmlParserCtxtPtr ctxt)
static void	xmlParseCharDataComplex (xmlParserCtxtPtr ctxt, int cdata)
void	xmlParseCharData (xmlParserCtxtPtr ctxt, int cdata)
xmlChar *	xmlParseExternalID (xmlParserCtxtPtr ctxt, xmlChar **publicID, int strict)
static void	xmlParseCommentComplex (xmlParserCtxtPtr ctxt, xmlChar *buf, size_t len, size_t size)
void	xmlParseComment (xmlParserCtxtPtr ctxt)
const xmlChar *	xmlParsePITarget (xmlParserCtxtPtr ctxt)
void	xmlParsePI (xmlParserCtxtPtr ctxt)
void	xmlParseNotationDecl (xmlParserCtxtPtr ctxt)
void	xmlParseEntityDecl (xmlParserCtxtPtr ctxt)
int	xmlParseDefaultDecl (xmlParserCtxtPtr ctxt, xmlChar **value)
xmlEnumerationPtr	xmlParseNotationType (xmlParserCtxtPtr ctxt)
xmlEnumerationPtr	xmlParseEnumerationType (xmlParserCtxtPtr ctxt)
int	xmlParseEnumeratedType (xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree)
int	xmlParseAttributeType (xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree)
void	xmlParseAttributeListDecl (xmlParserCtxtPtr ctxt)
xmlElementContentPtr	xmlParseElementMixedContentDecl (xmlParserCtxtPtr ctxt, int inputchk)
static xmlElementContentPtr	xmlParseElementChildrenContentDeclPriv (xmlParserCtxtPtr ctxt, int inputchk, int depth)
xmlElementContentPtr	xmlParseElementChildrenContentDecl (xmlParserCtxtPtr ctxt, int inputchk)

Macro Definition Documentation

BASE_PTR

#define BASE_PTR   ctxt->input->base

Definition at line 2068 of file parser.c.

CMP10

#define CMP10	(		s,
			c1,
			c2,
			c3,
			c4,
			c5,
			c6,
			c7,
			c8,
			c9,
			c10
	)

Value:

  ( CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) && \
    ((unsigned char *) s)[ 9 ] == c10 )

Definition at line 2084 of file parser.c.

CMP4

#define CMP4	(		s,
			c1,
			c2,
			c3,
			c4
	)

Value:

  ( ((unsigned char *) s)[ 0 ] == c1 && ((unsigned char *) s)[ 1 ] == c2 && \
    ((unsigned char *) s)[ 2 ] == c3 && ((unsigned char *) s)[ 3 ] == c4 )

Definition at line 2070 of file parser.c.

CMP5

#define CMP5	(		s,
			c1,
			c2,
			c3,
			c4,
			c5
	)		( CMP4( s, c1, c2, c3, c4 ) && ((unsigned char *) s)[ 4 ] == c5 )

Definition at line 2073 of file parser.c.

CMP6

#define CMP6	(		s,
			c1,
			c2,
			c3,
			c4,
			c5,
			c6
	)		( CMP5( s, c1, c2, c3, c4, c5 ) && ((unsigned char *) s)[ 5 ] == c6 )

Definition at line 2075 of file parser.c.

CMP7

#define CMP7	(		s,
			c1,
			c2,
			c3,
			c4,
			c5,
			c6,
			c7
	)		( CMP6( s, c1, c2, c3, c4, c5, c6 ) && ((unsigned char *) s)[ 6 ] == c7 )

Definition at line 2077 of file parser.c.

CMP8

#define CMP8	(		s,
			c1,
			c2,
			c3,
			c4,
			c5,
			c6,
			c7,
			c8
	)		( CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) && ((unsigned char *) s)[ 7 ] == c8 )

Definition at line 2079 of file parser.c.

CMP9

#define CMP9	(		s,
			c1,
			c2,
			c3,
			c4,
			c5,
			c6,
			c7,
			c8,
			c9
	)

Value:

  ( CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) && \
    ((unsigned char *) s)[ 8 ] == c9 )

Definition at line 2081 of file parser.c.

COPY_BUF

#define COPY_BUF	(		l,
			b,
			i,
			v
	)

Value:

    if (l == 1) b[i++] = (xmlChar) v;                   \
    else i += xmlCopyCharMultiByte(&b[i],v)

Definition at line 2166 of file parser.c.

CUR

#define CUR   (*ctxt->input->cur)

Definition at line 2065 of file parser.c.

CUR_CHAR

#define CUR_CHAR

(

l

)

xmlCurrentChar(ctxt, &l)

Definition at line 2163 of file parser.c.

CUR_CONSUMED

#define CUR_CONSUMED    (ctxt->input->consumed + (ctxt->input->cur - ctxt->input->base))

Definition at line 2170 of file parser.c.

CUR_PTR

#define CUR_PTR   ctxt->input->cur

Definition at line 2067 of file parser.c.

CUR_SCHAR

#define CUR_SCHAR	(		s,
			l
	)		xmlStringCurrentChar(ctxt, s, &l)

Definition at line 2164 of file parser.c.

DICT_FREE

#define DICT_FREE

(

str

)

Value:

    if ((str) && ((!dict) ||                \
        (xmlDictOwns(dict, (const xmlChar *)(str)) == 0)))  \
        xmlFree((char *)(str));

DICT_FREE: @str: a string

Free a string if it is not owned by the "dict" dictionary in the current scope

Definition at line 14789 of file parser.c.

GROW

#define GROW

Value:

         if ((ctxt->progressive == 0) &&                \
         (ctxt->input->end - ctxt->input->cur < INPUT_CHUNK))   \
    xmlGROW (ctxt);

Definition at line 2117 of file parser.c.

GROW_PARSE_ATT_VALUE_INTERNAL

#define GROW_PARSE_ATT_VALUE_INTERNAL	(		ctxt,
			in,
			start,
			end
	)

Value:

    const xmlChar *oldbase = ctxt->input->base;\
    GROW;\
    if (ctxt->instate == XML_PARSER_EOF)\
        return(NULL);\
    if (oldbase != ctxt->input->base) {\
        ptrdiff_t delta = ctxt->input->base - oldbase;\
        start = start + delta;\
        in = in + delta;\
    }\
    end = ctxt->input->end;

xmlParseAttValueInternal: @ctxt: an XML parser context @len: attribute len result @alloc: whether the attribute was reallocated as a new string @normalize: if 1 then further non-CDATA normalization must be done

parse a value for an attribute. NOTE: if no normalization is needed, the routine will return pointers directly from the data buffer.

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 if it was copied, this can be detected by val[*len] == 0.

Definition at line 8947 of file parser.c.

growBuffer

#define growBuffer	(		buffer,
			n
	)

Value:

    {                       \
    xmlChar *tmp;                           \
    size_t new_size = buffer##_size * 2 + n;                            \
    if (new_size < buffer##_size) goto mem_error;                       \
    tmp = (xmlChar *) xmlRealloc(buffer, new_size);                     \
    if (tmp == NULL) goto mem_error;                    \
    buffer = tmp;                           \
    buffer##_size = new_size;                                           \
}

Definition at line 2613 of file parser.c.

IN_LIBXML

#define IN_LIBXML

Definition at line 38 of file parser.c.

NEXT

#define NEXT   xmlNextChar(ctxt)

Definition at line 2147 of file parser.c.

NEXT1

#define NEXT1

Value:

    {                               \
    ctxt->input->col++;                     \
    ctxt->input->cur++;                     \
    if (*ctxt->input->cur == 0)                 \
        xmlParserInputGrow(ctxt->input, INPUT_CHUNK);       \
    }

Definition at line 2149 of file parser.c.

NEXTL

#define NEXTL

(

l

)

Value:

    do {                            \
    if (*(ctxt->input->cur) == '\n') {                  \
    ctxt->input->line++; ctxt->input->col = 1;          \
    } else ctxt->input->col++;                      \
    ctxt->input->cur += l;              \
  } while (0)

Definition at line 2156 of file parser.c.

NXT

#define NXT

(

val

)

ctxt->input->cur[(val)]

Definition at line 2066 of file parser.c.

RAW

#define RAW   (*ctxt->input->cur)

Definition at line 2064 of file parser.c.

SAX2

#define SAX2   1

Definition at line 274 of file parser.c.

SAX_COMPAT_MODE

#define SAX_COMPAT_MODE   BAD_CAST "SAX compatibility mode document"

Definition at line 277 of file parser.c.

SHRINK

#define SHRINK

Value:

           if ((ctxt->progressive == 0) &&              \
           (ctxt->input->cur - ctxt->input->base > 2 * INPUT_CHUNK) && \
           (ctxt->input->end - ctxt->input->cur < 2 * INPUT_CHUNK)) \
    xmlSHRINK (ctxt);

Definition at line 2106 of file parser.c.

SKIP

#define SKIP

(

val

)

Value:

    do {                            \
    ctxt->input->cur += (val),ctxt->input->col+=(val);          \
    if (*ctxt->input->cur == 0)                     \
        xmlParserInputGrow(ctxt->input, INPUT_CHUNK);           \
  } while (0)

Definition at line 2088 of file parser.c.

SKIP_BLANKS

#define SKIP_BLANKS   xmlSkipBlankChars(ctxt)

Definition at line 2145 of file parser.c.

SKIPL

#define SKIPL

(

val

)

Value:

    do {                            \
    int skipl;                              \
    for(skipl=0; skipl<val; skipl++) {                  \
    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);           \
  } while (0)

Definition at line 2094 of file parser.c.

XML_DIR_SEP

#define XML_DIR_SEP   '/'

Definition at line 44 of file parser.c.

XML_MAX_HUGE_LENGTH

#define XML_MAX_HUGE_LENGTH   1000000000

Definition at line 105 of file parser.c.

XML_PARSER_BIG_BUFFER_SIZE

#define XML_PARSER_BIG_BUFFER_SIZE   300

Definition at line 275 of file parser.c.

XML_PARSER_BIG_ENTITY

#define XML_PARSER_BIG_ENTITY   1000

Definition at line 107 of file parser.c.

XML_PARSER_BUFFER_SIZE

#define XML_PARSER_BUFFER_SIZE   100

Definition at line 276 of file parser.c.

XML_PARSER_CHUNK_SIZE

#define XML_PARSER_CHUNK_SIZE   100

XML_PARSER_CHUNK_SIZE

When calling GROW that's the minimal amount of data the parser expected to have received. It is not a hard limit but an optimization when reading strings like Names It is not strictly needed as long as inputs available characters are followed by 0, which should be provided by the I/O level

Definition at line 288 of file parser.c.

XML_PARSER_LOT_ENTITY

#define XML_PARSER_LOT_ENTITY   5000

Definition at line 108 of file parser.c.

XML_PARSER_NON_LINEAR

#define XML_PARSER_NON_LINEAR   10

Definition at line 116 of file parser.c.

Typedef Documentation

xmlDefAttrs

typedef struct _xmlDefAttrs xmlDefAttrs

Definition at line 1121 of file parser.c.

xmlDefAttrsPtr

typedef xmlDefAttrs* xmlDefAttrsPtr

Definition at line 1122 of file parser.c.

Function Documentation

areBlanks()

static int areBlanks ( xmlParserCtxtPtr  ctxt, const xmlChar *  str, int  len, int  blank_chars  )

static

areBlanks: @ctxt: an XML parser context @str: a xmlChar * @len: the size of @str @blank_chars: we know the chars are blanks

Is this a sequence of blank chars that one can ignore ?

Returns 1 if ignorable 0 otherwise.

Definition at line 2864 of file parser.c.

                                      {
    int i, ret;
    xmlNodePtr lastChild;
 
    /*
     * Don't spend time trying to differentiate them, the same callback is
     * used !
     */
    if (ctxt->sax->ignorableWhitespace == ctxt->sax->characters)
    return(0);
 
    /*
     * Check for xml:space value.
     */
    if ((ctxt->space == NULL) || (*(ctxt->space) == 1) ||
        (*(ctxt->space) == -2))
    return(0);
 
    /*
     * Check that the string is made of blanks
     */
    if (blank_chars == 0) {
    for (i = 0;i < len;i++)
        if (!(IS_BLANK_CH(str[i]))) return(0);
    }
 
    /*
     * Look if the element is mixed content in the DTD if available
     */
    if (ctxt->node == NULL) return(0);
    if (ctxt->myDoc != NULL) {
    ret = xmlIsMixedElement(ctxt->myDoc, ctxt->node->name);
        if (ret == 0) return(1);
        if (ret == 1) return(0);
    }
 
    /*
     * Otherwise, heuristic :-\
     */
    if ((RAW != '<') && (RAW != 0xD)) return(0);
    if ((ctxt->node->children == NULL) &&
    (RAW == '<') && (NXT(1) == '/')) return(0);
 
    lastChild = xmlGetLastChild(ctxt->node);
    if (lastChild == NULL) {
        if ((ctxt->node->type != XML_ELEMENT_NODE) &&
            (ctxt->node->content != NULL)) return(0);
    } else if (xmlNodeIsText(lastChild))
        return(0);
    else if ((ctxt->node->children != NULL) &&
             (xmlNodeIsText(ctxt->node->children)))
        return(0);
    return(1);
}

Referenced by xmlParseCharData(), and xmlParseCharDataComplex().

inputPop()

xmlParserInputPtr inputPop

(

xmlParserCtxtPtr

ctxt

)

inputPop: @ctxt: an XML parser context

Pops the top parser input from the input stack

Returns the input just removed

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

int inputPush	(	xmlParserCtxtPtr	ctxt,
		xmlParserInputPtr	value
	)

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

Pushes a new parser input on top of the input stack

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

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

LIBXML_ATTR_FORMAT()

static void LIBXML_ATTR_FORMAT ( 3  , 0    )

static

xmlFatalErrMsg: @ctxt: an XML parser context @error: the error number @msg: the error message

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

xmlWarningMsg: @ctxt: an XML parser context @error: the error number @msg: the error message @str1: extra data @str2: extra data

Handle a warning.

xmlValidityError: @ctxt: an XML parser context @error: the error number @msg: the error message @str1: extra data

Handle a validity error.

xmlFatalErrMsgInt: @ctxt: an XML parser context @error: the error number @msg: the error message @val: an integer value

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

xmlFatalErrMsgStrIntStr: @ctxt: an XML parser context @error: the error number @msg: the error message @str1: an string info @val: an integer value @str2: an string info

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

xmlFatalErrMsgStr: @ctxt: an XML parser context @error: the error number @msg: the error message @val: a string value

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

xmlErrMsgStr: @ctxt: an XML parser context @error: the error number @msg: the error message @val: a string value

Handle a non fatal parser error

xmlNsErr: @ctxt: an XML parser context @error: the error number @msg: the message @info1: extra information string @info2: extra information string

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

xmlNsWarn @ctxt: an XML parser context @error: the error number @msg: the message @info1: extra information string @info2: extra information string

Handle a namespace warning error

Definition at line 593 of file parser.c.

{
    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
        (ctxt->instate == XML_PARSER_EOF))
    return;
    if (ctxt != NULL)
    ctxt->errNo = error;
    __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
                    XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0, "%s", msg);
    if (ctxt != NULL) {
    ctxt->wellFormed = 0;
    if (ctxt->recovery == 0)
        ctxt->disableSAX = 1;
    }
}

nameNsPush()

static int nameNsPush ( xmlParserCtxtPtr  ctxt, const xmlChar *  value, const xmlChar *  prefix, const xmlChar *  URI, int  line, int  nsNr  )

static

nameNsPush: @ctxt: an XML parser context @value: the element name @prefix: the element prefix @URI: the element namespace name the current line number for error messages @nsNr: the number of namespaces pushed on the namespace table

Pushes a new element name/prefix/URL on top of the name stack

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

Definition at line 1870 of file parser.c.

{
    xmlStartTag *tag;
 
    if (ctxt->nameNr >= ctxt->nameMax) {
        const xmlChar * *tmp;
        xmlStartTag *tmp2;
        ctxt->nameMax *= 2;
        tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab,
                                    ctxt->nameMax *
                                    sizeof(ctxt->nameTab[0]));
        if (tmp == NULL) {
        ctxt->nameMax /= 2;
        goto mem_error;
        }
    ctxt->nameTab = tmp;
        tmp2 = (xmlStartTag *) xmlRealloc((void * *)ctxt->pushTab,
                                    ctxt->nameMax *
                                    sizeof(ctxt->pushTab[0]));
        if (tmp2 == NULL) {
        ctxt->nameMax /= 2;
        goto mem_error;
        }
    ctxt->pushTab = tmp2;
    } else if (ctxt->pushTab == NULL) {
        ctxt->pushTab = (xmlStartTag *) xmlMalloc(ctxt->nameMax *
                                            sizeof(ctxt->pushTab[0]));
        if (ctxt->pushTab == NULL)
            goto mem_error;
    }
    ctxt->nameTab[ctxt->nameNr] = value;
    ctxt->name = value;
    tag = &ctxt->pushTab[ctxt->nameNr];
    tag->prefix = prefix;
    tag->URI = URI;
    tag->line = line;
    tag->nsNr = nsNr;
    return (ctxt->nameNr++);
mem_error:
    xmlErrMemory(ctxt, NULL);
    return (-1);
}

Referenced by xmlParseElementStart().

namePop()

const xmlChar * 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()

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

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

int 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().

nsPop()

static int nsPop ( xmlParserCtxtPtr  ctxt, int  nr  )

static

nsPop: @ctxt: an XML parser context @nr: the number to pop

Pops the top @nr parser prefix/namespace from the ns stack

Returns the number of namespaces removed

Definition at line 1681 of file parser.c.

{
    int i;
 
    if (ctxt->nsTab == NULL) return(0);
    if (ctxt->nsNr < nr) {
        xmlGenericError(xmlGenericErrorContext, "Pbm popping %d NS\n", nr);
        nr = ctxt->nsNr;
    }
    if (ctxt->nsNr <= 0)
        return (0);
 
    for (i = 0;i < nr;i++) {
         ctxt->nsNr--;
     ctxt->nsTab[ctxt->nsNr] = NULL;
    }
    return(nr);
}

Referenced by xmlParseElementStart(), xmlParseEndTag2(), and xmlParseInNodeContext().

nsPush()

static int nsPush ( xmlParserCtxtPtr  ctxt, const xmlChar *  prefix, const xmlChar *  URL  )

static

nsPush: @ctxt: an XML parser context @prefix: the namespace prefix or NULL @URL: the namespace name

Pushes a new parser namespace on top of the ns stack

Returns -1 in case of error, -2 if the namespace should be discarded and the index in the stack otherwise.

Definition at line 1631 of file parser.c.

{
    if (ctxt->options & XML_PARSE_NSCLEAN) {
        int i;
    for (i = ctxt->nsNr - 2;i >= 0;i -= 2) {
        if (ctxt->nsTab[i] == prefix) {
        /* in scope */
            if (ctxt->nsTab[i + 1] == URL)
            return(-2);
        /* out of scope keep it */
        break;
        }
    }
    }
    if ((ctxt->nsMax == 0) || (ctxt->nsTab == NULL)) {
    ctxt->nsMax = 10;
    ctxt->nsNr = 0;
    ctxt->nsTab = (const xmlChar **)
                  xmlMalloc(ctxt->nsMax * sizeof(xmlChar *));
    if (ctxt->nsTab == NULL) {
        xmlErrMemory(ctxt, NULL);
        ctxt->nsMax = 0;
            return (-1);
    }
    } else if (ctxt->nsNr >= ctxt->nsMax) {
        const xmlChar ** tmp;
        ctxt->nsMax *= 2;
        tmp = (const xmlChar **) xmlRealloc((char *) ctxt->nsTab,
                    ctxt->nsMax * sizeof(ctxt->nsTab[0]));
        if (tmp == NULL) {
            xmlErrMemory(ctxt, NULL);
        ctxt->nsMax /= 2;
            return (-1);
        }
    ctxt->nsTab = tmp;
    }
    ctxt->nsTab[ctxt->nsNr++] = prefix;
    ctxt->nsTab[ctxt->nsNr++] = URL;
    return (ctxt->nsNr);
}

Referenced by xmlParseBalancedChunkMemoryInternal(), xmlParseInNodeContext(), and xmlParseStartTag2().

spacePop()

static int spacePop ( xmlParserCtxtPtr  ctxt )

static

Definition at line 2016 of file parser.c.

                                           {
    int ret;
    if (ctxt->spaceNr <= 0) return(0);
    ctxt->spaceNr--;
    if (ctxt->spaceNr > 0)
    ctxt->space = &ctxt->spaceTab[ctxt->spaceNr - 1];
    else
        ctxt->space = &ctxt->spaceTab[0];
    ret = ctxt->spaceTab[ctxt->spaceNr];
    ctxt->spaceTab[ctxt->spaceNr] = -1;
    return(ret);
}

Referenced by xmlParseElementStart(), and xmlParseEndTag2().

spacePush()

static int spacePush ( xmlParserCtxtPtr  ctxt, int  val  )

static

Definition at line 1997 of file parser.c.

                                                     {
    if (ctxt->spaceNr >= ctxt->spaceMax) {
        int *tmp;
 
    ctxt->spaceMax *= 2;
        tmp = (int *) xmlRealloc(ctxt->spaceTab,
                             ctxt->spaceMax * sizeof(ctxt->spaceTab[0]));
        if (tmp == NULL) {
        xmlErrMemory(ctxt, NULL);
        ctxt->spaceMax /=2;
        return(-1);
    }
    ctxt->spaceTab = tmp;
    }
    ctxt->spaceTab[ctxt->spaceNr] = val;
    ctxt->space = &ctxt->spaceTab[ctxt->spaceNr];
    return(ctxt->spaceNr++);
}

Referenced by xmlParseElementStart().

xmlAddDefAttrs()

static void xmlAddDefAttrs ( xmlParserCtxtPtr  ctxt, const xmlChar *  fullname, const xmlChar *  fullattr, const xmlChar *  value  )

static

xmlAddDefAttrs: @ctxt: an XML parser context @fullname: the element fullname @fullattr: the attribute fullname @value: the attribute value

Add a defaulted attribute for an element

Definition at line 1242 of file parser.c.

                                     {
    xmlDefAttrsPtr defaults;
    int len;
    const xmlChar *name;
    const xmlChar *prefix;
 
    /*
     * Allows to detect attribute redefinitions
     */
    if (ctxt->attsSpecial != NULL) {
        if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL)
        return;
    }
 
    if (ctxt->attsDefault == NULL) {
        ctxt->attsDefault = xmlHashCreateDict(10, ctxt->dict);
    if (ctxt->attsDefault == NULL)
        goto mem_error;
    }
 
    /*
     * split the element name into prefix:localname , the string found
     * are within the DTD and then not associated to namespace names.
     */
    name = xmlSplitQName3(fullname, &len);
    if (name == NULL) {
        name = xmlDictLookup(ctxt->dict, fullname, -1);
    prefix = NULL;
    } else {
        name = xmlDictLookup(ctxt->dict, name, -1);
    prefix = xmlDictLookup(ctxt->dict, fullname, len);
    }
 
    /*
     * make sure there is some storage
     */
    defaults = xmlHashLookup2(ctxt->attsDefault, name, prefix);
    if (defaults == NULL) {
        defaults = (xmlDefAttrsPtr) xmlMalloc(sizeof(xmlDefAttrs) +
                       (4 * 5) * sizeof(const xmlChar *));
    if (defaults == NULL)
        goto mem_error;
    defaults->nbAttrs = 0;
    defaults->maxAttrs = 4;
    if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix,
                            defaults, NULL) < 0) {
        xmlFree(defaults);
        goto mem_error;
    }
    } else if (defaults->nbAttrs >= defaults->maxAttrs) {
        xmlDefAttrsPtr temp;
 
        temp = (xmlDefAttrsPtr) xmlRealloc(defaults, sizeof(xmlDefAttrs) +
               (2 * defaults->maxAttrs * 5) * sizeof(const xmlChar *));
    if (temp == NULL)
        goto mem_error;
    defaults = temp;
    defaults->maxAttrs *= 2;
    if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix,
                            defaults, NULL) < 0) {
        xmlFree(defaults);
        goto mem_error;
    }
    }
 
    /*
     * Split the element name into prefix:localname , the string found
     * are within the DTD and hen not associated to namespace names.
     */
    name = xmlSplitQName3(fullattr, &len);
    if (name == NULL) {
        name = xmlDictLookup(ctxt->dict, fullattr, -1);
    prefix = NULL;
    } else {
        name = xmlDictLookup(ctxt->dict, name, -1);
    prefix = xmlDictLookup(ctxt->dict, fullattr, len);
    }
 
    defaults->values[5 * defaults->nbAttrs] = name;
    defaults->values[5 * defaults->nbAttrs + 1] = prefix;
    /* intern the string and precompute the end */
    len = xmlStrlen(value);
    value = xmlDictLookup(ctxt->dict, value, len);
    defaults->values[5 * defaults->nbAttrs + 2] = value;
    defaults->values[5 * defaults->nbAttrs + 3] = value + len;
    if (ctxt->external)
        defaults->values[5 * defaults->nbAttrs + 4] = BAD_CAST "external";
    else
        defaults->values[5 * defaults->nbAttrs + 4] = NULL;
    defaults->nbAttrs++;
 
    return;
 
mem_error:
    xmlErrMemory(ctxt, NULL);
    return;
}

Referenced by xmlParseAttributeListDecl().

xmlAddSpecialAttr()

static void xmlAddSpecialAttr ( xmlParserCtxtPtr  ctxt, const xmlChar *  fullname, const xmlChar *  fullattr, int  type  )

static

xmlAddSpecialAttr: @ctxt: an XML parser context @fullname: the element fullname @fullattr: the attribute fullname @type: the attribute type

Register this attribute type

Definition at line 1353 of file parser.c.

{
    if (ctxt->attsSpecial == NULL) {
        ctxt->attsSpecial = xmlHashCreateDict(10, ctxt->dict);
    if (ctxt->attsSpecial == NULL)
        goto mem_error;
    }
 
    if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL)
        return;
 
    xmlHashAddEntry2(ctxt->attsSpecial, fullname, fullattr,
                     (void *) (ptrdiff_t) type);
    return;
 
mem_error:
    xmlErrMemory(ctxt, NULL);
    return;
}

Referenced by xmlParseAttributeListDecl().

xmlAttrNormalizeSpace()

static xmlChar * xmlAttrNormalizeSpace ( const xmlChar *  src, xmlChar *  dst  )

static

xmlAttrNormalizeSpace: @src: the source string @dst: the target string

Normalize the space in non CDATA attribute values: If the attribute type 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. Note that the size of dst need to be at least src, and if one doesn't need to preserve dst (and it doesn't come from a dictionary or read-only) then passing src as dst is just fine.

Returns a pointer to the normalized value (dst) or NULL if no conversion is needed.

Definition at line 1152 of file parser.c.

{
    if ((src == NULL) || (dst == NULL))
        return(NULL);
 
    while (*src == 0x20) src++;
    while (*src != 0) {
    if (*src == 0x20) {
        while (*src == 0x20) src++;
        if (*src != 0)
        *dst++ = 0x20;
    } else {
        *dst++ = *src++;
    }
    }
    *dst = 0;
    if (dst == src)
       return(NULL);
    return(dst);
}

Referenced by xmlAttrNormalizeSpace2(), and xmlParseAttributeListDecl().

xmlAttrNormalizeSpace2()

static const xmlChar * xmlAttrNormalizeSpace2 ( xmlParserCtxtPtr  ctxt, xmlChar *  src, int *  len  )

static

xmlAttrNormalizeSpace2: @src: the source string

Normalize the space in non CDATA attribute values, a slightly more complex front end to avoid allocation problems when running on attribute values coming from the input.

Returns a pointer to the normalized value (dst) or NULL if no conversion is needed.

Definition at line 1185 of file parser.c.

{
    int i;
    int remove_head = 0;
    int need_realloc = 0;
    const xmlChar *cur;
 
    if ((ctxt == NULL) || (src == NULL) || (len == NULL))
        return(NULL);
    i = *len;
    if (i <= 0)
        return(NULL);
 
    cur = src;
    while (*cur == 0x20) {
        cur++;
    remove_head++;
    }
    while (*cur != 0) {
    if (*cur == 0x20) {
        cur++;
        if ((*cur == 0x20) || (*cur == 0)) {
            need_realloc = 1;
        break;
        }
    } else
        cur++;
    }
    if (need_realloc) {
        xmlChar *ret;
 
    ret = xmlStrndup(src + remove_head, i - remove_head + 1);
    if (ret == NULL) {
        xmlErrMemory(ctxt, NULL);
        return(NULL);
    }
    xmlAttrNormalizeSpace(ret, ret);
    *len = (int) strlen((const char *)ret);
        return(ret);
    } else if (remove_head) {
        *len -= remove_head;
        memmove(src, src + remove_head, 1 + *len);
    return(src);
    }
    return(NULL);
}

Referenced by xmlParseAttribute2().

xmlCheckLanguageID()

int 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().

xmlCleanSpecialAttr()

static void xmlCleanSpecialAttr ( xmlParserCtxtPtr  ctxt )

static

xmlCleanSpecialAttr: @ctxt: an XML parser context

Trim the list of attributes defined to remove all those of type CDATA as they are not special. This call should be done when finishing to parse the DTD and before starting to parse the document root.

Definition at line 1401 of file parser.c.

{
    if (ctxt->attsSpecial == NULL)
        return;
 
    xmlHashScanFull(ctxt->attsSpecial, xmlCleanSpecialAttrCallback, ctxt);
 
    if (xmlHashSize(ctxt->attsSpecial) == 0) {
        xmlHashFree(ctxt->attsSpecial, NULL);
        ctxt->attsSpecial = NULL;
    }
    return;
}

Referenced by xmlParseDocument().

xmlCleanSpecialAttrCallback()

static void xmlCleanSpecialAttrCallback ( void *  payload, void *  data, const xmlChar *  fullname, const xmlChar *  fullattr, const xmlChar *unused  ATTRIBUTE_UNUSED  )

static

xmlCleanSpecialAttrCallback:

Removes CDATA attributes from the special attribute table

Definition at line 1382 of file parser.c.

                                                                    {
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) data;
 
    if (((ptrdiff_t) payload) == XML_ATTRIBUTE_CDATA) {
        xmlHashRemoveEntry2(ctxt->attsSpecial, fullname, fullattr, NULL);
    }
}

Referenced by xmlCleanSpecialAttr().

xmlCleanupParser()

void xmlCleanupParser

(

void

)

xmlCleanupParser:

This function name is somewhat misleading. It does not clean up parser state, it cleans up memory allocated by the library itself. It is a cleanup function for the XML library. It tries to reclaim all related global memory allocated for the library processing. It doesn't deallocate any document related memory. One should call xmlCleanupParser() only when the process has finished using the library and all XML/HTML documents built with it. See also xmlInitParser() which has the opposite function of preparing the library for operations.

WARNING: if your application is multithreaded or has plugin support calling this may crash the application if another thread or a plugin is still using libxml2. It's sometimes very hard to guess if libxml2 is in use in the application, some libraries or plugins may use it without notice. In case of doubt abstain from calling this function or do it just before calling exit() to avoid leak reports from valgrind !

Definition at line 14739 of file parser.c.

                       {
    if (!xmlParserInitialized)
    return;
 
    xmlCleanupCharEncodingHandlers();
#ifdef LIBXML_CATALOG_ENABLED
    xmlCatalogCleanup();
#endif
    xmlDictCleanup();
    xmlCleanupInputCallbacks();
#ifdef LIBXML_OUTPUT_ENABLED
    xmlCleanupOutputCallbacks();
#endif
#ifdef LIBXML_SCHEMAS_ENABLED
    xmlSchemaCleanupTypes();
    xmlRelaxNGCleanupTypes();
#endif
    xmlCleanupGlobals();
    xmlCleanupThreads(); /* must be last if called not from the main thread */
    xmlCleanupMemory();
    xmlParserInitialized = 0;
}

Referenced by DllMain(), main(), and xmlInitParser().

xmlCreateDocParserCtxt()

xmlParserCtxtPtr xmlCreateDocParserCtxt

(

const xmlChar *

cur

)

xmlCreateDocParserCtxt: @cur: a pointer to an array of xmlChar

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

Returns the new parser context or NULL

Definition at line 14542 of file parser.c.

                                           {
    int len;
 
    if (cur == NULL)
    return(NULL);
    len = xmlStrlen(cur);
    return(xmlCreateMemoryParserCtxt((const char *)cur, len));
}

Referenced by xmlReadDoc().

xmlCreateEntityParserCtxt()

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

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

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

Returns the new parser context or NULL

Definition at line 14027 of file parser.c.

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

xmlCreateEntityParserCtxtInternal()

static xmlParserCtxtPtr xmlCreateEntityParserCtxtInternal ( const xmlChar *  URL, const xmlChar *  ID, const xmlChar *  base, xmlParserCtxtPtr  pctx  )

static

xmlCreateEntityParserCtxtInternal: @URL: the entity URL @ID: the entity PUBLIC ID @base: a possible base for the target URI @pctx: parser context used to set options on new context

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

                                                                  {
    xmlParserCtxtPtr ctxt;
    xmlParserInputPtr inputStream;
    char *directory = NULL;
    xmlChar *uri;
 
    ctxt = xmlNewParserCtxt();
    if (ctxt == NULL) {
    return(NULL);
    }
 
    if (pctx != NULL) {
        ctxt->options = pctx->options;
        ctxt->_private = pctx->_private;
    /*
     * this is a subparser of pctx, so the input_id should be
     * incremented to distinguish from main entity
     */
    ctxt->input_id = pctx->input_id + 1;
    }
 
    /* Don't read from stdin. */
    if (xmlStrcmp(URL, BAD_CAST "-") == 0)
        URL = BAD_CAST "./-";
 
    uri = xmlBuildURI(URL, base);
 
    if (uri == NULL) {
    inputStream = xmlLoadExternalEntity((char *)URL, (char *)ID, ctxt);
    if (inputStream == NULL) {
        xmlFreeParserCtxt(ctxt);
        return(NULL);
    }
 
    inputPush(ctxt, inputStream);
 
    if ((ctxt->directory == NULL) && (directory == NULL))
        directory = xmlParserGetDirectory((char *)URL);
    if ((ctxt->directory == NULL) && (directory != NULL))
        ctxt->directory = directory;
    } else {
    inputStream = xmlLoadExternalEntity((char *)uri, (char *)ID, ctxt);
    if (inputStream == NULL) {
        xmlFree(uri);
        xmlFreeParserCtxt(ctxt);
        return(NULL);
    }
 
    inputPush(ctxt, inputStream);
 
    if ((ctxt->directory == NULL) && (directory == NULL))
        directory = xmlParserGetDirectory((char *)uri);
    if ((ctxt->directory == NULL) && (directory != NULL))
        ctxt->directory = directory;
    xmlFree(uri);
    }
    return(ctxt);
}

Referenced by xmlCreateEntityParserCtxt(), and xmlParseExternalEntityPrivate().

xmlCreateFileParserCtxt()

xmlParserCtxtPtr xmlCreateFileParserCtxt

(

const char *

filename

)

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));
}

xmlCreateIOParserCtxt()

xmlParserCtxtPtr xmlCreateIOParserCtxt	(	xmlSAXHandlerPtr	sax,
		void *	user_data,
		xmlInputReadCallback	ioread,
		xmlInputCloseCallback	ioclose,
		void *	ioctx,
		xmlCharEncoding	enc
	)

xmlCreateIOParserCtxt: @sax: a SAX handler @user_data: The user data returned on SAX callbacks @ioread: an I/O read function @ioclose: an I/O close function @ioctx: an I/O handler @enc: the charset encoding if known

Create a parser context for using the XML parser with an existing I/O stream

Returns the new parser context or NULL

Definition at line 12605 of file parser.c.

                                      {
    xmlParserCtxtPtr ctxt;
    xmlParserInputPtr inputStream;
    xmlParserInputBufferPtr buf;
 
    if (ioread == NULL) return(NULL);
 
    buf = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx, enc);
    if (buf == NULL) {
        if (ioclose != NULL)
            ioclose(ioctx);
        return (NULL);
    }
 
    ctxt = xmlNewParserCtxt();
    if (ctxt == NULL) {
    xmlFreeParserInputBuffer(buf);
    return(NULL);
    }
    if (sax != NULL) {
#ifdef LIBXML_SAX1_ENABLED
    if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
#endif /* LIBXML_SAX1_ENABLED */
        xmlFree(ctxt->sax);
    ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
    if (ctxt->sax == NULL) {
        xmlFreeParserInputBuffer(buf);
        xmlErrMemory(ctxt, NULL);
        xmlFreeParserCtxt(ctxt);
        return(NULL);
    }
    memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
    if (sax->initialized == XML_SAX2_MAGIC)
        memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
    else
        memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
    if (user_data != NULL)
        ctxt->userData = user_data;
    }
 
    inputStream = xmlNewIOInputStream(ctxt, buf, enc);
    if (inputStream == NULL) {
    xmlFreeParserCtxt(ctxt);
    return(NULL);
    }
    inputPush(ctxt, inputStream);
 
    return(ctxt);
}

xmlCreateMemoryParserCtxt()

xmlParserCtxtPtr xmlCreateMemoryParserCtxt	(	const char *	buffer,
		int	size
	)

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

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

Returns the new parser context or NULL

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

xmlParserCtxtPtr xmlCreateURLParserCtxt	(	const char *	filename,
		int	options
	)

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

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

Returns the new parser context or NULL

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

xmlCtxtGrowAttrs()

static int xmlCtxtGrowAttrs ( xmlParserCtxtPtr  ctxt, int  nr  )

static

Definition at line 1702 of file parser.c.

                                                {
    const xmlChar **atts;
    int *attallocs;
    int maxatts;
 
    if (ctxt->atts == NULL) {
    maxatts = 55; /* allow for 10 attrs by default */
    atts = (const xmlChar **)
           xmlMalloc(maxatts * sizeof(xmlChar *));
    if (atts == NULL) goto mem_error;
    ctxt->atts = atts;
    attallocs = (int *) xmlMalloc((maxatts / 5) * sizeof(int));
    if (attallocs == NULL) goto mem_error;
    ctxt->attallocs = attallocs;
    ctxt->maxatts = maxatts;
    } else if (nr + 5 > ctxt->maxatts) {
    maxatts = (nr + 5) * 2;
    atts = (const xmlChar **) xmlRealloc((void *) ctxt->atts,
                     maxatts * sizeof(const xmlChar *));
    if (atts == NULL) goto mem_error;
    ctxt->atts = atts;
    attallocs = (int *) xmlRealloc((void *) ctxt->attallocs,
                                 (maxatts / 5) * sizeof(int));
    if (attallocs == NULL) goto mem_error;
    ctxt->attallocs = attallocs;
    ctxt->maxatts = maxatts;
    }
    return(ctxt->maxatts);
mem_error:
    xmlErrMemory(ctxt, NULL);
    return(-1);
}

Referenced by xmlParseStartTag2().

xmlCtxtReadDoc()

xmlDocPtr xmlCtxtReadDoc	(	xmlParserCtxtPtr	ctxt,
		const xmlChar *	cur,
		const char *	URL,
		const char *	encoding,
		int	options
	)

xmlCtxtReadDoc: @ctxt: an XML parser context @cur: a pointer to a zero terminated string @URL: the base URL to use for the document @encoding: the document encoding, or NULL @options: a combination of xmlParserOption

parse an XML in-memory document and build a tree. This reuses the existing @ctxt parser context

Returns the resulting document tree

Definition at line 15368 of file parser.c.

{
    if (cur == NULL)
        return (NULL);
    return (xmlCtxtReadMemory(ctxt, (const char *) cur, xmlStrlen(cur), URL,
                              encoding, options));
}

xmlCtxtReadFd()

xmlDocPtr xmlCtxtReadFd	(	xmlParserCtxtPtr	ctxt,
		int	fd,
		const char *	URL,
		const char *	encoding,
		int	options
	)

xmlCtxtReadFd: @ctxt: an XML parser context @fd: an open file descriptor @URL: the base URL to use for the document @encoding: the document encoding, or NULL @options: a combination of xmlParserOption

parse an XML from a file descriptor and build a tree. This reuses the existing @ctxt parser context NOTE that the file descriptor will not be closed when the reader is closed or reset.

Returns the resulting document tree

Definition at line 15471 of file parser.c.

{
    xmlParserInputBufferPtr input;
    xmlParserInputPtr stream;
 
    if (fd < 0)
        return (NULL);
    if (ctxt == NULL)
        return (NULL);
    xmlInitParser();
 
    xmlCtxtReset(ctxt);
 
 
    input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
    if (input == NULL)
        return (NULL);
    input->closecallback = NULL;
    stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
    if (stream == NULL) {
        xmlFreeParserInputBuffer(input);
        return (NULL);
    }
    inputPush(ctxt, stream);
    return (xmlDoRead(ctxt, URL, encoding, options, 1));
}

xmlCtxtReadFile()

xmlDocPtr xmlCtxtReadFile	(	xmlParserCtxtPtr	ctxt,
		const char *	filename,
		const char *	encoding,
		int	options
	)

xmlCtxtReadFile: @ctxt: an XML parser context @filename: a file or URL @encoding: the document encoding, or NULL @options: a combination of xmlParserOption

parse an XML file from the filesystem or the network. This reuses the existing @ctxt parser context

Returns the resulting document tree

Definition at line 15390 of file parser.c.

{
    xmlParserInputPtr stream;
 
    if (filename == NULL)
        return (NULL);
    if (ctxt == NULL)
        return (NULL);
    xmlInitParser();
 
    xmlCtxtReset(ctxt);
 
    stream = xmlLoadExternalEntity(filename, NULL, ctxt);
    if (stream == NULL) {
        return (NULL);
    }
    inputPush(ctxt, stream);
    return (xmlDoRead(ctxt, NULL, encoding, options, 1));
}

Referenced by parseAndPrintFile().

xmlCtxtReadIO()

xmlDocPtr xmlCtxtReadIO	(	xmlParserCtxtPtr	ctxt,
		xmlInputReadCallback	ioread,
		xmlInputCloseCallback	ioclose,
		void *	ioctx,
		const char *	URL,
		const char *	encoding,
		int	options
	)

xmlCtxtReadIO: @ctxt: an XML parser context @ioread: an I/O read function @ioclose: an I/O close function @ioctx: an I/O handler @URL: the base URL to use for the document @encoding: the document encoding, or NULL @options: a combination of xmlParserOption

parse an XML document from I/O functions and source and build a tree. This reuses the existing @ctxt parser context

Returns the resulting document tree

Definition at line 15515 of file parser.c.

{
    xmlParserInputBufferPtr input;
    xmlParserInputPtr stream;
 
    if (ioread == NULL)
        return (NULL);
    if (ctxt == NULL)
        return (NULL);
    xmlInitParser();
 
    xmlCtxtReset(ctxt);
 
    input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
                                         XML_CHAR_ENCODING_NONE);
    if (input == NULL) {
        if (ioclose != NULL)
            ioclose(ioctx);
        return (NULL);
    }
    stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
    if (stream == NULL) {
        xmlFreeParserInputBuffer(input);
        return (NULL);
    }
    inputPush(ctxt, stream);
    return (xmlDoRead(ctxt, URL, encoding, options, 1));
}

Referenced by parseAndPrintFile().

xmlCtxtReadMemory()

xmlDocPtr xmlCtxtReadMemory	(	xmlParserCtxtPtr	ctxt,
		const char *	buffer,
		int	size,
		const char *	URL,
		const char *	encoding,
		int	options
	)

xmlCtxtReadMemory: @ctxt: an XML parser context @buffer: a pointer to a char array @size: the size of the array @URL: the base URL to use for the document @encoding: the document encoding, or NULL @options: a combination of xmlParserOption

parse an XML in-memory document and build a tree. This reuses the existing @ctxt parser context

Returns the resulting document tree

Definition at line 15426 of file parser.c.

{
    xmlParserInputBufferPtr input;
    xmlParserInputPtr stream;
 
    if (ctxt == NULL)
        return (NULL);
    if (buffer == NULL)
        return (NULL);
    xmlInitParser();
 
    xmlCtxtReset(ctxt);
 
    input = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
    if (input == NULL) {
    return(NULL);
    }
 
    stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
    if (stream == NULL) {
    xmlFreeParserInputBuffer(input);
    return(NULL);
    }
 
    inputPush(ctxt, stream);
    return (xmlDoRead(ctxt, URL, encoding, options, 1));
}

Referenced by parseAndPrintFile(), and xmlCtxtReadDoc().

xmlCtxtReset()

void xmlCtxtReset

(

xmlParserCtxtPtr

ctxt

)

xmlCtxtReset: @ctxt: an XML parser context

Reset a parser context

Definition at line 14801 of file parser.c.

{
    xmlParserInputPtr input;
    xmlDictPtr dict;
 
    if (ctxt == NULL)
        return;
 
    dict = ctxt->dict;
 
    while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */
        xmlFreeInputStream(input);
    }
    ctxt->inputNr = 0;
    ctxt->input = NULL;
 
    ctxt->spaceNr = 0;
    if (ctxt->spaceTab != NULL) {
    ctxt->spaceTab[0] = -1;
    ctxt->space = &ctxt->spaceTab[0];
    } else {
        ctxt->space = NULL;
    }
 
 
    ctxt->nodeNr = 0;
    ctxt->node = NULL;
 
    ctxt->nameNr = 0;
    ctxt->name = NULL;
 
    ctxt->nsNr = 0;
 
    DICT_FREE(ctxt->version);
    ctxt->version = NULL;
    DICT_FREE(ctxt->encoding);
    ctxt->encoding = NULL;
    DICT_FREE(ctxt->directory);
    ctxt->directory = NULL;
    DICT_FREE(ctxt->extSubURI);
    ctxt->extSubURI = NULL;
    DICT_FREE(ctxt->extSubSystem);
    ctxt->extSubSystem = NULL;
    if (ctxt->myDoc != NULL)
        xmlFreeDoc(ctxt->myDoc);
    ctxt->myDoc = NULL;
 
    ctxt->standalone = -1;
    ctxt->hasExternalSubset = 0;
    ctxt->hasPErefs = 0;
    ctxt->html = 0;
    ctxt->external = 0;
    ctxt->instate = XML_PARSER_START;
    ctxt->token = 0;
 
    ctxt->wellFormed = 1;
    ctxt->nsWellFormed = 1;
    ctxt->disableSAX = 0;
    ctxt->valid = 1;
#if 0
    ctxt->vctxt.userData = ctxt;
    ctxt->vctxt.error = xmlParserValidityError;
    ctxt->vctxt.warning = xmlParserValidityWarning;
#endif
    ctxt->record_info = 0;
    ctxt->checkIndex = 0;
    ctxt->inSubset = 0;
    ctxt->errNo = XML_ERR_OK;
    ctxt->depth = 0;
    ctxt->charset = XML_CHAR_ENCODING_UTF8;
    ctxt->catalogs = NULL;
    ctxt->nbentities = 0;
    ctxt->sizeentities = 0;
    ctxt->sizeentcopy = 0;
    xmlInitNodeInfoSeq(&ctxt->node_seq);
 
    if (ctxt->attsDefault != NULL) {
        xmlHashFree(ctxt->attsDefault, xmlHashDefaultDeallocator);
        ctxt->attsDefault = NULL;
    }
    if (ctxt->attsSpecial != NULL) {
        xmlHashFree(ctxt->attsSpecial, NULL);
        ctxt->attsSpecial = NULL;
    }
 
#ifdef LIBXML_CATALOG_ENABLED
    if (ctxt->catalogs != NULL)
    xmlCatalogFreeLocal(ctxt->catalogs);
#endif
    if (ctxt->lastError.code != XML_ERR_OK)
        xmlResetError(&ctxt->lastError);
}

Referenced by xmlClearParserCtxt(), xmlCtxtReadFd(), xmlCtxtReadFile(), xmlCtxtReadIO(), xmlCtxtReadMemory(), and xmlCtxtResetPush().

xmlCtxtResetPush()

int xmlCtxtResetPush	(	xmlParserCtxtPtr	ctxt,
		const char *	chunk,
		int	size,
		const char *	filename,
		const char *	encoding
	)

xmlCtxtResetPush: @ctxt: an XML parser context @chunk: a pointer to an array of chars @size: number of chars in the array @filename: an optional file name or URI @encoding: the document encoding, or NULL

Reset a push parser context

Returns 0 in case of success and 1 in case of error

Definition at line 14907 of file parser.c.

{
    xmlParserInputPtr inputStream;
    xmlParserInputBufferPtr buf;
    xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
 
    if (ctxt == NULL)
        return(1);
 
    if ((encoding == NULL) && (chunk != NULL) && (size >= 4))
        enc = xmlDetectCharEncoding((const xmlChar *) chunk, size);
 
    buf = xmlAllocParserInputBuffer(enc);
    if (buf == NULL)
        return(1);
 
    if (ctxt == NULL) {
        xmlFreeParserInputBuffer(buf);
        return(1);
    }
 
    xmlCtxtReset(ctxt);
 
    if (filename == NULL) {
        ctxt->directory = NULL;
    } else {
        ctxt->directory = xmlParserGetDirectory(filename);
    }
 
    inputStream = xmlNewInputStream(ctxt);
    if (inputStream == NULL) {
        xmlFreeParserInputBuffer(buf);
        return(1);
    }
 
    if (filename == NULL)
        inputStream->filename = NULL;
    else
        inputStream->filename = (char *)
            xmlCanonicPath((const xmlChar *) filename);
    inputStream->buf = buf;
    xmlBufResetInput(buf->buffer, inputStream);
 
    inputPush(ctxt, inputStream);
 
    if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
        (ctxt->input->buf != NULL)) {
    size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, ctxt->input);
        size_t cur = ctxt->input->cur - ctxt->input->base;
 
        xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
 
        xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, base, cur);
#ifdef DEBUG_PUSH
        xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
#endif
    }
 
    if (encoding != NULL) {
        xmlCharEncodingHandlerPtr hdlr;
 
        if (ctxt->encoding != NULL)
        xmlFree((xmlChar *) ctxt->encoding);
        ctxt->encoding = xmlStrdup((const xmlChar *) encoding);
 
        hdlr = xmlFindCharEncodingHandler(encoding);
        if (hdlr != NULL) {
            xmlSwitchToEncoding(ctxt, hdlr);
    } else {
        xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
                  "Unsupported encoding %s\n", BAD_CAST encoding);
        }
    } else if (enc != XML_CHAR_ENCODING_NONE) {
        xmlSwitchEncoding(ctxt, enc);
    }
 
    return(0);
}

xmlCtxtUseOptions()

int xmlCtxtUseOptions	(	xmlParserCtxtPtr	ctxt,
		int	options
	)

xmlCtxtUseOptions: @ctxt: an XML parser context @options: a combination of xmlParserOption

Applies the options to the parser context

Returns 0 in case of success, the set of unknown or unimplemented options in case of error.

Definition at line 15141 of file parser.c.

{
   return(xmlCtxtUseOptionsInternal(ctxt, options, NULL));
}

Referenced by parseAndPrintFile(), and xsltDocDefaultLoaderFunc().

xmlCtxtUseOptionsInternal()

static int xmlCtxtUseOptionsInternal ( xmlParserCtxtPtr  ctxt, int  options, const char *  encoding  )

static

xmlCtxtUseOptionsInternal: @ctxt: an XML parser context @options: a combination of xmlParserOption @encoding: the user provided encoding to use

Applies the options to the parser context

Returns 0 in case of success, the set of unknown or unimplemented options in case of error.

Definition at line 15000 of file parser.c.

{
    if (ctxt == NULL)
        return(-1);
    if (encoding != NULL) {
        if (ctxt->encoding != NULL)
        xmlFree((xmlChar *) ctxt->encoding);
        ctxt->encoding = xmlStrdup((const xmlChar *) encoding);
    }
    if (options & XML_PARSE_RECOVER) {
        ctxt->recovery = 1;
        options -= XML_PARSE_RECOVER;
    ctxt->options |= XML_PARSE_RECOVER;
    } else
        ctxt->recovery = 0;
    if (options & XML_PARSE_DTDLOAD) {
        ctxt->loadsubset = XML_DETECT_IDS;
        options -= XML_PARSE_DTDLOAD;
    ctxt->options |= XML_PARSE_DTDLOAD;
    } else
        ctxt->loadsubset = 0;
    if (options & XML_PARSE_DTDATTR) {
        ctxt->loadsubset |= XML_COMPLETE_ATTRS;
        options -= XML_PARSE_DTDATTR;
    ctxt->options |= XML_PARSE_DTDATTR;
    }
    if (options & XML_PARSE_NOENT) {
        ctxt->replaceEntities = 1;
        /* ctxt->loadsubset |= XML_DETECT_IDS; */
        options -= XML_PARSE_NOENT;
    ctxt->options |= XML_PARSE_NOENT;
    } else
        ctxt->replaceEntities = 0;
    if (options & XML_PARSE_PEDANTIC) {
        ctxt->pedantic = 1;
        options -= XML_PARSE_PEDANTIC;
    ctxt->options |= XML_PARSE_PEDANTIC;
    } else
        ctxt->pedantic = 0;
    if (options & XML_PARSE_NOBLANKS) {
        ctxt->keepBlanks = 0;
        ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
        options -= XML_PARSE_NOBLANKS;
    ctxt->options |= XML_PARSE_NOBLANKS;
    } else
        ctxt->keepBlanks = 1;
    if (options & XML_PARSE_DTDVALID) {
        ctxt->validate = 1;
        if (options & XML_PARSE_NOWARNING)
            ctxt->vctxt.warning = NULL;
        if (options & XML_PARSE_NOERROR)
            ctxt->vctxt.error = NULL;
        options -= XML_PARSE_DTDVALID;
    ctxt->options |= XML_PARSE_DTDVALID;
    } else
        ctxt->validate = 0;
    if (options & XML_PARSE_NOWARNING) {
        ctxt->sax->warning = NULL;
        options -= XML_PARSE_NOWARNING;
    }
    if (options & XML_PARSE_NOERROR) {
        ctxt->sax->error = NULL;
        ctxt->sax->fatalError = NULL;
        options -= XML_PARSE_NOERROR;
    }
#ifdef LIBXML_SAX1_ENABLED
    if (options & XML_PARSE_SAX1) {
        ctxt->sax->startElement = xmlSAX2StartElement;
        ctxt->sax->endElement = xmlSAX2EndElement;
        ctxt->sax->startElementNs = NULL;
        ctxt->sax->endElementNs = NULL;
        ctxt->sax->initialized = 1;
        options -= XML_PARSE_SAX1;
    ctxt->options |= XML_PARSE_SAX1;
    }
#endif /* LIBXML_SAX1_ENABLED */
    if (options & XML_PARSE_NODICT) {
        ctxt->dictNames = 0;
        options -= XML_PARSE_NODICT;
    ctxt->options |= XML_PARSE_NODICT;
    } else {
        ctxt->dictNames = 1;
    }
    if (options & XML_PARSE_NOCDATA) {
        ctxt->sax->cdataBlock = NULL;
        options -= XML_PARSE_NOCDATA;
    ctxt->options |= XML_PARSE_NOCDATA;
    }
    if (options & XML_PARSE_NSCLEAN) {
    ctxt->options |= XML_PARSE_NSCLEAN;
        options -= XML_PARSE_NSCLEAN;
    }
    if (options & XML_PARSE_NONET) {
    ctxt->options |= XML_PARSE_NONET;
        options -= XML_PARSE_NONET;
    }
    if (options & XML_PARSE_COMPACT) {
    ctxt->options |= XML_PARSE_COMPACT;
        options -= XML_PARSE_COMPACT;
    }
    if (options & XML_PARSE_OLD10) {
    ctxt->options |= XML_PARSE_OLD10;
        options -= XML_PARSE_OLD10;
    }
    if (options & XML_PARSE_NOBASEFIX) {
    ctxt->options |= XML_PARSE_NOBASEFIX;
        options -= XML_PARSE_NOBASEFIX;
    }
    if (options & XML_PARSE_HUGE) {
    ctxt->options |= XML_PARSE_HUGE;
        options -= XML_PARSE_HUGE;
        if (ctxt->dict != NULL)
            xmlDictSetLimit(ctxt->dict, 0);
    }
    if (options & XML_PARSE_OLDSAX) {
    ctxt->options |= XML_PARSE_OLDSAX;
        options -= XML_PARSE_OLDSAX;
    }
    if (options & XML_PARSE_IGNORE_ENC) {
    ctxt->options |= XML_PARSE_IGNORE_ENC;
        options -= XML_PARSE_IGNORE_ENC;
    }
    if (options & XML_PARSE_BIG_LINES) {
    ctxt->options |= XML_PARSE_BIG_LINES;
        options -= XML_PARSE_BIG_LINES;
    }
    ctxt->linenumbers = 1;
    return (options);
}

Referenced by xmlCreateURLParserCtxt(), xmlCtxtUseOptions(), xmlDoRead(), and xmlParseInNodeContext().

xmlDetectSAX2()

static void xmlDetectSAX2 ( xmlParserCtxtPtr  ctxt )

static

xmlDetectSAX2: @ctxt: an XML parser context

Do the SAX2 detection and specific initialization

Definition at line 1094 of file parser.c.

                                     {
    xmlSAXHandlerPtr sax;
 
    /* Avoid unused variable warning if features are disabled. */
    (void) sax;
 
    if (ctxt == NULL) return;
    sax = ctxt->sax;
#ifdef LIBXML_SAX1_ENABLED
    if ((sax) &&  (sax->initialized == XML_SAX2_MAGIC) &&
        ((sax->startElementNs != NULL) ||
         (sax->endElementNs != NULL) ||
         ((sax->startElement == NULL) && (sax->endElement == NULL))))
        ctxt->sax2 = 1;
#else
    ctxt->sax2 = 1;
#endif /* LIBXML_SAX1_ENABLED */
 
    ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
    ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
    ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
    if ((ctxt->str_xml==NULL) || (ctxt->str_xmlns==NULL) ||
        (ctxt->str_xml_ns == NULL)) {
        xmlErrMemory(ctxt, NULL);
    }
}

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

xmlDoRead()

static xmlDocPtr xmlDoRead ( xmlParserCtxtPtr  ctxt, const char *  URL, const char *  encoding, int  options, int  reuse  )

static

xmlDoRead: @ctxt: an XML parser context @URL: the base URL to use for the document @encoding: the document encoding, or NULL @options: a combination of xmlParserOption @reuse: keep the context for reuse

Common front-end for the xmlRead functions

Returns the resulting document tree or NULL

Definition at line 15159 of file parser.c.

{
    xmlDocPtr ret;
 
    xmlCtxtUseOptionsInternal(ctxt, options, encoding);
    if (encoding != NULL) {
        xmlCharEncodingHandlerPtr hdlr;
 
    hdlr = xmlFindCharEncodingHandler(encoding);
    if (hdlr != NULL)
        xmlSwitchToEncoding(ctxt, hdlr);
    }
    if ((URL != NULL) && (ctxt->input != NULL) &&
        (ctxt->input->filename == NULL))
        ctxt->input->filename = (char *) xmlStrdup((const xmlChar *) URL);
    xmlParseDocument(ctxt);
    if ((ctxt->wellFormed) || ctxt->recovery)
        ret = ctxt->myDoc;
    else {
        ret = NULL;
    if (ctxt->myDoc != NULL) {
        xmlFreeDoc(ctxt->myDoc);
    }
    }
    ctxt->myDoc = NULL;
    if (!reuse) {
    xmlFreeParserCtxt(ctxt);
    }
 
    return (ret);
}

Referenced by xmlCtxtReadFd(), xmlCtxtReadFile(), xmlCtxtReadIO(), xmlCtxtReadMemory(), xmlReadDoc(), xmlReadFd(), xmlReadFile(), xmlReadIO(), and xmlReadMemory().

xmlErrAttributeDup()

static void xmlErrAttributeDup ( xmlParserCtxtPtr  ctxt, const xmlChar *  prefix, const xmlChar *  localname  )

static

xmlErrAttributeDup: @ctxt: an XML parser context @prefix: the attribute prefix @localname: the attribute localname

Handle a redefinition of attribute error

Definition at line 342 of file parser.c.

{
    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
        (ctxt->instate == XML_PARSER_EOF))
    return;
    if (ctxt != NULL)
    ctxt->errNo = XML_ERR_ATTRIBUTE_REDEFINED;
 
    if (prefix == NULL)
        __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
                        XML_ERR_ATTRIBUTE_REDEFINED, XML_ERR_FATAL, NULL, 0,
                        (const char *) localname, NULL, NULL, 0, 0,
                        "Attribute %s redefined\n", localname);
    else
        __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
                        XML_ERR_ATTRIBUTE_REDEFINED, XML_ERR_FATAL, NULL, 0,
                        (const char *) prefix, (const char *) localname,
                        NULL, 0, 0, "Attribute %s:%s redefined\n", prefix,
                        localname);
    if (ctxt != NULL) {
    ctxt->wellFormed = 0;
    if (ctxt->recovery == 0)
        ctxt->disableSAX = 1;
    }
}

Referenced by xmlParseStartTag2().

xmlFatalErr()

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

static

xmlFatalErr: @ctxt: an XML parser context @error: the error number @extra: extra information string

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

Definition at line 378 of file parser.c.

{
    const char *errmsg;
 
    if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
        (ctxt->instate == XML_PARSER_EOF))
    return;
    switch (error) {
        case XML_ERR_INVALID_HEX_CHARREF:
            errmsg = "CharRef: invalid hexadecimal value";
            break;
        case XML_ERR_INVALID_DEC_CHARREF:
            errmsg = "CharRef: invalid decimal value";
            break;
        case XML_ERR_INVALID_CHARREF:
            errmsg = "CharRef: invalid value";
            break;
        case XML_ERR_INTERNAL_ERROR:
            errmsg = "internal error";
            break;
        case XML_ERR_PEREF_AT_EOF:
            errmsg = "PEReference at end of document";
            break;
        case XML_ERR_PEREF_IN_PROLOG:
            errmsg = "PEReference in prolog";
            break;
        case XML_ERR_PEREF_IN_EPILOG:
            errmsg = "PEReference in epilog";
            break;
        case XML_ERR_PEREF_NO_NAME:
            errmsg = "PEReference: no name";
            break;
        case XML_ERR_PEREF_SEMICOL_MISSING:
            errmsg = "PEReference: expecting ';'";
            break;
        case XML_ERR_ENTITY_LOOP:
            errmsg = "Detected an entity reference loop";
            break;
        case XML_ERR_ENTITY_NOT_STARTED:
            errmsg = "EntityValue: \" or ' expected";
            break;
        case XML_ERR_ENTITY_PE_INTERNAL:
            errmsg = "PEReferences forbidden in internal subset";
            break;
        case XML_ERR_ENTITY_NOT_FINISHED:
            errmsg = "EntityValue: \" or ' expected";
            break;
        case XML_ERR_ATTRIBUTE_NOT_STARTED:
            errmsg = "AttValue: \" or ' expected";
            break;
        case XML_ERR_LT_IN_ATTRIBUTE:
            errmsg = "Unescaped '<' not allowed in attributes values";
            break;
        case XML_ERR_LITERAL_NOT_STARTED:
            errmsg = "SystemLiteral \" or ' expected";
            break;
        case XML_ERR_LITERAL_NOT_FINISHED:
            errmsg = "Unfinished System or Public ID \" or ' expected";
            break;
        case XML_ERR_MISPLACED_CDATA_END:
            errmsg = "Sequence ']]>' not allowed in content";
            break;
        case XML_ERR_URI_REQUIRED:
            errmsg = "SYSTEM or PUBLIC, the URI is missing";
            break;
        case XML_ERR_PUBID_REQUIRED:
            errmsg = "PUBLIC, the Public Identifier is missing";
            break;
        case XML_ERR_HYPHEN_IN_COMMENT:
            errmsg = "Comment must not contain '--' (double-hyphen)";
            break;
        case XML_ERR_PI_NOT_STARTED:
            errmsg = "xmlParsePI : no target name";
            break;
        case XML_ERR_RESERVED_XML_NAME:
            errmsg = "Invalid PI name";
            break;
        case XML_ERR_NOTATION_NOT_STARTED:
            errmsg = "NOTATION: Name expected here";
            break;
        case XML_ERR_NOTATION_NOT_FINISHED:
            errmsg = "'>' required to close NOTATION declaration";
            break;
        case XML_ERR_VALUE_REQUIRED:
            errmsg = "Entity value required";
            break;
        case XML_ERR_URI_FRAGMENT:
            errmsg = "Fragment not allowed";
            break;
        case XML_ERR_ATTLIST_NOT_STARTED:
            errmsg = "'(' required to start ATTLIST enumeration";
            break;
        case XML_ERR_NMTOKEN_REQUIRED:
            errmsg = "NmToken expected in ATTLIST enumeration";
            break;
        case XML_ERR_ATTLIST_NOT_FINISHED:
            errmsg = "')' required to finish ATTLIST enumeration";
            break;
        case XML_ERR_MIXED_NOT_STARTED:
            errmsg = "MixedContentDecl : '|' or ')*' expected";
            break;
        case XML_ERR_PCDATA_REQUIRED:
            errmsg = "MixedContentDecl : '#PCDATA' expected";
            break;
        case XML_ERR_ELEMCONTENT_NOT_STARTED:
            errmsg = "ContentDecl : Name or '(' expected";
            break;
        case XML_ERR_ELEMCONTENT_NOT_FINISHED:
            errmsg = "ContentDecl : ',' '|' or ')' expected";
            break;
        case XML_ERR_PEREF_IN_INT_SUBSET:
            errmsg =
                "PEReference: forbidden within markup decl in internal subset";
            break;
        case XML_ERR_GT_REQUIRED:
            errmsg = "expected '>'";
            break;
        case XML_ERR_CONDSEC_INVALID:
            errmsg = "XML conditional section '[' expected";
            break;
        case XML_ERR_EXT_SUBSET_NOT_FINISHED:
            errmsg = "Content error in the external subset";
            break;
        case XML_ERR_CONDSEC_INVALID_KEYWORD:
            errmsg =
                "conditional section INCLUDE or IGNORE keyword expected";
            break;
        case XML_ERR_CONDSEC_NOT_FINISHED:
            errmsg = "XML conditional section not closed";
            break;
        case XML_ERR_XMLDECL_NOT_STARTED:
            errmsg = "Text declaration '<?xml' required";
            break;
        case XML_ERR_XMLDECL_NOT_FINISHED:
            errmsg = "parsing XML declaration: '?>' expected";
            break;
        case XML_ERR_EXT_ENTITY_STANDALONE:
            errmsg = "external parsed entities cannot be standalone";
            break;
        case XML_ERR_ENTITYREF_SEMICOL_MISSING:
            errmsg = "EntityRef: expecting ';'";
            break;
        case XML_ERR_DOCTYPE_NOT_FINISHED:
            errmsg = "DOCTYPE improperly terminated";
            break;
        case XML_ERR_LTSLASH_REQUIRED:
            errmsg = "EndTag: '</' not found";
            break;
        case XML_ERR_EQUAL_REQUIRED:
            errmsg = "expected '='";
            break;
        case XML_ERR_STRING_NOT_CLOSED:
            errmsg = "String not closed expecting \" or '";
            break;
        case XML_ERR_STRING_NOT_STARTED:
            errmsg = "String not started expecting ' or \"";
            break;
        case XML_ERR_ENCODING_NAME:
            errmsg = "Invalid XML encoding name";
            break;
        case XML_ERR_STANDALONE_VALUE:
            errmsg = "standalone accepts only 'yes' or 'no'";
            break;
        case XML_ERR_DOCUMENT_EMPTY:
            errmsg = "Document is empty";
            break;
        case XML_ERR_DOCUMENT_END:
            errmsg = "Extra content at the end of the document";
            break;
        case XML_ERR_NOT_WELL_BALANCED:
            errmsg = "chunk is not well balanced";
            break;
        case XML_ERR_EXTRA_CONTENT:
            errmsg = "extra content at the end of well balanced chunk";
            break;
        case XML_ERR_VERSION_MISSING:
            errmsg = "Malformed declaration expecting version";
            break;
        case XML_ERR_NAME_TOO_LONG:
            errmsg = "Name too long";
            break;
#if 0
        case:
            errmsg = "";
            break;
#endif
        default:
            errmsg = "Unregistered error message";
    }
    if (ctxt != NULL)
    ctxt->errNo = error;
    if (info == NULL) {
        __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
                        XML_ERR_FATAL, NULL, 0, info, NULL, NULL, 0, 0, "%s\n",
                        errmsg);
    } else {
        __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
                        XML_ERR_FATAL, NULL, 0, info, NULL, NULL, 0, 0, "%s: %s\n",
                        errmsg, info);
    }
    if (ctxt != NULL) {
    ctxt->wellFormed = 0;
    if (ctxt->recovery == 0)
        ctxt->disableSAX = 1;
    }
}

Referenced by xmlGROW(), xmlLoadEntityContent(), xmlParseAttValueComplex(), xmlParseAttValueInternal(), xmlParseBalancedChunkMemoryInternal(), xmlParseCDSect(), xmlParseCharData(), xmlParseCharDataComplex(), xmlParseCharRef(), xmlParseCommentComplex(), xmlParseConditionalSections(), xmlParseContentInternal(), xmlParseDocTypeDecl(), xmlParseDocument(), xmlParseElementChildrenContentDeclPriv(), xmlParseElementDecl(), xmlParseElementMixedContentDecl(), xmlParseEncName(), xmlParseEncodingDecl(), xmlParseEndTag2(), xmlParseEntityDecl(), xmlParseEntityRef(), xmlParseEntityValue(), xmlParseEnumerationType(), xmlParseExternalEntityPrivate(), xmlParseExternalID(), xmlParseExternalSubset(), xmlParseExtParsedEnt(), xmlParseInNodeContext(), xmlParseInternalSubset(), xmlParseName(), xmlParseNameComplex(), xmlParseNCName(), xmlParseNCNameComplex(), xmlParseNmtoken(), xmlParseNotationDecl(), xmlParseNotationType(), xmlParsePEReference(), xmlParsePI(), xmlParsePITarget(), xmlParsePubidLiteral(), xmlParseReference(), xmlParserEntityCheck(), xmlParserHandlePEReference(), xmlParseSDDecl(), xmlParseStartTag2(), xmlParseStringCharRef(), xmlParseStringEntityRef(), xmlParseStringName(), xmlParseStringPEReference(), xmlParseSystemLiteral(), xmlParseTextDecl(), xmlParseVersionInfo(), xmlParseXMLDecl(), xmlPopInput(), xmlPushInput(), and xmlStringLenDecodeEntities().

xmlGenericErrorDefaultFunc()

void XMLCDECL xmlGenericErrorDefaultFunc	(	void *	ctx,
		const char *	msg,
			...
	)

Referenced by xmlInitParser().

xmlGetNamespace()

static const xmlChar * xmlGetNamespace ( xmlParserCtxtPtr  ctxt, const xmlChar *  prefix  )

static

Definition at line 8760 of file parser.c.

                                                              {
    int i;
 
    if (prefix == ctxt->str_xml) return(ctxt->str_xml_ns);
    for (i = ctxt->nsNr - 2;i >= 0;i-=2)
        if (ctxt->nsTab[i] == prefix) {
        if ((prefix == NULL) && (*ctxt->nsTab[i + 1] == 0))
            return(NULL);
        return(ctxt->nsTab[i + 1]);
    }
    return(NULL);
}

Referenced by xmlParseInNodeContext(), and xmlParseStartTag2().

xmlGROW()

static void xmlGROW ( xmlParserCtxtPtr  ctxt )

static

Definition at line 2121 of file parser.c.

                                            {
    ptrdiff_t curEnd = ctxt->input->end - ctxt->input->cur;
    ptrdiff_t curBase = ctxt->input->cur - ctxt->input->base;
 
    if (((curEnd > XML_MAX_LOOKUP_LIMIT) ||
         (curBase > XML_MAX_LOOKUP_LIMIT)) &&
         ((ctxt->input->buf) &&
          (ctxt->input->buf->readcallback != xmlInputReadCallbackNop)) &&
        ((ctxt->options & XML_PARSE_HUGE) == 0)) {
        xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, "Huge input lookup");
        xmlHaltParser(ctxt);
    return;
    }
    xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
    if ((ctxt->input->cur > ctxt->input->end) ||
        (ctxt->input->cur < ctxt->input->base)) {
        xmlHaltParser(ctxt);
        xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, "cur index out of bound");
    return;
    }
    if ((ctxt->input->cur != NULL) && (*ctxt->input->cur == 0))
        xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
}

xmlHaltParser()

static void xmlHaltParser ( xmlParserCtxtPtr  ctxt )

static

xmlHaltParser: @ctxt: an XML parser context

Blocks further parser processing don't override error for internal use

Definition at line 12549 of file parser.c.

                                     {
    if (ctxt == NULL)
        return;
    ctxt->instate = XML_PARSER_EOF;
    ctxt->disableSAX = 1;
    while (ctxt->inputNr > 1)
        xmlFreeInputStream(inputPop(ctxt));
    if (ctxt->input != NULL) {
        /*
     * in case there was a specific allocation deallocate before
     * overriding base
     */
        if (ctxt->input->free != NULL) {
        ctxt->input->free((xmlChar *) ctxt->input->base);
        ctxt->input->free = NULL;
    }
        if (ctxt->input->buf != NULL) {
            xmlFreeParserInputBuffer(ctxt->input->buf);
            ctxt->input->buf = NULL;
        }
    ctxt->input->cur = BAD_CAST"";
        ctxt->input->length = 0;
    ctxt->input->base = ctxt->input->cur;
        ctxt->input->end = ctxt->input->cur;
    }
}

Referenced by nodePush(), xmlGROW(), xmlParseConditionalSections(), xmlParseContentInternal(), xmlParseElementStart(), xmlParseEntityDecl(), xmlParseExternalSubset(), xmlParseReference(), and xmlStopParser().

xmlHasFeature()

int xmlHasFeature

(

xmlFeature

feature

)

xmlHasFeature: @feature: the feature to be examined

Examines if the library has been compiled with a given feature.

Returns a non-zero value if the feature exist, otherwise zero. Returns zero (0) if the feature does not exist or an unknown unknown feature is requested, non-zero otherwise.

Definition at line 874 of file parser.c.

{
    switch (feature) {
    case XML_WITH_THREAD:
#ifdef LIBXML_THREAD_ENABLED
        return(1);
#else
        return(0);
#endif
        case XML_WITH_TREE:
#ifdef LIBXML_TREE_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_OUTPUT:
#ifdef LIBXML_OUTPUT_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_PUSH:
#ifdef LIBXML_PUSH_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_READER:
#ifdef LIBXML_READER_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_PATTERN:
#ifdef LIBXML_PATTERN_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_WRITER:
#ifdef LIBXML_WRITER_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_SAX1:
#ifdef LIBXML_SAX1_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_FTP:
#ifdef LIBXML_FTP_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_HTTP:
#ifdef LIBXML_HTTP_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_VALID:
#ifdef LIBXML_VALID_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_HTML:
#ifdef LIBXML_HTML_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_LEGACY:
#ifdef LIBXML_LEGACY_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_C14N:
#ifdef LIBXML_C14N_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_CATALOG:
#ifdef LIBXML_CATALOG_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_XPATH:
#ifdef LIBXML_XPATH_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_XPTR:
#ifdef LIBXML_XPTR_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_XINCLUDE:
#ifdef LIBXML_XINCLUDE_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_ICONV:
#ifdef LIBXML_ICONV_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_ISO8859X:
#ifdef LIBXML_ISO8859X_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_UNICODE:
#ifdef LIBXML_UNICODE_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_REGEXP:
#ifdef LIBXML_REGEXP_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_AUTOMATA:
#ifdef LIBXML_AUTOMATA_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_EXPR:
#ifdef LIBXML_EXPR_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_SCHEMAS:
#ifdef LIBXML_SCHEMAS_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_SCHEMATRON:
#ifdef LIBXML_SCHEMATRON_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_MODULES:
#ifdef LIBXML_MODULES_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_DEBUG:
#ifdef LIBXML_DEBUG_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_DEBUG_MEM:
#ifdef DEBUG_MEMORY_LOCATION
            return(1);
#else
            return(0);
#endif
        case XML_WITH_DEBUG_RUN:
#ifdef LIBXML_DEBUG_RUNTIME
            return(1);
#else
            return(0);
#endif
        case XML_WITH_ZLIB:
#ifdef LIBXML_ZLIB_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_LZMA:
#ifdef LIBXML_LZMA_ENABLED
            return(1);
#else
            return(0);
#endif
        case XML_WITH_ICU:
#ifdef LIBXML_ICU_ENABLED
            return(1);
#else
            return(0);
#endif
        default:
        break;
     }
     return(0);
}

Referenced by showVersion().

xmlInitParser()

void xmlInitParser

(

void

)

xmlInitParser:

Initialization function for the XML parser. This is not reentrant. Call once before processing in case of use in multithreaded programs.

Definition at line 14676 of file parser.c.

                    {
    if (xmlParserInitialized != 0)
    return;
 
#if defined(_WIN32) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
    if (xmlFree == free)
        atexit(xmlCleanupParser);
#endif
 
#ifdef LIBXML_THREAD_ENABLED
    __xmlGlobalInitMutexLock();
    if (xmlParserInitialized == 0) {
#endif
    xmlInitThreads();
    xmlInitGlobals();
    if ((xmlGenericError == xmlGenericErrorDefaultFunc) ||
        (xmlGenericError == NULL))
        initGenericErrorDefaultFunc(NULL);
    xmlInitMemory();
        xmlInitializeDict();
    xmlInitCharEncodingHandlers();
    xmlDefaultSAXHandlerInit();
    xmlRegisterDefaultInputCallbacks();
#ifdef LIBXML_OUTPUT_ENABLED
    xmlRegisterDefaultOutputCallbacks();
#endif /* LIBXML_OUTPUT_ENABLED */
#ifdef LIBXML_HTML_ENABLED
    htmlInitAutoClose();
    htmlDefaultSAXHandlerInit();
#endif
#ifdef LIBXML_XPATH_ENABLED
    xmlXPathInit();
#endif
    xmlParserInitialized = 1;
#ifdef LIBXML_THREAD_ENABLED
    }
    __xmlGlobalInitMutexUnlock();
#endif
}

Referenced by DllMain(), xmlCheckVersion(), xmlCtxtReadFd(), xmlCtxtReadFile(), xmlCtxtReadIO(), xmlCtxtReadMemory(), xmlInitParserCtxt(), xmlParseDocument(), xmlReadDoc(), xmlReadFd(), xmlReadFile(), xmlReadIO(), and xmlReadMemory().

xmlIsNameChar()

static int xmlIsNameChar ( xmlParserCtxtPtr  ctxt, int  c  )

static

Definition at line 3161 of file parser.c.

                                            {
    if ((ctxt->options & XML_PARSE_OLD10) == 0) {
        /*
     * Use the new checks of production [4] [4a] amd [5] of the
     * Update 5 of XML-1.0
     */
    if ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */
        (((c >= 'a') && (c <= 'z')) ||
         ((c >= 'A') && (c <= 'Z')) ||
         ((c >= '0') && (c <= '9')) || /* !start */
         (c == '_') || (c == ':') ||
         (c == '-') || (c == '.') || (c == 0xB7) || /* !start */
         ((c >= 0xC0) && (c <= 0xD6)) ||
         ((c >= 0xD8) && (c <= 0xF6)) ||
         ((c >= 0xF8) && (c <= 0x2FF)) ||
         ((c >= 0x300) && (c <= 0x36F)) || /* !start */
         ((c >= 0x370) && (c <= 0x37D)) ||
         ((c >= 0x37F) && (c <= 0x1FFF)) ||
         ((c >= 0x200C) && (c <= 0x200D)) ||
         ((c >= 0x203F) && (c <= 0x2040)) || /* !start */
         ((c >= 0x2070) && (c <= 0x218F)) ||
         ((c >= 0x2C00) && (c <= 0x2FEF)) ||
         ((c >= 0x3001) && (c <= 0xD7FF)) ||
         ((c >= 0xF900) && (c <= 0xFDCF)) ||
         ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
         ((c >= 0x10000) && (c <= 0xEFFFF))))
         return(1);
    } else {
        if ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
            (c == '.') || (c == '-') ||
        (c == '_') || (c == ':') ||
        (IS_COMBINING(c)) ||
        (IS_EXTENDER(c)))
        return(1);
    }
    return(0);
}

Referenced by xmlParseNCNameComplex(), xmlParseNmtoken(), and xmlParseStringName().

xmlIsNameStartChar()

static int xmlIsNameStartChar ( xmlParserCtxtPtr  ctxt, int  c  )

static

Definition at line 3130 of file parser.c.

                                                 {
    if ((ctxt->options & XML_PARSE_OLD10) == 0) {
        /*
     * Use the new checks of production [4] [4a] amd [5] of the
     * Update 5 of XML-1.0
     */
    if ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */
        (((c >= 'a') && (c <= 'z')) ||
         ((c >= 'A') && (c <= 'Z')) ||
         (c == '_') || (c == ':') ||
         ((c >= 0xC0) && (c <= 0xD6)) ||
         ((c >= 0xD8) && (c <= 0xF6)) ||
         ((c >= 0xF8) && (c <= 0x2FF)) ||
         ((c >= 0x370) && (c <= 0x37D)) ||
         ((c >= 0x37F) && (c <= 0x1FFF)) ||
         ((c >= 0x200C) && (c <= 0x200D)) ||
         ((c >= 0x2070) && (c <= 0x218F)) ||
         ((c >= 0x2C00) && (c <= 0x2FEF)) ||
         ((c >= 0x3001) && (c <= 0xD7FF)) ||
         ((c >= 0xF900) && (c <= 0xFDCF)) ||
         ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
         ((c >= 0x10000) && (c <= 0xEFFFF))))
        return(1);
    } else {
        if (IS_LETTER(c) || (c == '_') || (c == ':'))
        return(1);
    }
    return(0);
}

Referenced by xmlParseNCNameComplex(), and xmlParseStringName().

xmlLoadEntityContent()

static int xmlLoadEntityContent ( xmlParserCtxtPtr  ctxt, xmlEntityPtr  entity  )

static

xmlLoadEntityContent: @ctxt: an XML parser context @entity: an unloaded system entity

Load the original content of the given system entity from the ExternalID/SystemID given. This is to be used for Included in Literal http://www.w3.org/TR/REC-xml/#inliteral processing of entities references

Returns 0 in case of success and -1 in case of failure

Definition at line 8060 of file parser.c.

                                                                 {
    xmlParserInputPtr input;
    xmlBufferPtr buf;
    int l, c;
    int count = 0;
 
    if ((ctxt == NULL) || (entity == NULL) ||
        ((entity->etype != XML_EXTERNAL_PARAMETER_ENTITY) &&
     (entity->etype != XML_EXTERNAL_GENERAL_PARSED_ENTITY)) ||
    (entity->content != NULL)) {
    xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
                "xmlLoadEntityContent parameter error");
        return(-1);
    }
 
    if (xmlParserDebugEntities)
    xmlGenericError(xmlGenericErrorContext,
        "Reading %s entity content input\n", entity->name);
 
    buf = xmlBufferCreate();
    if (buf == NULL) {
    xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
                "xmlLoadEntityContent parameter error");
        return(-1);
    }
    xmlBufferSetAllocationScheme(buf, XML_BUFFER_ALLOC_DOUBLEIT);
 
    input = xmlNewEntityInputStream(ctxt, entity);
    if (input == NULL) {
    xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
                "xmlLoadEntityContent input error");
    xmlBufferFree(buf);
        return(-1);
    }
 
    /*
     * Push the entity as the current input, read char by char
     * saving to the buffer until the end of the entity or an error
     */
    if (xmlPushInput(ctxt, input) < 0) {
        xmlBufferFree(buf);
    xmlFreeInputStream(input);
    return(-1);
    }
 
    GROW;
    c = CUR_CHAR(l);
    while ((ctxt->input == input) && (ctxt->input->cur < ctxt->input->end) &&
           (IS_CHAR(c))) {
        xmlBufferAdd(buf, ctxt->input->cur, l);
    if (count++ > XML_PARSER_CHUNK_SIZE) {
        count = 0;
        GROW;
            if (ctxt->instate == XML_PARSER_EOF) {
                xmlBufferFree(buf);
                return(-1);
            }
    }
    NEXTL(l);
    c = CUR_CHAR(l);
    if (c == 0) {
        count = 0;
        GROW;
            if (ctxt->instate == XML_PARSER_EOF) {
                xmlBufferFree(buf);
                return(-1);
            }
        c = CUR_CHAR(l);
    }
    }
 
    if ((ctxt->input == input) && (ctxt->input->cur >= ctxt->input->end)) {
        xmlPopInput(ctxt);
    } else if (!IS_CHAR(c)) {
        xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
                          "xmlLoadEntityContent: invalid char value %d\n",
                      c);
    xmlBufferFree(buf);
    return(-1);
    }
    entity->content = buf->content;
    buf->content = NULL;
    xmlBufferFree(buf);
 
    return(0);
}

Referenced by xmlStringLenDecodeEntities().

xmlParseAttribute2()

static const xmlChar * xmlParseAttribute2 ( xmlParserCtxtPtr  ctxt, const xmlChar *  pref, const xmlChar *  elem, const xmlChar **  prefix, xmlChar **  value, int *  len, int *  alloc  )

static

xmlParseAttribute2: @ctxt: an XML parser context @pref: the element prefix @elem: the element name @prefix: a xmlChar ** used to store the value of the attribute prefix @value: a xmlChar ** used to store the value of the attribute @len: an int * to save the length of the attribute @alloc: an int * to indicate if the attribute was allocated

parse an attribute in the new SAX2 framework.

Returns the attribute name, and the value in *value, .

Definition at line 9125 of file parser.c.

{
    const xmlChar *name;
    xmlChar *val, *internal_val = NULL;
    int normalize = 0;
 
    *value = NULL;
    GROW;
    name = xmlParseQName(ctxt, prefix);
    if (name == NULL) {
        xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
                       "error parsing attribute name\n");
        return (NULL);
    }
 
    /*
     * get the type if needed
     */
    if (ctxt->attsSpecial != NULL) {
        int type;
 
        type = (int) (ptrdiff_t) xmlHashQLookup2(ctxt->attsSpecial,
                                                 pref, elem, *prefix, name);
        if (type != 0)
            normalize = 1;
    }
 
    /*
     * read the value
     */
    SKIP_BLANKS;
    if (RAW == '=') {
        NEXT;
        SKIP_BLANKS;
        val = xmlParseAttValueInternal(ctxt, len, alloc, normalize);
    if (normalize) {
        /*
         * Sometimes a second normalisation pass for spaces is needed
         * but that only happens if charrefs or entities references
         * have been used in the attribute value, i.e. the attribute
         * value have been extracted in an allocated string already.
         */
        if (*alloc) {
            const xmlChar *val2;
 
            val2 = xmlAttrNormalizeSpace2(ctxt, val, len);
        if ((val2 != NULL) && (val2 != val)) {
            xmlFree(val);
            val = (xmlChar *) val2;
        }
        }
    }
        ctxt->instate = XML_PARSER_CONTENT;
    } else {
        xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
                          "Specification mandates value for attribute %s\n",
                          name);
        return (NULL);
    }
 
    if (*prefix == ctxt->str_xml) {
        /*
         * Check that xml:lang conforms to the specification
         * No more registered as an error, just generate a warning now
         * since this was deprecated in XML second edition
         */
        if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "lang"))) {
            internal_val = xmlStrndup(val, *len);
            if (!xmlCheckLanguageID(internal_val)) {
                xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
                              "Malformed value for xml:lang : %s\n",
                              internal_val, NULL);
            }
        }
 
        /*
         * Check that xml:space conforms to the specification
         */
        if (xmlStrEqual(name, BAD_CAST "space")) {
            internal_val = xmlStrndup(val, *len);
            if (xmlStrEqual(internal_val, BAD_CAST "default"))
                *(ctxt->space) = 0;
            else if (xmlStrEqual(internal_val, BAD_CAST "preserve"))
                *(ctxt->space) = 1;
            else {
                xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
                              "Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n",
                              internal_val, NULL);
            }
        }
        if (internal_val) {
            xmlFree(internal_val);
        }
    }
 
    *value = val;
    return (name);
}

Referenced by xmlParseStartTag2().

xmlParseAttributeListDecl()

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

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

xmlChar * 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().

xmlParseAttValueComplex()

static xmlChar * xmlParseAttValueComplex ( xmlParserCtxtPtr  ctxt, int *  attlen, int  normalize  )

static

xmlParseAttValueComplex: @ctxt: an XML parser context @len: the resulting attribute len @normalize: whether to apply the inner normalization

parse a value for an attribute, this is the fallback function of xmlParseAttValue() when the attribute parsing requires handling of non-ASCII characters, or normalization compaction.

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

Definition at line 3921 of file parser.c.

                                                                           {
    xmlChar limit = 0;
    xmlChar *buf = NULL;
    xmlChar *rep = NULL;
    size_t len = 0;
    size_t buf_size = 0;
    size_t maxLength = (ctxt->options & XML_PARSE_HUGE) ?
                       XML_MAX_HUGE_LENGTH :
                       XML_MAX_TEXT_LENGTH;
    int c, l, in_space = 0;
    xmlChar *current = NULL;
    xmlEntityPtr ent;
 
    if (NXT(0) == '"') {
    ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
    limit = '"';
        NEXT;
    } else if (NXT(0) == '\'') {
    limit = '\'';
    ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
        NEXT;
    } else {
    xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
    return(NULL);
    }
 
    /*
     * allocate a translation buffer.
     */
    buf_size = XML_PARSER_BUFFER_SIZE;
    buf = (xmlChar *) xmlMallocAtomic(buf_size);
    if (buf == NULL) goto mem_error;
 
    /*
     * OK loop until we reach one of the ending char or a size limit.
     */
    c = CUR_CHAR(l);
    while (((NXT(0) != limit) && /* checked */
            (IS_CHAR(c)) && (c != '<')) &&
            (ctxt->instate != XML_PARSER_EOF)) {
    if (c == '&') {
        in_space = 0;
        if (NXT(1) == '#') {
        int val = xmlParseCharRef(ctxt);
 
        if (val == '&') {
            if (ctxt->replaceEntities) {
            if (len + 10 > buf_size) {
                growBuffer(buf, 10);
            }
            buf[len++] = '&';
            } else {
            /*
             * The reparsing will be done in xmlStringGetNodeList()
             * called by the attribute() function in SAX.c
             */
            if (len + 10 > buf_size) {
                growBuffer(buf, 10);
            }
            buf[len++] = '&';
            buf[len++] = '#';
            buf[len++] = '3';
            buf[len++] = '8';
            buf[len++] = ';';
            }
        } else if (val != 0) {
            if (len + 10 > buf_size) {
            growBuffer(buf, 10);
            }
            len += xmlCopyChar(0, &buf[len], val);
        }
        } else {
        ent = xmlParseEntityRef(ctxt);
        ctxt->nbentities++;
        if (ent != NULL)
            ctxt->nbentities += ent->owner;
        if ((ent != NULL) &&
            (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
            if (len + 10 > buf_size) {
            growBuffer(buf, 10);
            }
            if ((ctxt->replaceEntities == 0) &&
                (ent->content[0] == '&')) {
            buf[len++] = '&';
            buf[len++] = '#';
            buf[len++] = '3';
            buf[len++] = '8';
            buf[len++] = ';';
            } else {
            buf[len++] = ent->content[0];
            }
        } else if ((ent != NULL) &&
                   (ctxt->replaceEntities != 0)) {
            if (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) {
            ++ctxt->depth;
            rep = xmlStringDecodeEntities(ctxt, ent->content,
                              XML_SUBSTITUTE_REF,
                              0, 0, 0);
            --ctxt->depth;
            if (rep != NULL) {
                current = rep;
                while (*current != 0) { /* non input consuming */
                                if ((*current == 0xD) || (*current == 0xA) ||
                                    (*current == 0x9)) {
                                    buf[len++] = 0x20;
                                    current++;
                                } else
                                    buf[len++] = *current++;
                if (len + 10 > buf_size) {
                    growBuffer(buf, 10);
                }
                }
                xmlFree(rep);
                rep = NULL;
            }
            } else {
            if (len + 10 > buf_size) {
                growBuffer(buf, 10);
            }
            if (ent->content != NULL)
                buf[len++] = ent->content[0];
            }
        } else if (ent != NULL) {
            int i = xmlStrlen(ent->name);
            const xmlChar *cur = ent->name;
 
            /*
             * This may look absurd but is needed to detect
             * entities problems
             */
            if ((ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
            (ent->content != NULL) && (ent->checked == 0)) {
            unsigned long oldnbent = ctxt->nbentities, diff;
 
            ++ctxt->depth;
            rep = xmlStringDecodeEntities(ctxt, ent->content,
                          XML_SUBSTITUTE_REF, 0, 0, 0);
            --ctxt->depth;
 
                        diff = ctxt->nbentities - oldnbent + 1;
                        if (diff > INT_MAX / 2)
                            diff = INT_MAX / 2;
                        ent->checked = diff * 2;
            if (rep != NULL) {
                if (xmlStrchr(rep, '<'))
                    ent->checked |= 1;
                xmlFree(rep);
                rep = NULL;
            } else {
                            ent->content[0] = 0;
                        }
            }
 
            /*
             * Just output the reference
             */
            buf[len++] = '&';
            while (len + i + 10 > buf_size) {
            growBuffer(buf, i + 10);
            }
            for (;i > 0;i--)
            buf[len++] = *cur++;
            buf[len++] = ';';
        }
        }
    } else {
        if ((c == 0x20) || (c == 0xD) || (c == 0xA) || (c == 0x9)) {
            if ((len != 0) || (!normalize)) {
            if ((!normalize) || (!in_space)) {
            COPY_BUF(l,buf,len,0x20);
            while (len + 10 > buf_size) {
                growBuffer(buf, 10);
            }
            }
            in_space = 1;
        }
        } else {
            in_space = 0;
        COPY_BUF(l,buf,len,c);
        if (len + 10 > buf_size) {
            growBuffer(buf, 10);
        }
        }
        NEXTL(l);
    }
    GROW;
    c = CUR_CHAR(l);
        if (len > maxLength) {
            xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
                           "AttValue length too long\n");
            goto mem_error;
        }
    }
    if (ctxt->instate == XML_PARSER_EOF)
        goto error;
 
    if ((in_space) && (normalize)) {
        while ((len > 0) && (buf[len - 1] == 0x20)) len--;
    }
    buf[len] = 0;
    if (RAW == '<') {
    xmlFatalErr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, NULL);
    } else if (RAW != limit) {
    if ((c != 0) && (!IS_CHAR(c))) {
        xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR,
               "invalid character in attribute value\n");
    } else {
        xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
               "AttValue: ' expected\n");
        }
    } else
    NEXT;
 
    if (attlen != NULL) *attlen = (int) len;
    return(buf);
 
mem_error:
    xmlErrMemory(ctxt, NULL);
error:
    if (buf != NULL)
        xmlFree(buf);
    if (rep != NULL)
        xmlFree(rep);
    return(NULL);
}

Referenced by xmlParseAttValueInternal().

xmlParseAttValueInternal()

static xmlChar * xmlParseAttValueInternal ( xmlParserCtxtPtr  ctxt, int *  len, int *  alloc, int  normalize  )

static

Definition at line 8960 of file parser.c.

{
    xmlChar limit = 0;
    const xmlChar *in = NULL, *start, *end, *last;
    xmlChar *ret = NULL;
    int line, col;
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
                    XML_MAX_HUGE_LENGTH :
                    XML_MAX_TEXT_LENGTH;
 
    GROW;
    in = (xmlChar *) CUR_PTR;
    line = ctxt->input->line;
    col = ctxt->input->col;
    if (*in != '"' && *in != '\'') {
        xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
        return (NULL);
    }
    ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
 
    /*
     * try to handle in this routine the most common case where no
     * allocation of a new string is required and where content is
     * pure ASCII.
     */
    limit = *in++;
    col++;
    end = ctxt->input->end;
    start = in;
    if (in >= end) {
        GROW_PARSE_ATT_VALUE_INTERNAL(ctxt, in, start, end)
    }
    if (normalize) {
        /*
     * Skip any leading spaces
     */
    while ((in < end) && (*in != limit) &&
           ((*in == 0x20) || (*in == 0x9) ||
            (*in == 0xA) || (*in == 0xD))) {
        if (*in == 0xA) {
            line++; col = 1;
        } else {
            col++;
        }
        in++;
        start = in;
        if (in >= end) {
                GROW_PARSE_ATT_VALUE_INTERNAL(ctxt, in, start, end)
                if ((in - start) > maxLength) {
                    xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
                                   "AttValue length too long\n");
                    return(NULL);
                }
        }
    }
    while ((in < end) && (*in != limit) && (*in >= 0x20) &&
           (*in <= 0x7f) && (*in != '&') && (*in != '<')) {
        col++;
        if ((*in++ == 0x20) && (*in == 0x20)) break;
        if (in >= end) {
                GROW_PARSE_ATT_VALUE_INTERNAL(ctxt, in, start, end)
                if ((in - start) > maxLength) {
                    xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
                                   "AttValue length too long\n");
                    return(NULL);
                }
        }
    }
    last = in;
    /*
     * skip the trailing blanks
     */
    while ((last[-1] == 0x20) && (last > start)) last--;
    while ((in < end) && (*in != limit) &&
           ((*in == 0x20) || (*in == 0x9) ||
            (*in == 0xA) || (*in == 0xD))) {
        if (*in == 0xA) {
            line++, col = 1;
        } else {
            col++;
        }
        in++;
        if (in >= end) {
        const xmlChar *oldbase = ctxt->input->base;
        GROW;
                if (ctxt->instate == XML_PARSER_EOF)
                    return(NULL);
        if (oldbase != ctxt->input->base) {
            ptrdiff_t delta = ctxt->input->base - oldbase;
            start = start + delta;
            in = in + delta;
            last = last + delta;
        }
        end = ctxt->input->end;
                if ((in - start) > maxLength) {
                    xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
                                   "AttValue length too long\n");
                    return(NULL);
                }
        }
    }
        if ((in - start) > maxLength) {
            xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
                           "AttValue length too long\n");
            return(NULL);
        }
    if (*in != limit) goto need_complex;
    } else {
    while ((in < end) && (*in != limit) && (*in >= 0x20) &&
           (*in <= 0x7f) && (*in != '&') && (*in != '<')) {
        in++;
        col++;
        if (in >= end) {
                GROW_PARSE_ATT_VALUE_INTERNAL(ctxt, in, start, end)
                if ((in - start) > maxLength) {
                    xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
                                   "AttValue length too long\n");
                    return(NULL);
                }
        }
    }
    last = in;
        if ((in - start) > maxLength) {
            xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
                           "AttValue length too long\n");
            return(NULL);
        }
    if (*in != limit) goto need_complex;
    }
    in++;
    col++;
    if (len != NULL) {
        *len = last - start;
        ret = (xmlChar *) start;
    } else {
        if (alloc) *alloc = 1;
        ret = xmlStrndup(start, last - start);
    }
    CUR_PTR = in;
    ctxt->input->line = line;
    ctxt->input->col = col;
    if (alloc) *alloc = 0;
    return ret;
need_complex:
    if (alloc) *alloc = 1;
    return xmlParseAttValueComplex(ctxt, len, normalize);
}

Referenced by xmlParseAttribute2(), and xmlParseAttValue().

xmlParseBalancedChunkMemoryInternal()

static xmlParserErrors xmlParseBalancedChunkMemoryInternal ( xmlParserCtxtPtr  oldctxt, const xmlChar *  string, void *  user_data, xmlNodePtr *  lst  )

static

xmlParseBalancedChunkMemoryInternal: @oldctxt: the existing parsing context @string: the input string in UTF8 or ISO-Latin (zero terminated) @user_data: the user data field for the parser context @lst: the return value for the set of parsed nodes

Parse a well-balanced chunk of an XML document called by the parser The allowed sequence for the Well Balanced Chunk is the one defined by the content production in the XML grammar:

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

Returns XML_ERR_OK if the chunk is well balanced, and the parser error code otherwise

In case recover is set to 1, the nodelist will not be empty even if the parsed chunk is not well balanced.

Definition at line 13303 of file parser.c.

                                                             {
    xmlParserCtxtPtr ctxt;
    xmlDocPtr newDoc = NULL;
    xmlNodePtr newRoot;
    xmlSAXHandlerPtr oldsax = NULL;
    xmlNodePtr content = NULL;
    xmlNodePtr last = NULL;
    int size;
    xmlParserErrors ret = XML_ERR_OK;
#ifdef SAX2
    int i;
#endif
 
    if (((oldctxt->depth > 40) && ((oldctxt->options & XML_PARSE_HUGE) == 0)) ||
        (oldctxt->depth >  1024)) {
    return(XML_ERR_ENTITY_LOOP);
    }
 
 
    if (lst != NULL)
        *lst = NULL;
    if (string == NULL)
        return(XML_ERR_INTERNAL_ERROR);
 
    size = xmlStrlen(string);
 
    ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
    if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
    if (user_data != NULL)
    ctxt->userData = user_data;
    else
    ctxt->userData = ctxt;
    if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
    ctxt->dict = oldctxt->dict;
    ctxt->input_id = oldctxt->input_id + 1;
    ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
    ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
    ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
 
#ifdef SAX2
    /* propagate namespaces down the entity */
    for (i = 0;i < oldctxt->nsNr;i += 2) {
        nsPush(ctxt, oldctxt->nsTab[i], oldctxt->nsTab[i+1]);
    }
#endif
 
    oldsax = ctxt->sax;
    ctxt->sax = oldctxt->sax;
    xmlDetectSAX2(ctxt);
    ctxt->replaceEntities = oldctxt->replaceEntities;
    ctxt->options = oldctxt->options;
 
    ctxt->_private = oldctxt->_private;
    if (oldctxt->myDoc == NULL) {
    newDoc = xmlNewDoc(BAD_CAST "1.0");
    if (newDoc == NULL) {
        ctxt->sax = oldsax;
        ctxt->dict = NULL;
        xmlFreeParserCtxt(ctxt);
        return(XML_ERR_INTERNAL_ERROR);
    }
    newDoc->properties = XML_DOC_INTERNAL;
    newDoc->dict = ctxt->dict;
    xmlDictReference(newDoc->dict);
    ctxt->myDoc = newDoc;
    } else {
    ctxt->myDoc = oldctxt->myDoc;
        content = ctxt->myDoc->children;
    last = ctxt->myDoc->last;
    }
    newRoot = xmlNewDocNode(ctxt->myDoc, NULL, BAD_CAST "pseudoroot", NULL);
    if (newRoot == NULL) {
    ctxt->sax = oldsax;
    ctxt->dict = NULL;
    xmlFreeParserCtxt(ctxt);
    if (newDoc != NULL) {
        xmlFreeDoc(newDoc);
    }
    return(XML_ERR_INTERNAL_ERROR);
    }
    ctxt->myDoc->children = NULL;
    ctxt->myDoc->last = NULL;
    xmlAddChild((xmlNodePtr) ctxt->myDoc, newRoot);
    nodePush(ctxt, ctxt->myDoc->children);
    ctxt->instate = XML_PARSER_CONTENT;
    ctxt->depth = oldctxt->depth + 1;
 
    ctxt->validate = 0;
    ctxt->loadsubset = oldctxt->loadsubset;
    if ((oldctxt->validate) || (oldctxt->replaceEntities != 0)) {
    /*
     * ID/IDREF registration will be done in xmlValidateElement below
     */
    ctxt->loadsubset |= XML_SKIP_IDS;
    }
    ctxt->dictNames = oldctxt->dictNames;
    ctxt->attsDefault = oldctxt->attsDefault;
    ctxt->attsSpecial = oldctxt->attsSpecial;
 
    xmlParseContent(ctxt);
    if ((RAW == '<') && (NXT(1) == '/')) {
    xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
    } else if (RAW != 0) {
    xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
    }
    if (ctxt->node != ctxt->myDoc->children) {
    xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
    }
 
    if (!ctxt->wellFormed) {
        if (ctxt->errNo == 0)
        ret = XML_ERR_INTERNAL_ERROR;
    else
        ret = (xmlParserErrors)ctxt->errNo;
    } else {
      ret = XML_ERR_OK;
    }
 
    if ((lst != NULL) && (ret == XML_ERR_OK)) {
    xmlNodePtr cur;
 
    /*
     * Return the newly created nodeset after unlinking it from
     * they pseudo parent.
     */
    cur = ctxt->myDoc->children->children;
    *lst = cur;
    while (cur != NULL) {
#ifdef LIBXML_VALID_ENABLED
        if ((oldctxt->validate) && (oldctxt->wellFormed) &&
        (oldctxt->myDoc) && (oldctxt->myDoc->intSubset) &&
        (cur->type == XML_ELEMENT_NODE)) {
        oldctxt->valid &= xmlValidateElement(&oldctxt->vctxt,
            oldctxt->myDoc, cur);
        }
#endif /* LIBXML_VALID_ENABLED */
        cur->parent = NULL;
        cur = cur->next;
    }
    ctxt->myDoc->children->children = NULL;
    }
    if (ctxt->myDoc != NULL) {
    xmlFreeNode(ctxt->myDoc->children);
        ctxt->myDoc->children = content;
        ctxt->myDoc->last = last;
    }
 
    /*
     * Record in the parent context the number of entities replacement
     * done when parsing that reference.
     */
    if (oldctxt != NULL)
        oldctxt->nbentities += ctxt->nbentities;
 
    /*
     * Also record the last error if any
     */
    if (ctxt->lastError.code != XML_ERR_OK)
        xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
 
    ctxt->sax = oldsax;
    ctxt->dict = NULL;
    ctxt->attsDefault = NULL;
    ctxt->attsSpecial = NULL;
    xmlFreeParserCtxt(ctxt);
    if (newDoc != NULL) {
    xmlFreeDoc(newDoc);
    }
 
    return(ret);
}

Referenced by xmlParseReference().

xmlParseCDSect()

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

void 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().

xmlParseCharDataComplex()

static void xmlParseCharDataComplex ( xmlParserCtxtPtr  ctxt, int  cdata  )

static

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

parse a CharData section.this is the fallback function of xmlParseCharData() when the parsing requires handling of non-ASCII characters.

Definition at line 4576 of file parser.c.

                                                          {
    xmlChar buf[XML_PARSER_BIG_BUFFER_SIZE + 5];
    int nbchar = 0;
    int cur, l;
    int count = 0;
 
    SHRINK;
    GROW;
    cur = CUR_CHAR(l);
    while ((cur != '<') && /* checked */
           (cur != '&') &&
       (IS_CHAR(cur))) /* test also done in xmlCurrentChar() */ {
    if ((cur == ']') && (NXT(1) == ']') &&
        (NXT(2) == '>')) {
        if (cdata) break;
        else {
        xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
        }
    }
    COPY_BUF(l,buf,nbchar,cur);
    /* move current position before possible calling of ctxt->sax->characters */
    NEXTL(l);
    cur = CUR_CHAR(l);
    if (nbchar >= XML_PARSER_BIG_BUFFER_SIZE) {
        buf[nbchar] = 0;
 
        /*
         * OK the segment is to be consumed as chars.
         */
        if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
        if (areBlanks(ctxt, buf, nbchar, 0)) {
            if (ctxt->sax->ignorableWhitespace != NULL)
            ctxt->sax->ignorableWhitespace(ctxt->userData,
                                           buf, nbchar);
        } else {
            if (ctxt->sax->characters != NULL)
            ctxt->sax->characters(ctxt->userData, buf, nbchar);
            if ((ctxt->sax->characters !=
                 ctxt->sax->ignorableWhitespace) &&
            (*ctxt->space == -1))
            *ctxt->space = -2;
        }
        }
        nbchar = 0;
            /* something really bad happened in the SAX callback */
            if (ctxt->instate != XML_PARSER_CONTENT)
                return;
    }
    count++;
    if (count > 50) {
        SHRINK;
        GROW;
        count = 0;
            if (ctxt->instate == XML_PARSER_EOF)
        return;
    }
    }
    if (nbchar != 0) {
        buf[nbchar] = 0;
    /*
     * OK the segment is to be consumed as chars.
     */
    if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
        if (areBlanks(ctxt, buf, nbchar, 0)) {
        if (ctxt->sax->ignorableWhitespace != NULL)
            ctxt->sax->ignorableWhitespace(ctxt->userData, buf, nbchar);
        } else {
        if (ctxt->sax->characters != NULL)
            ctxt->sax->characters(ctxt->userData, buf, nbchar);
        if ((ctxt->sax->characters != ctxt->sax->ignorableWhitespace) &&
            (*ctxt->space == -1))
            *ctxt->space = -2;
        }
    }
    }
    if ((cur != 0) && (!IS_CHAR(cur))) {
    /* Generate the error and skip the offending character */
        xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
                          "PCDATA invalid Char value %d\n",
                      cur);
    NEXTL(l);
    }
}

Referenced by xmlParseCharData().

xmlParseCharRef()

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

void 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().

xmlParseCommentComplex()

static void xmlParseCommentComplex ( xmlParserCtxtPtr  ctxt, xmlChar *  buf, size_t  len, size_t  size  )

static

xmlParseCommentComplex: @ctxt: an XML parser context @buf: the already parsed part of the buffer @len: number of bytes in the buffer @size: allocated size of the buffer

Skip an XML (SGML) comment The spec says that "For compatibility, the string "–" (double-hyphen) must not occur within comments. " This is the slow routine in case the accelerator for ascii didn't work

[15] Comment ::= ''

Definition at line 4750 of file parser.c.

                                                {
    int q, ql;
    int r, rl;
    int cur, l;
    size_t count = 0;
    size_t maxLength = (ctxt->options & XML_PARSE_HUGE) ?
                       XML_MAX_HUGE_LENGTH :
                       XML_MAX_TEXT_LENGTH;
    int inputid;
 
    inputid = ctxt->input->id;
 
    if (buf == NULL) {
        len = 0;
    size = XML_PARSER_BUFFER_SIZE;
    buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
    if (buf == NULL) {
        xmlErrMemory(ctxt, NULL);
        return;
    }
    }
    GROW;   /* Assure there's enough input data */
    q = CUR_CHAR(ql);
    if (q == 0)
        goto not_terminated;
    if (!IS_CHAR(q)) {
        xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
                          "xmlParseComment: invalid xmlChar value %d\n",
                      q);
    xmlFree (buf);
    return;
    }
    NEXTL(ql);
    r = CUR_CHAR(rl);
    if (r == 0)
        goto not_terminated;
    if (!IS_CHAR(r)) {
        xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
                          "xmlParseComment: invalid xmlChar value %d\n",
                      q);
    xmlFree (buf);
    return;
    }
    NEXTL(rl);
    cur = CUR_CHAR(l);
    if (cur == 0)
        goto not_terminated;
    while (IS_CHAR(cur) && /* checked */
           ((cur != '>') ||
        (r != '-') || (q != '-'))) {
    if ((r == '-') && (q == '-')) {
        xmlFatalErr(ctxt, XML_ERR_HYPHEN_IN_COMMENT, NULL);
    }
    if (len + 5 >= size) {
        xmlChar *new_buf;
            size_t new_size;
 
        new_size = size * 2;
        new_buf = (xmlChar *) xmlRealloc(buf, new_size);
        if (new_buf == NULL) {
        xmlFree (buf);
        xmlErrMemory(ctxt, NULL);
        return;
        }
        buf = new_buf;
            size = new_size;
    }
    COPY_BUF(ql,buf,len,q);
    q = r;
    ql = rl;
    r = cur;
    rl = l;
 
    count++;
    if (count > 50) {
        SHRINK;
        GROW;
        count = 0;
            if (ctxt->instate == XML_PARSER_EOF) {
        xmlFree(buf);
        return;
            }
    }
    NEXTL(l);
    cur = CUR_CHAR(l);
    if (cur == 0) {
        SHRINK;
        GROW;
        cur = CUR_CHAR(l);
    }
 
        if (len > maxLength) {
            xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
                         "Comment too big found", NULL);
            xmlFree (buf);
            return;
        }
    }
    buf[len] = 0;
    if (cur == 0) {
    xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
                         "Comment not terminated \n<!--%.50s\n", buf);
    } else if (!IS_CHAR(cur)) {
        xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
                          "xmlParseComment: invalid xmlChar value %d\n",
                      cur);
    } else {
    if (inputid != ctxt->input->id) {
        xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
                   "Comment doesn't start and stop in the same"
                           " entity\n");
    }
        NEXT;
    if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
        (!ctxt->disableSAX))
        ctxt->sax->comment(ctxt->userData, buf);
    }
    xmlFree(buf);
    return;
not_terminated:
    xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
             "Comment not terminated\n", NULL);
    xmlFree(buf);
    return;
}

Referenced by xmlParseComment().

xmlParseConditionalSections()

static void xmlParseConditionalSections ( xmlParserCtxtPtr  ctxt )

static

xmlParseConditionalSections @ctxt: an XML parser context

[61] conditionalSect ::= includeSect | ignoreSect [62] includeSect ::= '<![' S? 'INCLUDE' S? '[' extSubsetDecl ']]>' [63] ignoreSect ::= '<![' S? 'IGNORE' S? '[' ignoreSectContents* ']]>' [64] ignoreSectContents ::= Ignore ('<![' ignoreSectContents ']]>' Ignore)* [65] Ignore ::= Char* - (Char* ('<![' | ']]>') Char*)

Definition at line 6703 of file parser.c.

                                                   {
    int *inputIds = NULL;
    size_t inputIdsSize = 0;
    size_t depth = 0;
 
    while (ctxt->instate != XML_PARSER_EOF) {
        if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
            int id = ctxt->input->id;
 
            SKIP(3);
            SKIP_BLANKS;
 
            if (CMP7(CUR_PTR, 'I', 'N', 'C', 'L', 'U', 'D', 'E')) {
                SKIP(7);
                SKIP_BLANKS;
                if (RAW != '[') {
                    xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
                    xmlHaltParser(ctxt);
                    goto error;
                }
                if (ctxt->input->id != id) {
                    xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
                                   "All markup of the conditional section is"
                                   " not in the same entity\n");
                }
                NEXT;
 
                if (inputIdsSize <= depth) {
                    int *tmp;
 
                    inputIdsSize = (inputIdsSize == 0 ? 4 : inputIdsSize * 2);
                    tmp = (int *) xmlRealloc(inputIds,
                            inputIdsSize * sizeof(int));
                    if (tmp == NULL) {
                        xmlErrMemory(ctxt, NULL);
                        goto error;
                    }
                    inputIds = tmp;
                }
                inputIds[depth] = id;
                depth++;
            } else if (CMP6(CUR_PTR, 'I', 'G', 'N', 'O', 'R', 'E')) {
                int state;
                xmlParserInputState instate;
                size_t ignoreDepth = 0;
 
                SKIP(6);
                SKIP_BLANKS;
                if (RAW != '[') {
                    xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
                    xmlHaltParser(ctxt);
                    goto error;
                }
                if (ctxt->input->id != id) {
                    xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
                                   "All markup of the conditional section is"
                                   " not in the same entity\n");
                }
                NEXT;
 
                /*
                 * Parse up to the end of the conditional section but disable
                 * SAX event generating DTD building in the meantime
                 */
                state = ctxt->disableSAX;
                instate = ctxt->instate;
                if (ctxt->recovery == 0) ctxt->disableSAX = 1;
                ctxt->instate = XML_PARSER_IGNORE;
 
                while (RAW != 0) {
                    if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
                        SKIP(3);
                        ignoreDepth++;
                        /* Check for integer overflow */
                        if (ignoreDepth == 0) {
                            xmlErrMemory(ctxt, NULL);
                            goto error;
                        }
                    } else if ((RAW == ']') && (NXT(1) == ']') &&
                               (NXT(2) == '>')) {
                        if (ignoreDepth == 0)
                            break;
                        SKIP(3);
                        ignoreDepth--;
                    } else {
                        NEXT;
                    }
                }
 
                ctxt->disableSAX = state;
                ctxt->instate = instate;
 
        if (RAW == 0) {
            xmlFatalErr(ctxt, XML_ERR_CONDSEC_NOT_FINISHED, NULL);
                    goto error;
        }
                if (ctxt->input->id != id) {
                    xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
                                   "All markup of the conditional section is"
                                   " not in the same entity\n");
                }
                SKIP(3);
            } else {
                xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID_KEYWORD, NULL);
                xmlHaltParser(ctxt);
                goto error;
            }
        } else if ((depth > 0) &&
                   (RAW == ']') && (NXT(1) == ']') && (NXT(2) == '>')) {
            depth--;
            if (ctxt->input->id != inputIds[depth]) {
                xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
                               "All markup of the conditional section is not"
                               " in the same entity\n");
            }
            SKIP(3);
        } else {
            int id = ctxt->input->id;
            unsigned long cons = CUR_CONSUMED;
 
            xmlParseMarkupDecl(ctxt);
 
            if ((id == ctxt->input->id) && (cons == CUR_CONSUMED)) {
                xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
                xmlHaltParser(ctxt);
                goto error;
            }
        }
 
        if (depth == 0)
            break;
 
        SKIP_BLANKS;
        GROW;
    }
 
error:
    xmlFree(inputIds);
}

Referenced by xmlParseExternalSubset(), and xmlParseInternalSubset().

xmlParseContent()

void xmlParseContent

(

xmlParserCtxtPtr

ctxt

)

xmlParseContent: @ctxt: an XML parser context

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

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

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

xmlParseContentInternal()

static void xmlParseContentInternal ( xmlParserCtxtPtr  ctxt )

static

xmlParseContentInternal: @ctxt: an XML parser context

Parse a content sequence. Stops at EOF or '</'. Leaves checking of unexpected EOF to the caller.

Definition at line 9873 of file parser.c.

                                               {
    int nameNr = ctxt->nameNr;
 
    GROW;
    while ((RAW != 0) &&
       (ctxt->instate != XML_PARSER_EOF)) {
        int id = ctxt->input->id;
    unsigned long cons = CUR_CONSUMED;
    const xmlChar *cur = ctxt->input->cur;
 
    /*
     * First case : a Processing Instruction.
     */
    if ((*cur == '<') && (cur[1] == '?')) {
        xmlParsePI(ctxt);
    }
 
    /*
     * Second case : a CDSection
     */
    /* 2.6.0 test was *cur not RAW */
    else if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) {
        xmlParseCDSect(ctxt);
    }
 
    /*
     * Third case :  a comment
     */
    else if ((*cur == '<') && (NXT(1) == '!') &&
         (NXT(2) == '-') && (NXT(3) == '-')) {
        xmlParseComment(ctxt);
        ctxt->instate = XML_PARSER_CONTENT;
    }
 
    /*
     * Fourth case :  a sub-element.
     */
    else if (*cur == '<') {
            if (NXT(1) == '/') {
                if (ctxt->nameNr <= nameNr)
                    break;
            xmlParseElementEnd(ctxt);
            } else {
            xmlParseElementStart(ctxt);
            }
    }
 
    /*
     * Fifth case : a reference. If if has not been resolved,
     *    parsing returns it's Name, create the node
     */
 
    else if (*cur == '&') {
        xmlParseReference(ctxt);
    }
 
    /*
     * Last case, text. Note that References are handled directly.
     */
    else {
        xmlParseCharData(ctxt, 0);
    }
 
    GROW;
    SHRINK;
 
    if ((cons == CUR_CONSUMED) && (id == ctxt->input->id)) {
        xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
                    "detected an error in element content\n");
        xmlHaltParser(ctxt);
            break;
    }
    }
}

Referenced by xmlParseContent(), and xmlParseElement().

xmlParseCtxtExternalEntity()

int xmlParseCtxtExternalEntity	(	xmlParserCtxtPtr	ctx,
		const xmlChar *	URL,
		const xmlChar *	ID,
		xmlNodePtr *	lst
	)

xmlParseCtxtExternalEntity: @ctx: the existing parsing context @URL: the URL for the entity to load @ID: the System ID for the entity to load @lst: the return value for the set of parsed nodes

Parse an external general entity within an existing parsing context An external general parsed entity is well-formed if it matches the production labeled extParsedEnt.

[78] extParsedEnt ::= TextDecl? content

Returns 0 if the entity is well formed, -1 in case of args problem and the parser error code otherwise

Definition at line 12968 of file parser.c.

                                                       {
    void *userData;
 
    if (ctx == NULL) return(-1);
    /*
     * If the user provided their own SAX callbacks, then reuse the
     * userData callback field, otherwise the expected setup in a
     * DOM builder is to have userData == ctxt
     */
    if (ctx->userData == ctx)
        userData = NULL;
    else
        userData = ctx->userData;
    return xmlParseExternalEntityPrivate(ctx->myDoc, ctx, ctx->sax,
                                         userData, ctx->depth + 1,
                                         URL, ID, lst);
}

xmlParseDefaultDecl()

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

void 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().

xmlParseDocument()

int xmlParseDocument

(

xmlParserCtxtPtr

ctxt

)

xmlParseDocument: @ctxt: an XML parser context

parse an XML document (and build a tree if using the standard SAX interface).

[1] document ::= prolog element Misc*

[22] prolog ::= XMLDecl? Misc* (doctypedecl Misc*)?

Returns 0, -1 in case of error. the parser context is augmented as a result of the parsing.

Definition at line 10697 of file parser.c.

                                        {
    xmlChar start[4];
    xmlCharEncoding enc;
 
    xmlInitParser();
 
    if ((ctxt == NULL) || (ctxt->input == NULL))
        return(-1);
 
    GROW;
 
    /*
     * SAX: detecting the level.
     */
    xmlDetectSAX2(ctxt);
 
    /*
     * SAX: beginning of the document processing.
     */
    if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
        ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
    if (ctxt->instate == XML_PARSER_EOF)
    return(-1);
 
    if ((ctxt->encoding == NULL) &&
        ((ctxt->input->end - ctxt->input->cur) >= 4)) {
    /*
     * Get the 4 first bytes and decode the charset
     * if enc != XML_CHAR_ENCODING_NONE
     * plug some encoding conversion routines.
     */
    start[0] = RAW;
    start[1] = NXT(1);
    start[2] = NXT(2);
    start[3] = NXT(3);
    enc = xmlDetectCharEncoding(&start[0], 4);
    if (enc != XML_CHAR_ENCODING_NONE) {
        xmlSwitchEncoding(ctxt, enc);
    }
    }
 
 
    if (CUR == 0) {
    xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
    return(-1);
    }
 
    /*
     * Check for the XMLDecl in the Prolog.
     * do not GROW here to avoid the detected encoder to decode more
     * than just the first line, unless the amount of data is really
     * too small to hold "<?xml version="1.0" encoding="foo"
     */
    if ((ctxt->input->end - ctxt->input->cur) < 35) {
       GROW;
    }
    if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
 
    /*
     * Note that we will switch encoding on the fly.
     */
    xmlParseXMLDecl(ctxt);
    if ((ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) ||
        (ctxt->instate == XML_PARSER_EOF)) {
        /*
         * The XML REC instructs us to stop parsing right here
         */
        return(-1);
    }
    ctxt->standalone = ctxt->input->standalone;
    SKIP_BLANKS;
    } else {
    ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
    }
    if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
        ctxt->sax->startDocument(ctxt->userData);
    if (ctxt->instate == XML_PARSER_EOF)
    return(-1);
    if ((ctxt->myDoc != NULL) && (ctxt->input != NULL) &&
        (ctxt->input->buf != NULL) && (ctxt->input->buf->compressed >= 0)) {
    ctxt->myDoc->compression = ctxt->input->buf->compressed;
    }
 
    /*
     * The Misc part of the Prolog
     */
    xmlParseMisc(ctxt);
 
    /*
     * Then possibly doc type declaration(s) and more Misc
     * (doctypedecl Misc*)?
     */
    GROW;
    if (CMP9(CUR_PTR, '<', '!', 'D', 'O', 'C', 'T', 'Y', 'P', 'E')) {
 
    ctxt->inSubset = 1;
    xmlParseDocTypeDecl(ctxt);
    if (RAW == '[') {
        ctxt->instate = XML_PARSER_DTD;
        xmlParseInternalSubset(ctxt);
        if (ctxt->instate == XML_PARSER_EOF)
        return(-1);
    }
 
    /*
     * Create and update the external subset.
     */
    ctxt->inSubset = 2;
    if ((ctxt->sax != NULL) && (ctxt->sax->externalSubset != NULL) &&
        (!ctxt->disableSAX))
        ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
                                  ctxt->extSubSystem, ctxt->extSubURI);
    if (ctxt->instate == XML_PARSER_EOF)
        return(-1);
    ctxt->inSubset = 0;
 
        xmlCleanSpecialAttr(ctxt);
 
    ctxt->instate = XML_PARSER_PROLOG;
    xmlParseMisc(ctxt);
    }
 
    /*
     * Time to start parsing the tree itself
     */
    GROW;
    if (RAW != '<') {
    xmlFatalErrMsg(ctxt, XML_ERR_DOCUMENT_EMPTY,
               "Start tag expected, '<' not found\n");
    } else {
    ctxt->instate = XML_PARSER_CONTENT;
    xmlParseElement(ctxt);
    ctxt->instate = XML_PARSER_EPILOG;
 
 
    /*
     * The Misc part at the end
     */
    xmlParseMisc(ctxt);
 
    if (RAW != 0) {
        xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
    }
    ctxt->instate = XML_PARSER_EOF;
    }
 
    /*
     * SAX: end of the document processing.
     */
    if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
        ctxt->sax->endDocument(ctxt->userData);
 
    /*
     * Remove locally kept entity definitions if the tree was not built
     */
    if ((ctxt->myDoc != NULL) &&
    (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
    xmlFreeDoc(ctxt->myDoc);
    ctxt->myDoc = NULL;
    }
 
    if ((ctxt->wellFormed) && (ctxt->myDoc != NULL)) {
        ctxt->myDoc->properties |= XML_DOC_WELLFORMED;
    if (ctxt->valid)
        ctxt->myDoc->properties |= XML_DOC_DTDVALID;
    if (ctxt->nsWellFormed)
        ctxt->myDoc->properties |= XML_DOC_NSVALID;
    if (ctxt->options & XML_PARSE_OLD10)
        ctxt->myDoc->properties |= XML_DOC_OLD10;
    }
    if (! ctxt->wellFormed) {
    ctxt->valid = 0;
    return(-1);
    }
    return(0);
}

Referenced by testSAX(), xmlDoRead(), and xsltDocDefaultLoaderFunc().

xmlParseElement()

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

xmlElementContentPtr 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));
}

xmlParseElementChildrenContentDeclPriv()

static xmlElementContentPtr xmlParseElementChildrenContentDeclPriv ( xmlParserCtxtPtr  ctxt, int  inputchk, int  depth  )

static

xmlParseElementChildrenContentDeclPriv: @ctxt: an XML parser context @inputchk: the input used for the current entity, needed for boundary checks @depth: the level of recursion

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

                                                  {
    xmlElementContentPtr ret = NULL, cur = NULL, last = NULL, op = NULL;
    const xmlChar *elem;
    xmlChar type = 0;
 
    if (((depth > 128) && ((ctxt->options & XML_PARSE_HUGE) == 0)) ||
        (depth >  2048)) {
        xmlFatalErrMsgInt(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED,
"xmlParseElementChildrenContentDecl : depth %d too deep, use XML_PARSE_HUGE\n",
                          depth);
    return(NULL);
    }
    SKIP_BLANKS;
    GROW;
    if (RAW == '(') {
    int inputid = ctxt->input->id;
 
        /* Recurse on first child */
    NEXT;
    SKIP_BLANKS;
        cur = ret = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
                                                           depth + 1);
        if (cur == NULL)
            return(NULL);
    SKIP_BLANKS;
    GROW;
    } else {
    elem = xmlParseName(ctxt);
    if (elem == NULL) {
        xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
        return(NULL);
    }
        cur = ret = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
    if (cur == NULL) {
        xmlErrMemory(ctxt, NULL);
        return(NULL);
    }
    GROW;
    if (RAW == '?') {
        cur->ocur = XML_ELEMENT_CONTENT_OPT;
        NEXT;
    } else if (RAW == '*') {
        cur->ocur = XML_ELEMENT_CONTENT_MULT;
        NEXT;
    } else if (RAW == '+') {
        cur->ocur = XML_ELEMENT_CONTENT_PLUS;
        NEXT;
    } else {
        cur->ocur = XML_ELEMENT_CONTENT_ONCE;
    }
    GROW;
    }
    SKIP_BLANKS;
    SHRINK;
    while ((RAW != ')') && (ctxt->instate != XML_PARSER_EOF)) {
        /*
     * Each loop we parse one separator and one element.
     */
        if (RAW == ',') {
        if (type == 0) type = CUR;
 
        /*
         * Detect "Name | Name , Name" error
         */
        else if (type != CUR) {
        xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
            "xmlParseElementChildrenContentDecl : '%c' expected\n",
                          type);
        if ((last != NULL) && (last != ret))
            xmlFreeDocElementContent(ctxt->myDoc, last);
        if (ret != NULL)
            xmlFreeDocElementContent(ctxt->myDoc, ret);
        return(NULL);
        }
        NEXT;
 
        op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_SEQ);
        if (op == NULL) {
        if ((last != NULL) && (last != ret))
            xmlFreeDocElementContent(ctxt->myDoc, last);
            xmlFreeDocElementContent(ctxt->myDoc, ret);
        return(NULL);
        }
        if (last == NULL) {
        op->c1 = ret;
        if (ret != NULL)
            ret->parent = op;
        ret = cur = op;
        } else {
            cur->c2 = op;
        if (op != NULL)
            op->parent = cur;
        op->c1 = last;
        if (last != NULL)
            last->parent = op;
        cur =op;
        last = NULL;
        }
    } else if (RAW == '|') {
        if (type == 0) type = CUR;
 
        /*
         * Detect "Name , Name | Name" error
         */
        else if (type != CUR) {
        xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
            "xmlParseElementChildrenContentDecl : '%c' expected\n",
                  type);
        if ((last != NULL) && (last != ret))
            xmlFreeDocElementContent(ctxt->myDoc, last);
        if (ret != NULL)
            xmlFreeDocElementContent(ctxt->myDoc, ret);
        return(NULL);
        }
        NEXT;
 
        op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
        if (op == NULL) {
        if ((last != NULL) && (last != ret))
            xmlFreeDocElementContent(ctxt->myDoc, last);
        if (ret != NULL)
            xmlFreeDocElementContent(ctxt->myDoc, ret);
        return(NULL);
        }
        if (last == NULL) {
        op->c1 = ret;
        if (ret != NULL)
            ret->parent = op;
        ret = cur = op;
        } else {
            cur->c2 = op;
        if (op != NULL)
            op->parent = cur;
        op->c1 = last;
        if (last != NULL)
            last->parent = op;
        cur =op;
        last = NULL;
        }
    } else {
        xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED, NULL);
        if ((last != NULL) && (last != ret))
            xmlFreeDocElementContent(ctxt->myDoc, last);
        if (ret != NULL)
        xmlFreeDocElementContent(ctxt->myDoc, ret);
        return(NULL);
    }
    GROW;
    SKIP_BLANKS;
    GROW;
    if (RAW == '(') {
        int inputid = ctxt->input->id;
        /* Recurse on second child */
        NEXT;
        SKIP_BLANKS;
        last = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
                                                          depth + 1);
            if (last == NULL) {
        if (ret != NULL)
            xmlFreeDocElementContent(ctxt->myDoc, ret);
        return(NULL);
            }
        SKIP_BLANKS;
    } else {
        elem = xmlParseName(ctxt);
        if (elem == NULL) {
        xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
        if (ret != NULL)
            xmlFreeDocElementContent(ctxt->myDoc, ret);
        return(NULL);
        }
        last = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
        if (last == NULL) {
        if (ret != NULL)
            xmlFreeDocElementContent(ctxt->myDoc, ret);
        return(NULL);
        }
        if (RAW == '?') {
        last->ocur = XML_ELEMENT_CONTENT_OPT;
        NEXT;
        } else if (RAW == '*') {
        last->ocur = XML_ELEMENT_CONTENT_MULT;
        NEXT;
        } else if (RAW == '+') {
        last->ocur = XML_ELEMENT_CONTENT_PLUS;
        NEXT;
        } else {
        last->ocur = XML_ELEMENT_CONTENT_ONCE;
        }
    }
    SKIP_BLANKS;
    GROW;
    }
    if ((cur != NULL) && (last != NULL)) {
        cur->c2 = last;
    if (last != NULL)
        last->parent = cur;
    }
    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;
    if (RAW == '?') {
    if (ret != NULL) {
        if ((ret->ocur == XML_ELEMENT_CONTENT_PLUS) ||
            (ret->ocur == XML_ELEMENT_CONTENT_MULT))
            ret->ocur = XML_ELEMENT_CONTENT_MULT;
        else
            ret->ocur = XML_ELEMENT_CONTENT_OPT;
    }
    NEXT;
    } else if (RAW == '*') {
    if (ret != NULL) {
        ret->ocur = XML_ELEMENT_CONTENT_MULT;
        cur = ret;
        /*
         * Some normalization:
         * (a | b* | c?)* == (a | b | c)*
         */
        while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) {
        if ((cur->c1 != NULL) &&
                ((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) ||
             (cur->c1->ocur == XML_ELEMENT_CONTENT_MULT)))
            cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE;
        if ((cur->c2 != NULL) &&
                ((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) ||
             (cur->c2->ocur == XML_ELEMENT_CONTENT_MULT)))
            cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE;
        cur = cur->c2;
        }
    }
    NEXT;
    } else if (RAW == '+') {
    if (ret != NULL) {
        int found = 0;
 
        if ((ret->ocur == XML_ELEMENT_CONTENT_OPT) ||
            (ret->ocur == XML_ELEMENT_CONTENT_MULT))
            ret->ocur = XML_ELEMENT_CONTENT_MULT;
        else
            ret->ocur = XML_ELEMENT_CONTENT_PLUS;
        /*
         * Some normalization:
         * (a | b*)+ == (a | b)*
         * (a | b?)+ == (a | b)*
         */
        while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) {
        if ((cur->c1 != NULL) &&
                ((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) ||
             (cur->c1->ocur == XML_ELEMENT_CONTENT_MULT))) {
            cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE;
            found = 1;
        }
        if ((cur->c2 != NULL) &&
                ((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) ||
             (cur->c2->ocur == XML_ELEMENT_CONTENT_MULT))) {
            cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE;
            found = 1;
        }
        cur = cur->c2;
        }
        if (found)
        ret->ocur = XML_ELEMENT_CONTENT_MULT;
    }
    NEXT;
    }
    return(ret);
}

Referenced by xmlParseElementChildrenContentDecl(), xmlParseElementChildrenContentDeclPriv(), and xmlParseElementContentDecl().

xmlParseElementContentDecl()

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

int 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().

xmlParseElementEnd()

static void xmlParseElementEnd ( xmlParserCtxtPtr  ctxt )

static

xmlParseElementEnd: @ctxt: an XML parser context

Parse the end of an XML element.

Definition at line 10144 of file parser.c.

                                          {
    xmlParserNodeInfo node_info;
    xmlNodePtr ret = ctxt->node;
 
    if (ctxt->nameNr <= 0)
        return;
 
    /*
     * parse the end of tag: '</' should be here.
     */
    if (ctxt->sax2) {
    xmlParseEndTag2(ctxt, &ctxt->pushTab[ctxt->nameNr - 1]);
    namePop(ctxt);
    }
#ifdef LIBXML_SAX1_ENABLED
    else
    xmlParseEndTag1(ctxt, 0);
#endif /* LIBXML_SAX1_ENABLED */
 
    /*
     * Capture end position and add node
     */
    if ( ret != NULL && ctxt->record_info ) {
       node_info.end_pos = ctxt->input->consumed +
                          (CUR_PTR - ctxt->input->base);
       node_info.end_line = ctxt->input->line;
       node_info.node = ret;
       xmlParserAddNodeInfo(ctxt, &node_info);
    }
}

Referenced by xmlParseContentInternal(), and xmlParseElement().

xmlParseElementMixedContentDecl()

xmlElementContentPtr 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().

xmlParseElementStart()

static int xmlParseElementStart ( xmlParserCtxtPtr  ctxt )

static

xmlParseElementStart: @ctxt: an XML parser context

Parse the start of an XML element. Returns -1 in case of error, 0 if an opening tag was parsed, 1 if an empty element was parsed.

Definition at line 10015 of file parser.c.

                                            {
    const xmlChar *name;
    const xmlChar *prefix = NULL;
    const xmlChar *URI = NULL;
    xmlParserNodeInfo node_info;
    int line, tlen = 0;
    xmlNodePtr ret;
    int nsNr = ctxt->nsNr;
 
    if (((unsigned int) ctxt->nameNr > 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);
    }
 
    /* Capture start position */
    if (ctxt->record_info) {
        node_info.begin_pos = ctxt->input->consumed +
                          (CUR_PTR - ctxt->input->base);
    node_info.begin_line = ctxt->input->line;
    }
 
    if (ctxt->spaceNr == 0)
    spacePush(ctxt, -1);
    else if (*ctxt->space == -2)
    spacePush(ctxt, -1);
    else
    spacePush(ctxt, *ctxt->space);
 
    line = ctxt->input->line;
#ifdef LIBXML_SAX1_ENABLED
    if (ctxt->sax2)
#endif /* LIBXML_SAX1_ENABLED */
        name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
#ifdef LIBXML_SAX1_ENABLED
    else
    name = xmlParseStartTag(ctxt);
#endif /* LIBXML_SAX1_ENABLED */
    if (ctxt->instate == XML_PARSER_EOF)
    return(-1);
    if (name == NULL) {
    spacePop(ctxt);
        return(-1);
    }
    nameNsPush(ctxt, name, prefix, URI, line, ctxt->nsNr - nsNr);
    ret = ctxt->node;
 
#ifdef LIBXML_VALID_ENABLED
    /*
     * [ VC: Root Element Type ]
     * The Name in the document type declaration must match the element
     * type of the root element.
     */
    if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
        ctxt->node && (ctxt->node == ctxt->myDoc->children))
        ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
#endif /* LIBXML_VALID_ENABLED */
 
    /*
     * Check for an Empty Element.
     */
    if ((RAW == '/') && (NXT(1) == '>')) {
        SKIP(2);
    if (ctxt->sax2) {
        if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
        (!ctxt->disableSAX))
        ctxt->sax->endElementNs(ctxt->userData, name, prefix, URI);
#ifdef LIBXML_SAX1_ENABLED
    } else {
        if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
        (!ctxt->disableSAX))
        ctxt->sax->endElement(ctxt->userData, name);
#endif /* LIBXML_SAX1_ENABLED */
    }
    namePop(ctxt);
    spacePop(ctxt);
    if (nsNr != ctxt->nsNr)
        nsPop(ctxt, ctxt->nsNr - nsNr);
    if ( ret != NULL && ctxt->record_info ) {
       node_info.end_pos = ctxt->input->consumed +
                  (CUR_PTR - ctxt->input->base);
       node_info.end_line = ctxt->input->line;
       node_info.node = ret;
       xmlParserAddNodeInfo(ctxt, &node_info);
    }
    return(1);
    }
    if (RAW == '>') {
        NEXT1;
    } else {
        xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_GT_REQUIRED,
             "Couldn't find end of Start Tag %s line %d\n",
                        name, line, NULL);
 
    /*
     * end of parsing of this node.
     */
    nodePop(ctxt);
    namePop(ctxt);
    spacePop(ctxt);
    if (nsNr != ctxt->nsNr)
        nsPop(ctxt, ctxt->nsNr - nsNr);
 
    /*
     * Capture end position and add node
     */
    if ( ret != NULL && ctxt->record_info ) {
       node_info.end_pos = ctxt->input->consumed +
                  (CUR_PTR - ctxt->input->base);
       node_info.end_line = ctxt->input->line;
       node_info.node = ret;
       xmlParserAddNodeInfo(ctxt, &node_info);
    }
    return(-1);
    }
 
    return(0);
}

Referenced by xmlParseContentInternal(), and xmlParseElement().

xmlParseEncName()

xmlChar * xmlParseEncName

(

xmlParserCtxtPtr

ctxt

)

xmlParseEncName: @ctxt: an XML parser context

parse the XML encoding name

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

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

const xmlChar * 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().

xmlParseEndTag2()

static void xmlParseEndTag2 ( xmlParserCtxtPtr  ctxt, const xmlStartTag *  tag  )

static

xmlParseEndTag2: @ctxt: an XML parser context line of the start tag @nsNr: number of namespaces on the start tag

parse an end of tag

[42] ETag ::= '</' Name S? '>'

With namespace

[NS 9] ETag ::= '</' QName S? '>'

Definition at line 9697 of file parser.c.

                                                               {
    const xmlChar *name;
 
    GROW;
    if ((RAW != '<') || (NXT(1) != '/')) {
    xmlFatalErr(ctxt, XML_ERR_LTSLASH_REQUIRED, NULL);
    return;
    }
    SKIP(2);
 
    if (tag->prefix == NULL)
        name = xmlParseNameAndCompare(ctxt, ctxt->name);
    else
        name = xmlParseQNameAndCompare(ctxt, ctxt->name, tag->prefix);
 
    /*
     * We should definitely be at the ending "S? '>'" part
     */
    GROW;
    if (ctxt->instate == XML_PARSER_EOF)
        return;
    SKIP_BLANKS;
    if ((!IS_BYTE_CHAR(RAW)) || (RAW != '>')) {
    xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
    } else
    NEXT1;
 
    /*
     * [ WFC: Element Type Match ]
     * The Name in an element's end-tag must match the element type in the
     * start-tag.
     *
     */
    if (name != (xmlChar*)1) {
        if (name == NULL) name = BAD_CAST "unparsable";
        xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
             "Opening and ending tag mismatch: %s line %d and %s\n",
                        ctxt->name, tag->line, name);
    }
 
    /*
     * SAX: End of Tag
     */
    if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
    (!ctxt->disableSAX))
    ctxt->sax->endElementNs(ctxt->userData, ctxt->name, tag->prefix,
                                tag->URI);
 
    spacePop(ctxt);
    if (tag->nsNr != 0)
    nsPop(ctxt, tag->nsNr);
}

Referenced by xmlParseElementEnd().

xmlParseEntityDecl()

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

xmlEntityPtr xmlParseEntityRef

(

xmlParserCtxtPtr

ctxt

)

xmlParseEntityRef: @ctxt: an XML parser context

parse ENTITY references declarations

[68] EntityRef ::= '&' Name ';'

[ WFC: Entity Declared ] In a document without any DTD, a document with only an internal DTD subset which contains no parameter entity references, or a document with "standalone='yes'", the Name given in the entity reference must match that in an entity declaration, except that well-formed documents need not declare any of the following entities: amp, lt, gt, apos, quot. The declaration of a parameter entity must precede any reference to it. Similarly, the declaration of a general entity must precede any reference to it which appears in a default value in an attribute-list declaration. Note that if entities are declared in the external subset or in external parameter entities, a non-validating processor is not obligated to read and process their declarations; for such documents, the rule that an entity must be declared is a well-formedness constraint only if standalone='yes'.

[ WFC: Parsed Entity ] An entity reference must not contain the name of an unparsed entity

Returns the xmlEntityPtr if found, or NULL otherwise.

Definition at line 7531 of file parser.c.

                                         {
    const xmlChar *name;
    xmlEntityPtr ent = NULL;
 
    GROW;
    if (ctxt->instate == XML_PARSER_EOF)
        return(NULL);
 
    if (RAW != '&')
        return(NULL);
    NEXT;
    name = xmlParseName(ctxt);
    if (name == NULL) {
    xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
               "xmlParseEntityRef: no name\n");
        return(NULL);
    }
    if (RAW != ';') {
    xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
    return(NULL);
    }
    NEXT;
 
    /*
     * Predefined entities override any extra definition
     */
    if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
        ent = xmlGetPredefinedEntity(name);
        if (ent != NULL)
            return(ent);
    }
 
    /*
     * Increase the number of entity references parsed
     */
    ctxt->nbentities++;
 
    /*
     * Ask first SAX for entity resolution, otherwise try the
     * entities which may have stored in the parser context.
     */
    if (ctxt->sax != NULL) {
    if (ctxt->sax->getEntity != NULL)
        ent = ctxt->sax->getEntity(ctxt->userData, name);
    if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
        (ctxt->options & XML_PARSE_OLDSAX))
        ent = xmlGetPredefinedEntity(name);
    if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
        (ctxt->userData==ctxt)) {
        ent = xmlSAX2GetEntity(ctxt, name);
    }
    }
    if (ctxt->instate == XML_PARSER_EOF)
    return(NULL);
    /*
     * [ WFC: Entity Declared ]
     * In a document without any DTD, a document with only an
     * internal DTD subset which contains no parameter entity
     * references, or a document with "standalone='yes'", the
     * Name given in the entity reference must match that in an
     * entity declaration, except that well-formed documents
     * need not declare any of the following entities: amp, lt,
     * gt, apos, quot.
     * The declaration of a parameter entity must precede any
     * reference to it.
     * Similarly, the declaration of a general entity must
     * precede any reference to it which appears in a default
     * value in an attribute-list declaration. Note that if
     * entities are declared in the external subset or in
     * external parameter entities, a non-validating processor
     * is not obligated to read and process their declarations;
     * for such documents, the rule that an entity must be
     * declared is a well-formedness constraint only if
     * standalone='yes'.
     */
    if (ent == NULL) {
    if ((ctxt->standalone == 1) ||
        ((ctxt->hasExternalSubset == 0) &&
         (ctxt->hasPErefs == 0))) {
        xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
             "Entity '%s' not defined\n", name);
    } else {
        xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
             "Entity '%s' not defined\n", name);
        if ((ctxt->inSubset == 0) &&
        (ctxt->sax != NULL) &&
        (ctxt->sax->reference != NULL)) {
        ctxt->sax->reference(ctxt->userData, name);
        }
    }
    xmlParserEntityCheck(ctxt, 0, ent, 0);
    ctxt->valid = 0;
    }
 
    /*
     * [ WFC: Parsed Entity ]
     * An entity reference must not contain the name of an
     * unparsed entity
     */
    else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
    xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
         "Entity reference to unparsed entity %s\n", name);
    }
 
    /*
     * [ WFC: No External Entity References ]
     * Attribute values cannot contain direct or indirect
     * entity references to external entities.
     */
    else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
         (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
    xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
         "Attribute references external entity '%s'\n", name);
    }
    /*
     * [ WFC: No < in Attribute Values ]
     * The replacement text of any entity referred to directly or
     * indirectly in an attribute value (other than "&lt;") must
     * not contain a <.
     */
    else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
         (ent != NULL) && 
         (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY)) {
    if (((ent->checked & 1) || (ent->checked == 0)) &&
         (ent->content != NULL) && (xmlStrchr(ent->content, '<'))) {
        xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
    "'<' in entity '%s' is not allowed in attributes values\n", name);
        }
    }
 
    /*
     * Internal check, no parameter entities here ...
     */
    else {
    switch (ent->etype) {
        case XML_INTERNAL_PARAMETER_ENTITY:
        case XML_EXTERNAL_PARAMETER_ENTITY:
        xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
         "Attempt to reference the parameter entity '%s'\n",
                  name);
        break;
        default:
        break;
    }
    }
 
    /*
     * [ WFC: No Recursion ]
     * A parsed entity must not contain a recursive reference
     * to itself, either directly or indirectly.
     * Done somewhere else
     */
    return(ent);
}

Referenced by xmlParseAttValueComplex(), and xmlParseReference().

xmlParseEntityValue()

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

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

parse a value for ENTITY declarations

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

Returns the EntityValue parsed with reference substituted or NULL

Definition at line 3767 of file parser.c.

                                                           {
    xmlChar *buf = NULL;
    int len = 0;
    int size = XML_PARSER_BUFFER_SIZE;
    int c, l;
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
                    XML_MAX_HUGE_LENGTH :
                    XML_MAX_TEXT_LENGTH;
    xmlChar stop;
    xmlChar *ret = NULL;
    const xmlChar *cur = NULL;
    xmlParserInputPtr input;
 
    if (RAW == '"') stop = '"';
    else if (RAW == '\'') stop = '\'';
    else {
    xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_STARTED, NULL);
    return(NULL);
    }
    buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
    if (buf == NULL) {
    xmlErrMemory(ctxt, NULL);
    return(NULL);
    }
 
    /*
     * The content of the entity definition is copied in a buffer.
     */
 
    ctxt->instate = XML_PARSER_ENTITY_VALUE;
    input = ctxt->input;
    GROW;
    if (ctxt->instate == XML_PARSER_EOF)
        goto error;
    NEXT;
    c = CUR_CHAR(l);
    /*
     * NOTE: 4.4.5 Included in Literal
     * When a parameter entity reference appears in a literal entity
     * value, ... a single or double quote character in the replacement
     * text is always treated as a normal data character and will not
     * terminate the literal.
     * In practice it means we stop the loop only when back at parsing
     * the initial entity and the quote is found
     */
    while (((IS_CHAR(c)) && ((c != stop) || /* checked */
        (ctxt->input != input))) && (ctxt->instate != XML_PARSER_EOF)) {
    if (len + 5 >= size) {
        xmlChar *tmp;
 
        size *= 2;
        tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
        if (tmp == NULL) {
        xmlErrMemory(ctxt, NULL);
                goto error;
        }
        buf = tmp;
    }
    COPY_BUF(l,buf,len,c);
    NEXTL(l);
 
    GROW;
    c = CUR_CHAR(l);
    if (c == 0) {
        GROW;
        c = CUR_CHAR(l);
    }
 
        if (len > maxLength) {
            xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_NOT_FINISHED,
                           "entity value too long\n");
            goto error;
        }
    }
    buf[len] = 0;
    if (ctxt->instate == XML_PARSER_EOF)
        goto error;
    if (c != stop) {
        xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_FINISHED, NULL);
        goto error;
    }
    NEXT;
 
    /*
     * Raise problem w.r.t. '&' and '%' being used in non-entities
     * reference constructs. Note Charref will be handled in
     * xmlStringDecodeEntities()
     */
    cur = buf;
    while (*cur != 0) { /* non input consuming */
    if ((*cur == '%') || ((*cur == '&') && (cur[1] != '#'))) {
        xmlChar *name;
        xmlChar tmp = *cur;
            int nameOk = 0;
 
        cur++;
        name = xmlParseStringName(ctxt, &cur);
            if (name != NULL) {
                nameOk = 1;
                xmlFree(name);
            }
            if ((nameOk == 0) || (*cur != ';')) {
        xmlFatalErrMsgInt(ctxt, XML_ERR_ENTITY_CHAR_ERROR,
        "EntityValue: '%c' forbidden except for entities references\n",
                              tmp);
                goto error;
        }
        if ((tmp == '%') && (ctxt->inSubset == 1) &&
        (ctxt->inputNr == 1)) {
        xmlFatalErr(ctxt, XML_ERR_ENTITY_PE_INTERNAL, NULL);
                goto error;
        }
        if (*cur == 0)
            break;
    }
    cur++;
    }
 
    /*
     * Then PEReference entities are substituted.
     *
     * NOTE: 4.4.7 Bypassed
     * When a general entity reference appears in the EntityValue in
     * an entity declaration, it is bypassed and left as is.
     * so XML_SUBSTITUTE_REF is not set here.
     */
    ++ctxt->depth;
    ret = xmlStringDecodeEntities(ctxt, buf, XML_SUBSTITUTE_PEREF,
                                  0, 0, 0);
    --ctxt->depth;
    if (orig != NULL) {
        *orig = buf;
        buf = NULL;
    }
 
error:
    if (buf != NULL)
        xmlFree(buf);
    return(ret);
}

Referenced by xmlParseEntityDecl().

xmlParseEnumeratedType()

int xmlParseEnumeratedType	(	xmlParserCtxtPtr	ctxt,
		xmlEnumerationPtr *	tree
	)

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

parse an Enumerated attribute type.

[57] EnumeratedType ::= NotationType | Enumeration

[58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'

Returns: XML_ATTRIBUTE_ENUMERATION or XML_ATTRIBUTE_NOTATION

Definition at line 5871 of file parser.c.

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

Referenced by xmlParseAttributeType().

xmlParseEnumerationType()

xmlEnumerationPtr xmlParseEnumerationType

(

xmlParserCtxtPtr

ctxt

)

xmlParseEnumerationType: @ctxt: an XML parser context

parse an Enumeration attribute type.

[59] Enumeration ::= '(' S? Nmtoken (S? '|' S? Nmtoken)* S? ')'

[ VC: Enumeration ] Values of this type must match one of the Nmtoken tokens in the declaration

Returns: the enumeration attribute tree built while parsing

Definition at line 5802 of file parser.c.

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

Referenced by xmlParseEnumeratedType().

xmlParseExternalEntityPrivate()

static xmlParserErrors xmlParseExternalEntityPrivate ( xmlDocPtr  doc, xmlParserCtxtPtr  oldctxt, xmlSAXHandlerPtr  sax, void *  user_data, int  depth, const xmlChar *  URL, const xmlChar *  ID, xmlNodePtr *  list  )

static

xmlParseExternalEntityPrivate: @doc: the document the chunk pertains to @oldctxt: the previous parser context if available @sax: the SAX handler block (possibly NULL) @user_data: The user data returned on SAX callbacks (possibly NULL) @depth: Used for loop detection, use 0 @URL: the URL for the entity to load @ID: the System ID for the entity to load @list: the return value for the set of parsed nodes

Private version of xmlParseExternalEntity()

Returns 0 if the entity is well formed, -1 in case of args problem and the parser error code otherwise

Definition at line 13005 of file parser.c.

                                                   {
    xmlParserCtxtPtr ctxt;
    xmlDocPtr newDoc;
    xmlNodePtr newRoot;
    xmlSAXHandlerPtr oldsax = NULL;
    xmlParserErrors ret = XML_ERR_OK;
    xmlChar start[4];
    xmlCharEncoding enc;
 
    if (((depth > 40) &&
    ((oldctxt == NULL) || (oldctxt->options & XML_PARSE_HUGE) == 0)) ||
    (depth > 1024)) {
    return(XML_ERR_ENTITY_LOOP);
    }
 
    if (list != NULL)
        *list = NULL;
    if ((URL == NULL) && (ID == NULL))
    return(XML_ERR_INTERNAL_ERROR);
    if (doc == NULL)
    return(XML_ERR_INTERNAL_ERROR);
 
 
    ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, oldctxt);
    if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
    ctxt->userData = ctxt;
    if (sax != NULL) {
    oldsax = ctxt->sax;
        ctxt->sax = sax;
    if (user_data != NULL)
        ctxt->userData = user_data;
    }
    xmlDetectSAX2(ctxt);
    newDoc = xmlNewDoc(BAD_CAST "1.0");
    if (newDoc == NULL) {
    xmlFreeParserCtxt(ctxt);
    return(XML_ERR_INTERNAL_ERROR);
    }
    newDoc->properties = XML_DOC_INTERNAL;
    if (doc) {
        newDoc->intSubset = doc->intSubset;
        newDoc->extSubset = doc->extSubset;
        if (doc->dict) {
            newDoc->dict = doc->dict;
            xmlDictReference(newDoc->dict);
        }
        if (doc->URL != NULL) {
            newDoc->URL = xmlStrdup(doc->URL);
        }
    }
    newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
    if (newRoot == NULL) {
    if (sax != NULL)
        ctxt->sax = oldsax;
    xmlFreeParserCtxt(ctxt);
    newDoc->intSubset = NULL;
    newDoc->extSubset = NULL;
        xmlFreeDoc(newDoc);
    return(XML_ERR_INTERNAL_ERROR);
    }
    xmlAddChild((xmlNodePtr) newDoc, newRoot);
    nodePush(ctxt, newDoc->children);
    if (doc == NULL) {
        ctxt->myDoc = newDoc;
    } else {
        ctxt->myDoc = doc;
        newRoot->doc = doc;
    }
 
    /*
     * Get the 4 first bytes and decode the charset
     * if enc != XML_CHAR_ENCODING_NONE
     * plug some encoding conversion routines.
     */
    GROW;
    if ((ctxt->input->end - ctxt->input->cur) >= 4) {
    start[0] = RAW;
    start[1] = NXT(1);
    start[2] = NXT(2);
    start[3] = NXT(3);
    enc = xmlDetectCharEncoding(start, 4);
    if (enc != XML_CHAR_ENCODING_NONE) {
        xmlSwitchEncoding(ctxt, enc);
    }
    }
 
    /*
     * Parse a possible text declaration first
     */
    if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
    xmlParseTextDecl(ctxt);
        /*
         * An XML-1.0 document can't reference an entity not XML-1.0
         */
        if ((xmlStrEqual(oldctxt->version, BAD_CAST "1.0")) &&
            (!xmlStrEqual(ctxt->input->version, BAD_CAST "1.0"))) {
            xmlFatalErrMsg(ctxt, XML_ERR_VERSION_MISMATCH,
                           "Version mismatch between document and entity\n");
        }
    }
 
    ctxt->instate = XML_PARSER_CONTENT;
    ctxt->depth = depth;
    if (oldctxt != NULL) {
    ctxt->_private = oldctxt->_private;
    ctxt->loadsubset = oldctxt->loadsubset;
    ctxt->validate = oldctxt->validate;
    ctxt->valid = oldctxt->valid;
    ctxt->replaceEntities = oldctxt->replaceEntities;
        if (oldctxt->validate) {
            ctxt->vctxt.error = oldctxt->vctxt.error;
            ctxt->vctxt.warning = oldctxt->vctxt.warning;
            ctxt->vctxt.userData = oldctxt->vctxt.userData;
        }
    ctxt->external = oldctxt->external;
        if (ctxt->dict) xmlDictFree(ctxt->dict);
        ctxt->dict = oldctxt->dict;
        ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
        ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
        ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
        ctxt->dictNames = oldctxt->dictNames;
        ctxt->attsDefault = oldctxt->attsDefault;
        ctxt->attsSpecial = oldctxt->attsSpecial;
        ctxt->linenumbers = oldctxt->linenumbers;
    ctxt->record_info = oldctxt->record_info;
    ctxt->node_seq.maximum = oldctxt->node_seq.maximum;
    ctxt->node_seq.length = oldctxt->node_seq.length;
    ctxt->node_seq.buffer = oldctxt->node_seq.buffer;
    } else {
    /*
     * Doing validity checking on chunk without context
     * doesn't make sense
     */
    ctxt->_private = NULL;
    ctxt->validate = 0;
    ctxt->external = 2;
    ctxt->loadsubset = 0;
    }
 
    xmlParseContent(ctxt);
 
    if ((RAW == '<') && (NXT(1) == '/')) {
    xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
    } else if (RAW != 0) {
    xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
    }
    if (ctxt->node != newDoc->children) {
    xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
    }
 
    if (!ctxt->wellFormed) {
        if (ctxt->errNo == 0)
        ret = XML_ERR_INTERNAL_ERROR;
    else
        ret = (xmlParserErrors)ctxt->errNo;
    } else {
    if (list != NULL) {
        xmlNodePtr cur;
 
        /*
         * Return the newly created nodeset after unlinking it from
         * they pseudo parent.
         */
        cur = newDoc->children->children;
        *list = cur;
        while (cur != NULL) {
        cur->parent = NULL;
        cur = cur->next;
        }
            newDoc->children->children = NULL;
    }
    ret = XML_ERR_OK;
    }
 
    /*
     * Record in the parent context the number of entities replacement
     * done when parsing that reference.
     */
    if (oldctxt != NULL)
        oldctxt->nbentities += ctxt->nbentities;
 
    /*
     * Also record the size of the entity parsed
     */
    if (ctxt->input != NULL && oldctxt != NULL) {
    oldctxt->sizeentities += ctxt->input->consumed;
    oldctxt->sizeentities += (ctxt->input->cur - ctxt->input->base);
    }
    /*
     * And record the last error if any
     */
    if ((oldctxt != NULL) && (ctxt->lastError.code != XML_ERR_OK))
        xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
 
    if (sax != NULL)
    ctxt->sax = oldsax;
    if (oldctxt != NULL) {
        ctxt->dict = NULL;
        ctxt->attsDefault = NULL;
        ctxt->attsSpecial = NULL;
        oldctxt->validate = ctxt->validate;
        oldctxt->valid = ctxt->valid;
        oldctxt->node_seq.maximum = ctxt->node_seq.maximum;
        oldctxt->node_seq.length = ctxt->node_seq.length;
        oldctxt->node_seq.buffer = ctxt->node_seq.buffer;
    }
    ctxt->node_seq.maximum = 0;
    ctxt->node_seq.length = 0;
    ctxt->node_seq.buffer = NULL;
    xmlFreeParserCtxt(ctxt);
    newDoc->intSubset = NULL;
    newDoc->extSubset = NULL;
    xmlFreeDoc(newDoc);
 
    return(ret);
}

Referenced by xmlParseCtxtExternalEntity(), and xmlParseReference().

xmlParseExternalID()

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

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

Parse an External ID or a Public ID

NOTE: Productions [75] and [83] interact badly since [75] can generate 'PUBLIC' S PubidLiteral S SystemLiteral

[75] ExternalID ::= 'SYSTEM' S SystemLiteral | 'PUBLIC' S PubidLiteral S SystemLiteral

[83] PublicID ::= 'PUBLIC' S PubidLiteral

Returns the function returns SystemLiteral and in the second case publicID receives PubidLiteral, is strict is off it is possible to return NULL and have publicID set.

Definition at line 4683 of file parser.c.

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

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

xmlParseExternalSubset()

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

xmlParseExternalSubset: @ctxt: an XML parser context @ExternalID: the external identifier @SystemID: the system identifier (or URL)

parse Markup declarations from an external subset

[30] extSubset ::= textDecl? extSubsetDecl

[31] extSubsetDecl ::= (markupdecl | conditionalSect | PEReference | S) *

Definition at line 6998 of file parser.c.

                                                {
    xmlDetectSAX2(ctxt);
    GROW;
 
    if ((ctxt->encoding == NULL) &&
        (ctxt->input->end - ctxt->input->cur >= 4)) {
        xmlChar start[4];
    xmlCharEncoding enc;
 
    start[0] = RAW;
    start[1] = NXT(1);
    start[2] = NXT(2);
    start[3] = NXT(3);
    enc = xmlDetectCharEncoding(start, 4);
    if (enc != XML_CHAR_ENCODING_NONE)
        xmlSwitchEncoding(ctxt, enc);
    }
 
    if (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) {
    xmlParseTextDecl(ctxt);
    if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
        /*
         * The XML REC instructs us to stop parsing right here
         */
        xmlHaltParser(ctxt);
        return;
    }
    }
    if (ctxt->myDoc == NULL) {
        ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
    if (ctxt->myDoc == NULL) {
        xmlErrMemory(ctxt, "New Doc failed");
        return;
    }
    ctxt->myDoc->properties = XML_DOC_INTERNAL;
    }
    if ((ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset == NULL))
        xmlCreateIntSubset(ctxt->myDoc, NULL, ExternalID, SystemID);
 
    ctxt->instate = XML_PARSER_DTD;
    ctxt->external = 1;
    SKIP_BLANKS;
    while (((RAW == '<') && (NXT(1) == '?')) ||
           ((RAW == '<') && (NXT(1) == '!')) ||
       (RAW == '%')) {
    int id = ctxt->input->id;
    unsigned long cons = CUR_CONSUMED;
 
    GROW;
        if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
        xmlParseConditionalSections(ctxt);
    } else
        xmlParseMarkupDecl(ctxt);
        SKIP_BLANKS;
 
    if ((id == ctxt->input->id) && (cons == CUR_CONSUMED)) {
        xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
        break;
    }
    }
 
    if (RAW != 0) {
    xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
    }
 
}

Referenced by xmlSAX2ExternalSubset().

xmlParseExtParsedEnt()

int xmlParseExtParsedEnt

(

xmlParserCtxtPtr

ctxt

)

xmlParseExtParsedEnt: @ctxt: an XML parser context

parse a general parsed entity An external general parsed entity is well-formed if it matches the production labeled extParsedEnt.

[78] extParsedEnt ::= TextDecl? content

Returns 0, -1 in case of error. the parser context is augmented as a result of the parsing.

Definition at line 10889 of file parser.c.

                                            {
    xmlChar start[4];
    xmlCharEncoding enc;
 
    if ((ctxt == NULL) || (ctxt->input == NULL))
        return(-1);
 
    xmlDetectSAX2(ctxt);
 
    GROW;
 
    /*
     * SAX: beginning of the document processing.
     */
    if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
        ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
 
    /*
     * Get the 4 first bytes and decode the charset
     * if enc != XML_CHAR_ENCODING_NONE
     * plug some encoding conversion routines.
     */
    if ((ctxt->input->end - ctxt->input->cur) >= 4) {
    start[0] = RAW;
    start[1] = NXT(1);
    start[2] = NXT(2);
    start[3] = NXT(3);
    enc = xmlDetectCharEncoding(start, 4);
    if (enc != XML_CHAR_ENCODING_NONE) {
        xmlSwitchEncoding(ctxt, enc);
    }
    }
 
 
    if (CUR == 0) {
    xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
    }
 
    /*
     * Check for the XMLDecl in the Prolog.
     */
    GROW;
    if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
 
    /*
     * Note that we will switch encoding on the fly.
     */
    xmlParseXMLDecl(ctxt);
    if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
        /*
         * The XML REC instructs us to stop parsing right here
         */
        return(-1);
    }
    SKIP_BLANKS;
    } else {
    ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
    }
    if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
        ctxt->sax->startDocument(ctxt->userData);
    if (ctxt->instate == XML_PARSER_EOF)
    return(-1);
 
    /*
     * Doing validity checking on chunk doesn't make sense
     */
    ctxt->instate = XML_PARSER_CONTENT;
    ctxt->validate = 0;
    ctxt->loadsubset = 0;
    ctxt->depth = 0;
 
    xmlParseContent(ctxt);
    if (ctxt->instate == XML_PARSER_EOF)
    return(-1);
 
    if ((RAW == '<') && (NXT(1) == '/')) {
    xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
    } else if (RAW != 0) {
    xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
    }
 
    /*
     * SAX: end of the document processing.
     */
    if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
        ctxt->sax->endDocument(ctxt->userData);
 
    if (! ctxt->wellFormed) return(-1);
    return(0);
}

xmlParseInNodeContext()

xmlParserErrors xmlParseInNodeContext	(	xmlNodePtr	node,
		const char *	data,
		int	datalen,
		int	options,
		xmlNodePtr *	lst
	)

xmlParseInNodeContext: @node: the context node @data: the input string @datalen: the input string length in bytes @options: a combination of xmlParserOption @lst: the return value for the set of parsed nodes

Parse a well-balanced chunk of an XML document within the context (DTD, namespaces, etc ...) of the given node.

The allowed sequence for the data is a Well Balanced Chunk defined by the content production in the XML grammar:

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

Returns XML_ERR_OK if the chunk is well balanced, and the parser error code otherwise

Definition at line 13496 of file parser.c.

                                                    {
#ifdef SAX2
    xmlParserCtxtPtr ctxt;
    xmlDocPtr doc = NULL;
    xmlNodePtr fake, cur;
    int nsnr = 0;
 
    xmlParserErrors ret = XML_ERR_OK;
 
    /*
     * check all input parameters, grab the document
     */
    if ((lst == NULL) || (node == NULL) || (data == NULL) || (datalen < 0))
        return(XML_ERR_INTERNAL_ERROR);
    switch (node->type) {
        case XML_ELEMENT_NODE:
        case XML_ATTRIBUTE_NODE:
        case XML_TEXT_NODE:
        case XML_CDATA_SECTION_NODE:
        case XML_ENTITY_REF_NODE:
        case XML_PI_NODE:
        case XML_COMMENT_NODE:
        case XML_DOCUMENT_NODE:
        case XML_HTML_DOCUMENT_NODE:
        break;
    default:
        return(XML_ERR_INTERNAL_ERROR);
 
    }
    while ((node != NULL) && (node->type != XML_ELEMENT_NODE) &&
           (node->type != XML_DOCUMENT_NODE) &&
       (node->type != XML_HTML_DOCUMENT_NODE))
    node = node->parent;
    if (node == NULL)
    return(XML_ERR_INTERNAL_ERROR);
    if (node->type == XML_ELEMENT_NODE)
    doc = node->doc;
    else
        doc = (xmlDocPtr) node;
    if (doc == NULL)
    return(XML_ERR_INTERNAL_ERROR);
 
    /*
     * allocate a context and set-up everything not related to the
     * node position in the tree
     */
    if (doc->type == XML_DOCUMENT_NODE)
    ctxt = xmlCreateMemoryParserCtxt((char *) data, datalen);
#ifdef LIBXML_HTML_ENABLED
    else if (doc->type == XML_HTML_DOCUMENT_NODE) {
    ctxt = htmlCreateMemoryParserCtxt((char *) data, datalen);
        /*
         * When parsing in context, it makes no sense to add implied
         * elements like html/body/etc...
         */
        options |= HTML_PARSE_NOIMPLIED;
    }
#endif
    else
        return(XML_ERR_INTERNAL_ERROR);
 
    if (ctxt == NULL)
        return(XML_ERR_NO_MEMORY);
 
    /*
     * Use input doc's dict if present, else assure XML_PARSE_NODICT is set.
     * We need a dictionary for xmlDetectSAX2, so if there's no doc dict
     * we must wait until the last moment to free the original one.
     */
    if (doc->dict != NULL) {
        if (ctxt->dict != NULL)
        xmlDictFree(ctxt->dict);
    ctxt->dict = doc->dict;
    } else
        options |= XML_PARSE_NODICT;
 
    if (doc->encoding != NULL) {
        xmlCharEncodingHandlerPtr hdlr;
 
        if (ctxt->encoding != NULL)
        xmlFree((xmlChar *) ctxt->encoding);
        ctxt->encoding = xmlStrdup((const xmlChar *) doc->encoding);
 
        hdlr = xmlFindCharEncodingHandler((const char *) doc->encoding);
        if (hdlr != NULL) {
            xmlSwitchToEncoding(ctxt, hdlr);
    } else {
            return(XML_ERR_UNSUPPORTED_ENCODING);
        }
    }
 
    xmlCtxtUseOptionsInternal(ctxt, options, NULL);
    xmlDetectSAX2(ctxt);
    ctxt->myDoc = doc;
    /* parsing in context, i.e. as within existing content */
    ctxt->input_id = 2;
    ctxt->instate = XML_PARSER_CONTENT;
 
    fake = xmlNewDocComment(node->doc, NULL);
    if (fake == NULL) {
        xmlFreeParserCtxt(ctxt);
    return(XML_ERR_NO_MEMORY);
    }
    xmlAddChild(node, fake);
 
    if (node->type == XML_ELEMENT_NODE) {
    nodePush(ctxt, node);
    /*
     * initialize the SAX2 namespaces stack
     */
    cur = node;
    while ((cur != NULL) && (cur->type == XML_ELEMENT_NODE)) {
        xmlNsPtr ns = cur->nsDef;
        const xmlChar *iprefix, *ihref;
 
        while (ns != NULL) {
        if (ctxt->dict) {
            iprefix = xmlDictLookup(ctxt->dict, ns->prefix, -1);
            ihref = xmlDictLookup(ctxt->dict, ns->href, -1);
        } else {
            iprefix = ns->prefix;
            ihref = ns->href;
        }
 
            if (xmlGetNamespace(ctxt, iprefix) == NULL) {
            nsPush(ctxt, iprefix, ihref);
            nsnr++;
        }
        ns = ns->next;
        }
        cur = cur->parent;
    }
    }
 
    if ((ctxt->validate) || (ctxt->replaceEntities != 0)) {
    /*
     * ID/IDREF registration will be done in xmlValidateElement below
     */
    ctxt->loadsubset |= XML_SKIP_IDS;
    }
 
#ifdef LIBXML_HTML_ENABLED
    if (doc->type == XML_HTML_DOCUMENT_NODE)
        __htmlParseContent(ctxt);
    else
#endif
    xmlParseContent(ctxt);
 
    nsPop(ctxt, nsnr);
    if ((RAW == '<') && (NXT(1) == '/')) {
    xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
    } else if (RAW != 0) {
    xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
    }
    if ((ctxt->node != NULL) && (ctxt->node != node)) {
    xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
    ctxt->wellFormed = 0;
    }
 
    if (!ctxt->wellFormed) {
        if (ctxt->errNo == 0)
        ret = XML_ERR_INTERNAL_ERROR;
    else
        ret = (xmlParserErrors)ctxt->errNo;
    } else {
        ret = XML_ERR_OK;
    }
 
    /*
     * Return the newly created nodeset after unlinking it from
     * the pseudo sibling.
     */
 
    cur = fake->next;
    fake->next = NULL;
    node->last = fake;
 
    if (cur != NULL) {
    cur->prev = NULL;
    }
 
    *lst = cur;
 
    while (cur != NULL) {
    cur->parent = NULL;
    cur = cur->next;
    }
 
    xmlUnlinkNode(fake);
    xmlFreeNode(fake);
 
 
    if (ret != XML_ERR_OK) {
        xmlFreeNodeList(*lst);
    *lst = NULL;
    }
 
    if (doc->dict != NULL)
        ctxt->dict = NULL;
    xmlFreeParserCtxt(ctxt);
 
    return(ret);
#else /* !SAX2 */
    return(XML_ERR_INTERNAL_ERROR);
#endif
}

xmlParseInternalSubset()

static void xmlParseInternalSubset ( xmlParserCtxtPtr  ctxt )

static

xmlParseInternalSubset: @ctxt: an XML parser context

parse the internal subset declaration

[28 end] ('[' (markupdecl | PEReference | S)* ']' S?)? '>'

Definition at line 8354 of file parser.c.

                                              {
    /*
     * Is there any DTD definition ?
     */
    if (RAW == '[') {
        int baseInputNr = ctxt->inputNr;
        ctxt->instate = XML_PARSER_DTD;
        NEXT;
    /*
     * Parse the succession of Markup declarations and
     * PEReferences.
     * Subsequence (markupdecl | PEReference | S)*
     */
    while (((RAW != ']') || (ctxt->inputNr > baseInputNr)) &&
               (ctxt->instate != XML_PARSER_EOF)) {
        int id = ctxt->input->id;
        unsigned long cons = CUR_CONSUMED;
 
        SKIP_BLANKS;
        xmlParseMarkupDecl(ctxt);
        xmlParsePEReference(ctxt);
 
            /*
             * Conditional sections are allowed from external entities included
             * by PE References in the internal subset.
             */
            if ((ctxt->inputNr > 1) && (ctxt->input->filename != NULL) &&
                (RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
                xmlParseConditionalSections(ctxt);
            }
 
        if ((id == ctxt->input->id) && (cons == CUR_CONSUMED)) {
        xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
         "xmlParseInternalSubset: error detected in Markup declaration\n");
                if (ctxt->inputNr > baseInputNr)
                    xmlPopInput(ctxt);
                else
            break;
        }
    }
    if (RAW == ']') {
        NEXT;
        SKIP_BLANKS;
    }
    }
 
    /*
     * We should be at the end of the DOCTYPE declaration.
     */
    if (RAW != '>') {
    xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
    return;
    }
    NEXT;
}

Referenced by xmlParseDocument().

xmlParseMarkupDecl()

void xmlParseMarkupDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseMarkupDecl: @ctxt: an XML parser context

parse Markup declarations

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

[ VC: Proper Declaration/PE Nesting ] Parameter-entity replacement text must be properly nested with markup declarations. That is to say, if either the first character or the last character of a markup declaration (markupdecl above) is contained in the replacement text for a parameter-entity reference, both must be contained in the same replacement text.

[ WFC: PEs in Internal Subset ] In the internal DTD subset, parameter-entity references can occur only where markup declarations can occur, not within markup declarations. (This does not apply to references that occur in external parameter entities or to the external subset.)

Definition at line 6866 of file parser.c.

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

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

xmlParseMisc()

void xmlParseMisc

(

xmlParserCtxtPtr

ctxt

)

xmlParseMisc: @ctxt: an XML parser context

parse an XML Misc* optional field.

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

Definition at line 10667 of file parser.c.

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

Referenced by xmlParseDocument().

xmlParseName()

const xmlChar * xmlParseName

(

xmlParserCtxtPtr

ctxt

)

xmlParseName: @ctxt: an XML parser context

parse an XML name.

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

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

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

Returns the Name parsed or NULL

Definition at line 3344 of file parser.c.

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

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

xmlParseNameAndCompare()

static const xmlChar * xmlParseNameAndCompare ( xmlParserCtxtPtr  ctxt, xmlChar const *  other  )

static

xmlParseNameAndCompare: @ctxt: an XML parser context

parse an XML name and compares for match (specialized for endtag parsing)

Returns NULL for an illegal name, (xmlChar*) 1 for success and the name for mismatch

Definition at line 3525 of file parser.c.

                                                                    {
    register const xmlChar *cmp = other;
    register const xmlChar *in;
    const xmlChar *ret;
 
    GROW;
    if (ctxt->instate == XML_PARSER_EOF)
        return(NULL);
 
    in = ctxt->input->cur;
    while (*in != 0 && *in == *cmp) {
    ++in;
    ++cmp;
    }
    if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) {
    /* success */
    ctxt->input->col += in - ctxt->input->cur;
    ctxt->input->cur = in;
    return (const xmlChar*) 1;
    }
    /* failure (or end of input buffer), check with full function */
    ret = xmlParseName (ctxt);
    /* strings coming from the dictionary direct compare possible */
    if (ret == other) {
    return (const xmlChar*) 1;
    }
    return ret;
}

Referenced by xmlParseEndTag2(), and xmlParseQNameAndCompare().

xmlParseNameComplex()

static const xmlChar * xmlParseNameComplex ( xmlParserCtxtPtr  ctxt )

static

Definition at line 3203 of file parser.c.

                                           {
    int len = 0, l;
    int c;
    int count = 0;
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
                    XML_MAX_TEXT_LENGTH :
                    XML_MAX_NAME_LENGTH;
 
#ifdef DEBUG
    nbParseNameComplex++;
#endif
 
    /*
     * Handler for more complex cases
     */
    GROW;
    if (ctxt->instate == XML_PARSER_EOF)
        return(NULL);
    c = CUR_CHAR(l);
    if ((ctxt->options & XML_PARSE_OLD10) == 0) {
        /*
     * Use the new checks of production [4] [4a] amd [5] of the
     * Update 5 of XML-1.0
     */
    if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
        (!(((c >= 'a') && (c <= 'z')) ||
           ((c >= 'A') && (c <= 'Z')) ||
           (c == '_') || (c == ':') ||
           ((c >= 0xC0) && (c <= 0xD6)) ||
           ((c >= 0xD8) && (c <= 0xF6)) ||
           ((c >= 0xF8) && (c <= 0x2FF)) ||
           ((c >= 0x370) && (c <= 0x37D)) ||
           ((c >= 0x37F) && (c <= 0x1FFF)) ||
           ((c >= 0x200C) && (c <= 0x200D)) ||
           ((c >= 0x2070) && (c <= 0x218F)) ||
           ((c >= 0x2C00) && (c <= 0x2FEF)) ||
           ((c >= 0x3001) && (c <= 0xD7FF)) ||
           ((c >= 0xF900) && (c <= 0xFDCF)) ||
           ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
           ((c >= 0x10000) && (c <= 0xEFFFF))))) {
        return(NULL);
    }
    len += l;
    NEXTL(l);
    c = CUR_CHAR(l);
    while ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */
           (((c >= 'a') && (c <= 'z')) ||
            ((c >= 'A') && (c <= 'Z')) ||
            ((c >= '0') && (c <= '9')) || /* !start */
            (c == '_') || (c == ':') ||
            (c == '-') || (c == '.') || (c == 0xB7) || /* !start */
            ((c >= 0xC0) && (c <= 0xD6)) ||
            ((c >= 0xD8) && (c <= 0xF6)) ||
            ((c >= 0xF8) && (c <= 0x2FF)) ||
            ((c >= 0x300) && (c <= 0x36F)) || /* !start */
            ((c >= 0x370) && (c <= 0x37D)) ||
            ((c >= 0x37F) && (c <= 0x1FFF)) ||
            ((c >= 0x200C) && (c <= 0x200D)) ||
            ((c >= 0x203F) && (c <= 0x2040)) || /* !start */
            ((c >= 0x2070) && (c <= 0x218F)) ||
            ((c >= 0x2C00) && (c <= 0x2FEF)) ||
            ((c >= 0x3001) && (c <= 0xD7FF)) ||
            ((c >= 0xF900) && (c <= 0xFDCF)) ||
            ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
            ((c >= 0x10000) && (c <= 0xEFFFF))
        )) {
        if (count++ > XML_PARSER_CHUNK_SIZE) {
        count = 0;
        GROW;
                if (ctxt->instate == XML_PARSER_EOF)
                    return(NULL);
        }
            if (len <= INT_MAX - l)
            len += l;
        NEXTL(l);
        c = CUR_CHAR(l);
    }
    } else {
    if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
        (!IS_LETTER(c) && (c != '_') &&
         (c != ':'))) {
        return(NULL);
    }
    len += l;
    NEXTL(l);
    c = CUR_CHAR(l);
 
    while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
           ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
        (c == '.') || (c == '-') ||
        (c == '_') || (c == ':') ||
        (IS_COMBINING(c)) ||
        (IS_EXTENDER(c)))) {
        if (count++ > XML_PARSER_CHUNK_SIZE) {
        count = 0;
        GROW;
                if (ctxt->instate == XML_PARSER_EOF)
                    return(NULL);
        }
            if (len <= INT_MAX - l)
            len += l;
        NEXTL(l);
        c = CUR_CHAR(l);
    }
    }
    if (len > maxLength) {
        xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Name");
        return(NULL);
    }
    if (ctxt->input->cur - ctxt->input->base < len) {
        /*
         * There were a couple of bugs where PERefs lead to to a change
         * of the buffer. Check the buffer size to avoid passing an invalid
         * pointer to xmlDictLookup.
         */
        xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
                    "unexpected change of input buffer");
        return (NULL);
    }
    if ((*ctxt->input->cur == '\n') && (ctxt->input->cur[-1] == '\r'))
        return(xmlDictLookup(ctxt->dict, ctxt->input->cur - (len + 1), len));
    return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
}

Referenced by xmlParseName().

xmlParseNCName()

static const xmlChar * xmlParseNCName ( xmlParserCtxtPtr  ctxt )

static

xmlParseNCName: @ctxt: an XML parser context @len: length of the string parsed

parse an XML name.

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

[5NS] NCName ::= (Letter | '_') (NCNameChar)*

Returns the Name parsed or NULL

Definition at line 3465 of file parser.c.

                                      {
    const xmlChar *in, *e;
    const xmlChar *ret;
    size_t count = 0;
    size_t maxLength = (ctxt->options & XML_PARSE_HUGE) ?
                       XML_MAX_TEXT_LENGTH :
                       XML_MAX_NAME_LENGTH;
 
#ifdef DEBUG
    nbParseNCName++;
#endif
 
    /*
     * Accelerator for simple ASCII names
     */
    in = ctxt->input->cur;
    e = ctxt->input->end;
    if ((((*in >= 0x61) && (*in <= 0x7A)) ||
     ((*in >= 0x41) && (*in <= 0x5A)) ||
     (*in == '_')) && (in < e)) {
    in++;
    while ((((*in >= 0x61) && (*in <= 0x7A)) ||
            ((*in >= 0x41) && (*in <= 0x5A)) ||
            ((*in >= 0x30) && (*in <= 0x39)) ||
            (*in == '_') || (*in == '-') ||
            (*in == '.')) && (in < e))
        in++;
    if (in >= e)
        goto complex;
    if ((*in > 0) && (*in < 0x80)) {
        count = in - ctxt->input->cur;
            if (count > maxLength) {
                xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
                return(NULL);
            }
        ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
        ctxt->input->cur = in;
        ctxt->input->col += count;
        if (ret == NULL) {
            xmlErrMemory(ctxt, NULL);
        }
        return(ret);
    }
    }
complex:
    return(xmlParseNCNameComplex(ctxt));
}

Referenced by xmlParseQName().

xmlParseNCNameComplex()

static const xmlChar * xmlParseNCNameComplex ( xmlParserCtxtPtr  ctxt )

static

Definition at line 3391 of file parser.c.

                                             {
    int len = 0, l;
    int c;
    int count = 0;
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
                    XML_MAX_TEXT_LENGTH :
                    XML_MAX_NAME_LENGTH;
    size_t startPosition = 0;
 
#ifdef DEBUG
    nbParseNCNameComplex++;
#endif
 
    /*
     * Handler for more complex cases
     */
    GROW;
    startPosition = CUR_PTR - BASE_PTR;
    c = CUR_CHAR(l);
    if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
    (!xmlIsNameStartChar(ctxt, c) || (c == ':'))) {
    return(NULL);
    }
 
    while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
       (xmlIsNameChar(ctxt, c) && (c != ':'))) {
    if (count++ > XML_PARSER_CHUNK_SIZE) {
        count = 0;
        GROW;
            if (ctxt->instate == XML_PARSER_EOF)
                return(NULL);
    }
        if (len <= INT_MAX - l)
        len += l;
    NEXTL(l);
    c = CUR_CHAR(l);
    if (c == 0) {
        count = 0;
        /*
         * when shrinking to extend the buffer we really need to preserve
         * the part of the name we already parsed. Hence rolling back
         * by current length.
         */
        ctxt->input->cur -= l;
        GROW;
            if (ctxt->instate == XML_PARSER_EOF)
                return(NULL);
        ctxt->input->cur += l;
        c = CUR_CHAR(l);
    }
    }
    if (len > maxLength) {
        xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
        return(NULL);
    }
    return(xmlDictLookup(ctxt->dict, (BASE_PTR + startPosition), len));
}

Referenced by xmlParseNCName().

xmlParseNmtoken()

xmlChar * xmlParseNmtoken

(

xmlParserCtxtPtr

ctxt

)

xmlParseNmtoken: @ctxt: an XML parser context

parse an XML Nmtoken.

[7] Nmtoken ::= (NameChar)+

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

Returns the Nmtoken parsed or NULL

Definition at line 3662 of file parser.c.

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

Referenced by xmlParseEnumerationType(), and xmlParseQName().

xmlParseNotationDecl()

void xmlParseNotationDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseNotationDecl: @ctxt: an XML parser context

parse a notation declaration

[82] NotationDecl ::= '<!NOTATION' S Name S (ExternalID | PublicID) S? '>'

Hence there is actually 3 choices: 'PUBLIC' S PubidLiteral 'PUBLIC' S PubidLiteral S SystemLiteral and 'SYSTEM' S SystemLiteral

See the NOTE on xmlParseExternalID().

Definition at line 5331 of file parser.c.

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

Referenced by xmlParseMarkupDecl().

xmlParseNotationType()

xmlEnumerationPtr xmlParseNotationType

(

xmlParserCtxtPtr

ctxt

)

xmlParseNotationType: @ctxt: an XML parser context

parse an Notation attribute type.

Note: the leading 'NOTATION' S part has already being parsed...

[58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'

[ VC: Notation Attributes ] Values of this type must match one of the notation names included in the declaration; all notation names in the declaration must be declared.

Returns: the notation attribute tree built while parsing

Definition at line 5732 of file parser.c.

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

Referenced by xmlParseEnumeratedType().

xmlParsePEReference()

void xmlParsePEReference

(

xmlParserCtxtPtr

ctxt

)

xmlParsePEReference: @ctxt: an XML parser context

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

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

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

[ WFC: Entity Declared ] In a document without any DTD, a document with only an internal DTD subset which contains no parameter entity references, or a document with "standalone='yes'", ... ... The declaration of a parameter entity must precede any reference to it...

[ VC: Entity Declared ] In a document with an external subset or external parameter entities with "standalone='no'", ... ... The declaration of a parameter entity must precede any reference to it...

[ WFC: In DTD ] Parameter-entity references may only appear in the DTD. NOTE: misleading but this is handled.

Definition at line 7912 of file parser.c.

{
    const xmlChar *name;
    xmlEntityPtr entity = NULL;
    xmlParserInputPtr input;
 
    if (RAW != '%')
        return;
    NEXT;
    name = xmlParseName(ctxt);
    if (name == NULL) {
    xmlFatalErrMsg(ctxt, XML_ERR_PEREF_NO_NAME, "PEReference: no name\n");
    return;
    }
    if (xmlParserDebugEntities)
    xmlGenericError(xmlGenericErrorContext,
        "PEReference: %s\n", name);
    if (RAW != ';') {
    xmlFatalErr(ctxt, XML_ERR_PEREF_SEMICOL_MISSING, NULL);
        return;
    }
 
    NEXT;
 
    /*
     * Increase the number of entity references parsed
     */
    ctxt->nbentities++;
 
    /*
     * Request the entity from SAX
     */
    if ((ctxt->sax != NULL) &&
    (ctxt->sax->getParameterEntity != NULL))
    entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
    if (ctxt->instate == XML_PARSER_EOF)
    return;
    if (entity == NULL) {
    /*
     * [ WFC: Entity Declared ]
     * In a document without any DTD, a document with only an
     * internal DTD subset which contains no parameter entity
     * references, or a document with "standalone='yes'", ...
     * ... The declaration of a parameter entity must precede
     * any reference to it...
     */
    if ((ctxt->standalone == 1) ||
        ((ctxt->hasExternalSubset == 0) &&
         (ctxt->hasPErefs == 0))) {
        xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
                  "PEReference: %%%s; not found\n",
                  name);
    } else {
        /*
         * [ VC: Entity Declared ]
         * In a document with an external subset or external
         * parameter entities with "standalone='no'", ...
         * ... The declaration of a parameter entity must
         * precede any reference to it...
         */
            if ((ctxt->validate) && (ctxt->vctxt.error != NULL)) {
                xmlValidityError(ctxt, XML_WAR_UNDECLARED_ENTITY,
                                 "PEReference: %%%s; not found\n",
                                 name, NULL);
            } else
                xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
                              "PEReference: %%%s; not found\n",
                              name, NULL);
            ctxt->valid = 0;
    }
    xmlParserEntityCheck(ctxt, 0, NULL, 0);
    } else {
    /*
     * Internal checking in case the entity quest barfed
     */
    if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
        (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
        xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
          "Internal: %%%s; is not a parameter entity\n",
              name, NULL);
    } else {
            xmlChar start[4];
            xmlCharEncoding enc;
 
        if (xmlParserEntityCheck(ctxt, 0, entity, 0))
            return;
 
        if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
            ((ctxt->options & XML_PARSE_NOENT) == 0) &&
        ((ctxt->options & XML_PARSE_DTDVALID) == 0) &&
        ((ctxt->options & XML_PARSE_DTDLOAD) == 0) &&
        ((ctxt->options & XML_PARSE_DTDATTR) == 0) &&
        (ctxt->replaceEntities == 0) &&
        (ctxt->validate == 0))
        return;
 
        input = xmlNewEntityInputStream(ctxt, entity);
        if (xmlPushInput(ctxt, input) < 0) {
                xmlFreeInputStream(input);
        return;
            }
 
        if (entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) {
                /*
                 * Get the 4 first bytes and decode the charset
                 * if enc != XML_CHAR_ENCODING_NONE
                 * plug some encoding conversion routines.
                 * Note that, since we may have some non-UTF8
                 * encoding (like UTF16, bug 135229), the 'length'
                 * is not known, but we can calculate based upon
                 * the amount of data in the buffer.
                 */
                GROW
                if (ctxt->instate == XML_PARSER_EOF)
                    return;
                if ((ctxt->input->end - ctxt->input->cur)>=4) {
                    start[0] = RAW;
                    start[1] = NXT(1);
                    start[2] = NXT(2);
                    start[3] = NXT(3);
                    enc = xmlDetectCharEncoding(start, 4);
                    if (enc != XML_CHAR_ENCODING_NONE) {
                        xmlSwitchEncoding(ctxt, enc);
                    }
                }
 
                if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) &&
                    (IS_BLANK_CH(NXT(5)))) {
                    xmlParseTextDecl(ctxt);
                }
            }
    }
    }
    ctxt->hasPErefs = 1;
}

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

xmlParsePI()

void xmlParsePI

(

xmlParserCtxtPtr

ctxt

)

xmlParsePI: @ctxt: an XML parser context

parse an XML Processing Instruction.

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

The processing is transferred to SAX once parsed.

Definition at line 5174 of file parser.c.

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

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

xmlParsePITarget()

const xmlChar * xmlParsePITarget

(

xmlParserCtxtPtr

ctxt

)

xmlParsePITarget: @ctxt: an XML parser context

parse the name of a PI

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

Returns the PITarget name or NULL

Definition at line 5066 of file parser.c.

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

Referenced by xmlParsePI().

xmlParsePubidLiteral()

xmlChar * xmlParsePubidLiteral

(

xmlParserCtxtPtr

ctxt

)

xmlParsePubidLiteral: @ctxt: an XML parser context

parse an XML public literal

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

Returns the PubidLiteral parsed or NULL.

Definition at line 4291 of file parser.c.

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

Referenced by xmlParseExternalID().

xmlParseQName()

static const xmlChar * xmlParseQName ( xmlParserCtxtPtr  ctxt, const xmlChar **  prefix  )

static

xmlParseQName: @ctxt: an XML parser context @prefix: pointer to store the prefix part

parse an XML Namespace QName

[6] QName ::= (Prefix ':')? LocalPart [7] Prefix ::= NCName [8] LocalPart ::= NCName

Returns the Name parsed or NULL

Definition at line 8788 of file parser.c.

                                                             {
    const xmlChar *l, *p;
 
    GROW;
 
    l = xmlParseNCName(ctxt);
    if (l == NULL) {
        if (CUR == ':') {
        l = xmlParseName(ctxt);
        if (l != NULL) {
            xmlNsErr(ctxt, XML_NS_ERR_QNAME,
                 "Failed to parse QName '%s'\n", l, NULL, NULL);
        *prefix = NULL;
        return(l);
        }
    }
        return(NULL);
    }
    if (CUR == ':') {
        NEXT;
    p = l;
    l = xmlParseNCName(ctxt);
    if (l == NULL) {
        xmlChar *tmp;
 
            if (ctxt->instate == XML_PARSER_EOF)
                return(NULL);
            xmlNsErr(ctxt, XML_NS_ERR_QNAME,
                 "Failed to parse QName '%s:'\n", p, NULL, NULL);
        l = xmlParseNmtoken(ctxt);
        if (l == NULL) {
                if (ctxt->instate == XML_PARSER_EOF)
                    return(NULL);
        tmp = xmlBuildQName(BAD_CAST "", p, NULL, 0);
            } else {
        tmp = xmlBuildQName(l, p, NULL, 0);
        xmlFree((char *)l);
        }
        p = xmlDictLookup(ctxt->dict, tmp, -1);
        if (tmp != NULL) xmlFree(tmp);
        *prefix = NULL;
        return(p);
    }
    if (CUR == ':') {
        xmlChar *tmp;
 
            xmlNsErr(ctxt, XML_NS_ERR_QNAME,
                 "Failed to parse QName '%s:%s:'\n", p, l, NULL);
        NEXT;
        tmp = (xmlChar *) xmlParseName(ctxt);
        if (tmp != NULL) {
            tmp = xmlBuildQName(tmp, l, NULL, 0);
        l = xmlDictLookup(ctxt->dict, tmp, -1);
        if (tmp != NULL) xmlFree(tmp);
        *prefix = p;
        return(l);
        }
            if (ctxt->instate == XML_PARSER_EOF)
                return(NULL);
        tmp = xmlBuildQName(BAD_CAST "", l, NULL, 0);
        l = xmlDictLookup(ctxt->dict, tmp, -1);
        if (tmp != NULL) xmlFree(tmp);
        *prefix = p;
        return(l);
    }
    *prefix = p;
    } else
        *prefix = NULL;
    return(l);
}

Referenced by xmlParseAttribute2(), xmlParseQNameAndCompare(), and xmlParseStartTag2().

xmlParseQNameAndCompare()

static const xmlChar * xmlParseQNameAndCompare ( xmlParserCtxtPtr  ctxt, xmlChar const *  name, xmlChar const *  prefix  )

static

Definition at line 8873 of file parser.c.

                                               {
    const xmlChar *cmp;
    const xmlChar *in;
    const xmlChar *ret;
    const xmlChar *prefix2;
 
    if (prefix == NULL) return(xmlParseNameAndCompare(ctxt, name));
 
    GROW;
    in = ctxt->input->cur;
 
    cmp = prefix;
    while (*in != 0 && *in == *cmp) {
    ++in;
    ++cmp;
    }
    if ((*cmp == 0) && (*in == ':')) {
        in++;
    cmp = name;
    while (*in != 0 && *in == *cmp) {
        ++in;
        ++cmp;
    }
    if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) {
        /* success */
            ctxt->input->col += in - ctxt->input->cur;
        ctxt->input->cur = in;
        return((const xmlChar*) 1);
    }
    }
    /*
     * all strings coms from the dictionary, equality can be done directly
     */
    ret = xmlParseQName (ctxt, &prefix2);
    if ((ret == name) && (prefix == prefix2))
    return((const xmlChar*) 1);
    return ret;
}

Referenced by xmlParseEndTag2().

xmlParseReference()

void xmlParseReference

(

xmlParserCtxtPtr

ctxt

)

xmlParseReference: @ctxt: an XML parser context

parse and handle entity references in content, depending on the SAX interface, this may end-up in a call to character() if this is a CharRef, a predefined entity, if there is no reference() callback. or if the parser was asked to switch to that mode.

[67] Reference ::= EntityRef | CharRef

Definition at line 7078 of file parser.c.

                                         {
    xmlEntityPtr ent;
    xmlChar *val;
    int was_checked;
    xmlNodePtr list = NULL;
    xmlParserErrors ret = XML_ERR_OK;
 
 
    if (RAW != '&')
        return;
 
    /*
     * Simple case of a CharRef
     */
    if (NXT(1) == '#') {
    int i = 0;
    xmlChar out[16];
    int hex = NXT(2);
    int value = xmlParseCharRef(ctxt);
 
    if (value == 0)
        return;
    if (ctxt->charset != XML_CHAR_ENCODING_UTF8) {
        /*
         * So we are using non-UTF-8 buffers
         * Check that the char fit on 8bits, if not
         * generate a CharRef.
         */
        if (value <= 0xFF) {
        out[0] = value;
        out[1] = 0;
        if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
            (!ctxt->disableSAX))
            ctxt->sax->characters(ctxt->userData, out, 1);
        } else {
        if ((hex == 'x') || (hex == 'X'))
            snprintf((char *)out, sizeof(out), "#x%X", value);
        else
            snprintf((char *)out, sizeof(out), "#%d", value);
        if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
            (!ctxt->disableSAX))
            ctxt->sax->reference(ctxt->userData, out);
        }
    } else {
        /*
         * Just encode the value in UTF-8
         */
        COPY_BUF(0 ,out, i, value);
        out[i] = 0;
        if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
        (!ctxt->disableSAX))
        ctxt->sax->characters(ctxt->userData, out, i);
    }
    return;
    }
 
    /*
     * We are seeing an entity reference
     */
    ent = xmlParseEntityRef(ctxt);
    if (ent == NULL) return;
    if (!ctxt->wellFormed)
    return;
    was_checked = ent->checked;
 
    /* special case of predefined entities */
    if ((ent->name == NULL) ||
        (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
    val = ent->content;
    if (val == NULL) return;
    /*
     * inline the entity.
     */
    if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
        (!ctxt->disableSAX))
        ctxt->sax->characters(ctxt->userData, val, xmlStrlen(val));
    return;
    }
 
    /*
     * The first reference to the entity trigger a parsing phase
     * where the ent->children is filled with the result from
     * the parsing.
     * Note: external parsed entities will not be loaded, it is not
     * required for a non-validating parser, unless the parsing option
     * of validating, or substituting entities were given. Doing so is
     * far more secure as the parser will only process data coming from
     * the document entity by default.
     */
    if (((ent->checked == 0) ||
         ((ent->children == NULL) && (ctxt->options & XML_PARSE_NOENT))) &&
        ((ent->etype != XML_EXTERNAL_GENERAL_PARSED_ENTITY) ||
         (ctxt->options & (XML_PARSE_NOENT | XML_PARSE_DTDVALID)))) {
    unsigned long oldnbent = ctxt->nbentities, diff;
 
    /*
     * This is a bit hackish but this seems the best
     * way to make sure both SAX and DOM entity support
     * behaves okay.
     */
    void *user_data;
    if (ctxt->userData == ctxt)
        user_data = NULL;
    else
        user_data = ctxt->userData;
 
    /*
     * Check that this entity is well formed
     * 4.3.2: An internal general parsed entity is well-formed
     * if its replacement text matches the production labeled
     * content.
     */
    if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
        ctxt->depth++;
        ret = xmlParseBalancedChunkMemoryInternal(ctxt, ent->content,
                                                  user_data, &list);
        ctxt->depth--;
 
    } else if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
        ctxt->depth++;
        ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt, ctxt->sax,
                                       user_data, ctxt->depth, ent->URI,
                       ent->ExternalID, &list);
        ctxt->depth--;
    } else {
        ret = XML_ERR_ENTITY_PE_INTERNAL;
        xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
             "invalid entity type found\n", NULL);
    }
 
    /*
     * Store the number of entities needing parsing for this entity
     * content and do checkings
     */
        diff = ctxt->nbentities - oldnbent + 1;
        if (diff > INT_MAX / 2)
            diff = INT_MAX / 2;
        ent->checked = diff * 2;
    if ((ent->content != NULL) && (xmlStrchr(ent->content, '<')))
        ent->checked |= 1;
    if (ret == XML_ERR_ENTITY_LOOP) {
        xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
            xmlHaltParser(ctxt);
        xmlFreeNodeList(list);
        return;
    }
    if (xmlParserEntityCheck(ctxt, 0, ent, 0)) {
        xmlFreeNodeList(list);
        return;
    }
 
    if ((ret == XML_ERR_OK) && (list != NULL)) {
        if (((ent->etype == XML_INTERNAL_GENERAL_ENTITY) ||
         (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY))&&
        (ent->children == NULL)) {
        ent->children = list;
                /*
                 * Prune it directly in the generated document
                 * except for single text nodes.
                 */
                if ((ctxt->replaceEntities == 0) ||
                    (ctxt->parseMode == XML_PARSE_READER) ||
                    ((list->type == XML_TEXT_NODE) &&
                     (list->next == NULL))) {
                    ent->owner = 1;
                    while (list != NULL) {
                        list->parent = (xmlNodePtr) ent;
                        if (list->doc != ent->doc)
                            xmlSetTreeDoc(list, ent->doc);
                        if (list->next == NULL)
                            ent->last = list;
                        list = list->next;
                    }
                    list = NULL;
                } else {
                    ent->owner = 0;
                    while (list != NULL) {
                        list->parent = (xmlNodePtr) ctxt->node;
                        list->doc = ctxt->myDoc;
                        if (list->next == NULL)
                            ent->last = list;
                        list = list->next;
                    }
                    list = ent->children;
#ifdef LIBXML_LEGACY_ENABLED
                    if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
                        xmlAddEntityReference(ent, list, NULL);
#endif /* LIBXML_LEGACY_ENABLED */
                }
        } else {
        xmlFreeNodeList(list);
        list = NULL;
        }
    } else if ((ret != XML_ERR_OK) &&
           (ret != XML_WAR_UNDECLARED_ENTITY)) {
        xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
             "Entity '%s' failed to parse\n", ent->name);
            if (ent->content != NULL)
                ent->content[0] = 0;
        xmlParserEntityCheck(ctxt, 0, ent, 0);
    } else if (list != NULL) {
        xmlFreeNodeList(list);
        list = NULL;
    }
    if (ent->checked == 0)
        ent->checked = 2;
 
        /* Prevent entity from being parsed and expanded twice (Bug 760367). */
        was_checked = 0;
    } else if (ent->checked != 1) {
    ctxt->nbentities += ent->checked / 2;
    }
 
    /*
     * Now that the entity content has been gathered
     * provide it to the application, this can take different forms based
     * on the parsing modes.
     */
    if (ent->children == NULL) {
    /*
     * Probably running in SAX mode and the callbacks don't
     * build the entity content. So unless we already went
     * though parsing for first checking go though the entity
     * content to generate callbacks associated to the entity
     */
    if (was_checked != 0) {
        void *user_data;
        /*
         * This is a bit hackish but this seems the best
         * way to make sure both SAX and DOM entity support
         * behaves okay.
         */
        if (ctxt->userData == ctxt)
        user_data = NULL;
        else
        user_data = ctxt->userData;
 
        if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
        ctxt->depth++;
        ret = xmlParseBalancedChunkMemoryInternal(ctxt,
                   ent->content, user_data, NULL);
        ctxt->depth--;
        } else if (ent->etype ==
               XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
        ctxt->depth++;
        ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt,
               ctxt->sax, user_data, ctxt->depth,
               ent->URI, ent->ExternalID, NULL);
        ctxt->depth--;
        } else {
        ret = XML_ERR_ENTITY_PE_INTERNAL;
        xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
                 "invalid entity type found\n", NULL);
        }
        if (ret == XML_ERR_ENTITY_LOOP) {
        xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
        return;
        }
    }
    if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
        (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
        /*
         * Entity reference callback comes second, it's somewhat
         * superfluous but a compatibility to historical behaviour
         */
        ctxt->sax->reference(ctxt->userData, ent->name);
    }
    return;
    }
 
    /*
     * If we didn't get any children for the entity being built
     */
    if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
    (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
    /*
     * Create a node.
     */
    ctxt->sax->reference(ctxt->userData, ent->name);
    return;
    }
 
    if ((ctxt->replaceEntities) || (ent->children == NULL))  {
    /*
     * There is a problem on the handling of _private for entities
     * (bug 155816): Should we copy the content of the field from
     * the entity (possibly overwriting some value set by the user
     * when a copy is created), should we leave it alone, or should
     * we try to take care of different situations?  The problem
     * is exacerbated by the usage of this field by the xmlReader.
     * To fix this bug, we look at _private on the created node
     * and, if it's NULL, we copy in whatever was in the entity.
     * If it's not NULL we leave it alone.  This is somewhat of a
     * hack - maybe we should have further tests to determine
     * what to do.
     */
    if ((ctxt->node != NULL) && (ent->children != NULL)) {
        /*
         * Seems we are generating the DOM content, do
         * a simple tree copy for all references except the first
         * In the first occurrence list contains the replacement.
         */
        if (((list == NULL) && (ent->owner == 0)) ||
        (ctxt->parseMode == XML_PARSE_READER)) {
        xmlNodePtr nw = NULL, cur, firstChild = NULL;
 
        /*
         * We are copying here, make sure there is no abuse
         */
        ctxt->sizeentcopy += ent->length + 5;
        if (xmlParserEntityCheck(ctxt, 0, ent, ctxt->sizeentcopy))
            return;
 
        /*
         * when operating on a reader, the entities definitions
         * are always owning the entities subtree.
        if (ctxt->parseMode == XML_PARSE_READER)
            ent->owner = 1;
         */
 
        cur = ent->children;
        while (cur != NULL) {
            nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
            if (nw != NULL) {
            if (nw->_private == NULL)
                nw->_private = cur->_private;
            if (firstChild == NULL){
                firstChild = nw;
            }
            nw = xmlAddChild(ctxt->node, nw);
            }
            if (cur == ent->last) {
            /*
             * needed to detect some strange empty
             * node cases in the reader tests
             */
            if ((ctxt->parseMode == XML_PARSE_READER) &&
                (nw != NULL) &&
                (nw->type == XML_ELEMENT_NODE) &&
                (nw->children == NULL))
                nw->extra = 1;
 
            break;
            }
            cur = cur->next;
        }
#ifdef LIBXML_LEGACY_ENABLED
        if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
          xmlAddEntityReference(ent, firstChild, nw);
#endif /* LIBXML_LEGACY_ENABLED */
        } else if ((list == NULL) || (ctxt->inputNr > 0)) {
        xmlNodePtr nw = NULL, cur, next, last,
               firstChild = NULL;
 
        /*
         * We are copying here, make sure there is no abuse
         */
        ctxt->sizeentcopy += ent->length + 5;
        if (xmlParserEntityCheck(ctxt, 0, ent, ctxt->sizeentcopy))
            return;
 
        /*
         * Copy the entity child list and make it the new
         * entity child list. The goal is to make sure any
         * ID or REF referenced will be the one from the
         * document content and not the entity copy.
         */
        cur = ent->children;
        ent->children = NULL;
        last = ent->last;
        ent->last = NULL;
        while (cur != NULL) {
            next = cur->next;
            cur->next = NULL;
            cur->parent = NULL;
            nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
            if (nw != NULL) {
            if (nw->_private == NULL)
                nw->_private = cur->_private;
            if (firstChild == NULL){
                firstChild = cur;
            }
            xmlAddChild((xmlNodePtr) ent, nw);
            xmlAddChild(ctxt->node, cur);
            }
            if (cur == last)
            break;
            cur = next;
        }
        if (ent->owner == 0)
            ent->owner = 1;
#ifdef LIBXML_LEGACY_ENABLED
        if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
          xmlAddEntityReference(ent, firstChild, nw);
#endif /* LIBXML_LEGACY_ENABLED */
        } else {
        const xmlChar *nbktext;
 
        /*
         * the name change is to avoid coalescing of the
         * node with a possible previous text one which
         * would make ent->children a dangling pointer
         */
        nbktext = xmlDictLookup(ctxt->dict, BAD_CAST "nbktext",
                    -1);
        if (ent->children->type == XML_TEXT_NODE)
            ent->children->name = nbktext;
        if ((ent->last != ent->children) &&
            (ent->last->type == XML_TEXT_NODE))
            ent->last->name = nbktext;
        xmlAddChildList(ctxt->node, ent->children);
        }
 
        /*
         * This is to avoid a nasty side effect, see
         * characters() in SAX.c
         */
        ctxt->nodemem = 0;
        ctxt->nodelen = 0;
        return;
    }
    }
}

Referenced by xmlParseContentInternal().

xmlParserEntityCheck()

static int xmlParserEntityCheck ( xmlParserCtxtPtr  ctxt, size_t  size, xmlEntityPtr  ent, size_t  replacement  )

static

Definition at line 128 of file parser.c.

{
    size_t consumed = 0;
    int i;
 
    if ((ctxt == NULL) || (ctxt->options & XML_PARSE_HUGE))
        return (0);
    if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
        return (1);
 
    /*
     * This may look absurd but is needed to detect
     * entities problems
     */
    if ((ent != NULL) && (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
    (ent->content != NULL) && (ent->checked == 0) &&
    (ctxt->errNo != XML_ERR_ENTITY_LOOP)) {
    unsigned long oldnbent = ctxt->nbentities, diff;
    xmlChar *rep;
 
    ent->checked = 1;
 
        ++ctxt->depth;
    rep = xmlStringDecodeEntities(ctxt, ent->content,
                  XML_SUBSTITUTE_REF, 0, 0, 0);
        --ctxt->depth;
    if ((rep == NULL) || (ctxt->errNo == XML_ERR_ENTITY_LOOP)) {
        ent->content[0] = 0;
    }
 
        diff = ctxt->nbentities - oldnbent + 1;
        if (diff > INT_MAX / 2)
            diff = INT_MAX / 2;
    ent->checked = diff * 2;
    if (rep != NULL) {
        if (xmlStrchr(rep, '<'))
        ent->checked |= 1;
        xmlFree(rep);
        rep = NULL;
    }
    }
 
    /*
     * Prevent entity exponential check, not just replacement while
     * parsing the DTD
     * The check is potentially costly so do that only once in a thousand
     */
    if ((ctxt->instate == XML_PARSER_DTD) && (ctxt->nbentities > 10000) &&
        (ctxt->nbentities % 1024 == 0)) {
    for (i = 0;i < ctxt->inputNr;i++) {
        consumed += ctxt->inputTab[i]->consumed +
                   (ctxt->inputTab[i]->cur - ctxt->inputTab[i]->base);
    }
    if (ctxt->nbentities > consumed * XML_PARSER_NON_LINEAR) {
        xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
        ctxt->instate = XML_PARSER_EOF;
        return (1);
    }
    consumed = 0;
    }
 
 
 
    if (replacement != 0) {
    if (replacement < XML_MAX_TEXT_LENGTH)
        return(0);
 
        /*
     * If the volume of entity copy reaches 10 times the
     * amount of parsed data and over the large text threshold
     * then that's very likely to be an abuse.
     */
        if (ctxt->input != NULL) {
        consumed = ctxt->input->consumed +
                   (ctxt->input->cur - ctxt->input->base);
    }
        consumed += ctxt->sizeentities;
 
        if (replacement < XML_PARSER_NON_LINEAR * consumed)
        return(0);
    } else if (size != 0) {
        /*
         * Do the check based on the replacement size of the entity
         */
        if (size < XML_PARSER_BIG_ENTITY)
        return(0);
 
        /*
         * A limit on the amount of text data reasonably used
         */
        if (ctxt->input != NULL) {
            consumed = ctxt->input->consumed +
                (ctxt->input->cur - ctxt->input->base);
        }
        consumed += ctxt->sizeentities;
 
        if ((size < XML_PARSER_NON_LINEAR * consumed) &&
        (ctxt->nbentities * 3 < XML_PARSER_NON_LINEAR * consumed))
            return (0);
    } else if (ent != NULL) {
        /*
         * use the number of parsed entities in the replacement
         */
        size = ent->checked / 2;
 
        /*
         * The amount of data parsed counting entities size only once
         */
        if (ctxt->input != NULL) {
            consumed = ctxt->input->consumed +
                (ctxt->input->cur - ctxt->input->base);
        }
        consumed += ctxt->sizeentities;
 
        /*
         * Check the density of entities for the amount of data
     * knowing an entity reference will take at least 3 bytes
         */
        if (size * 3 < consumed * XML_PARSER_NON_LINEAR)
            return (0);
    } else {
        /*
         * strange we got no data for checking
         */
    if (((ctxt->lastError.code != XML_ERR_UNDECLARED_ENTITY) &&
         (ctxt->lastError.code != XML_WAR_UNDECLARED_ENTITY)) ||
        (ctxt->nbentities <= 10000))
        return (0);
    }
    xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
    return (1);
}

Referenced by xmlParseEntityRef(), xmlParsePEReference(), xmlParseReference(), xmlParseStringEntityRef(), xmlParseStringPEReference(), and xmlStringLenDecodeEntities().

xmlParserHandlePEReference()

void xmlParserHandlePEReference

(

xmlParserCtxtPtr

ctxt

)

xmlParserHandlePEReference: @ctxt: the parser context

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

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

[ WFC: Entity Declared ] In a document without any DTD, a document with only an internal DTD subset which contains no parameter entity references, or a document with "standalone='yes'", ... ... The declaration of a parameter entity must precede any reference to it...

[ VC: Entity Declared ] In a document with an external subset or external parameter entities with "standalone='no'", ... ... The declaration of a parameter entity must precede any reference to it...

[ WFC: In DTD ] Parameter-entity references may only appear in the DTD. NOTE: misleading but this is handled.

A PEReference may have been detected in the current input stream the handling is done accordingly to http://www.w3.org/TR/REC-xml#entproc i.e.

• Included in literal in entity values
• Included as Parameter Entity reference within DTDs

Definition at line 2550 of file parser.c.

                                                  {
    switch(ctxt->instate) {
    case XML_PARSER_CDATA_SECTION:
        return;
        case XML_PARSER_COMMENT:
        return;
    case XML_PARSER_START_TAG:
        return;
    case XML_PARSER_END_TAG:
        return;
        case XML_PARSER_EOF:
        xmlFatalErr(ctxt, XML_ERR_PEREF_AT_EOF, NULL);
        return;
        case XML_PARSER_PROLOG:
    case XML_PARSER_START:
    case XML_PARSER_MISC:
        xmlFatalErr(ctxt, XML_ERR_PEREF_IN_PROLOG, NULL);
        return;
    case XML_PARSER_ENTITY_DECL:
        case XML_PARSER_CONTENT:
        case XML_PARSER_ATTRIBUTE_VALUE:
        case XML_PARSER_PI:
    case XML_PARSER_SYSTEM_LITERAL:
    case XML_PARSER_PUBLIC_LITERAL:
        /* we just ignore it there */
        return;
        case XML_PARSER_EPILOG:
        xmlFatalErr(ctxt, XML_ERR_PEREF_IN_EPILOG, NULL);
        return;
    case XML_PARSER_ENTITY_VALUE:
        /*
         * NOTE: in the case of entity values, we don't do the
         *       substitution here since we need the literal
         *       entity value to be able to save the internal
         *       subset of the document.
         *       This will be handled by xmlStringDecodeEntities
         */
        return;
        case XML_PARSER_DTD:
        /*
         * [WFC: Well-Formedness Constraint: PEs in Internal Subset]
         * In the internal DTD subset, parameter-entity references
         * can occur only where markup declarations can occur, not
         * within markup declarations.
         * In that case this is handled in xmlParseMarkupDecl
         */
        if ((ctxt->external == 0) && (ctxt->inputNr == 1))
        return;
        if (IS_BLANK_CH(NXT(1)) || NXT(1) == 0)
        return;
            break;
        case XML_PARSER_IGNORE:
            return;
    }
 
    xmlParsePEReference(ctxt);
}

xmlParseSDDecl()

int xmlParseSDDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseSDDecl: @ctxt: an XML parser context

parse the XML standalone declaration

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

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

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

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

Definition at line 10490 of file parser.c.

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

Referenced by xmlParseXMLDecl().

xmlParseStartTag2()

static const xmlChar * xmlParseStartTag2 ( xmlParserCtxtPtr  ctxt, const xmlChar **  pref, const xmlChar **  URI, int *  tlen  )

static

xmlParseStartTag2: @ctxt: an XML parser context

parse a start of tag either for rule element or EmptyElement. In both case we don't parse the tag closing chars. This routine is called when running SAX2 parsing

[40] STag ::= '<' Name (S Attribute)* S? '>'

[ WFC: Unique Att Spec ] No attribute name may appear more than once in the same start-tag or empty-element tag.

[44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'

[ WFC: Unique Att Spec ] No attribute name may appear more than once in the same start-tag or empty-element tag.

With namespace:

[NS 8] STag ::= '<' QName (S Attribute)* S? '>'

[NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'

Returns the element name parsed

Definition at line 9256 of file parser.c.

                                                  {
    const xmlChar *localname;
    const xmlChar *prefix;
    const xmlChar *attname;
    const xmlChar *aprefix;
    const xmlChar *nsname;
    xmlChar *attvalue;
    const xmlChar **atts = ctxt->atts;
    int maxatts = ctxt->maxatts;
    int nratts, nbatts, nbdef, inputid;
    int i, j, nbNs, attval;
    unsigned long cur;
    int nsNr = ctxt->nsNr;
 
    if (RAW != '<') return(NULL);
    NEXT1;
 
    /*
     * NOTE: it is crucial with the SAX2 API to never call SHRINK beyond that
     *       point since the attribute values may be stored as pointers to
     *       the buffer and calling SHRINK would destroy them !
     *       The Shrinking is only possible once the full set of attribute
     *       callbacks have been done.
     */
    SHRINK;
    cur = ctxt->input->cur - ctxt->input->base;
    inputid = ctxt->input->id;
    nbatts = 0;
    nratts = 0;
    nbdef = 0;
    nbNs = 0;
    attval = 0;
    /* Forget any namespaces added during an earlier parse of this element. */
    ctxt->nsNr = nsNr;
 
    localname = xmlParseQName(ctxt, &prefix);
    if (localname == NULL) {
    xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
               "StartTag: invalid element name\n");
        return(NULL);
    }
    *tlen = ctxt->input->cur - ctxt->input->base - cur;
 
    /*
     * Now parse the attributes, it ends up with the ending
     *
     * (S Attribute)* S?
     */
    SKIP_BLANKS;
    GROW;
 
    while (((RAW != '>') &&
       ((RAW != '/') || (NXT(1) != '>')) &&
       (IS_BYTE_CHAR(RAW))) && (ctxt->instate != XML_PARSER_EOF)) {
    int id = ctxt->input->id;
    unsigned long cons = CUR_CONSUMED;
    int len = -1, alloc = 0;
 
    attname = xmlParseAttribute2(ctxt, prefix, localname,
                                 &aprefix, &attvalue, &len, &alloc);
        if ((attname == NULL) || (attvalue == NULL))
            goto next_attr;
    if (len < 0) len = xmlStrlen(attvalue);
 
        if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
            const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
            xmlURIPtr uri;
 
            if (URL == NULL) {
                xmlErrMemory(ctxt, "dictionary allocation failure");
                if ((attvalue != NULL) && (alloc != 0))
                    xmlFree(attvalue);
                localname = NULL;
                goto done;
            }
            if (*URL != 0) {
                uri = xmlParseURI((const char *) URL);
                if (uri == NULL) {
                    xmlNsErr(ctxt, XML_WAR_NS_URI,
                             "xmlns: '%s' is not a valid URI\n",
                                       URL, NULL, NULL);
                } else {
                    if (uri->scheme == NULL) {
                        xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
                                  "xmlns: URI %s is not absolute\n",
                                  URL, NULL, NULL);
                    }
                    xmlFreeURI(uri);
                }
                if (URL == ctxt->str_xml_ns) {
                    if (attname != ctxt->str_xml) {
                        xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
                     "xml namespace URI cannot be the default namespace\n",
                                 NULL, NULL, NULL);
                    }
                    goto next_attr;
                }
                if ((len == 29) &&
                    (xmlStrEqual(URL,
                             BAD_CAST "http://www.w3.org/2000/xmlns/"))) {
                    xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
                         "reuse of the xmlns namespace name is forbidden\n",
                             NULL, NULL, NULL);
                    goto next_attr;
                }
            }
            /*
             * check that it's not a defined namespace
             */
            for (j = 1;j <= nbNs;j++)
                if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
                    break;
            if (j <= nbNs)
                xmlErrAttributeDup(ctxt, NULL, attname);
            else
                if (nsPush(ctxt, NULL, URL) > 0) nbNs++;
 
        } else if (aprefix == ctxt->str_xmlns) {
            const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
            xmlURIPtr uri;
 
            if (attname == ctxt->str_xml) {
                if (URL != ctxt->str_xml_ns) {
                    xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
                             "xml namespace prefix mapped to wrong URI\n",
                             NULL, NULL, NULL);
                }
                /*
                 * Do not keep a namespace definition node
                 */
                goto next_attr;
            }
            if (URL == ctxt->str_xml_ns) {
                if (attname != ctxt->str_xml) {
                    xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
                             "xml namespace URI mapped to wrong prefix\n",
                             NULL, NULL, NULL);
                }
                goto next_attr;
            }
            if (attname == ctxt->str_xmlns) {
                xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
                         "redefinition of the xmlns prefix is forbidden\n",
                         NULL, NULL, NULL);
                goto next_attr;
            }
            if ((len == 29) &&
                (xmlStrEqual(URL,
                             BAD_CAST "http://www.w3.org/2000/xmlns/"))) {
                xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
                         "reuse of the xmlns namespace name is forbidden\n",
                         NULL, NULL, NULL);
                goto next_attr;
            }
            if ((URL == NULL) || (URL[0] == 0)) {
                xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
                         "xmlns:%s: Empty XML namespace is not allowed\n",
                              attname, NULL, NULL);
                goto next_attr;
            } else {
                uri = xmlParseURI((const char *) URL);
                if (uri == NULL) {
                    xmlNsErr(ctxt, XML_WAR_NS_URI,
                         "xmlns:%s: '%s' is not a valid URI\n",
                                       attname, URL, NULL);
                } else {
                    if ((ctxt->pedantic) && (uri->scheme == NULL)) {
                        xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
                                  "xmlns:%s: URI %s is not absolute\n",
                                  attname, URL, NULL);
                    }
                    xmlFreeURI(uri);
                }
            }
 
            /*
             * check that it's not a defined namespace
             */
            for (j = 1;j <= nbNs;j++)
                if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
                    break;
            if (j <= nbNs)
                xmlErrAttributeDup(ctxt, aprefix, attname);
            else
                if (nsPush(ctxt, attname, URL) > 0) nbNs++;
 
        } else {
            /*
             * Add the pair to atts
             */
            if ((atts == NULL) || (nbatts + 5 > maxatts)) {
                if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
                    goto next_attr;
                }
                maxatts = ctxt->maxatts;
                atts = ctxt->atts;
            }
            ctxt->attallocs[nratts++] = alloc;
            atts[nbatts++] = attname;
            atts[nbatts++] = aprefix;
            /*
             * The namespace URI field is used temporarily to point at the
             * base of the current input buffer for non-alloced attributes.
             * When the input buffer is reallocated, all the pointers become
             * invalid, but they can be reconstructed later.
             */
            if (alloc)
                atts[nbatts++] = NULL;
            else
                atts[nbatts++] = ctxt->input->base;
            atts[nbatts++] = attvalue;
            attvalue += len;
            atts[nbatts++] = attvalue;
            /*
             * tag if some deallocation is needed
             */
            if (alloc != 0) attval = 1;
            attvalue = NULL; /* moved into atts */
        }
 
next_attr:
        if ((attvalue != NULL) && (alloc != 0)) {
            xmlFree(attvalue);
            attvalue = NULL;
        }
 
    GROW
        if (ctxt->instate == XML_PARSER_EOF)
            break;
    if ((RAW == '>') || (((RAW == '/') && (NXT(1) == '>'))))
        break;
    if (SKIP_BLANKS == 0) {
        xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
               "attributes construct error\n");
        break;
    }
        if ((cons == CUR_CONSUMED) && (id == ctxt->input->id) &&
            (attname == NULL) && (attvalue == NULL)) {
        xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
             "xmlParseStartTag: problem parsing attributes\n");
        break;
    }
        GROW;
    }
 
    if (ctxt->input->id != inputid) {
        xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
                    "Unexpected change of input\n");
        localname = NULL;
        goto done;
    }
 
    /* Reconstruct attribute value pointers. */
    for (i = 0, j = 0; j < nratts; i += 5, j++) {
        if (atts[i+2] != NULL) {
            /*
             * Arithmetic on dangling pointers is technically undefined
             * behavior, but well...
             */
            ptrdiff_t offset = ctxt->input->base - atts[i+2];
            atts[i+2]  = NULL;    /* Reset repurposed namespace URI */
            atts[i+3] += offset;  /* value */
            atts[i+4] += offset;  /* valuend */
        }
    }
 
    /*
     * The attributes defaulting
     */
    if (ctxt->attsDefault != NULL) {
        xmlDefAttrsPtr defaults;
 
    defaults = xmlHashLookup2(ctxt->attsDefault, localname, prefix);
    if (defaults != NULL) {
        for (i = 0;i < defaults->nbAttrs;i++) {
            attname = defaults->values[5 * i];
        aprefix = defaults->values[5 * i + 1];
 
                /*
         * special work for namespaces defaulted defs
         */
        if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
            /*
             * check that it's not a defined namespace
             */
            for (j = 1;j <= nbNs;j++)
                if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
                break;
                if (j <= nbNs) continue;
 
            nsname = xmlGetNamespace(ctxt, NULL);
            if (nsname != defaults->values[5 * i + 2]) {
            if (nsPush(ctxt, NULL,
                       defaults->values[5 * i + 2]) > 0)
                nbNs++;
            }
        } else if (aprefix == ctxt->str_xmlns) {
            /*
             * check that it's not a defined namespace
             */
            for (j = 1;j <= nbNs;j++)
                if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
                break;
                if (j <= nbNs) continue;
 
            nsname = xmlGetNamespace(ctxt, attname);
            if (nsname != defaults->values[2]) {
            if (nsPush(ctxt, attname,
                       defaults->values[5 * i + 2]) > 0)
                nbNs++;
            }
        } else {
            /*
             * check that it's not a defined attribute
             */
            for (j = 0;j < nbatts;j+=5) {
            if ((attname == atts[j]) && (aprefix == atts[j+1]))
                break;
            }
            if (j < nbatts) continue;
 
            if ((atts == NULL) || (nbatts + 5 > maxatts)) {
            if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
                            localname = NULL;
                            goto done;
            }
            maxatts = ctxt->maxatts;
            atts = ctxt->atts;
            }
            atts[nbatts++] = attname;
            atts[nbatts++] = aprefix;
            if (aprefix == NULL)
            atts[nbatts++] = NULL;
            else
                atts[nbatts++] = xmlGetNamespace(ctxt, aprefix);
            atts[nbatts++] = defaults->values[5 * i + 2];
            atts[nbatts++] = defaults->values[5 * i + 3];
            if ((ctxt->standalone == 1) &&
                (defaults->values[5 * i + 4] != NULL)) {
            xmlValidityError(ctxt, XML_DTD_STANDALONE_DEFAULTED,
      "standalone: attribute %s on %s defaulted from external subset\n",
                                     attname, localname);
            }
            nbdef++;
        }
        }
    }
    }
 
    /*
     * The attributes checkings
     */
    for (i = 0; i < nbatts;i += 5) {
        /*
    * The default namespace does not apply to attribute names.
    */
    if (atts[i + 1] != NULL) {
        nsname = xmlGetNamespace(ctxt, atts[i + 1]);
        if (nsname == NULL) {
        xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
            "Namespace prefix %s for %s on %s is not defined\n",
            atts[i + 1], atts[i], localname);
        }
        atts[i + 2] = nsname;
    } else
        nsname = NULL;
    /*
     * [ WFC: Unique Att Spec ]
     * No attribute name may appear more than once in the same
     * start-tag or empty-element tag.
     * As extended by the Namespace in XML REC.
     */
        for (j = 0; j < i;j += 5) {
        if (atts[i] == atts[j]) {
            if (atts[i+1] == atts[j+1]) {
            xmlErrAttributeDup(ctxt, atts[i+1], atts[i]);
            break;
        }
        if ((nsname != NULL) && (atts[j + 2] == nsname)) {
            xmlNsErr(ctxt, XML_NS_ERR_ATTRIBUTE_REDEFINED,
                 "Namespaced Attribute %s in '%s' redefined\n",
                 atts[i], nsname, NULL);
            break;
        }
        }
    }
    }
 
    nsname = xmlGetNamespace(ctxt, prefix);
    if ((prefix != NULL) && (nsname == NULL)) {
    xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
             "Namespace prefix %s on %s is not defined\n",
         prefix, localname, NULL);
    }
    *pref = prefix;
    *URI = nsname;
 
    /*
     * SAX: Start of Element !
     */
    if ((ctxt->sax != NULL) && (ctxt->sax->startElementNs != NULL) &&
    (!ctxt->disableSAX)) {
    if (nbNs > 0)
        ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
              nsname, nbNs, &ctxt->nsTab[ctxt->nsNr - 2 * nbNs],
              nbatts / 5, nbdef, atts);
    else
        ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
                      nsname, 0, NULL, nbatts / 5, nbdef, atts);
    }
 
done:
    /*
     * Free up attribute allocated strings if needed
     */
    if (attval != 0) {
    for (i = 3,j = 0; j < nratts;i += 5,j++)
        if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
            xmlFree((xmlChar *) atts[i]);
    }
 
    return(localname);
}

Referenced by xmlParseElementStart().

xmlParseStringCharRef()

static int xmlParseStringCharRef ( xmlParserCtxtPtr  ctxt, const xmlChar **  str  )

static

xmlParseStringCharRef: @ctxt: an XML parser context @str: a pointer to an index in the string

parse Reference declarations, variant parsing from a string rather than an an input flow.

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

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

Returns the value parsed (as an int), 0 in case of error, str will be updated to the current value of the index

Definition at line 2442 of file parser.c.

                                                                  {
    const xmlChar *ptr;
    xmlChar cur;
    int val = 0;
 
    if ((str == NULL) || (*str == NULL)) return(0);
    ptr = *str;
    cur = *ptr;
    if ((cur == '&') && (ptr[1] == '#') && (ptr[2] == 'x')) {
    ptr += 3;
    cur = *ptr;
    while (cur != ';') { /* Non input consuming loop */
        if ((cur >= '0') && (cur <= '9'))
            val = val * 16 + (cur - '0');
        else if ((cur >= 'a') && (cur <= 'f'))
            val = val * 16 + (cur - 'a') + 10;
        else if ((cur >= 'A') && (cur <= 'F'))
            val = val * 16 + (cur - 'A') + 10;
        else {
        xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
        val = 0;
        break;
        }
        if (val > 0x110000)
            val = 0x110000;
 
        ptr++;
        cur = *ptr;
    }
    if (cur == ';')
        ptr++;
    } else if  ((cur == '&') && (ptr[1] == '#')){
    ptr += 2;
    cur = *ptr;
    while (cur != ';') { /* Non input consuming loops */
        if ((cur >= '0') && (cur <= '9'))
            val = val * 10 + (cur - '0');
        else {
        xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
        val = 0;
        break;
        }
        if (val > 0x110000)
            val = 0x110000;
 
        ptr++;
        cur = *ptr;
    }
    if (cur == ';')
        ptr++;
    } else {
    xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
    return(0);
    }
    *str = ptr;
 
    /*
     * [ WFC: Legal Character ]
     * Characters referred to using character references must match the
     * production for Char.
     */
    if (val >= 0x110000) {
        xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
                "xmlParseStringCharRef: character reference out of bounds\n",
                val);
    } else if (IS_CHAR(val)) {
        return(val);
    } else {
        xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
              "xmlParseStringCharRef: invalid xmlChar value %d\n",
              val);
    }
    return(0);
}

Referenced by xmlStringLenDecodeEntities().

xmlParseStringEntityRef()

static xmlEntityPtr xmlParseStringEntityRef ( xmlParserCtxtPtr  ctxt, const xmlChar **  str  )

static

xmlParseStringEntityRef: @ctxt: an XML parser context @str: a pointer to an index in the string

parse ENTITY references declarations, but this version parses it from a string value.

[68] EntityRef ::= '&' Name ';'

[ WFC: Entity Declared ] In a document without any DTD, a document with only an internal DTD subset which contains no parameter entity references, or a document with "standalone='yes'", the Name given in the entity reference must match that in an entity declaration, except that well-formed documents need not declare any of the following entities: amp, lt, gt, apos, quot. The declaration of a parameter entity must precede any reference to it. Similarly, the declaration of a general entity must precede any reference to it which appears in a default value in an attribute-list declaration. Note that if entities are declared in the external subset or in external parameter entities, a non-validating processor is not obligated to read and process their declarations; for such documents, the rule that an entity must be declared is a well-formedness constraint only if standalone='yes'.

[ WFC: Parsed Entity ] An entity reference must not contain the name of an unparsed entity

Returns the xmlEntityPtr if found, or NULL otherwise. The str pointer is updated to the current location in the string.

Definition at line 7718 of file parser.c.

                                                                     {
    xmlChar *name;
    const xmlChar *ptr;
    xmlChar cur;
    xmlEntityPtr ent = NULL;
 
    if ((str == NULL) || (*str == NULL))
        return(NULL);
    ptr = *str;
    cur = *ptr;
    if (cur != '&')
    return(NULL);
 
    ptr++;
    name = xmlParseStringName(ctxt, &ptr);
    if (name == NULL) {
    xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
               "xmlParseStringEntityRef: no name\n");
    *str = ptr;
    return(NULL);
    }
    if (*ptr != ';') {
    xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
        xmlFree(name);
    *str = ptr;
    return(NULL);
    }
    ptr++;
 
 
    /*
     * Predefined entities override any extra definition
     */
    if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
        ent = xmlGetPredefinedEntity(name);
        if (ent != NULL) {
            xmlFree(name);
            *str = ptr;
            return(ent);
        }
    }
 
    /*
     * Increase the number of entity references parsed
     */
    ctxt->nbentities++;
 
    /*
     * Ask first SAX for entity resolution, otherwise try the
     * entities which may have stored in the parser context.
     */
    if (ctxt->sax != NULL) {
    if (ctxt->sax->getEntity != NULL)
        ent = ctxt->sax->getEntity(ctxt->userData, name);
    if ((ent == NULL) && (ctxt->options & XML_PARSE_OLDSAX))
        ent = xmlGetPredefinedEntity(name);
    if ((ent == NULL) && (ctxt->userData==ctxt)) {
        ent = xmlSAX2GetEntity(ctxt, name);
    }
    }
    if (ctxt->instate == XML_PARSER_EOF) {
    xmlFree(name);
    return(NULL);
    }
 
    /*
     * [ WFC: Entity Declared ]
     * In a document without any DTD, a document with only an
     * internal DTD subset which contains no parameter entity
     * references, or a document with "standalone='yes'", the
     * Name given in the entity reference must match that in an
     * entity declaration, except that well-formed documents
     * need not declare any of the following entities: amp, lt,
     * gt, apos, quot.
     * The declaration of a parameter entity must precede any
     * reference to it.
     * Similarly, the declaration of a general entity must
     * precede any reference to it which appears in a default
     * value in an attribute-list declaration. Note that if
     * entities are declared in the external subset or in
     * external parameter entities, a non-validating processor
     * is not obligated to read and process their declarations;
     * for such documents, the rule that an entity must be
     * declared is a well-formedness constraint only if
     * standalone='yes'.
     */
    if (ent == NULL) {
    if ((ctxt->standalone == 1) ||
        ((ctxt->hasExternalSubset == 0) &&
         (ctxt->hasPErefs == 0))) {
        xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
             "Entity '%s' not defined\n", name);
    } else {
        xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
              "Entity '%s' not defined\n",
              name);
    }
    xmlParserEntityCheck(ctxt, 0, ent, 0);
    /* TODO ? check regressions ctxt->valid = 0; */
    }
 
    /*
     * [ WFC: Parsed Entity ]
     * An entity reference must not contain the name of an
     * unparsed entity
     */
    else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
    xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
         "Entity reference to unparsed entity %s\n", name);
    }
 
    /*
     * [ WFC: No External Entity References ]
     * Attribute values cannot contain direct or indirect
     * entity references to external entities.
     */
    else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
         (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
    xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
     "Attribute references external entity '%s'\n", name);
    }
    /*
     * [ WFC: No < in Attribute Values ]
     * The replacement text of any entity referred to directly or
     * indirectly in an attribute value (other than "&lt;") must
     * not contain a <.
     */
    else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
         (ent != NULL) && (ent->content != NULL) &&
         (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
         (xmlStrchr(ent->content, '<'))) {
    xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
     "'<' in entity '%s' is not allowed in attributes values\n",
              name);
    }
 
    /*
     * Internal check, no parameter entities here ...
     */
    else {
    switch (ent->etype) {
        case XML_INTERNAL_PARAMETER_ENTITY:
        case XML_EXTERNAL_PARAMETER_ENTITY:
        xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
         "Attempt to reference the parameter entity '%s'\n",
                  name);
        break;
        default:
        break;
    }
    }
 
    /*
     * [ WFC: No Recursion ]
     * A parsed entity must not contain a recursive reference
     * to itself, either directly or indirectly.
     * Done somewhere else
     */
 
    xmlFree(name);
    *str = ptr;
    return(ent);
}

Referenced by xmlStringLenDecodeEntities().

xmlParseStringName()

static xmlChar * xmlParseStringName ( xmlParserCtxtPtr  ctxt, const xmlChar **  str  )

static

xmlParseStringName: @ctxt: an XML parser context @str: a pointer to the string pointer (IN/OUT)

parse an XML name.

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

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

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

Returns the Name parsed or NULL. The @str pointer is updated to the current location in the string.

Definition at line 3573 of file parser.c.

                                                               {
    xmlChar buf[XML_MAX_NAMELEN + 5];
    const xmlChar *cur = *str;
    int len = 0, l;
    int c;
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
                    XML_MAX_TEXT_LENGTH :
                    XML_MAX_NAME_LENGTH;
 
#ifdef DEBUG
    nbParseStringName++;
#endif
 
    c = CUR_SCHAR(cur, l);
    if (!xmlIsNameStartChar(ctxt, c)) {
    return(NULL);
    }
 
    COPY_BUF(l,buf,len,c);
    cur += l;
    c = CUR_SCHAR(cur, l);
    while (xmlIsNameChar(ctxt, c)) {
    COPY_BUF(l,buf,len,c);
    cur += l;
    c = CUR_SCHAR(cur, l);
    if (len >= XML_MAX_NAMELEN) { /* test bigentname.xml */
        /*
         * Okay someone managed to make a huge name, so he's ready to pay
         * for the processing speed.
         */
        xmlChar *buffer;
        int max = len * 2;
 
        buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
        if (buffer == NULL) {
            xmlErrMemory(ctxt, NULL);
        return(NULL);
        }
        memcpy(buffer, buf, len);
        while (xmlIsNameChar(ctxt, c)) {
        if (len + 10 > max) {
            xmlChar *tmp;
 
            max *= 2;
            tmp = (xmlChar *) xmlRealloc(buffer,
                                        max * sizeof(xmlChar));
            if (tmp == NULL) {
            xmlErrMemory(ctxt, NULL);
            xmlFree(buffer);
            return(NULL);
            }
            buffer = tmp;
        }
        COPY_BUF(l,buffer,len,c);
        cur += l;
        c = CUR_SCHAR(cur, l);
                if (len > maxLength) {
                    xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
                    xmlFree(buffer);
                    return(NULL);
                }
        }
        buffer[len] = 0;
        *str = cur;
        return(buffer);
    }
    }
    if (len > maxLength) {
        xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
        return(NULL);
    }
    *str = cur;
    return(xmlStrndup(buf, len));
}

Referenced by xmlParseEntityValue(), xmlParseStringEntityRef(), and xmlParseStringPEReference().

xmlParseStringPEReference()

static xmlEntityPtr xmlParseStringPEReference ( xmlParserCtxtPtr  ctxt, const xmlChar **  str  )

static

xmlParseStringPEReference: @ctxt: an XML parser context @str: a pointer to an index in the string

parse PEReference declarations

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

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

[ WFC: Entity Declared ] In a document without any DTD, a document with only an internal DTD subset which contains no parameter entity references, or a document with "standalone='yes'", ... ... The declaration of a parameter entity must precede any reference to it...

[ VC: Entity Declared ] In a document with an external subset or external parameter entities with "standalone='no'", ... ... The declaration of a parameter entity must precede any reference to it...

[ WFC: In DTD ] Parameter-entity references may only appear in the DTD. NOTE: misleading but this is handled.

Returns the string of the entity content. str is updated to the current value of the index

Definition at line 8179 of file parser.c.

                                                                      {
    const xmlChar *ptr;
    xmlChar cur;
    xmlChar *name;
    xmlEntityPtr entity = NULL;
 
    if ((str == NULL) || (*str == NULL)) return(NULL);
    ptr = *str;
    cur = *ptr;
    if (cur != '%')
        return(NULL);
    ptr++;
    name = xmlParseStringName(ctxt, &ptr);
    if (name == NULL) {
    xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
               "xmlParseStringPEReference: no name\n");
    *str = ptr;
    return(NULL);
    }
    cur = *ptr;
    if (cur != ';') {
    xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
    xmlFree(name);
    *str = ptr;
    return(NULL);
    }
    ptr++;
 
    /*
     * Increase the number of entity references parsed
     */
    ctxt->nbentities++;
 
    /*
     * Request the entity from SAX
     */
    if ((ctxt->sax != NULL) &&
    (ctxt->sax->getParameterEntity != NULL))
    entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
    if (ctxt->instate == XML_PARSER_EOF) {
    xmlFree(name);
    *str = ptr;
    return(NULL);
    }
    if (entity == NULL) {
    /*
     * [ WFC: Entity Declared ]
     * In a document without any DTD, a document with only an
     * internal DTD subset which contains no parameter entity
     * references, or a document with "standalone='yes'", ...
     * ... The declaration of a parameter entity must precede
     * any reference to it...
     */
    if ((ctxt->standalone == 1) ||
        ((ctxt->hasExternalSubset == 0) && (ctxt->hasPErefs == 0))) {
        xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
         "PEReference: %%%s; not found\n", name);
    } else {
        /*
         * [ VC: Entity Declared ]
         * In a document with an external subset or external
         * parameter entities with "standalone='no'", ...
         * ... The declaration of a parameter entity must
         * precede any reference to it...
         */
        xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
              "PEReference: %%%s; not found\n",
              name, NULL);
        ctxt->valid = 0;
    }
    xmlParserEntityCheck(ctxt, 0, NULL, 0);
    } else {
    /*
     * Internal checking in case the entity quest barfed
     */
    if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
        (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
        xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
              "%%%s; is not a parameter entity\n",
              name, NULL);
    }
    }
    ctxt->hasPErefs = 1;
    xmlFree(name);
    *str = ptr;
    return(entity);
}

Referenced by xmlStringLenDecodeEntities().

xmlParseSystemLiteral()

xmlChar * xmlParseSystemLiteral

(

xmlParserCtxtPtr

ctxt

)

xmlParseSystemLiteral: @ctxt: an XML parser context

parse an XML Literal

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

Returns the SystemLiteral parsed or NULL

Definition at line 4199 of file parser.c.

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

Referenced by xmlParseExternalID().

xmlParseTextDecl()

void xmlParseTextDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseTextDecl: @ctxt: an XML parser context

parse an XML declaration header for external entities

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

Definition at line 6915 of file parser.c.

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

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

xmlParseVersionInfo()

xmlChar * xmlParseVersionInfo

(

xmlParserCtxtPtr

ctxt

)

xmlParseVersionInfo: @ctxt: an XML parser context

parse the XML version.

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

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

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

Definition at line 10249 of file parser.c.

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

Referenced by xmlParseTextDecl(), and xmlParseXMLDecl().

xmlParseVersionNum()

xmlChar * xmlParseVersionNum

(

xmlParserCtxtPtr

ctxt

)

xmlParseVersionNum: @ctxt: an XML parser context

parse the XML version value.

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

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

Returns the string giving the XML version number, or NULL

Definition at line 10188 of file parser.c.

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

Referenced by xmlParseVersionInfo().

xmlParseXMLDecl()

void xmlParseXMLDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseXMLDecl: @ctxt: an XML parser context

parse an XML declaration header

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

Definition at line 10552 of file parser.c.

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

Referenced by xmlParseDocument(), and xmlParseExtParsedEnt().

xmlPopInput()

xmlChar xmlPopInput

(

xmlParserCtxtPtr

ctxt

)

xmlPopInput: @ctxt: an XML parser context

xmlPopInput: the current input pointed by ctxt->input came to an end pop it and return the next char.

Returns the current xmlChar in the parser context

Definition at line 2265 of file parser.c.

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

Referenced by xmlLoadEntityContent(), xmlParseInternalSubset(), xmlSAX2ExternalSubset(), and xmlSkipBlankChars().

xmlPushInput()

int xmlPushInput	(	xmlParserCtxtPtr	ctxt,
		xmlParserInputPtr	input
	)

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

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

Definition at line 2290 of file parser.c.

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

Referenced by xmlLoadEntityContent(), xmlParsePEReference(), and xmlSAX2ExternalSubset().

xmlReadDoc()

xmlDocPtr xmlReadDoc	(	const xmlChar *	cur,
		const char *	URL,
		const char *	encoding,
		int	options
	)

xmlReadDoc: @cur: a pointer to a zero terminated string @URL: the base URL to use for the document @encoding: the document encoding, or NULL @options: a combination of xmlParserOption

parse an XML in-memory document and build a tree.

Returns the resulting document tree

Definition at line 15204 of file parser.c.

{
    xmlParserCtxtPtr ctxt;
 
    if (cur == NULL)
        return (NULL);
    xmlInitParser();
 
    ctxt = xmlCreateDocParserCtxt(cur);
    if (ctxt == NULL)
        return (NULL);
    return (xmlDoRead(ctxt, URL, encoding, options, 0));
}

xmlReadFd()

xmlDocPtr xmlReadFd	(	int	fd,
		const char *	URL,
		const char *	encoding,
		int	options
	)

xmlReadFd: @fd: an open file descriptor @URL: the base URL to use for the document @encoding: the document encoding, or NULL @options: a combination of xmlParserOption

parse an XML from a file descriptor and build a tree. NOTE that the file descriptor will not be closed when the reader is closed or reset.

Returns the resulting document tree

Definition at line 15278 of file parser.c.

{
    xmlParserCtxtPtr ctxt;
    xmlParserInputBufferPtr input;
    xmlParserInputPtr stream;
 
    if (fd < 0)
        return (NULL);
    xmlInitParser();
 
    input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
    if (input == NULL)
        return (NULL);
    input->closecallback = NULL;
    ctxt = xmlNewParserCtxt();
    if (ctxt == NULL) {
        xmlFreeParserInputBuffer(input);
        return (NULL);
    }
    stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
    if (stream == NULL) {
        xmlFreeParserInputBuffer(input);
    xmlFreeParserCtxt(ctxt);
        return (NULL);
    }
    inputPush(ctxt, stream);
    return (xmlDoRead(ctxt, URL, encoding, options, 0));
}

Referenced by parseAndPrintFile().

xmlReadFile()

xmlDocPtr xmlReadFile	(	const char *	filename,
		const char *	encoding,
		int	options
	)

xmlReadFile: @filename: a file or URL @encoding: the document encoding, or NULL @options: a combination of xmlParserOption

parse an XML file from the filesystem or the network.

Returns the resulting document tree

Definition at line 15229 of file parser.c.

{
    xmlParserCtxtPtr ctxt;
 
    xmlInitParser();
    ctxt = xmlCreateURLParserCtxt(filename, options);
    if (ctxt == NULL)
        return (NULL);
    return (xmlDoRead(ctxt, NULL, encoding, options, 0));
}

Referenced by parseAndPrintFile().

xmlReadIO()

xmlDocPtr xmlReadIO	(	xmlInputReadCallback	ioread,
		xmlInputCloseCallback	ioclose,
		void *	ioctx,
		const char *	URL,
		const char *	encoding,
		int	options
	)

xmlReadIO: @ioread: an I/O read function @ioclose: an I/O close function @ioctx: an I/O handler @URL: the base URL to use for the document @encoding: the document encoding, or NULL @options: a combination of xmlParserOption

parse an XML document from I/O functions and source and build a tree.

Returns the resulting document tree

Definition at line 15321 of file parser.c.

{
    xmlParserCtxtPtr ctxt;
    xmlParserInputBufferPtr input;
    xmlParserInputPtr stream;
 
    if (ioread == NULL)
        return (NULL);
    xmlInitParser();
 
    input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
                                         XML_CHAR_ENCODING_NONE);
    if (input == NULL) {
        if (ioclose != NULL)
            ioclose(ioctx);
        return (NULL);
    }
    ctxt = xmlNewParserCtxt();
    if (ctxt == NULL) {
        xmlFreeParserInputBuffer(input);
        return (NULL);
    }
    stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
    if (stream == NULL) {
        xmlFreeParserInputBuffer(input);
    xmlFreeParserCtxt(ctxt);
        return (NULL);
    }
    inputPush(ctxt, stream);
    return (xmlDoRead(ctxt, URL, encoding, options, 0));
}

Referenced by parseAndPrintFile().

xmlReadMemory()

xmlDocPtr xmlReadMemory	(	const char *	buffer,
		int	size,
		const char *	URL,
		const char *	encoding,
		int	options
	)

xmlReadMemory: @buffer: a pointer to a char array @size: the size of the array @URL: the base URL to use for the document @encoding: the document encoding, or NULL @options: a combination of xmlParserOption

parse an XML in-memory document and build a tree.

Returns the resulting document tree

Definition at line 15253 of file parser.c.

{
    xmlParserCtxtPtr ctxt;
 
    xmlInitParser();
    ctxt = xmlCreateMemoryParserCtxt(buffer, size);
    if (ctxt == NULL)
        return (NULL);
    return (xmlDoRead(ctxt, URL, encoding, options, 0));
}

Referenced by parseAndPrintFile().

xmlSHRINK()

static void xmlSHRINK ( xmlParserCtxtPtr  ctxt )

static

Definition at line 2111 of file parser.c.

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

xmlSkipBlankChars()

int xmlSkipBlankChars

(

xmlParserCtxtPtr

ctxt

)

xmlSkipBlankChars: @ctxt: the XML parser context

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

Returns the number of space chars skipped

Definition at line 2184 of file parser.c.

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

xmlSplitQName()

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

Namespaces.

Definition at line 2946 of file parser.c.

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

Referenced by xmlSAX2AttributeDecl().

xmlStopParser()

void xmlStopParser

(

xmlParserCtxtPtr

ctxt

)

xmlStopParser: @ctxt: an XML parser context

Blocks further parser processing

Definition at line 12583 of file parser.c.

                                     {
    if (ctxt == NULL)
        return;
    xmlHaltParser(ctxt);
    ctxt->errNo = XML_ERR_USER_STOP;
}

Referenced by xmlNextChar(), and xmlSwitchEncoding().

xmlStringDecodeEntities()

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

xmlStringDecodeEntities: @ctxt: the parser context @str: the input string @what: combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF @end: an end marker xmlChar, 0 if none @end2: an end marker xmlChar, 0 if none @end3: an end marker xmlChar, 0 if none

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

[67] Reference ::= EntityRef | CharRef

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

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

Definition at line 2839 of file parser.c.

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

Referenced by xmlParseAttValueComplex(), xmlParseEntityValue(), xmlParserEntityCheck(), and xmlStringLenDecodeEntities().

xmlStringLenDecodeEntities()

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

xmlStringLenDecodeEntities: @ctxt: the parser context @str: the input string @len: the string length @what: combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF @end: an end marker xmlChar, 0 if none @end2: an end marker xmlChar, 0 if none @end3: an end marker xmlChar, 0 if none

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

[67] Reference ::= EntityRef | CharRef

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

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

Definition at line 2643 of file parser.c.

                                                                  {
    xmlChar *buffer = NULL;
    size_t buffer_size = 0;
    size_t nbchars = 0;
 
    xmlChar *current = NULL;
    xmlChar *rep = NULL;
    const xmlChar *last;
    xmlEntityPtr ent;
    int c,l;
 
    if ((ctxt == NULL) || (str == NULL) || (len < 0))
    return(NULL);
    last = str + len;
 
    if (((ctxt->depth > 40) &&
         ((ctxt->options & XML_PARSE_HUGE) == 0)) ||
    (ctxt->depth > 1024)) {
    xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
    return(NULL);
    }
 
    /*
     * allocate a translation buffer.
     */
    buffer_size = XML_PARSER_BIG_BUFFER_SIZE;
    buffer = (xmlChar *) xmlMallocAtomic(buffer_size);
    if (buffer == NULL) goto mem_error;
 
    /*
     * OK loop until we reach one of the ending char or a size limit.
     * we are operating on already parsed values.
     */
    if (str < last)
    c = CUR_SCHAR(str, l);
    else
        c = 0;
    while ((c != 0) && (c != end) && /* non input consuming loop */
           (c != end2) && (c != end3) &&
           (ctxt->instate != XML_PARSER_EOF)) {
 
    if (c == 0) break;
        if ((c == '&') && (str[1] == '#')) {
        int val = xmlParseStringCharRef(ctxt, &str);
        if (val == 0)
                goto int_error;
        COPY_BUF(0,buffer,nbchars,val);
        if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
            growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
        }
    } else if ((c == '&') && (what & XML_SUBSTITUTE_REF)) {
        if (xmlParserDebugEntities)
        xmlGenericError(xmlGenericErrorContext,
            "String decoding Entity Reference: %.30s\n",
            str);
        ent = xmlParseStringEntityRef(ctxt, &str);
        xmlParserEntityCheck(ctxt, 0, ent, 0);
        if (ent != NULL)
            ctxt->nbentities += ent->checked / 2;
        if ((ent != NULL) &&
        (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
        if (ent->content != NULL) {
            COPY_BUF(0,buffer,nbchars,ent->content[0]);
            if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
            growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
            }
        } else {
            xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
                "predefined entity has no content\n");
                    goto int_error;
        }
        } else if ((ent != NULL) && (ent->content != NULL)) {
        ctxt->depth++;
        rep = xmlStringDecodeEntities(ctxt, ent->content, what,
                                  0, 0, 0);
        ctxt->depth--;
        if (rep == NULL) {
                    ent->content[0] = 0;
                    goto int_error;
                }
 
                current = rep;
                while (*current != 0) { /* non input consuming loop */
                    buffer[nbchars++] = *current++;
                    if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
                        if (xmlParserEntityCheck(ctxt, nbchars, ent, 0))
                            goto int_error;
                        growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
                    }
                }
                xmlFree(rep);
                rep = NULL;
        } else if (ent != NULL) {
        int i = xmlStrlen(ent->name);
        const xmlChar *cur = ent->name;
 
        buffer[nbchars++] = '&';
        if (nbchars + i + XML_PARSER_BUFFER_SIZE > buffer_size) {
            growBuffer(buffer, i + XML_PARSER_BUFFER_SIZE);
        }
        for (;i > 0;i--)
            buffer[nbchars++] = *cur++;
        buffer[nbchars++] = ';';
        }
    } else if (c == '%' && (what & XML_SUBSTITUTE_PEREF)) {
        if (xmlParserDebugEntities)
        xmlGenericError(xmlGenericErrorContext,
            "String decoding PE Reference: %.30s\n", str);
        ent = xmlParseStringPEReference(ctxt, &str);
        xmlParserEntityCheck(ctxt, 0, ent, 0);
        if (ent != NULL)
            ctxt->nbentities += ent->checked / 2;
        if (ent != NULL) {
                if (ent->content == NULL) {
            /*
             * Note: external parsed entities will not be loaded,
             * it is not required for a non-validating parser to
             * complete external PEReferences coming from the
             * internal subset
             */
            if (((ctxt->options & XML_PARSE_NOENT) != 0) ||
            ((ctxt->options & XML_PARSE_DTDVALID) != 0) ||
            (ctxt->validate != 0)) {
            xmlLoadEntityContent(ctxt, ent);
            } else {
            xmlWarningMsg(ctxt, XML_ERR_ENTITY_PROCESSING,
          "not validating will not read content for PE entity %s\n",
                              ent->name, NULL);
            }
        }
        ctxt->depth++;
        rep = xmlStringDecodeEntities(ctxt, ent->content, what,
                                  0, 0, 0);
        ctxt->depth--;
        if (rep == NULL) {
                    if (ent->content != NULL)
                        ent->content[0] = 0;
                    goto int_error;
                }
                current = rep;
                while (*current != 0) { /* non input consuming loop */
                    buffer[nbchars++] = *current++;
                    if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
                        if (xmlParserEntityCheck(ctxt, nbchars, ent, 0))
                            goto int_error;
                        growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
                    }
                }
                xmlFree(rep);
                rep = NULL;
        }
    } else {
        COPY_BUF(l,buffer,nbchars,c);
        str += l;
        if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
            growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
        }
    }
    if (str < last)
        c = CUR_SCHAR(str, l);
    else
        c = 0;
    }
    buffer[nbchars] = 0;
    return(buffer);
 
mem_error:
    xmlErrMemory(ctxt, NULL);
int_error:
    if (rep != NULL)
        xmlFree(rep);
    if (buffer != NULL)
        xmlFree(buffer);
    return(NULL);
}

Referenced by xmlStringDecodeEntities().

Variable Documentation

test_char_data

const unsigned char test_char_data[256]

static

Definition at line 4373 of file parser.c.

Referenced by xmlParseCharData().

xmlParserInitialized

int xmlParserInitialized = 0

static

Definition at line 14665 of file parser.c.

Referenced by xmlCleanupParser(), and xmlInitParser().

xmlParserMaxDepth

unsigned int xmlParserMaxDepth = 256

xmlParserMaxDepth:

arbitrary depth limit for the XML documents that we allow to process. This is not a limitation of the parser but a safety boundary feature. It can be disabled with the XML_PARSE_HUGE parser option.

Definition at line 270 of file parser.c.

Referenced by nodePush(), and xmlParseElementStart().

xmlW3CPIs

const char* const xmlW3CPIs[]

static

Initial value:

= {
    "xml-stylesheet",
    "xml-model",
    NULL
}

Definition at line 294 of file parser.c.

Referenced by xmlParsePITarget().