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/parser.h>
#include <libxml/xmlmemory.h>
#include <libxml/tree.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 <libxml/SAX2.h>
#include "private/buf.h"
#include "private/dict.h"
#include "private/entities.h"
#include "private/error.h"
#include "private/html.h"
#include "private/io.h"
#include "private/parser.h"

Include dependency graph for parser.c:

Go to the source code of this file.

Classes
struct	_xmlStartTag
struct	xmlParserNsExtra
struct	xmlParserNsBucket
struct	_xmlParserNsData
struct	_xmlAttrHashBucket
struct	xmlDefAttr
struct	_xmlDefAttrs

Macros
#define	IN_LIBXML
#define	XML_DIR_SEP   '/'
#define	NS_INDEX_EMPTY   INT_MAX
#define	NS_INDEX_XML   (INT_MAX - 1)
#define	URI_HASH_EMPTY   0xD943A04E
#define	URI_HASH_XML   0xF0451F02
#define	XML_PARSER_BIG_ENTITY   1000
#define	XML_PARSER_LOT_ENTITY   5000
#define	XML_PARSER_ALLOWED_EXPANSION   1000000
#define	XML_ENT_FIXED_COST   20
#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(b, i, v)
#define	growBuffer(buffer, n)

Typedefs
typedef struct _xmlDefAttrs	xmlDefAttrs
typedef xmlDefAttrs *	xmlDefAttrsPtr

Functions
static void	xmlErrAttributeDup (xmlParserCtxtPtr ctxt, const xmlChar *prefix, const xmlChar *localname)
static void	LIBXML_ATTR_FORMAT (3, 0)
static void	xmlSaturatedAdd (unsigned long *dst, unsigned long val)
static void	xmlSaturatedAddSizeT (unsigned long *dst, unsigned long val)
static int	xmlParserEntityCheck (xmlParserCtxtPtr ctxt, unsigned long extra)
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)
xmlParserNsData *	xmlParserNsCreate (void)
void	xmlParserNsFree (xmlParserNsData *nsdb)
static void	xmlParserNsReset (xmlParserNsData *nsdb)
static int	xmlParserNsStartElement (xmlParserNsData *nsdb)
static int	xmlParserNsLookup (xmlParserCtxtPtr ctxt, const xmlHashedString *prefix, xmlParserNsBucket **bucketPtr)
static const xmlChar *	xmlParserNsLookupUri (xmlParserCtxtPtr ctxt, const xmlHashedString *prefix)
void *	xmlParserNsLookupSax (xmlParserCtxtPtr ctxt, const xmlChar *prefix)
int	xmlParserNsUpdateSax (xmlParserCtxtPtr ctxt, const xmlChar *prefix, void *saxData)
static int	xmlParserNsGrow (xmlParserCtxtPtr ctxt)
static int	xmlParserNsPush (xmlParserCtxtPtr ctxt, const xmlHashedString *prefix, const xmlHashedString *uri, void *saxData, int defAttr)
static int	xmlParserNsPop (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)
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)
static xmlChar *	xmlStringDecodeEntitiesInt (xmlParserCtxtPtr ctxt, const xmlChar *str, int len, int what, xmlChar end, xmlChar end2, xmlChar end3, int check)
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 DEPRECATED: Internal function, don't use. 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 xmlHashedString	xmlParseQNameHashed (xmlParserCtxtPtr ctxt, xmlHashedString *prefix)
static const xmlChar *	xmlParseQName (xmlParserCtxtPtr ctxt, const xmlChar **prefix)

Variables
unsigned int	xmlParserMaxDepth = 256
const char *const	xmlParserVersion = LIBXML_VERSION_STRING LIBXML_VERSION_EXTRA
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)
static const xmlChar *	xmlParseQNameAndCompare (xmlParserCtxtPtr ctxt, xmlChar const *name, xmlChar const *prefix)
static xmlHashedString	xmlParseAttribute2 (xmlParserCtxtPtr ctxt, const xmlChar *pref, const xmlChar *elem, xmlHashedString *hprefix, xmlChar **value, int *len, int *alloc)

: attribute name
xmlAttrHashInsert: @ctxt: parser context @size: size of the hash table @uri: namespace uri @hashValue: combined hash value of name and uri @aindex: attribute index (this is a multiple of 5) Inserts a new attribute into the hash table. Returns INT_MAX if no existing attribute was found, the attribute index if an attribute was found, -1 if a memory allocation failed.
#define	DICT_FREE(str)
static xmlParserCtxtPtr	xmlCreateEntityParserCtxtInternal (xmlSAXHandlerPtr sax, void *userData, const xmlChar *URL, const xmlChar *ID, const xmlChar *base, xmlParserCtxtPtr pctx)
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)
static xmlParserErrors	xmlParseBalancedChunkMemoryInternal (xmlParserCtxtPtr oldctxt, const xmlChar *string, void *user_data, xmlNodePtr *lst)
static int	xmlAttrHashInsert (xmlParserCtxtPtr ctxt, unsigned size, const xmlChar *name, const xmlChar *uri, unsigned hashValue, int aindex)
static const xmlChar *	xmlParseStartTag2 (xmlParserCtxtPtr ctxt, const xmlChar **pref, const xmlChar **URI, int *nbNsPtr)
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 *str)
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)
void	xmlCtxtSetMaxAmplification (xmlParserCtxtPtr ctxt, unsigned maxAmpl)
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 *str, 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 xmlHashedString	xmlParseNCNameComplex (xmlParserCtxtPtr ctxt)
static xmlHashedString	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 partial)
static void	xmlParseCharDataInternal (xmlParserCtxtPtr ctxt, int partial)
void	xmlParseCharData (xmlParserCtxtPtr ctxt, ATTRIBUTE_UNUSED 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 2230 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 2246 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 2232 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 2235 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 2237 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 2239 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 2241 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 2243 of file parser.c.

COPY_BUF

#define COPY_BUF	(		b,
			i,
			v
	)

Value:

    if (v < 0x80) b[i++] = v;                       \
    else i += xmlCopyCharMultiByte(&b[i],v)

Definition at line 2299 of file parser.c.

CUR

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

Definition at line 2227 of file parser.c.

CUR_CHAR

#define CUR_CHAR

(

l

)

xmlCurrentChar(ctxt, &l)

Definition at line 2296 of file parser.c.

CUR_PTR

#define CUR_PTR   ctxt->input->cur

Definition at line 2229 of file parser.c.

CUR_SCHAR

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

Definition at line 2297 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 14360 of file parser.c.

GROW

#define GROW

Value:

    if (ctxt->input->end - ctxt->input->cur < INPUT_CHUNK)  \
    xmlParserGrow(ctxt);

Definition at line 2275 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 9108 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 2779 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 2280 of file parser.c.

NEXT1

#define NEXT1

Value:

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

Definition at line 2282 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 2289 of file parser.c.

NS_INDEX_EMPTY

#define NS_INDEX_EMPTY   INT_MAX

Definition at line 77 of file parser.c.

NS_INDEX_XML

#define NS_INDEX_XML   (INT_MAX - 1)

Definition at line 78 of file parser.c.

NXT

#define NXT

(

val

)

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

Definition at line 2228 of file parser.c.

RAW

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

Definition at line 2226 of file parser.c.

SAX_COMPAT_MODE

#define SAX_COMPAT_MODE   BAD_CAST "SAX compatibility mode document"

Definition at line 168 of file parser.c.

SHRINK

#define SHRINK

Value:

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

Definition at line 2269 of file parser.c.

SKIP

#define SKIP

(

val

)

Value:

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

Definition at line 2250 of file parser.c.

SKIP_BLANKS

#define SKIP_BLANKS   xmlSkipBlankChars(ctxt)

Definition at line 2278 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)                     \
        xmlParserGrow(ctxt);                        \
  } while (0)

Definition at line 2256 of file parser.c.

URI_HASH_EMPTY

#define URI_HASH_EMPTY   0xD943A04E

Definition at line 79 of file parser.c.

URI_HASH_XML

#define URI_HASH_XML   0xF0451F02

Definition at line 80 of file parser.c.

XML_DIR_SEP

#define XML_DIR_SEP   '/'

Definition at line 44 of file parser.c.

XML_ENT_FIXED_COST

#define XML_ENT_FIXED_COST   20

Definition at line 152 of file parser.c.

XML_PARSER_ALLOWED_EXPANSION

#define XML_PARSER_ALLOWED_EXPANSION   1000000

Definition at line 145 of file parser.c.

XML_PARSER_BIG_BUFFER_SIZE

#define XML_PARSER_BIG_BUFFER_SIZE   300

Definition at line 166 of file parser.c.

XML_PARSER_BIG_ENTITY

#define XML_PARSER_BIG_ENTITY   1000

Definition at line 134 of file parser.c.

XML_PARSER_BUFFER_SIZE

#define XML_PARSER_BUFFER_SIZE   100

Definition at line 167 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 179 of file parser.c.

XML_PARSER_LOT_ENTITY

#define XML_PARSER_LOT_ENTITY   5000

Definition at line 135 of file parser.c.

Typedef Documentation

xmlDefAttrs

typedef struct _xmlDefAttrs xmlDefAttrs

Definition at line 896 of file parser.c.

xmlDefAttrsPtr

typedef xmlDefAttrs* xmlDefAttrsPtr

Definition at line 897 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 3075 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 xmlParseCharDataComplex(), and xmlParseCharDataInternal().

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

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

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

inputPush()

int inputPush	(	xmlParserCtxtPtr	ctxt,
		xmlParserInputPtr	value
	)

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

Pushes a new parser input on top of the input stack

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

Definition at line 1897 of file parser.c.

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

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

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 275 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 2027 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

DEPRECATED: Internal function, do not use.

Pops the top element name from the name stack

Returns the name just removed

Definition at line 2143 of file parser.c.

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

Referenced by xmlParseElementEnd(), and xmlParseElementStart().

namePush()

int namePush	(	xmlParserCtxtPtr	ctxt,
		const xmlChar *	value
	)

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

DEPRECATED: Internal function, do not use.

Pushes a new element name on top of the name stack

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

Definition at line 2109 of file parser.c.

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

nodePop()

xmlNodePtr nodePop

(

xmlParserCtxtPtr

ctxt

)

nodePop: @ctxt: an XML parser context

DEPRECATED: Internal function, do not use.

Pops the top element node from the node stack

Returns the node just removed

Definition at line 1996 of file parser.c.

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

Referenced by xmlParseElementStart(), and xmlSAX2EndElementNs().

nodePush()

int nodePush	(	xmlParserCtxtPtr	ctxt,
		xmlNodePtr	value
	)

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

DEPRECATED: Internal function, do not use.

Pushes a new element node on top of the node stack

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

Definition at line 1956 of file parser.c.

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

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

spacePop()

static int spacePop ( xmlParserCtxtPtr  ctxt )

static

Definition at line 2178 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 2159 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 1017 of file parser.c.

                                     {
    xmlDefAttrsPtr defaults;
    xmlDefAttr *attr;
    int len, expandedSize;
    xmlHashedString name;
    xmlHashedString prefix;
    xmlHashedString hvalue;
    const xmlChar *localname;
 
    /*
     * 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.
     */
    localname = xmlSplitQName3(fullname, &len);
    if (localname == NULL) {
        name = xmlDictLookupHashed(ctxt->dict, fullname, -1);
    prefix.name = NULL;
    } else {
        name = xmlDictLookupHashed(ctxt->dict, localname, -1);
    prefix = xmlDictLookupHashed(ctxt->dict, fullname, len);
        if (prefix.name == NULL)
            goto mem_error;
    }
    if (name.name == NULL)
        goto mem_error;
 
    /*
     * make sure there is some storage
     */
    defaults = xmlHashLookup2(ctxt->attsDefault, name.name, prefix.name);
    if ((defaults == NULL) ||
        (defaults->nbAttrs >= defaults->maxAttrs)) {
        xmlDefAttrsPtr temp;
        int newSize;
 
        newSize = (defaults != NULL) ? 2 * defaults->maxAttrs : 4;
        temp = xmlRealloc(defaults,
                          sizeof(*defaults) + newSize * sizeof(xmlDefAttr));
    if (temp == NULL)
        goto mem_error;
        if (defaults == NULL)
            temp->nbAttrs = 0;
    temp->maxAttrs = newSize;
        defaults = temp;
    if (xmlHashUpdateEntry2(ctxt->attsDefault, name.name, prefix.name,
                            defaults, NULL) < 0) {
        xmlFree(defaults);
        goto mem_error;
    }
    }
 
    /*
     * Split the attribute name into prefix:localname , the string found
     * are within the DTD and hen not associated to namespace names.
     */
    localname = xmlSplitQName3(fullattr, &len);
    if (localname == NULL) {
        name = xmlDictLookupHashed(ctxt->dict, fullattr, -1);
    prefix.name = NULL;
    } else {
        name = xmlDictLookupHashed(ctxt->dict, localname, -1);
    prefix = xmlDictLookupHashed(ctxt->dict, fullattr, len);
        if (prefix.name == NULL)
            goto mem_error;
    }
    if (name.name == NULL)
        goto mem_error;
 
    /* intern the string and precompute the end */
    len = strlen((const char *) value);
    hvalue = xmlDictLookupHashed(ctxt->dict, value, len);
    if (hvalue.name == NULL)
        goto mem_error;
 
    expandedSize = strlen((const char *) name.name);
    if (prefix.name != NULL)
        expandedSize += strlen((const char *) prefix.name);
    expandedSize += len;
 
    attr = &defaults->attrs[defaults->nbAttrs++];
    attr->name = name;
    attr->prefix = prefix;
    attr->value = hvalue;
    attr->valueEnd = hvalue.name + len;
    attr->external = ctxt->external;
    attr->expandedSize = expandedSize;
 
    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 1138 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().

xmlAttrHashInsert()

static int xmlAttrHashInsert ( xmlParserCtxtPtr  ctxt, unsigned  size, const xmlChar *  name, const xmlChar *  uri, unsigned  hashValue, int  aindex  )

static

Definition at line 9414 of file parser.c.

                                                                      {
    xmlAttrHashBucket *table = ctxt->attrHash;
    xmlAttrHashBucket *bucket;
    unsigned hindex;
 
    hindex = hashValue & (size - 1);
    bucket = &table[hindex];
 
    while (bucket->index >= 0) {
        const xmlChar **atts = &ctxt->atts[bucket->index];
 
        if (name == atts[0]) {
            int nsIndex = (int) (ptrdiff_t) atts[2];
 
            if ((nsIndex == NS_INDEX_EMPTY) ? (uri == NULL) :
                (nsIndex == NS_INDEX_XML) ? (uri == ctxt->str_xml_ns) :
                (uri == ctxt->nsTab[nsIndex * 2 + 1]))
                return(bucket->index);
        }
 
        hindex++;
        bucket++;
        if (hindex >= size) {
            hindex = 0;
            bucket = table;
        }
    }
 
    bucket->index = aindex;
 
    return(INT_MAX);
}

Referenced by xmlParseStartTag2().

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 927 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 960 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 = 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

DEPRECATED: Internal function, do not use.

Checks that the value conforms to the LanguageID production:

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

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

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

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

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

script = 4ALPHA ; ISO 15924 code

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

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

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

                                ; Single alphanumerics
                                ; "x" reserved for private use

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

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

Returns 1 if correct 0 otherwise

Definition at line 1261 of file parser.c.

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

Referenced by xmlParseAttribute2().

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

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

Referenced by xmlCleanSpecialAttr().

xmlCreateDocParserCtxt()

xmlParserCtxtPtr xmlCreateDocParserCtxt

(

const xmlChar *

str

)

xmlCreateDocParserCtxt: @str: 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 14207 of file parser.c.

                                           {
    xmlParserCtxtPtr ctxt;
    xmlParserInputPtr input;
    xmlParserInputBufferPtr buf;
 
    if (str == NULL)
    return(NULL);
 
    ctxt = xmlNewParserCtxt();
    if (ctxt == NULL)
    return(NULL);
 
    buf = xmlParserInputBufferCreateString(str);
    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 xmlParseBalancedChunkMemoryInternal(), and 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 13670 of file parser.c.

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

xmlCreateEntityParserCtxtInternal()

static xmlParserCtxtPtr xmlCreateEntityParserCtxtInternal ( xmlSAXHandlerPtr  sax, void *  userData, 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 13600 of file parser.c.

                               {
    xmlParserCtxtPtr ctxt;
    xmlParserInputPtr inputStream;
    char *directory = NULL;
    xmlChar *uri;
 
    ctxt = xmlNewSAXParserCtxt(sax, userData);
    if (ctxt == NULL) {
    return(NULL);
    }
 
    if (pctx != NULL) {
        ctxt->options = pctx->options;
        ctxt->_private = pctx->_private;
    ctxt->input_id = pctx->input_id;
    }
 
    /* 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 13736 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 12333 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 = xmlNewSAXParserCtxt(sax, user_data);
    if (ctxt == NULL) {
    xmlFreeParserInputBuffer(buf);
    return(NULL);
    }
 
    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 13996 of file parser.c.

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

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

xmlCreateURLParserCtxt()

xmlParserCtxtPtr xmlCreateURLParserCtxt	(	const char *	filename,
		int	options
	)

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

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

Returns the new parser context or NULL

Definition at line 13694 of file parser.c.

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

Referenced by xmlCreateFileParserCtxt(), and xmlReadFile().

xmlCtxtGrowAttrs()

static int xmlCtxtGrowAttrs ( xmlParserCtxtPtr  ctxt, int  nr  )

static

Definition at line 1858 of file parser.c.

                                                {
    const xmlChar **atts;
    unsigned *attallocs;
    int maxatts;
 
    if (nr + 5 > ctxt->maxatts) {
    maxatts = ctxt->maxatts == 0 ? 55 : (nr + 5) * 2;
    atts = (const xmlChar **) xmlMalloc(
                     maxatts * sizeof(const xmlChar *));
    if (atts == NULL) goto mem_error;
    attallocs = xmlRealloc(ctxt->attallocs,
                               (maxatts / 5) * sizeof(attallocs[0]));
    if (attallocs == NULL) {
            xmlFree(atts);
            goto mem_error;
        }
        if (ctxt->maxatts > 0)
            memcpy(atts, ctxt->atts, ctxt->maxatts * sizeof(const xmlChar *));
        xmlFree(ctxt->atts);
    ctxt->atts = atts;
    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 *	str,
		const char *	URL,
		const char *	encoding,
		int	options
	)

xmlCtxtReadDoc: @ctxt: an XML parser context @str: 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 14950 of file parser.c.

{
    xmlParserInputBufferPtr input;
    xmlParserInputPtr stream;
 
    if (ctxt == NULL)
        return (NULL);
    if (str == NULL)
        return (NULL);
    xmlInitParser();
 
    xmlCtxtReset(ctxt);
 
    input = xmlParserInputBufferCreateString(str);
    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));
}

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

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

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

{
    xmlParserInputBufferPtr input;
    xmlParserInputPtr stream;
 
    if (ctxt == NULL)
        return (NULL);
    if (buffer == NULL)
        return (NULL);
    xmlInitParser();
 
    xmlCtxtReset(ctxt);
 
    input = xmlParserInputBufferCreateStatic(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));
}

xmlCtxtReset()

void xmlCtxtReset

(

xmlParserCtxtPtr

ctxt

)

xmlCtxtReset: @ctxt: an XML parser context

Reset a parser context

Definition at line 14372 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;
    xmlParserNsReset(ctxt->nsdb);
 
    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->endCheckState = 0;
    ctxt->inSubset = 0;
    ctxt->errNo = XML_ERR_OK;
    ctxt->depth = 0;
    ctxt->catalogs = NULL;
    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
    ctxt->nbErrors = 0;
    ctxt->nbWarnings = 0;
    if (ctxt->lastError.code != XML_ERR_OK)
        xmlResetError(&ctxt->lastError);
}

Referenced by xmlClearParserCtxt(), xmlCtxtReadDoc(), 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 14480 of file parser.c.

{
    xmlParserInputPtr inputStream;
    xmlParserInputBufferPtr buf;
 
    if (ctxt == NULL)
        return(1);
 
    buf = xmlAllocParserInputBuffer(XML_CHAR_ENCODING_NONE);
    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 pos = ctxt->input->cur - ctxt->input->base;
        int res;
 
        res = xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
        xmlBufUpdateInput(ctxt->input->buf->buffer, ctxt->input, pos);
        if (res < 0) {
            xmlFatalErr(ctxt, ctxt->input->buf->error, NULL);
            xmlHaltParser(ctxt);
            return(1);
        }
    }
 
    if (encoding != NULL) {
        xmlCharEncodingHandlerPtr hdlr;
 
        hdlr = xmlFindCharEncodingHandler(encoding);
        if (hdlr != NULL) {
            xmlSwitchToEncoding(ctxt, hdlr);
    } else {
        xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
                  "Unsupported encoding %s\n", BAD_CAST encoding);
        }
    }
 
    return(0);
}

xmlCtxtSetMaxAmplification()

void xmlCtxtSetMaxAmplification	(	xmlParserCtxtPtr	ctxt,
		unsigned	maxAmpl
	)

xmlCtxtSetMaxAmplification: @ctxt: an XML parser context @maxAmpl: maximum amplification factor

To protect against exponential entity expansion ("billion laughs"), the size of serialized output is (roughly) limited to the input size multiplied by this factor. The default value is 5.

When working with documents making heavy use of entity expansion, it can be necessary to increase the value. For security reasons, this should only be considered when processing trusted input.

Definition at line 14717 of file parser.c.

{
    ctxt->maxAmpl = maxAmpl;
}

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

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

Referenced by xslt_doc_default_loader(), and xsltDocDefaultLoaderFunc().

xmlCtxtUseOptionsInternal()

static int xmlCtxtUseOptionsInternal ( xmlParserCtxtPtr  ctxt, int  options  )

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

{
    if (ctxt == NULL)
        return(-1);
    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->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 856 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
    /*
     * Only enable SAX2 if there SAX2 element handlers, except when there
     * are no element handlers at all.
     */
    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 14735 of file parser.c.

{
    xmlDocPtr ret;
 
    xmlCtxtUseOptionsInternal(ctxt, options);
    if (encoding != NULL) {
        xmlCharEncodingHandlerPtr hdlr;
 
        /*
         * TODO: We should consider to set XML_PARSE_IGNORE_ENC if the
         * caller provided an encoding. Otherwise, we might switch to
         * the encoding from the XML declaration which is likely to
         * break things. Also see xmlSwitchInputEncoding.
         */
    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 xmlCtxtReadDoc(), 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 240 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 xmlParserNsPush(), and xmlParseStartTag2().

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 640 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:
            return(0);
        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);
}

xmlIsNameChar()

static int xmlIsNameChar ( xmlParserCtxtPtr  ctxt, int  c  )

static

Definition at line 3362 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 3331 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 8202 of file parser.c.

                                                                 {
    xmlParserInputPtr oldinput, input = NULL;
    xmlParserInputPtr *oldinputTab;
    const xmlChar *oldencoding;
    xmlChar *content = NULL;
    size_t length, i;
    int oldinputNr, oldinputMax, oldprogressive;
    int ret = -1;
    int res;
 
    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);
 
    input = xmlLoadExternalEntity((char *) entity->URI,
           (char *) entity->ExternalID, ctxt);
    if (input == NULL) {
    xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
                "xmlLoadEntityContent input error");
        return(-1);
    }
 
    oldinput = ctxt->input;
    oldinputNr = ctxt->inputNr;
    oldinputMax = ctxt->inputMax;
    oldinputTab = ctxt->inputTab;
    oldencoding = ctxt->encoding;
    oldprogressive = ctxt->progressive;
 
    ctxt->input = NULL;
    ctxt->inputNr = 0;
    ctxt->inputMax = 1;
    ctxt->encoding = NULL;
    ctxt->progressive = 0;
    ctxt->inputTab = xmlMalloc(sizeof(xmlParserInputPtr));
    if (ctxt->inputTab == NULL) {
        xmlErrMemory(ctxt, NULL);
        xmlFreeInputStream(input);
        goto error;
    }
 
    xmlBufResetInput(input->buf->buffer, input);
 
    inputPush(ctxt, input);
 
    xmlDetectEncoding(ctxt);
 
    /*
     * 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(ctxt->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");
        }
    }
 
    if (ctxt->instate == XML_PARSER_EOF)
        goto error;
 
    length = input->cur - input->base;
    xmlBufShrink(input->buf->buffer, length);
    xmlSaturatedAdd(&ctxt->sizeentities, length);
 
    while ((res = xmlParserInputBufferGrow(input->buf, 4096)) > 0)
        ;
 
    xmlBufResetInput(input->buf->buffer, input);
 
    if (res < 0) {
        xmlFatalErr(ctxt, input->buf->error, NULL);
        goto error;
    }
 
    length = xmlBufUse(input->buf->buffer);
    content = xmlBufDetach(input->buf->buffer);
 
    if (length > INT_MAX) {
        xmlErrMemory(ctxt, NULL);
        goto error;
    }
 
    for (i = 0; i < length; ) {
        int clen = length - i;
        int c = xmlGetUTF8Char(content + i, &clen);
 
        if ((c < 0) || (!IS_CHAR(c))) {
            xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
                              "xmlLoadEntityContent: invalid char value %d\n",
                              content[i]);
            goto error;
        }
        i += clen;
    }
 
    xmlSaturatedAdd(&ctxt->sizeentities, length);
    entity->content = content;
    entity->length = length;
    content = NULL;
    ret = 0;
 
error:
    while (ctxt->inputNr > 0)
        xmlFreeInputStream(inputPop(ctxt));
    xmlFree(ctxt->inputTab);
    xmlFree((xmlChar *) ctxt->encoding);
 
    ctxt->input = oldinput;
    ctxt->inputNr = oldinputNr;
    ctxt->inputMax = oldinputMax;
    ctxt->inputTab = oldinputTab;
    ctxt->encoding = oldencoding;
    ctxt->progressive = oldprogressive;
 
    xmlFree(content);
 
    return(ret);
}

Referenced by xmlStringDecodeEntitiesInt().

xmlParseAttribute2()

static xmlHashedString xmlParseAttribute2 ( xmlParserCtxtPtr  ctxt, const xmlChar *  pref, const xmlChar *  elem, xmlHashedString *  hprefix, 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 9286 of file parser.c.

{
    xmlHashedString hname;
    const xmlChar *prefix, *name;
    xmlChar *val, *internal_val = NULL;
    int normalize = 0;
 
    *value = NULL;
    GROW;
    hname = xmlParseQNameHashed(ctxt, hprefix);
    if (hname.name == NULL) {
        xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
                       "error parsing attribute name\n");
        return(hname);
    }
    name = hname.name;
    if (hprefix->name != NULL)
        prefix = hprefix->name;
    else
        prefix = 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 (val == NULL) {
            hname.name = NULL;
            return(hname);
        }
    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(hname);
    }
 
    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 (hname);
}

Referenced by xmlParseStartTag2().

xmlParseAttributeListDecl()

void xmlParseAttributeListDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseAttributeListDecl: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

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

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

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

Definition at line 6130 of file parser.c.

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

Referenced by xmlParseMarkupDecl().

xmlParseAttributeType()

int xmlParseAttributeType	(	xmlParserCtxtPtr	ctxt,
		xmlEnumerationPtr *	tree
	)

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

DEPRECATED: Internal function, don't use.

parse the Attribute list def for an element

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

[55] StringType ::= 'CDATA'

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

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

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

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

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

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

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

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

Returns the attribute type

Definition at line 6087 of file parser.c.

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

Referenced by xmlParseAttributeListDecl().

xmlParseAttValue()

xmlChar * xmlParseAttValue

(

xmlParserCtxtPtr

ctxt

)

xmlParseAttValue: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

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

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

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

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

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

Definition at line 4342 of file parser.c.

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

Referenced by xmlParseDefaultDecl().

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 4061 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);
        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) {
                        if (xmlParserEntityCheck(ctxt, ent->length))
                            goto error;
 
            ++ctxt->depth;
            rep = xmlStringDecodeEntitiesInt(ctxt, ent->content,
                                ent->length, XML_SUBSTITUTE_REF, 0, 0, 0,
                                /* check */ 1);
            --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;
 
            /*
                     * We also check for recursion and amplification
                     * when entities are not substituted. They're
                     * often expanded later.
             */
            if ((ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
            (ent->content != NULL)) {
                        if ((ent->flags & XML_ENT_CHECKED) == 0) {
                            unsigned long oldCopy = ctxt->sizeentcopy;
 
                            ctxt->sizeentcopy = ent->length;
 
                            ++ctxt->depth;
                            rep = xmlStringDecodeEntitiesInt(ctxt,
                                    ent->content, ent->length,
                                    XML_SUBSTITUTE_REF, 0, 0, 0,
                                    /* check */ 1);
                            --ctxt->depth;
 
                            /*
                             * If we're parsing DTD content, the entity
                             * might reference other entities which
                             * weren't defined yet, so the check isn't
                             * reliable.
                             */
                            if (ctxt->inSubset == 0) {
                                ent->flags |= XML_ENT_CHECKED;
                                ent->expandedSize = ctxt->sizeentcopy;
                            }
 
                            if (rep != NULL) {
                                xmlFree(rep);
                                rep = NULL;
                            } else {
                                ent->content[0] = 0;
                            }
 
                            if (xmlParserEntityCheck(ctxt, oldCopy))
                                goto error;
                        } else {
                            if (xmlParserEntityCheck(ctxt, ent->expandedSize))
                                goto error;
                        }
            }
 
            /*
             * 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(buf, len, 0x20);
            while (len + 10 > buf_size) {
                growBuffer(buf, 10);
            }
            }
            in_space = 1;
        }
        } else {
            in_space = 0;
        COPY_BUF(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 = 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 9121 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) {
        if (alloc) *alloc = 0;
        *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;
    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 12935 of file parser.c.

                                                             {
    xmlParserCtxtPtr ctxt;
    xmlDocPtr newDoc = NULL;
    xmlNodePtr newRoot;
    xmlSAXHandlerPtr oldsax = NULL;
    xmlNodePtr content = NULL;
    xmlNodePtr last = NULL;
    xmlParserErrors ret = XML_ERR_OK;
    xmlHashedString hprefix, huri;
    unsigned i;
 
    if (((oldctxt->depth > 40) && ((oldctxt->options & XML_PARSE_HUGE) == 0)) ||
        (oldctxt->depth >  100)) {
    xmlFatalErrMsg(oldctxt, XML_ERR_ENTITY_LOOP,
                       "Maximum entity nesting depth exceeded");
    return(XML_ERR_ENTITY_LOOP);
    }
 
 
    if (lst != NULL)
        *lst = NULL;
    if (string == NULL)
        return(XML_ERR_INTERNAL_ERROR);
 
    ctxt = xmlCreateDocParserCtxt(string);
    if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
    ctxt->nbErrors = oldctxt->nbErrors;
    ctxt->nbWarnings = oldctxt->nbWarnings;
    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;
    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);
 
    /*
     * Propagate namespaces down the entity
     *
     * Making entities and namespaces work correctly requires additional
     * changes, see xmlParseReference.
     */
 
    /* Default namespace */
    hprefix.name = NULL;
    hprefix.hashValue = 0;
    huri.name = xmlParserNsLookupUri(oldctxt, &hprefix);
    huri.hashValue = 0;
    if (huri.name != NULL)
        xmlParserNsPush(ctxt, NULL, &huri, NULL, 0);
 
    for (i = 0; i < oldctxt->nsdb->hashSize; i++) {
        xmlParserNsBucket *bucket = &oldctxt->nsdb->hash[i];
        const xmlChar **ns;
        xmlParserNsExtra *extra;
        unsigned nsIndex;
 
        if ((bucket->hashValue != 0) &&
            (bucket->index != INT_MAX)) {
            nsIndex = bucket->index;
            ns = &oldctxt->nsTab[nsIndex * 2];
            extra = &oldctxt->nsdb->extra[nsIndex];
 
            hprefix.name = ns[0];
            hprefix.hashValue = bucket->hashValue;
            huri.name = ns[1];
            huri.hashValue = extra->uriHashValue;
            /*
             * Don't copy SAX data to avoid a use-after-free with XML reader.
             * This matches the pre-2.12 behavior.
             */
            xmlParserNsPush(ctxt, &hprefix, &huri, NULL, 0);
        }
    }
 
    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) {
            ret = XML_ERR_INTERNAL_ERROR;
            goto 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) {
        ret = XML_ERR_INTERNAL_ERROR;
        goto 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;
 
    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) {
    ret = (xmlParserErrors)ctxt->errNo;
        oldctxt->errNo = ctxt->errNo;
        oldctxt->wellFormed = 0;
        xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
    } 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;
    }
 
    /*
     * Also record the size of the entity parsed
     */
    if (ctxt->input != NULL && oldctxt != NULL) {
        unsigned long consumed = ctxt->input->consumed;
 
        xmlSaturatedAddSizeT(&consumed, ctxt->input->cur - ctxt->input->base);
 
        xmlSaturatedAdd(&oldctxt->sizeentcopy, consumed);
        xmlSaturatedAdd(&oldctxt->sizeentcopy, ctxt->sizeentcopy);
    }
 
    oldctxt->nbErrors = ctxt->nbErrors;
    oldctxt->nbWarnings = ctxt->nbWarnings;
 
error:
    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

DEPRECATED: Internal function, don't use.

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

[18] CDSect ::= CDStart CData CDEnd

[19] CDStart ::= ''

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

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

Definition at line 10117 of file parser.c.

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

Referenced by xmlParseContentInternal().

xmlParseCharData()

void xmlParseCharData	(	xmlParserCtxtPtr	ctxt,
		ATTRIBUTE_UNUSED int	cdata
	)

xmlParseCharData: @ctxt: an XML parser context @cdata: unused

DEPRECATED: Internal function, don't use.

Definition at line 4811 of file parser.c.

                                                                    {
    xmlParseCharDataInternal(ctxt, 0);
}

xmlParseCharDataComplex()

static void xmlParseCharDataComplex ( xmlParserCtxtPtr  ctxt, int  partial  )

static

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

Always makes progress if the first char isn't '<' or '&'.

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

Definition at line 4716 of file parser.c.

                                                            {
    xmlChar buf[XML_PARSER_BIG_BUFFER_SIZE + 5];
    int nbchar = 0;
    int cur, l;
 
    cur = CUR_CHAR(l);
    while ((cur != '<') && /* checked */
           (cur != '&') &&
       (IS_CHAR(cur))) {
    if ((cur == ']') && (NXT(1) == ']') && (NXT(2) == '>')) {
        xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
    }
    COPY_BUF(buf, nbchar, cur);
    /* move current position before possible calling of ctxt->sax->characters */
    NEXTL(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;
            SHRINK;
    }
    cur = CUR_CHAR(l);
    }
    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;
        }
    }
    }
    /*
     * cur == 0 can mean
     *
     * - XML_PARSER_EOF or memory error. This is checked above.
     * - An actual 0 character.
     * - End of buffer.
     * - An incomplete UTF-8 sequence. This is allowed if partial is set.
     */
    if (ctxt->input->cur < ctxt->input->end) {
        if ((cur == 0) && (CUR != 0)) {
            if (partial == 0) {
                xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
                        "Incomplete UTF-8 sequence starting with %02X\n", CUR);
                NEXTL(1);
            }
        } else if ((cur != '<') && (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 xmlParseCharDataInternal().

xmlParseCharDataInternal()

static void xmlParseCharDataInternal ( xmlParserCtxtPtr  ctxt, int  partial  )

static

xmlParseCharDataInternal: @ctxt: an XML parser context @partial: buffer may contain partial UTF-8 sequences

Parse character data. Always makes progress if the first char isn't '<' or '&'.

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

                                                             {
    const xmlChar *in;
    int nbchar = 0;
    int line = ctxt->input->line;
    int col = ctxt->input->col;
    int ccol;
 
    GROW;
    /*
     * Accelerated common case where input don't need to be
     * modified before passing it to the handler.
     */
    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->disableSAX == 0) &&
                    (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->disableSAX == 0) &&
                           (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);
                if (ctxt->instate != XML_PARSER_EOF)
                    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->disableSAX == 0) &&
                (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) &&
                       (ctxt->disableSAX == 0)) {
                if (ctxt->sax->characters != NULL)
                    ctxt->sax->characters(ctxt->userData,
                                          ctxt->input->cur, nbchar);
                line = ctxt->input->line;
                col = ctxt->input->col;
            }
            if (ctxt->instate == XML_PARSER_EOF)
                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));
    ctxt->input->line = line;
    ctxt->input->col = col;
    xmlParseCharDataComplex(ctxt, partial);
}

Referenced by xmlParseCharData(), and xmlParseContentInternal().

xmlParseCharRef()

int xmlParseCharRef

(

xmlParserCtxtPtr

ctxt

)

xmlParseCharRef: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

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

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

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

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

Definition at line 2493 of file parser.c.

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

Referenced by xmlParseAttValueComplex(), and xmlParseReference().

xmlParseComment()

void xmlParseComment

(

xmlParserCtxtPtr

ctxt

)

xmlParseComment: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

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

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

[15] Comment ::= ''

Definition at line 5034 of file parser.c.

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

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

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

                                                {
    int q, ql;
    int r, rl;
    int cur, l;
    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);
    if (buf == NULL) {
        xmlErrMemory(ctxt, NULL);
        return;
    }
    }
    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",
                      r);
    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(buf, len, q);
        if (len > maxLength) {
            xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
                         "Comment too big found", NULL);
            xmlFree (buf);
            return;
        }
 
    q = r;
    ql = rl;
    r = cur;
    rl = l;
 
    NEXTL(l);
    cur = CUR_CHAR(l);
 
    }
    buf[len] = 0;
    if (ctxt->instate == XML_PARSER_EOF) {
        xmlFree(buf);
        return;
    }
    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

Parse a conditional section. Always consumes '<!['.

[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 6873 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')) {
                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;
 
                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;
                    }
                }
 
        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 if ((RAW == '<') && ((NXT(1) == '!') || (NXT(1) == '?'))) {
            xmlParseMarkupDecl(ctxt);
        } else {
            xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
            xmlHaltParser(ctxt);
            goto error;
        }
 
        if (depth == 0)
            break;
 
        SKIP_BLANKS;
        SHRINK;
        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 10294 of file parser.c.

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

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

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

                                               {
    int nameNr = ctxt->nameNr;
 
    GROW;
    while ((ctxt->input->cur < ctxt->input->end) &&
       (ctxt->instate != XML_PARSER_EOF)) {
    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 {
        xmlParseCharDataInternal(ctxt, 0);
    }
 
    SHRINK;
    GROW;
    }
}

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 12621 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

DEPRECATED: Internal function, don't use.

Parse an attribute default declaration

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

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

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

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

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

returns: XML_ATTRIBUTE_NONE, XML_ATTRIBUTE_REQUIRED, XML_ATTRIBUTE_IMPLIED or XML_ATTRIBUTE_FIXED.

Definition at line 5829 of file parser.c.

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

Referenced by xmlParseAttributeListDecl().

xmlParseDocTypeDecl()

void xmlParseDocTypeDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseDocTypeDecl: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse a DOCTYPE declaration

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

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

Definition at line 8466 of file parser.c.

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

Referenced by xmlParseDocument().

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

                                        {
    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);
 
    xmlDetectEncoding(ctxt);
 
    if (CUR == 0) {
    xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
    return(-1);
    }
 
    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);
    }
    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 (ctxt->input->cur < ctxt->input->end) {
            if (ctxt->errNo == XML_ERR_OK)
            xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
        } else if ((ctxt->input->buf != NULL) &&
                   (ctxt->input->buf->encoder != NULL) &&
                   (!xmlBufIsEmpty(ctxt->input->buf->raw))) {
            xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR,
                           "Truncated multi-byte sequence at EOF\n");
        }
    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 doparse(), internal_parseBuffer(), xmlDoRead(), xslt_doc_default_loader(), and xsltDocDefaultLoaderFunc().

xmlParseElement()

void xmlParseElement

(

xmlParserCtxtPtr

ctxt

)

xmlParseElement: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse an XML element

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

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

Definition at line 10327 of file parser.c.

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

Referenced by xmlParseDocument().

xmlParseElementChildrenContentDecl()

xmlElementContentPtr xmlParseElementChildrenContentDecl	(	xmlParserCtxtPtr	ctxt,
		int	inputchk
	)

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

DEPRECATED: Internal function, don't use.

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

[47] children ::= (choice | seq) ('?' | '*' | '+')?

[48] cp ::= (Name | choice | seq) ('?' | '*' | '+')?

[49] choice ::= '(' S? cp ( S? '|' S? cp )* S? ')'

[50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')'

[ VC: Proper Group/PE Nesting ] applies to [49] and [50] TODO Parameter-entity replacement text must be properly nested with parenthesized groups. That is to say, if either of the opening or closing parentheses in a choice, seq, or Mixed construct is contained in the replacement text for a parameter entity, both must be contained in the same replacement text. For interoperability, if a parameter-entity reference appears in a choice, seq, or Mixed construct, its replacement text should not be empty, and neither the first nor last non-blank character of the replacement text should be a connector (| or ,).

Returns the tree of xmlElementContentPtr describing the element hierarchy.

Definition at line 6693 of file parser.c.

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

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 6389 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;
    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 6715 of file parser.c.

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

Referenced by xmlParseElementDecl().

xmlParseElementDecl()

int xmlParseElementDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseElementDecl: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

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

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

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

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

Definition at line 6762 of file parser.c.

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

Referenced by xmlParseMarkupDecl().

xmlParseElementEnd()

static void xmlParseElementEnd ( xmlParserCtxtPtr  ctxt )

static

xmlParseElementEnd: @ctxt: an XML parser context

Parse the end of an XML element. Always consumes '</'.

Definition at line 10483 of file parser.c.

                                          {
    xmlNodePtr cur = ctxt->node;
 
    if (ctxt->nameNr <= 0) {
        if ((RAW == '<') && (NXT(1) == '/'))
            SKIP(2);
        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
     */
    if (cur != NULL && ctxt->record_info) {
        xmlParserNodeInfoPtr node_info;
 
        node_info = (xmlParserNodeInfoPtr) xmlParserFindNodeInfo(ctxt, cur);
        if (node_info != NULL) {
            node_info->end_pos = ctxt->input->consumed +
                                 (CUR_PTR - ctxt->input->base);
            node_info->end_line = ctxt->input->line;
        }
    }
}

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

DEPRECATED: Internal function, don't use.

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

[51] Mixed ::= '(' S? '#PCDATA' (S? '|' S? Name)* S? ')*' | '(' S? '#PCDATA' S? ')'

[ VC: Proper Group/PE Nesting ] applies to [51] too (see [49])

[ VC: No Duplicate Types ] The same name must not appear more than once in a single mixed-content declaration.

returns: the list of the xmlElementContentPtr describing the element choices

Definition at line 6264 of file parser.c.

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

Referenced by xmlParseElementContentDecl().

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.

Always consumes '<'.

Definition at line 10359 of file parser.c.

                                            {
    const xmlChar *name;
    const xmlChar *prefix = NULL;
    const xmlChar *URI = NULL;
    xmlParserNodeInfo node_info;
    int line;
    xmlNodePtr cur;
    int nbNs = 0;
 
    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, &nbNs);
#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, nbNs);
    cur = 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 (nbNs > 0)
        xmlParserNsPop(ctxt, nbNs);
    if (cur != NULL && ctxt->record_info) {
            node_info.node = cur;
            node_info.end_pos = ctxt->input->consumed +
                                (CUR_PTR - ctxt->input->base);
            node_info.end_line = ctxt->input->line;
            xmlParserAddNodeInfo(ctxt, &node_info);
    }
    return(1);
    }
    if (RAW == '>') {
        NEXT1;
        if (cur != NULL && ctxt->record_info) {
            node_info.node = cur;
            node_info.end_pos = 0;
            node_info.end_line = 0;
            xmlParserAddNodeInfo(ctxt, &node_info);
        }
    } 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 (nbNs > 0)
        xmlParserNsPop(ctxt, nbNs);
    return(-1);
    }
 
    return(0);
}

Referenced by xmlParseContentInternal(), and xmlParseElement().

xmlParseEncName()

xmlChar * xmlParseEncName

(

xmlParserCtxtPtr

ctxt

)

xmlParseEncName: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse the XML encoding name

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

Returns the encoding name value or NULL

Definition at line 10643 of file parser.c.

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

Referenced by xmlParseEncodingDecl().

xmlParseEncodingDecl()

const xmlChar * xmlParseEncodingDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseEncodingDecl: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse the XML encoding declaration

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

this setups the conversion filters.

Returns the encoding value or NULL

Definition at line 10713 of file parser.c.

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

Referenced by xmlParseTextDecl(), and xmlParseXMLDecl().

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 tag. Always consumes '</'.

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

With namespace

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

Definition at line 10047 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)
    xmlParserNsPop(ctxt, tag->nsNr);
}

Referenced by xmlParseElementEnd().

xmlParseEntityDecl()

void xmlParseEntityDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseEntityDecl: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

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

[70] EntityDecl ::= GEDecl | PEDecl

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

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

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

[74] PEDef ::= EntityValue | ExternalID

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

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

Definition at line 5551 of file parser.c.

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

Referenced by xmlParseMarkupDecl().

xmlParseEntityRef()

xmlEntityPtr xmlParseEntityRef

(

xmlParserCtxtPtr

ctxt

)

xmlParseEntityRef: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

Parse an entitiy reference. Always consumes '&'.

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

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

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

Returns the xmlEntityPtr if found, or NULL otherwise.

Definition at line 7683 of file parser.c.

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

Referenced by xmlParseAttValueComplex(), and xmlParseReference().

xmlParseEntityValue()

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

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

DEPRECATED: Internal function, don't use.

parse a value for ENTITY declarations

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

Returns the EntityValue parsed with reference substituted or NULL

Definition at line 3906 of file parser.c.

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

Referenced by xmlParseEntityDecl().

xmlParseEnumeratedType()

int xmlParseEnumeratedType	(	xmlParserCtxtPtr	ctxt,
		xmlEnumerationPtr *	tree
	)

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

DEPRECATED: Internal function, don't use.

parse an Enumerated attribute type.

[57] EnumeratedType ::= NotationType | Enumeration

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

Returns: XML_ATTRIBUTE_ENUMERATION or XML_ATTRIBUTE_NOTATION

Definition at line 6022 of file parser.c.

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

Referenced by xmlParseAttributeType().

xmlParseEnumerationType()

xmlEnumerationPtr xmlParseEnumerationType

(

xmlParserCtxtPtr

ctxt

)

xmlParseEnumerationType: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse an Enumeration attribute type.

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

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

Returns: the enumeration attribute tree built while parsing

Definition at line 5952 of file parser.c.

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

Referenced by xmlParseEnumeratedType().

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

                                                   {
    xmlParserCtxtPtr ctxt;
    xmlDocPtr newDoc;
    xmlNodePtr newRoot;
    xmlParserErrors ret = XML_ERR_OK;
 
    if (((depth > 40) &&
    ((oldctxt == NULL) || (oldctxt->options & XML_PARSE_HUGE) == 0)) ||
    (depth > 100)) {
    xmlFatalErrMsg(oldctxt, XML_ERR_ENTITY_LOOP,
                       "Maximum entity nesting depth exceeded");
        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(sax, user_data, URL, ID, NULL,
                                             oldctxt);
    if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
    if (oldctxt != NULL) {
        ctxt->nbErrors = oldctxt->nbErrors;
        ctxt->nbWarnings = oldctxt->nbWarnings;
    }
    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)
    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;
    }
 
    xmlDetectEncoding(ctxt);
 
    /*
     * 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->vctxt.flags = oldctxt->vctxt.flags;
        }
    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) {
    ret = (xmlParserErrors)ctxt->errNo;
        if (oldctxt != NULL) {
            oldctxt->errNo = ctxt->errNo;
            oldctxt->wellFormed = 0;
            xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
        }
    } 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;
    }
 
    /*
     * Also record the size of the entity parsed
     */
    if (ctxt->input != NULL && oldctxt != NULL) {
        unsigned long consumed = ctxt->input->consumed;
 
        xmlSaturatedAddSizeT(&consumed, ctxt->input->cur - ctxt->input->base);
 
        xmlSaturatedAdd(&oldctxt->sizeentities, consumed);
        xmlSaturatedAdd(&oldctxt->sizeentities, ctxt->sizeentities);
 
        xmlSaturatedAdd(&oldctxt->sizeentcopy, consumed);
        xmlSaturatedAdd(&oldctxt->sizeentcopy, ctxt->sizeentcopy);
    }
 
    if (oldctxt != NULL) {
        ctxt->dict = NULL;
        ctxt->attsDefault = NULL;
        ctxt->attsSpecial = NULL;
        oldctxt->nbErrors = ctxt->nbErrors;
        oldctxt->nbWarnings = ctxt->nbWarnings;
        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

DEPRECATED: Internal function, don't use.

Parse an External ID or a Public ID

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

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

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

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

Definition at line 4840 of file parser.c.

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

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

xmlParseExternalSubset()

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

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

parse Markup declarations from an external subset

[30] extSubset ::= textDecl? extSubsetDecl

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

Definition at line 7160 of file parser.c.

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

Referenced by xmlSAX2ExternalSubset().

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

                                            {
    if ((ctxt == NULL) || (ctxt->input == NULL))
        return(-1);
 
    xmlDetectSAX2(ctxt);
 
    /*
     * SAX: beginning of the document processing.
     */
    if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
        ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
 
    xmlDetectEncoding(ctxt);
 
    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 13156 of file parser.c.

                                                    {
    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;
 
        hdlr = xmlFindCharEncodingHandler((const char *) doc->encoding);
        if (hdlr != NULL) {
            xmlSwitchToEncoding(ctxt, hdlr);
    } else {
            return(XML_ERR_UNSUPPORTED_ENCODING);
        }
    }
 
    xmlCtxtUseOptionsInternal(ctxt, options);
    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);
 
    if ((ctxt->html == 0) && (node->type == XML_ELEMENT_NODE)) {
    /*
     * initialize the SAX2 namespaces stack
     */
    cur = node;
    while ((cur != NULL) && (cur->type == XML_ELEMENT_NODE)) {
        xmlNsPtr ns = cur->nsDef;
            xmlHashedString hprefix, huri;
 
        while (ns != NULL) {
                hprefix = xmlDictLookupHashed(ctxt->dict, ns->prefix, -1);
                huri = xmlDictLookupHashed(ctxt->dict, ns->href, -1);
                if (xmlParserNsPush(ctxt, &hprefix, &huri, ns, 1) > 0)
                    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);
 
    xmlParserNsPop(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);
}

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 8538 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)*
     */
    SKIP_BLANKS;
    while (((RAW != ']') || (ctxt->inputNr > baseInputNr)) &&
               (ctxt->instate != XML_PARSER_EOF)) {
 
            /*
             * 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);
            } else if ((RAW == '<') && ((NXT(1) == '!') || (NXT(1) == '?'))) {
            xmlParseMarkupDecl(ctxt);
            } else if (RAW == '%') {
            xmlParsePEReference(ctxt);
            } else {
        xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
                        "xmlParseInternalSubset: error detected in"
                        " Markup declaration\n");
                xmlHaltParser(ctxt);
                return;
            }
        SKIP_BLANKS;
            SHRINK;
            GROW;
    }
    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

DEPRECATED: Internal function, don't use.

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

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

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

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

Definition at line 7020 of file parser.c.

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

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

xmlParseMisc()

void xmlParseMisc

(

xmlParserCtxtPtr

ctxt

)

xmlParseMisc: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse an XML Misc* optional field.

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

Definition at line 10979 of file parser.c.

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

Referenced by xmlParseDocument().

xmlParseName()

const xmlChar * xmlParseName

(

xmlParserCtxtPtr

ctxt

)

xmlParseName: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse an XML name.

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

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

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

Returns the Name parsed or NULL

Definition at line 3529 of file parser.c.

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

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

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

                                           {
    int len = 0, l;
    int c;
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
                    XML_MAX_TEXT_LENGTH :
                    XML_MAX_NAME_LENGTH;
 
    /*
     * Handler for more complex cases
     */
    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 (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 (len <= INT_MAX - l)
            len += l;
        NEXTL(l);
        c = CUR_CHAR(l);
    }
    }
    if (ctxt->instate == XML_PARSER_EOF)
        return(NULL);
    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 xmlHashedString 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 3629 of file parser.c.

                                      {
    const xmlChar *in, *e;
    xmlHashedString ret;
    size_t count = 0;
    size_t maxLength = (ctxt->options & XML_PARSE_HUGE) ?
                       XML_MAX_TEXT_LENGTH :
                       XML_MAX_NAME_LENGTH;
 
    ret.name = NULL;
 
    /*
     * 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(ret);
            }
        ret = xmlDictLookupHashed(ctxt->dict, ctxt->input->cur, count);
        ctxt->input->cur = in;
        ctxt->input->col += count;
        if (ret.name == NULL) {
            xmlErrMemory(ctxt, NULL);
        }
        return(ret);
    }
    }
complex:
    return(xmlParseNCNameComplex(ctxt));
}

Referenced by xmlParseQNameHashed().

xmlParseNCNameComplex()

static xmlHashedString xmlParseNCNameComplex ( xmlParserCtxtPtr  ctxt )

static

Definition at line 3574 of file parser.c.

                                             {
    xmlHashedString ret;
    int len = 0, l;
    int c;
    int maxLength = (ctxt->options & XML_PARSE_HUGE) ?
                    XML_MAX_TEXT_LENGTH :
                    XML_MAX_NAME_LENGTH;
    size_t startPosition = 0;
 
    ret.name = NULL;
    ret.hashValue = 0;
 
    /*
     * Handler for more complex cases
     */
    startPosition = CUR_PTR - BASE_PTR;
    c = CUR_CHAR(l);
    if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
    (!xmlIsNameStartChar(ctxt, c) || (c == ':'))) {
    return(ret);
    }
 
    while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
       (xmlIsNameChar(ctxt, c) && (c != ':'))) {
        if (len <= INT_MAX - l)
        len += l;
    NEXTL(l);
    c = CUR_CHAR(l);
    }
    if (ctxt->instate == XML_PARSER_EOF)
        return(ret);
    if (len > maxLength) {
        xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
        return(ret);
    }
    ret = xmlDictLookupHashed(ctxt->dict, (BASE_PTR + startPosition), len);
    return(ret);
}

Referenced by xmlParseNCName().

xmlParseNmtoken()

xmlChar * xmlParseNmtoken

(

xmlParserCtxtPtr

ctxt

)

xmlParseNmtoken: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse an XML Nmtoken.

[7] Nmtoken ::= (NameChar)+

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

Returns the Nmtoken parsed or NULL

Definition at line 3821 of file parser.c.

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

Referenced by xmlParseEnumerationType(), and xmlParseQNameHashed().

xmlParseNotationDecl()

void xmlParseNotationDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseNotationDecl: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

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

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

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

See the NOTE on xmlParseExternalID().

Definition at line 5468 of file parser.c.

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

Referenced by xmlParseMarkupDecl().

xmlParseNotationType()

xmlEnumerationPtr xmlParseNotationType

(

xmlParserCtxtPtr

ctxt

)

xmlParseNotationType: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse an Notation attribute type.

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

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

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

Returns: the notation attribute tree built while parsing

Definition at line 5881 of file parser.c.

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

Referenced by xmlParseEnumeratedType().

xmlParsePEReference()

void xmlParsePEReference

(

xmlParserCtxtPtr

ctxt

)

xmlParsePEReference: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

Parse a parameter entity reference. Always consumes ''.

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

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

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

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

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

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

Definition at line 8063 of file parser.c.

{
    const xmlChar *name;
    xmlEntityPtr entity = NULL;
    xmlParserInputPtr input;
 
    if (RAW != '%')
        return;
    NEXT;
    name = xmlParseName(ctxt);
    if (name == NULL) {
    xmlFatalErrMsg(ctxt, XML_ERR_PEREF_NO_NAME, "PEReference: no name\n");
    return;
    }
    if (xmlParserDebugEntities)
    xmlGenericError(xmlGenericErrorContext,
        "PEReference: %s\n", name);
    if (RAW != ';') {
    xmlFatalErr(ctxt, XML_ERR_PEREF_SEMICOL_MISSING, NULL);
        return;
    }
 
    NEXT;
 
    /*
     * Request the entity from SAX
     */
    if ((ctxt->sax != NULL) &&
    (ctxt->sax->getParameterEntity != NULL))
    entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
    if (ctxt->instate == XML_PARSER_EOF)
    return;
    if (entity == NULL) {
    /*
     * [ WFC: Entity Declared ]
     * In a document without any DTD, a document with only an
     * internal DTD subset which contains no parameter entity
     * references, or a document with "standalone='yes'", ...
     * ... The declaration of a parameter entity must precede
     * any reference to it...
     */
    if ((ctxt->standalone == 1) ||
        ((ctxt->hasExternalSubset == 0) &&
         (ctxt->hasPErefs == 0))) {
        xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
                  "PEReference: %%%s; not found\n",
                  name);
    } else {
        /*
         * [ VC: Entity Declared ]
         * In a document with an external subset or external
         * parameter entities with "standalone='no'", ...
         * ... The declaration of a parameter entity must
         * precede any reference to it...
         */
            if ((ctxt->validate) && (ctxt->vctxt.error != NULL)) {
                xmlValidityError(ctxt, XML_WAR_UNDECLARED_ENTITY,
                                 "PEReference: %%%s; not found\n",
                                 name, NULL);
            } else
                xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
                              "PEReference: %%%s; not found\n",
                              name, NULL);
            ctxt->valid = 0;
    }
    } else {
    /*
     * Internal checking in case the entity quest barfed
     */
    if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
        (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
        xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
          "Internal: %%%s; is not a parameter entity\n",
              name, NULL);
    } else {
            unsigned long parentConsumed;
            xmlEntityPtr oldEnt;
 
        if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
            ((ctxt->options & XML_PARSE_NOENT) == 0) &&
        ((ctxt->options & XML_PARSE_DTDVALID) == 0) &&
        ((ctxt->options & XML_PARSE_DTDLOAD) == 0) &&
        ((ctxt->options & XML_PARSE_DTDATTR) == 0) &&
        (ctxt->replaceEntities == 0) &&
        (ctxt->validate == 0))
        return;
 
            if (entity->flags & XML_ENT_EXPANDING) {
                xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
                xmlHaltParser(ctxt);
                return;
            }
 
            /* Must be computed from old input before pushing new input. */
            parentConsumed = ctxt->input->parentConsumed;
            oldEnt = ctxt->input->entity;
            if ((oldEnt == NULL) ||
                ((oldEnt->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
                 ((oldEnt->flags & XML_ENT_PARSED) == 0))) {
                xmlSaturatedAdd(&parentConsumed, ctxt->input->consumed);
                xmlSaturatedAddSizeT(&parentConsumed,
                                     ctxt->input->cur - ctxt->input->base);
            }
 
        input = xmlNewEntityInputStream(ctxt, entity);
        if (xmlPushInput(ctxt, input) < 0) {
                xmlFreeInputStream(input);
        return;
            }
 
            entity->flags |= XML_ENT_EXPANDING;
 
            input->parentConsumed = parentConsumed;
 
        if (entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) {
                xmlDetectEncoding(ctxt);
 
                if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) &&
                    (IS_BLANK_CH(NXT(5)))) {
                    xmlParseTextDecl(ctxt);
                }
            }
    }
    }
    ctxt->hasPErefs = 1;
}

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

xmlParsePI()

void xmlParsePI

(

xmlParserCtxtPtr

ctxt

)

xmlParsePI: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse an XML Processing Instruction.

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

The processing is transferred to SAX once parsed.

Definition at line 5322 of file parser.c.

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

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

xmlParsePITarget()

const xmlChar * xmlParsePITarget

(

xmlParserCtxtPtr

ctxt

)

xmlParsePITarget: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse the name of a PI

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

Returns the PITarget name or NULL

Definition at line 5212 of file parser.c.

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

Referenced by xmlParsePI().

xmlParsePubidLiteral()

xmlChar * xmlParsePubidLiteral

(

xmlParserCtxtPtr

ctxt

)

xmlParsePubidLiteral: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse an XML public literal

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

Returns the PubidLiteral parsed or NULL.

Definition at line 4442 of file parser.c.

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

Referenced by xmlParseExternalID().

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

                                                             {
    xmlHashedString n, p;
 
    n = xmlParseQNameHashed(ctxt, &p);
    if (n.name == NULL)
        return(NULL);
    *prefix = p.name;
    return(n.name);
}

Referenced by xmlParseQNameAndCompare().

xmlParseQNameAndCompare()

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

static

Definition at line 9032 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 == NULL)
        return(NULL);
    if ((ret == name) && (prefix == prefix2))
    return((const xmlChar*) 1);
    return ret;
}

Referenced by xmlParseEndTag2().

xmlParseQNameHashed()

static xmlHashedString xmlParseQNameHashed ( xmlParserCtxtPtr  ctxt, xmlHashedString *  prefix  )

static

xmlParseQNameHashed: @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 8948 of file parser.c.

                                                                    {
    xmlHashedString l, p;
    int start, isNCName = 0;
 
    l.name = NULL;
    p.name = NULL;
 
    GROW;
    if (ctxt->instate == XML_PARSER_EOF)
        return(l);
    start = CUR_PTR - BASE_PTR;
 
    l = xmlParseNCName(ctxt);
    if (l.name != NULL) {
        isNCName = 1;
        if (CUR == ':') {
            NEXT;
            p = l;
            l = xmlParseNCName(ctxt);
        }
    }
    if ((l.name == NULL) || (CUR == ':')) {
        xmlChar *tmp;
 
        l.name = NULL;
        p.name = NULL;
        if (ctxt->instate == XML_PARSER_EOF)
            return(l);
        if ((isNCName == 0) && (CUR != ':'))
            return(l);
        tmp = xmlParseNmtoken(ctxt);
        if (tmp != NULL)
            xmlFree(tmp);
        if (ctxt->instate == XML_PARSER_EOF)
            return(l);
        l = xmlDictLookupHashed(ctxt->dict, BASE_PTR + start,
                                CUR_PTR - (BASE_PTR + start));
        xmlNsErr(ctxt, XML_NS_ERR_QNAME,
                 "Failed to parse QName '%s'\n", l.name, NULL, NULL);
    }
 
    *prefix = p;
    return(l);
}

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

xmlParseReference()

void xmlParseReference

(

xmlParserCtxtPtr

ctxt

)

xmlParseReference: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

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

Always consumes '&'.

[67] Reference ::= EntityRef | CharRef

Definition at line 7227 of file parser.c.

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

Referenced by xmlParseContentInternal().

xmlParserEntityCheck()

static int xmlParserEntityCheck ( xmlParserCtxtPtr  ctxt, unsigned long  extra  )

static

xmlParserEntityCheck: @ctxt: parser context @extra: sum of unexpanded entity sizes

Check for non-linear entity expansion behaviour.

In some cases like xmlStringDecodeEntities, this function is called for each, possibly nested entity and its unexpanded content length.

In other cases like xmlParseReference, it's only called for each top-level entity with its unexpanded content length plus the sum of the unexpanded content lengths (plus fixed cost) of all nested entities.

Summing the unexpanded lengths also adds the length of the reference. This is by design. Taking the length of the entity name into account discourages attacks that try to waste CPU time with abusively long entity names. See test/recurse/lol6.xml for example. Each call also adds some fixed cost XML_ENT_FIXED_COST to discourage attacks with short entities.

Returns 1 on error, 0 on success.

Definition at line 580 of file parser.c.

{
    unsigned long consumed;
    xmlParserInputPtr input = ctxt->input;
    xmlEntityPtr entity = input->entity;
 
    /*
     * Compute total consumed bytes so far, including input streams of
     * external entities.
     */
    consumed = input->parentConsumed;
    if ((entity == NULL) ||
        ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
         ((entity->flags & XML_ENT_PARSED) == 0))) {
        xmlSaturatedAdd(&consumed, input->consumed);
        xmlSaturatedAddSizeT(&consumed, input->cur - input->base);
    }
    xmlSaturatedAdd(&consumed, ctxt->sizeentities);
 
    /*
     * Add extra cost and some fixed cost.
     */
    xmlSaturatedAdd(&ctxt->sizeentcopy, extra);
    xmlSaturatedAdd(&ctxt->sizeentcopy, XML_ENT_FIXED_COST);
 
    /*
     * It's important to always use saturation arithmetic when tracking
     * entity sizes to make the size checks reliable. If "sizeentcopy"
     * overflows, we have to abort.
     */
    if ((ctxt->sizeentcopy > XML_PARSER_ALLOWED_EXPANSION) &&
        ((ctxt->sizeentcopy >= ULONG_MAX) ||
         (ctxt->sizeentcopy / ctxt->maxAmpl > consumed))) {
        xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_LOOP,
                       "Maximum entity amplification factor exceeded, see "
                       "xmlCtxtSetMaxAmplification.\n");
        xmlHaltParser(ctxt);
        return(1);
    }
 
    return(0);
}

Referenced by xmlParseAttValueComplex(), xmlParseReference(), xmlParseStartTag2(), xmlSkipBlankChars(), and xmlStringDecodeEntitiesInt().

xmlParserHandlePEReference()

void xmlParserHandlePEReference

(

xmlParserCtxtPtr

ctxt

)

xmlParserHandlePEReference: @ctxt: the parser context

DEPRECATED: Internal function, do not use.

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

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

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

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

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

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

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

Definition at line 2715 of file parser.c.

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

xmlParserNsCreate()

xmlParserNsData * xmlParserNsCreate

(

void

)

xmlParserNsCreate:

Create a new namespace database.

Returns the new obejct.

Definition at line 1413 of file parser.c.

                        {
    xmlParserNsData *nsdb = xmlMalloc(sizeof(*nsdb));
 
    if (nsdb == NULL)
        return(NULL);
    memset(nsdb, 0, sizeof(*nsdb));
    nsdb->defaultNsIndex = INT_MAX;
 
    return(nsdb);
}

Referenced by xmlInitSAXParserCtxt().

xmlParserNsFree()

void xmlParserNsFree

(

xmlParserNsData *

nsdb

)

xmlParserNsFree: @nsdb: namespace database

Free a namespace database.

Definition at line 1431 of file parser.c.

                                       {
    if (nsdb == NULL)
        return;
 
    xmlFree(nsdb->extra);
    xmlFree(nsdb->hash);
    xmlFree(nsdb);
}

Referenced by xmlFreeParserCtxt().

xmlParserNsGrow()

static int xmlParserNsGrow ( xmlParserCtxtPtr  ctxt )

static

xmlParserNsGrow: @ctxt: parser context

Grows the namespace tables.

Returns 0 on success, -1 if a memory allocation failed.

Definition at line 1631 of file parser.c.

                                       {
    const xmlChar **table;
    xmlParserNsExtra *extra;
    int newSize;
 
    if (ctxt->nsMax > INT_MAX / 2)
        goto error;
    newSize = ctxt->nsMax ? ctxt->nsMax * 2 : 16;
 
    table = xmlRealloc(ctxt->nsTab, 2 * newSize * sizeof(table[0]));
    if (table == NULL)
        goto error;
    ctxt->nsTab = table;
 
    extra = xmlRealloc(ctxt->nsdb->extra, newSize * sizeof(extra[0]));
    if (extra == NULL)
        goto error;
    ctxt->nsdb->extra = extra;
 
    ctxt->nsMax = newSize;
    return(0);
 
error:
    xmlErrMemory(ctxt, NULL);
    return(-1);
}

Referenced by xmlParserNsPush().

xmlParserNsLookup()

static int xmlParserNsLookup ( xmlParserCtxtPtr  ctxt, const xmlHashedString *  prefix, xmlParserNsBucket **  bucketPtr  )

static

xmlParserNsLookup: @ctxt: parser context @prefix: namespace prefix @bucketPtr: optional bucket (return value)

Lookup namespace with given prefix. If @bucketPtr is non-NULL, it will be set to the matching bucket, or the first empty bucket if no match was found.

Returns the namespace index on success, INT_MAX if no namespace was found.

Definition at line 1490 of file parser.c.

                                                 {
    xmlParserNsBucket *bucket, *tombstone;
    unsigned index, hashValue;
 
    if (prefix->name == NULL)
        return(ctxt->nsdb->defaultNsIndex);
 
    if (ctxt->nsdb->hashSize == 0)
        return(INT_MAX);
 
    hashValue = prefix->hashValue;
    index = hashValue & (ctxt->nsdb->hashSize - 1);
    bucket = &ctxt->nsdb->hash[index];
    tombstone = NULL;
 
    while (bucket->hashValue) {
        if (bucket->index == INT_MAX) {
            if (tombstone == NULL)
                tombstone = bucket;
        } else if (bucket->hashValue == hashValue) {
            if (ctxt->nsTab[bucket->index * 2] == prefix->name) {
                if (bucketPtr != NULL)
                    *bucketPtr = bucket;
                return(bucket->index);
            }
        }
 
        index++;
        bucket++;
        if (index == ctxt->nsdb->hashSize) {
            index = 0;
            bucket = ctxt->nsdb->hash;
        }
    }
 
    if (bucketPtr != NULL)
        *bucketPtr = tombstone ? tombstone : bucket;
    return(INT_MAX);
}

Referenced by xmlParserNsLookupSax(), xmlParserNsLookupUri(), xmlParserNsPop(), xmlParserNsPush(), xmlParserNsUpdateSax(), and xmlParseStartTag2().

xmlParserNsLookupSax()

void * xmlParserNsLookupSax	(	xmlParserCtxtPtr	ctxt,
		const xmlChar *	prefix
	)

xmlParserNsLookupSax: @ctxt: parser context @prefix: namespace prefix

Lookup extra data for the given prefix. This returns data stored with xmlParserNsUdpateSax.

Returns the data on success, NULL if no namespace was found.

Definition at line 1569 of file parser.c.

                                                                   {
    xmlHashedString hprefix;
    int nsIndex;
 
    if (prefix == ctxt->str_xml)
        return(NULL);
 
    hprefix.name = prefix;
    if (prefix != NULL)
        hprefix.hashValue = xmlDictComputeHash(ctxt->dict, prefix);
    else
        hprefix.hashValue = 0;
    nsIndex = xmlParserNsLookup(ctxt, &hprefix, NULL);
    if (nsIndex == INT_MAX)
        return(NULL);
 
    return(ctxt->nsdb->extra[nsIndex].saxData);
}

Referenced by xmlSAX2AttributeNs(), and xmlSAX2StartElementNs().

xmlParserNsLookupUri()

static const xmlChar * xmlParserNsLookupUri ( xmlParserCtxtPtr  ctxt, const xmlHashedString *  prefix  )

static

xmlParserNsLookupUri: @ctxt: parser context @prefix: namespace prefix

Lookup namespace URI with given prefix.

Returns the namespace URI on success, NULL if no namespace was found.

Definition at line 1541 of file parser.c.

                                                                           {
    const xmlChar *ret;
    int nsIndex;
 
    if (prefix->name == ctxt->str_xml)
        return(ctxt->str_xml_ns);
 
    nsIndex = xmlParserNsLookup(ctxt, prefix, NULL);
    if (nsIndex == INT_MAX)
        return(NULL);
 
    ret = ctxt->nsTab[nsIndex * 2 + 1];
    if (ret[0] == 0)
        ret = NULL;
    return(ret);
}

Referenced by xmlParseBalancedChunkMemoryInternal(), and xmlParseStartTag2().

xmlParserNsPop()

static int xmlParserNsPop ( xmlParserCtxtPtr  ctxt, int  nr  )

static

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

Pops the top @nr namespaces and restores the hash table.

Returns the number of namespaces popped.

Definition at line 1829 of file parser.c.

{
    int i;
 
    /* assert(nr <= ctxt->nsNr); */
 
    for (i = ctxt->nsNr - 1; i >= ctxt->nsNr - nr; i--) {
        const xmlChar *prefix = ctxt->nsTab[i * 2];
        xmlParserNsExtra *extra = &ctxt->nsdb->extra[i];
 
        if (prefix == NULL) {
            ctxt->nsdb->defaultNsIndex = extra->oldIndex;
        } else {
            xmlHashedString hprefix;
            xmlParserNsBucket *bucket = NULL;
 
            hprefix.name = prefix;
            hprefix.hashValue = extra->prefixHashValue;
            xmlParserNsLookup(ctxt, &hprefix, &bucket);
            /* assert(bucket && bucket->hashValue); */
            bucket->index = extra->oldIndex;
        }
    }
 
    ctxt->nsNr -= nr;
    return(nr);
}

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

xmlParserNsPush()

static int xmlParserNsPush ( xmlParserCtxtPtr  ctxt, const xmlHashedString *  prefix, const xmlHashedString *  uri, void *  saxData, int  defAttr  )

static

xmlParserNsPush: @ctxt: parser context @prefix: prefix with hash value @uri: uri with hash value @saxData: extra data for SAX handler @defAttr: whether the namespace comes from a default attribute

Push a new namespace on the table.

Returns 1 if the namespace was pushed, 0 if the namespace was ignored, -1 if a memory allocation failed.

Definition at line 1672 of file parser.c.

                                                                        {
    xmlParserNsBucket *bucket = NULL;
    xmlParserNsExtra *extra;
    const xmlChar **ns;
    unsigned hashValue, nsIndex, oldIndex;
 
    if ((prefix != NULL) && (prefix->name == ctxt->str_xml))
        return(0);
 
    if ((ctxt->nsNr >= ctxt->nsMax) && (xmlParserNsGrow(ctxt) < 0)) {
        xmlErrMemory(ctxt, NULL);
        return(-1);
    }
 
    /*
     * Default namespace and 'xml' namespace
     */
    if ((prefix == NULL) || (prefix->name == NULL)) {
        oldIndex = ctxt->nsdb->defaultNsIndex;
 
        if (oldIndex != INT_MAX) {
            extra = &ctxt->nsdb->extra[oldIndex];
 
            if (extra->elementId == ctxt->nsdb->elementId) {
                if (defAttr == 0)
                    xmlErrAttributeDup(ctxt, NULL, BAD_CAST "xmlns");
                return(0);
            }
 
            if ((ctxt->options & XML_PARSE_NSCLEAN) &&
                (uri->name == ctxt->nsTab[oldIndex * 2 + 1]))
                return(0);
        }
 
        ctxt->nsdb->defaultNsIndex = ctxt->nsNr;
        goto populate_entry;
    }
 
    /*
     * Hash table lookup
     */
    oldIndex = xmlParserNsLookup(ctxt, prefix, &bucket);
    if (oldIndex != INT_MAX) {
        extra = &ctxt->nsdb->extra[oldIndex];
 
        /*
         * Check for duplicate definitions on the same element.
         */
        if (extra->elementId == ctxt->nsdb->elementId) {
            if (defAttr == 0)
                xmlErrAttributeDup(ctxt, BAD_CAST "xmlns", prefix->name);
            return(0);
        }
 
        if ((ctxt->options & XML_PARSE_NSCLEAN) &&
            (uri->name == ctxt->nsTab[bucket->index * 2 + 1]))
            return(0);
 
        bucket->index = ctxt->nsNr;
        goto populate_entry;
    }
 
    /*
     * Insert new bucket
     */
 
    hashValue = prefix->hashValue;
 
    /*
     * Grow hash table, 50% fill factor
     */
    if (ctxt->nsdb->hashElems + 1 > ctxt->nsdb->hashSize / 2) {
        xmlParserNsBucket *newHash;
        unsigned newSize, i, index;
 
        if (ctxt->nsdb->hashSize > UINT_MAX / 2) {
            xmlErrMemory(ctxt, NULL);
            return(-1);
        }
        newSize = ctxt->nsdb->hashSize ? ctxt->nsdb->hashSize * 2 : 16;
        newHash = xmlMalloc(newSize * sizeof(newHash[0]));
        if (newHash == NULL) {
            xmlErrMemory(ctxt, NULL);
            return(-1);
        }
        memset(newHash, 0, newSize * sizeof(newHash[0]));
 
        for (i = 0; i < ctxt->nsdb->hashSize; i++) {
            unsigned hv = ctxt->nsdb->hash[i].hashValue;
            unsigned newIndex;
 
            if ((hv == 0) || (ctxt->nsdb->hash[i].index == INT_MAX))
                continue;
            newIndex = hv & (newSize - 1);
 
            while (newHash[newIndex].hashValue != 0) {
                newIndex++;
                if (newIndex == newSize)
                    newIndex = 0;
            }
 
            newHash[newIndex] = ctxt->nsdb->hash[i];
        }
 
        xmlFree(ctxt->nsdb->hash);
        ctxt->nsdb->hash = newHash;
        ctxt->nsdb->hashSize = newSize;
 
        /*
         * Relookup
         */
        index = hashValue & (newSize - 1);
 
        while (newHash[index].hashValue != 0) {
            index++;
            if (index == newSize)
                index = 0;
        }
 
        bucket = &newHash[index];
    }
 
    bucket->hashValue = hashValue;
    bucket->index = ctxt->nsNr;
    ctxt->nsdb->hashElems++;
    oldIndex = INT_MAX;
 
populate_entry:
    nsIndex = ctxt->nsNr;
 
    ns = &ctxt->nsTab[nsIndex * 2];
    ns[0] = prefix ? prefix->name : NULL;
    ns[1] = uri->name;
 
    extra = &ctxt->nsdb->extra[nsIndex];
    extra->saxData = saxData;
    extra->prefixHashValue = prefix ? prefix->hashValue : 0;
    extra->uriHashValue = uri->hashValue;
    extra->elementId = ctxt->nsdb->elementId;
    extra->oldIndex = oldIndex;
 
    ctxt->nsNr++;
 
    return(1);
}

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

xmlParserNsReset()

static void xmlParserNsReset ( xmlParserNsData *  nsdb )

static

xmlParserNsReset: @nsdb: namespace database

Reset a namespace database.

Definition at line 1447 of file parser.c.

                                        {
    if (nsdb == NULL)
        return;
 
    nsdb->hashElems = 0;
    nsdb->elementId = 0;
    nsdb->defaultNsIndex = INT_MAX;
 
    if (nsdb->hash)
        memset(nsdb->hash, 0, nsdb->hashSize * sizeof(nsdb->hash[0]));
}

Referenced by xmlCtxtReset().

xmlParserNsStartElement()

static int xmlParserNsStartElement ( xmlParserNsData *  nsdb )

static

xmlParserStartElement: @nsdb: namespace database

Signal that a new element has started.

Returns 0 on success, -1 if the element counter overflowed.

Definition at line 1468 of file parser.c.

                                               {
    if (nsdb->elementId == UINT_MAX)
        return(-1);
    nsdb->elementId++;
 
    return(0);
}

Referenced by xmlParseStartTag2().

xmlParserNsUpdateSax()

int xmlParserNsUpdateSax	(	xmlParserCtxtPtr	ctxt,
		const xmlChar *	prefix,
		void *	saxData
	)

xmlParserNsUpdateSax: @ctxt: parser context @prefix: namespace prefix @saxData: extra data for SAX handler

Sets or updates extra data for the given prefix. This value will be returned by xmlParserNsLookupSax as long as the namespace with the given prefix is in scope.

Returns the data on success, NULL if no namespace was found.

Definition at line 1601 of file parser.c.

                                    {
    xmlHashedString hprefix;
    int nsIndex;
 
    if (prefix == ctxt->str_xml)
        return(-1);
 
    hprefix.name = prefix;
    if (prefix != NULL)
        hprefix.hashValue = xmlDictComputeHash(ctxt->dict, prefix);
    else
        hprefix.hashValue = 0;
    nsIndex = xmlParserNsLookup(ctxt, &hprefix, NULL);
    if (nsIndex == INT_MAX)
        return(-1);
 
    ctxt->nsdb->extra[nsIndex].saxData = saxData;
    return(0);
}

Referenced by xmlSAX2StartElementNs().

xmlParseSDDecl()

int xmlParseSDDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseSDDecl: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse the XML standalone declaration

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

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

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

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

Definition at line 10792 of file parser.c.

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

Referenced by xmlParseXMLDecl().

xmlParseStartTag2()

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

static

xmlParseStartTag2: @ctxt: an XML parser context

Parse a start tag. Always consumes '<'.

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

                                                     {
    xmlHashedString hlocalname;
    xmlHashedString hprefix;
    xmlHashedString hattname;
    xmlHashedString haprefix;
    const xmlChar *localname;
    const xmlChar *prefix;
    const xmlChar *attname;
    const xmlChar *aprefix;
    const xmlChar *uri;
    xmlChar *attvalue = NULL;
    const xmlChar **atts = ctxt->atts;
    unsigned attrHashSize = 0;
    int maxatts = ctxt->maxatts;
    int nratts, nbatts, nbdef, inputid;
    int i, j, nbNs, nbTotalDef, attval, nsIndex, maxAtts;
    int alloc = 0;
 
    if (RAW != '<') return(NULL);
    NEXT1;
 
    inputid = ctxt->input->id;
    nbatts = 0;
    nratts = 0;
    nbdef = 0;
    nbNs = 0;
    nbTotalDef = 0;
    attval = 0;
 
    if (xmlParserNsStartElement(ctxt->nsdb) < 0) {
        xmlErrMemory(ctxt, NULL);
        return(NULL);
    }
 
    hlocalname = xmlParseQNameHashed(ctxt, &hprefix);
    if (hlocalname.name == NULL) {
    xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
               "StartTag: invalid element name\n");
        return(NULL);
    }
    localname = hlocalname.name;
    prefix = hprefix.name;
 
    /*
     * Now parse the attributes, it ends up with the ending
     *
     * (S Attribute)* S?
     */
    SKIP_BLANKS;
    GROW;
 
    /*
     * The ctxt->atts array will be ultimately passed to the SAX callback
     * containing five xmlChar pointers for each attribute:
     *
     * [0] attribute name
     * [1] attribute prefix
     * [2] namespace URI
     * [3] attribute value
     * [4] end of attribute value
     *
     * To save memory, we reuse this array temporarily and store integers
     * in these pointer variables.
     *
     * [0] attribute name
     * [1] attribute prefix
     * [2] hash value of attribute prefix, and later namespace index
     * [3] for non-allocated values: ptrdiff_t offset into input buffer
     * [4] for non-allocated values: ptrdiff_t offset into input buffer
     *
     * The ctxt->attallocs array contains an additional unsigned int for
     * each attribute, containing the hash value of the attribute name
     * and the alloc flag in bit 31.
     */
 
    while (((RAW != '>') &&
       ((RAW != '/') || (NXT(1) != '>')) &&
       (IS_BYTE_CHAR(RAW))) && (ctxt->instate != XML_PARSER_EOF)) {
    int len = -1;
 
    hattname = xmlParseAttribute2(ctxt, prefix, localname,
                                          &haprefix, &attvalue, &len,
                                          &alloc);
        if (hattname.name == NULL) {
        xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
             "xmlParseStartTag: problem parsing attributes\n");
        break;
    }
        if (attvalue == NULL)
            goto next_attr;
        attname = hattname.name;
        aprefix = haprefix.name;
    if (len < 0) len = xmlStrlen(attvalue);
 
        if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
            xmlHashedString huri;
            xmlURIPtr parsedUri;
 
            huri = xmlDictLookupHashed(ctxt->dict, attvalue, len);
            uri = huri.name;
            if (uri == NULL) {
                xmlErrMemory(ctxt, NULL);
                goto next_attr;
            }
            if (*uri != 0) {
                parsedUri = xmlParseURI((const char *) uri);
                if (parsedUri == NULL) {
                    xmlNsErr(ctxt, XML_WAR_NS_URI,
                             "xmlns: '%s' is not a valid URI\n",
                                       uri, NULL, NULL);
                } else {
                    if (parsedUri->scheme == NULL) {
                        xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
                                  "xmlns: URI %s is not absolute\n",
                                  uri, NULL, NULL);
                    }
                    xmlFreeURI(parsedUri);
                }
                if (uri == 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(uri,
                             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 (xmlParserNsPush(ctxt, NULL, &huri, NULL, 0) > 0)
                nbNs++;
        } else if (aprefix == ctxt->str_xmlns) {
            xmlHashedString huri;
            xmlURIPtr parsedUri;
 
            huri = xmlDictLookupHashed(ctxt->dict, attvalue, len);
            uri = huri.name;
            if (uri == NULL) {
                xmlErrMemory(ctxt, NULL);
                goto next_attr;
            }
 
            if (attname == ctxt->str_xml) {
                if (uri != 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 (uri == 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(uri,
                             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 ((uri == NULL) || (uri[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 {
                parsedUri = xmlParseURI((const char *) uri);
                if (parsedUri == NULL) {
                    xmlNsErr(ctxt, XML_WAR_NS_URI,
                         "xmlns:%s: '%s' is not a valid URI\n",
                                       attname, uri, NULL);
                } else {
                    if ((ctxt->pedantic) && (parsedUri->scheme == NULL)) {
                        xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
                                  "xmlns:%s: URI %s is not absolute\n",
                                  attname, uri, NULL);
                    }
                    xmlFreeURI(parsedUri);
                }
            }
 
            if (xmlParserNsPush(ctxt, &hattname, &huri, NULL, 0) > 0)
                nbNs++;
        } else {
            /*
             * Populate attributes array, see above for repurposing
             * of xmlChar pointers.
             */
            if ((atts == NULL) || (nbatts + 5 > maxatts)) {
                if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
                    goto next_attr;
                }
                maxatts = ctxt->maxatts;
                atts = ctxt->atts;
            }
            ctxt->attallocs[nratts++] = (hattname.hashValue & 0x7FFFFFFF) |
                                        ((unsigned) alloc << 31);
            atts[nbatts++] = attname;
            atts[nbatts++] = aprefix;
            atts[nbatts++] = (const xmlChar *) (size_t) haprefix.hashValue;
            if (alloc) {
                atts[nbatts++] = attvalue;
                attvalue += len;
                atts[nbatts++] = attvalue;
            } else {
                /*
                 * attvalue points into the input buffer which can be
                 * reallocated. Store differences to input->base instead.
                 * The pointers will be reconstructed later.
                 */
                atts[nbatts++] = (void *) (attvalue - BASE_PTR);
                attvalue += len;
                atts[nbatts++] = (void *) (attvalue - BASE_PTR);
            }
            /*
             * 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;
    }
        GROW;
    }
 
    if (ctxt->input->id != inputid) {
        xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
                    "Unexpected change of input\n");
        localname = NULL;
        goto done;
    }
 
    /*
     * Namespaces from default attributes
     */
    if (ctxt->attsDefault != NULL) {
        xmlDefAttrsPtr defaults;
 
    defaults = xmlHashLookup2(ctxt->attsDefault, localname, prefix);
    if (defaults != NULL) {
        for (i = 0; i < defaults->nbAttrs; i++) {
                xmlDefAttr *attr = &defaults->attrs[i];
 
            attname = attr->name.name;
        aprefix = attr->prefix.name;
 
        if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
                    xmlParserEntityCheck(ctxt, attr->expandedSize);
 
                    if (xmlParserNsPush(ctxt, NULL, &attr->value, NULL, 1) > 0)
                        nbNs++;
        } else if (aprefix == ctxt->str_xmlns) {
                    xmlParserEntityCheck(ctxt, attr->expandedSize);
 
                    if (xmlParserNsPush(ctxt, &attr->name, &attr->value,
                                      NULL, 1) > 0)
                        nbNs++;
        } else {
                    nbTotalDef += 1;
                }
        }
    }
    }
 
    /*
     * Resolve attribute namespaces
     */
    for (i = 0; i < nbatts; i += 5) {
        attname = atts[i];
        aprefix = atts[i+1];
 
        /*
    * The default namespace does not apply to attribute names.
    */
    if (aprefix == NULL) {
            nsIndex = NS_INDEX_EMPTY;
        } else if (aprefix == ctxt->str_xml) {
            nsIndex = NS_INDEX_XML;
        } else {
            haprefix.name = aprefix;
            haprefix.hashValue = (size_t) atts[i+2];
            nsIndex = xmlParserNsLookup(ctxt, &haprefix, NULL);
        if (nsIndex == INT_MAX) {
                xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
            "Namespace prefix %s for %s on %s is not defined\n",
            aprefix, attname, localname);
                nsIndex = NS_INDEX_EMPTY;
            }
        }
 
        atts[i+2] = (const xmlChar *) (ptrdiff_t) nsIndex;
    }
 
    /*
     * Maximum number of attributes including default attributes.
     */
    maxAtts = nratts + nbTotalDef;
 
    /*
     * Verify that attribute names are unique.
     */
    if (maxAtts > 1) {
        attrHashSize = 4;
        while (attrHashSize / 2 < (unsigned) maxAtts)
            attrHashSize *= 2;
 
        if (attrHashSize > ctxt->attrHashMax) {
            xmlAttrHashBucket *tmp;
 
            tmp = xmlRealloc(ctxt->attrHash, attrHashSize * sizeof(tmp[0]));
            if (tmp == NULL) {
                xmlErrMemory(ctxt, NULL);
                goto done;
            }
 
            ctxt->attrHash = tmp;
            ctxt->attrHashMax = attrHashSize;
        }
 
        memset(ctxt->attrHash, -1, attrHashSize * sizeof(ctxt->attrHash[0]));
 
        for (i = 0, j = 0; j < nratts; i += 5, j++) {
            const xmlChar *nsuri;
            unsigned hashValue, nameHashValue, uriHashValue;
            int res;
 
            attname = atts[i];
            aprefix = atts[i+1];
            nsIndex = (ptrdiff_t) atts[i+2];
            /* Hash values always have bit 31 set, see dict.c */
            nameHashValue = ctxt->attallocs[j] | 0x80000000;
 
            if (nsIndex == NS_INDEX_EMPTY) {
                nsuri = NULL;
                uriHashValue = URI_HASH_EMPTY;
            } else if (nsIndex == NS_INDEX_XML) {
                nsuri = ctxt->str_xml_ns;
                uriHashValue = URI_HASH_XML;
            } else {
                nsuri = ctxt->nsTab[nsIndex * 2 + 1];
                uriHashValue = ctxt->nsdb->extra[nsIndex].uriHashValue;
            }
 
            hashValue = xmlDictCombineHash(nameHashValue, uriHashValue);
            res = xmlAttrHashInsert(ctxt, attrHashSize, attname, nsuri,
                                    hashValue, i);
            if (res < 0)
                continue;
 
            /*
             * [ 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.
             */
            if (res < INT_MAX) {
                if (aprefix == atts[res+1]) {
                    xmlErrAttributeDup(ctxt, aprefix, attname);
                } else {
                    xmlNsErr(ctxt, XML_NS_ERR_ATTRIBUTE_REDEFINED,
                             "Namespaced Attribute %s in '%s' redefined\n",
                             attname, nsuri, NULL);
                }
            }
        }
    }
 
    /*
     * Default attributes
     */
    if (ctxt->attsDefault != NULL) {
        xmlDefAttrsPtr defaults;
 
    defaults = xmlHashLookup2(ctxt->attsDefault, localname, prefix);
    if (defaults != NULL) {
        for (i = 0; i < defaults->nbAttrs; i++) {
                xmlDefAttr *attr = &defaults->attrs[i];
                const xmlChar *nsuri;
                unsigned hashValue, uriHashValue;
                int res;
 
            attname = attr->name.name;
        aprefix = attr->prefix.name;
 
        if ((attname == ctxt->str_xmlns) && (aprefix == NULL))
                    continue;
        if (aprefix == ctxt->str_xmlns)
                    continue;
 
                if (aprefix == NULL) {
                    nsIndex = NS_INDEX_EMPTY;
                    nsuri = NULL;
                    uriHashValue = URI_HASH_EMPTY;
                } if (aprefix == ctxt->str_xml) {
                    nsIndex = NS_INDEX_XML;
                    nsuri = ctxt->str_xml_ns;
                    uriHashValue = URI_HASH_XML;
                } else if (aprefix != NULL) {
                    nsIndex = xmlParserNsLookup(ctxt, &attr->prefix, NULL);
                    if (nsIndex == INT_MAX) {
                        xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
                                 "Namespace prefix %s for %s on %s is not "
                                 "defined\n",
                                 aprefix, attname, localname);
                        nsIndex = NS_INDEX_EMPTY;
                        nsuri = NULL;
                        uriHashValue = URI_HASH_EMPTY;
                    } else {
                        nsuri = ctxt->nsTab[nsIndex * 2 + 1];
                        uriHashValue = ctxt->nsdb->extra[nsIndex].uriHashValue;
                    }
                }
 
                /*
                 * Check whether the attribute exists
                 */
                if (maxAtts > 1) {
                    hashValue = xmlDictCombineHash(attr->name.hashValue,
                                                   uriHashValue);
                    res = xmlAttrHashInsert(ctxt, attrHashSize, attname, nsuri,
                                            hashValue, nbatts);
                    if (res < 0)
                        continue;
                    if (res < INT_MAX) {
                        if (aprefix == atts[res+1])
                            continue;
                        xmlNsErr(ctxt, XML_NS_ERR_ATTRIBUTE_REDEFINED,
                                 "Namespaced Attribute %s in '%s' redefined\n",
                                 attname, nsuri, NULL);
                    }
                }
 
                xmlParserEntityCheck(ctxt, attr->expandedSize);
 
                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;
                atts[nbatts++] = (const xmlChar *) (ptrdiff_t) nsIndex;
                atts[nbatts++] = attr->value.name;
                atts[nbatts++] = attr->valueEnd;
                if ((ctxt->standalone == 1) && (attr->external != 0)) {
                    xmlValidityError(ctxt, XML_DTD_STANDALONE_DEFAULTED,
                            "standalone: attribute %s on %s defaulted "
                            "from external subset\n",
                            attname, localname);
                }
                nbdef++;
        }
    }
    }
 
    /*
     * Reconstruct attribute pointers
     */
    for (i = 0, j = 0; i < nbatts; i += 5, j++) {
        /* namespace URI */
        nsIndex = (ptrdiff_t) atts[i+2];
        if (nsIndex == INT_MAX)
            atts[i+2] = NULL;
        else if (nsIndex == INT_MAX - 1)
            atts[i+2] = ctxt->str_xml_ns;
        else
            atts[i+2] = ctxt->nsTab[nsIndex * 2 + 1];
 
        if ((j < nratts) && (ctxt->attallocs[j] & 0x80000000) == 0) {
            atts[i+3] = BASE_PTR + (ptrdiff_t) atts[i+3];  /* value */
            atts[i+4] = BASE_PTR + (ptrdiff_t) atts[i+4];  /* valuend */
        }
    }
 
    uri = xmlParserNsLookupUri(ctxt, &hprefix);
    if ((prefix != NULL) && (uri == NULL)) {
    xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
             "Namespace prefix %s on %s is not defined\n",
         prefix, localname, NULL);
    }
    *pref = prefix;
    *URI = uri;
 
    /*
     * SAX callback
     */
    if ((ctxt->sax != NULL) && (ctxt->sax->startElementNs != NULL) &&
    (!ctxt->disableSAX)) {
    if (nbNs > 0)
        ctxt->sax->startElementNs(ctxt->userData, localname, prefix, uri,
                          nbNs, ctxt->nsTab + 2 * (ctxt->nsNr - nbNs),
              nbatts / 5, nbdef, atts);
    else
        ctxt->sax->startElementNs(ctxt->userData, localname, prefix, uri,
                          0, NULL, nbatts / 5, nbdef, atts);
    }
 
done:
    /*
     * Free allocated attribute values
     */
    if (attval != 0) {
    for (i = 0, j = 0; j < nratts; i += 5, j++)
        if (ctxt->attallocs[j] & 0x80000000)
            xmlFree((xmlChar *) atts[i+3]);
    }
 
    *nbNsPtr = nbNs;
    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 2605 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 xmlStringDecodeEntitiesInt().

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 7868 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);
        }
    }
 
    /*
     * 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);
    }
    /* 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->etype != XML_INTERNAL_PREDEFINED_ENTITY)) {
    if ((ent->flags & XML_ENT_CHECKED_LT) == 0) {
            if ((ent->content != NULL) && (xmlStrchr(ent->content, '<')))
                ent->flags |= XML_ENT_CONTAINS_LT;
            ent->flags |= XML_ENT_CHECKED_LT;
        }
        if (ent->flags & XML_ENT_CONTAINS_LT)
            xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
                    "'<' in entity '%s' is not allowed in attributes "
                    "values\n", name);
    }
 
    /*
     * Internal check, no parameter entities here ...
     */
    else {
    switch (ent->etype) {
        case XML_INTERNAL_PARAMETER_ENTITY:
        case XML_EXTERNAL_PARAMETER_ENTITY:
        xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
         "Attempt to reference the parameter entity '%s'\n",
                  name);
        break;
        default:
        break;
    }
    }
 
    /*
     * [ WFC: No Recursion ]
     * A parsed entity must not contain a recursive reference
     * to itself, either directly or indirectly.
     * Done somewhere else
     */
 
    xmlFree(name);
    *str = ptr;
    return(ent);
}

Referenced by xmlStringDecodeEntitiesInt().

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 3735 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;
 
    c = CUR_SCHAR(cur, l);
    if (!xmlIsNameStartChar(ctxt, c)) {
    return(NULL);
    }
 
    COPY_BUF(buf, len, c);
    cur += l;
    c = CUR_SCHAR(cur, l);
    while (xmlIsNameChar(ctxt, c)) {
    COPY_BUF(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);
        if (buffer == NULL) {
            xmlErrMemory(ctxt, NULL);
        return(NULL);
        }
        memcpy(buffer, buf, len);
        while (xmlIsNameChar(ctxt, c)) {
        if (len + 10 > max) {
            xmlChar *tmp;
 
            max *= 2;
            tmp = (xmlChar *) xmlRealloc(buffer, max);
            if (tmp == NULL) {
            xmlErrMemory(ctxt, NULL);
            xmlFree(buffer);
            return(NULL);
            }
            buffer = tmp;
        }
        COPY_BUF(buffer, len, c);
        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 8367 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++;
 
    /*
     * 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;
    }
    } 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 xmlStringDecodeEntitiesInt().

xmlParseSystemLiteral()

xmlChar * xmlParseSystemLiteral

(

xmlParserCtxtPtr

ctxt

)

xmlParseSystemLiteral: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse an XML Literal

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

Returns the SystemLiteral parsed or NULL

Definition at line 4361 of file parser.c.

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

Referenced by xmlParseExternalID().

xmlParseTextDecl()

void xmlParseTextDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseTextDecl: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse an XML declaration header for external entities

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

Definition at line 7074 of file parser.c.

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

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

xmlParseVersionInfo()

xmlChar * xmlParseVersionInfo

(

xmlParserCtxtPtr

ctxt

)

xmlParseVersionInfo: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse the XML version.

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

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

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

Definition at line 10597 of file parser.c.

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

Referenced by xmlParseTextDecl(), and xmlParseXMLDecl().

xmlParseVersionNum()

xmlChar * xmlParseVersionNum

(

xmlParserCtxtPtr

ctxt

)

xmlParseVersionNum: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse the XML version value.

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

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

Returns the string giving the XML version number, or NULL

Definition at line 10534 of file parser.c.

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

Referenced by xmlParseVersionInfo().

xmlParseXMLDecl()

void xmlParseXMLDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseXMLDecl: @ctxt: an XML parser context

DEPRECATED: Internal function, don't use.

parse an XML declaration header

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

Definition at line 10856 of file parser.c.

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

Referenced by xmlParseDocument(), and xmlParseExtParsedEnt().

xmlPopInput()

xmlChar xmlPopInput

(

xmlParserCtxtPtr

ctxt

)

xmlPopInput: @ctxt: an XML parser context

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

Returns the current xmlChar in the parser context

Definition at line 2419 of file parser.c.

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

Referenced by xmlSAX2ExternalSubset(), and xmlSkipBlankChars().

xmlPushInput()

int xmlPushInput	(	xmlParserCtxtPtr	ctxt,
		xmlParserInputPtr	input
	)

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

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

Definition at line 2449 of file parser.c.

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

Referenced by xmlParsePEReference(), and xmlSAX2ExternalSubset().

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

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

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

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

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 14835 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 parse_xml().

xmlSaturatedAdd()

static void xmlSaturatedAdd ( unsigned long *  dst, unsigned long  val  )

static

Definition at line 540 of file parser.c.

                                                       {
    if (val > ULONG_MAX - *dst)
        *dst = ULONG_MAX;
    else
        *dst += val;
}

Referenced by xmlLoadEntityContent(), xmlParseBalancedChunkMemoryInternal(), xmlParseExternalEntityPrivate(), xmlParsePEReference(), xmlParserEntityCheck(), and xmlSkipBlankChars().

xmlSaturatedAddSizeT()

static void xmlSaturatedAddSizeT ( unsigned long *  dst, unsigned long  val  )

static

Definition at line 548 of file parser.c.

                                                            {
    if (val > ULONG_MAX - *dst)
        *dst = ULONG_MAX;
    else
        *dst += val;
}

Referenced by xmlParseBalancedChunkMemoryInternal(), xmlParseExternalEntityPrivate(), xmlParsePEReference(), xmlParserEntityCheck(), and xmlSkipBlankChars().

xmlSkipBlankChars()

int xmlSkipBlankChars

(

xmlParserCtxtPtr

ctxt

)

xmlSkipBlankChars: @ctxt: the XML parser context

DEPRECATED: Internal function, do not use.

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

Returns the number of space chars skipped

Definition at line 2316 of file parser.c.

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

xmlSplitQName()

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

Namespaces.

Definition at line 3157 of file parser.c.

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

Referenced by xmlSAX2AttributeDecl().

xmlStopParser()

void xmlStopParser

(

xmlParserCtxtPtr

ctxt

)

xmlStopParser: @ctxt: an XML parser context

Blocks further parser processing

Definition at line 12311 of file parser.c.

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

Referenced by format_error_message_from_id(), libxmlFatalError(), 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

DEPRECATED: Internal function, don't use.

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

[67] Reference ::= EntityRef | CharRef

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

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

Definition at line 3050 of file parser.c.

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

xmlStringDecodeEntitiesInt()

static xmlChar * xmlStringDecodeEntitiesInt ( xmlParserCtxtPtr  ctxt, const xmlChar *  str, int  len, int  what, xmlChar  end, xmlChar  end2, xmlChar  end3, int  check  )

static

xmlStringDecodeEntitiesInt: @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 @check: whether to perform entity checks

Definition at line 2801 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 (str == NULL)
        return(NULL);
    last = str + len;
 
    if (((ctxt->depth > 40) &&
         ((ctxt->options & XML_PARSE_HUGE) == 0)) ||
    (ctxt->depth > 100)) {
    xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_LOOP,
                       "Maximum entity nesting depth exceeded");
    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(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);
        if ((ent != NULL) &&
        (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
        if (ent->content != NULL) {
            COPY_BUF(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)) {
            if ((check) && (xmlParserEntityCheck(ctxt, ent->length)))
                    goto int_error;
 
                if (ent->flags & XML_ENT_EXPANDING) {
                xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
                    xmlHaltParser(ctxt);
                    ent->content[0] = 0;
                    goto int_error;
                }
 
                ent->flags |= XML_ENT_EXPANDING;
        ctxt->depth++;
        rep = xmlStringDecodeEntitiesInt(ctxt, ent->content,
                        ent->length, what, 0, 0, 0, check);
        ctxt->depth--;
                ent->flags &= ~XML_ENT_EXPANDING;
 
        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) {
                        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);
        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);
            }
        }
 
            if ((check) && (xmlParserEntityCheck(ctxt, ent->length)))
                    goto int_error;
 
                if (ent->flags & XML_ENT_EXPANDING) {
                xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
                    xmlHaltParser(ctxt);
                    if (ent->content != NULL)
                        ent->content[0] = 0;
                    goto int_error;
                }
 
                ent->flags |= XML_ENT_EXPANDING;
        ctxt->depth++;
        rep = xmlStringDecodeEntitiesInt(ctxt, ent->content,
                        ent->length, what, 0, 0, 0, check);
        ctxt->depth--;
                ent->flags &= ~XML_ENT_EXPANDING;
 
        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) {
                        growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
                    }
                }
                xmlFree(rep);
                rep = NULL;
        }
    } else {
        COPY_BUF(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 xmlParseAttValueComplex(), xmlParseEntityValue(), xmlStringDecodeEntities(), xmlStringDecodeEntitiesInt(), 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

DEPRECATED: Internal function, don't use.

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

[67] Reference ::= EntityRef | CharRef

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

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

Definition at line 3020 of file parser.c.

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

Variable Documentation

test_char_data

const unsigned char test_char_data[256]

static

Definition at line 4511 of file parser.c.

Referenced by xmlParseCharDataInternal().

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

Referenced by nodePush(), and xmlParseElementStart().

xmlParserVersion

const char* const xmlParserVersion = LIBXML_VERSION_STRING LIBXML_VERSION_EXTRA

xmlParserVersion:

Constant string describing the internal version of the library

Definition at line 187 of file parser.c.

xmlW3CPIs

const char* const xmlW3CPIs[]

static

Initial value:

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

Definition at line 193 of file parser.c.

Referenced by xmlParsePITarget().