parser.c File Reference

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

Include dependency graph for parser.c:

Go to the source code of this file.

Classes
struct	_xmlStartTag
struct	_xmlDefAttrs

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

Typedefs
typedef struct _xmlDefAttrs	xmlDefAttrs
typedef xmlDefAttrs *	xmlDefAttrsPtr

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

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

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

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

Macro Definition Documentation

BASE_PTR

#define BASE_PTR   ctxt->input->base

Definition at line 2068 of file parser.c.

CMP10

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

Value:

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

Definition at line 2084 of file parser.c.

CMP4

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

Value:

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

Definition at line 2070 of file parser.c.

CMP5

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

Definition at line 2073 of file parser.c.

CMP6

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

Definition at line 2075 of file parser.c.

CMP7

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

Definition at line 2077 of file parser.c.

CMP8

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

Definition at line 2079 of file parser.c.

CMP9

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

Value:

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

Definition at line 2081 of file parser.c.

COPY_BUF

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

Value:

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

Definition at line 2166 of file parser.c.

CUR

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

Definition at line 2065 of file parser.c.

CUR_CHAR

#define CUR_CHAR

(

l

)

xmlCurrentChar(ctxt, &l)

Definition at line 2163 of file parser.c.

CUR_CONSUMED

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

Definition at line 2170 of file parser.c.

CUR_PTR

#define CUR_PTR   ctxt->input->cur

Definition at line 2067 of file parser.c.

CUR_SCHAR

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

Definition at line 2164 of file parser.c.

DICT_FREE

#define DICT_FREE

(

str

)

Value:

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

DICT_FREE: @str: a string

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

Definition at line 14789 of file parser.c.

GROW

#define GROW

Value:

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

Definition at line 2117 of file parser.c.

GROW_PARSE_ATT_VALUE_INTERNAL

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

Value:

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

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

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

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

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

Returns the AttValue parsed or NULL. The value has to be freed by the caller if it was copied, this can be detected by val[*len] == 0.

Definition at line 8947 of file parser.c.

growBuffer

#define growBuffer	(		buffer,
			n
	)

Value:

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

Definition at line 2613 of file parser.c.

IN_LIBXML

#define IN_LIBXML

Definition at line 38 of file parser.c.

NEXT

#define NEXT   xmlNextChar(ctxt)

Definition at line 2147 of file parser.c.

NEXT1

#define NEXT1

Value:

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

Definition at line 2149 of file parser.c.

NEXTL

#define NEXTL

(

l

)

Value:

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

Definition at line 2156 of file parser.c.

NXT

#define NXT

(

val

)

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

Definition at line 2066 of file parser.c.

RAW

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

Definition at line 2064 of file parser.c.

SAX2

#define SAX2   1

Definition at line 274 of file parser.c.

SAX_COMPAT_MODE

#define SAX_COMPAT_MODE   BAD_CAST "SAX compatibility mode document"

Definition at line 277 of file parser.c.

SHRINK

#define SHRINK

Value:

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

Definition at line 2106 of file parser.c.

SKIP

#define SKIP

(

val

)

Value:

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

Definition at line 2088 of file parser.c.

SKIP_BLANKS

#define SKIP_BLANKS   xmlSkipBlankChars(ctxt)

Definition at line 2145 of file parser.c.

SKIPL

#define SKIPL

(

val

)

Value:

    do {                            \
    int skipl;                              \
    for(skipl=0; skipl<val; skipl++) {                  \
    if (*(ctxt->input->cur) == '\n') {              \
    ctxt->input->line++; ctxt->input->col = 1;          \
    } else ctxt->input->col++;                  \
    ctxt->input->cur++;                     \
    }                                   \
    if (*ctxt->input->cur == 0)                     \
        xmlParserInputGrow(ctxt->input, INPUT_CHUNK);           \
  } while (0)

Definition at line 2094 of file parser.c.

XML_DIR_SEP

#define XML_DIR_SEP   '/'

Definition at line 44 of file parser.c.

XML_MAX_HUGE_LENGTH

#define XML_MAX_HUGE_LENGTH   1000000000

Definition at line 105 of file parser.c.

XML_PARSER_BIG_BUFFER_SIZE

#define XML_PARSER_BIG_BUFFER_SIZE   300

Definition at line 275 of file parser.c.

XML_PARSER_BIG_ENTITY

#define XML_PARSER_BIG_ENTITY   1000

Definition at line 107 of file parser.c.

XML_PARSER_BUFFER_SIZE

#define XML_PARSER_BUFFER_SIZE   100

Definition at line 276 of file parser.c.

XML_PARSER_CHUNK_SIZE

#define XML_PARSER_CHUNK_SIZE   100

XML_PARSER_CHUNK_SIZE

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

Definition at line 288 of file parser.c.

XML_PARSER_LOT_ENTITY

#define XML_PARSER_LOT_ENTITY   5000

Definition at line 108 of file parser.c.

XML_PARSER_NON_LINEAR

#define XML_PARSER_NON_LINEAR   10

Definition at line 116 of file parser.c.

Typedef Documentation

xmlDefAttrs

typedef struct _xmlDefAttrs xmlDefAttrs

Definition at line 1121 of file parser.c.

xmlDefAttrsPtr

typedef xmlDefAttrs* xmlDefAttrsPtr

Definition at line 1122 of file parser.c.

Function Documentation

areBlanks()

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

static

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

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

Returns 1 if ignorable 0 otherwise.

Definition at line 2864 of file parser.c.

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

Referenced by xmlParseCharData(), and xmlParseCharDataComplex().

inputPop()

xmlParserInputPtr inputPop

(

xmlParserCtxtPtr

ctxt

)

inputPop: @ctxt: an XML parser context

Pops the top parser input from the input stack

Returns the input just removed

Definition at line 1774 of file parser.c.

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

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

inputPush()

int inputPush	(	xmlParserCtxtPtr	ctxt,
		xmlParserInputPtr	value
	)

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

Pushes a new parser input on top of the input stack

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

Definition at line 1745 of file parser.c.

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

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

LIBXML_ATTR_FORMAT()

static void LIBXML_ATTR_FORMAT ( 3  , 0    )

static

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

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

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

Handle a warning.

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

Handle a validity error.

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

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

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

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

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

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

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

Handle a non fatal parser error

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

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

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

Handle a namespace warning error

Definition at line 593 of file parser.c.

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

nameNsPush()

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

static

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

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

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

Definition at line 1870 of file parser.c.

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

Referenced by xmlParseElementStart().

namePop()

const xmlChar * namePop

(

xmlParserCtxtPtr

ctxt

)

namePop: @ctxt: an XML parser context

Pops the top element name from the name stack

Returns the name just removed

Definition at line 1981 of file parser.c.

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

Referenced by xmlParseElementEnd(), and xmlParseElementStart().

namePush()

int namePush	(	xmlParserCtxtPtr	ctxt,
		const xmlChar *	value
	)

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

Pushes a new element name on top of the name stack

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

Definition at line 1950 of file parser.c.

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

nodePop()

xmlNodePtr nodePop

(

xmlParserCtxtPtr

ctxt

)

nodePop: @ctxt: an XML parser context

Pops the top element node from the node stack

Returns the node just removed

Definition at line 1839 of file parser.c.

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

Referenced by xmlParseElementStart(), and xmlSAX2EndElementNs().

nodePush()

int nodePush	(	xmlParserCtxtPtr	ctxt,
		xmlNodePtr	value
	)

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

Pushes a new element node on top of the node stack

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

Definition at line 1801 of file parser.c.

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

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

nsPop()

static int nsPop ( xmlParserCtxtPtr  ctxt, int  nr  )

static

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

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

Returns the number of namespaces removed

Definition at line 1681 of file parser.c.

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

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

nsPush()

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

static

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

Pushes a new parser namespace on top of the ns stack

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

Definition at line 1631 of file parser.c.

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

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

spacePop()

static int spacePop ( xmlParserCtxtPtr  ctxt )

static

Definition at line 2016 of file parser.c.

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

Referenced by xmlParseElementStart(), and xmlParseEndTag2().

spacePush()

static int spacePush ( xmlParserCtxtPtr  ctxt, int  val  )

static

Definition at line 1997 of file parser.c.

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

Referenced by xmlParseElementStart().

xmlAddDefAttrs()

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

static

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

Add a defaulted attribute for an element

Definition at line 1242 of file parser.c.

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

Referenced by xmlParseAttributeListDecl().

xmlAddSpecialAttr()

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

static

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

Register this attribute type

Definition at line 1353 of file parser.c.

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

Referenced by xmlParseAttributeListDecl().

xmlAttrNormalizeSpace()

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

static

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

Normalize the space in non CDATA attribute values: If the attribute type is not CDATA, then the XML processor MUST further process the normalized attribute value by discarding any leading and trailing space (#x20) characters, and by replacing sequences of space (#x20) characters by a single space (#x20) character. Note that the size of dst need to be at least src, and if one doesn't need to preserve dst (and it doesn't come from a dictionary or read-only) then passing src as dst is just fine.

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

Definition at line 1152 of file parser.c.

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

Referenced by xmlAttrNormalizeSpace2(), and xmlParseAttributeListDecl().

xmlAttrNormalizeSpace2()

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

static

xmlAttrNormalizeSpace2: @src: the source string

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

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

Definition at line 1185 of file parser.c.

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

Referenced by xmlParseAttribute2().

xmlCheckLanguageID()

int xmlCheckLanguageID

(

const xmlChar *

lang

)

xmlCheckLanguageID: @lang: pointer to the string value

Checks that the value conforms to the LanguageID production:

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

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

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

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

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

script = 4ALPHA ; ISO 15924 code

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

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

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

                                ; Single alphanumerics
                                ; "x" reserved for private use

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

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

Returns 1 if correct 0 otherwise

Definition at line 1474 of file parser.c.

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

Referenced by xmlParseAttribute2().

xmlCleanSpecialAttr()

static void xmlCleanSpecialAttr ( xmlParserCtxtPtr  ctxt )

static

xmlCleanSpecialAttr: @ctxt: an XML parser context

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

Definition at line 1401 of file parser.c.

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

Referenced by xmlParseDocument().

xmlCleanSpecialAttrCallback()

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

static

xmlCleanSpecialAttrCallback:

Removes CDATA attributes from the special attribute table

Definition at line 1382 of file parser.c.

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

Referenced by xmlCleanSpecialAttr().

xmlCleanupParser()

void xmlCleanupParser

(

void

)

xmlCleanupParser:

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

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

Definition at line 14739 of file parser.c.

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

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

xmlCreateDocParserCtxt()

xmlParserCtxtPtr xmlCreateDocParserCtxt

(

const xmlChar *

cur

)

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

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

Returns the new parser context or NULL

Definition at line 14542 of file parser.c.

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

Referenced by xmlReadDoc().

xmlCreateEntityParserCtxt()

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

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

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

Returns the new parser context or NULL

Definition at line 14027 of file parser.c.

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

xmlCreateEntityParserCtxtInternal()

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

static

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

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

Returns the new parser context or NULL

Definition at line 13954 of file parser.c.

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

Referenced by xmlCreateEntityParserCtxt(), and xmlParseExternalEntityPrivate().

xmlCreateFileParserCtxt()

xmlParserCtxtPtr xmlCreateFileParserCtxt

(

const char *

filename

)

xmlCreateFileParserCtxt: @filename: the filename

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

Returns the new parser context or NULL

Definition at line 14093 of file parser.c.

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

xmlCreateIOParserCtxt()

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

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

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

Returns the new parser context or NULL

Definition at line 12605 of file parser.c.

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

xmlCreateMemoryParserCtxt()

xmlParserCtxtPtr xmlCreateMemoryParserCtxt	(	const char *	buffer,
		int	size
	)

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

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

Returns the new parser context or NULL

Definition at line 14339 of file parser.c.

                                                        {
    xmlParserCtxtPtr ctxt;
    xmlParserInputPtr input;
    xmlParserInputBufferPtr buf;
 
    if (buffer == NULL)
    return(NULL);
    if (size <= 0)
    return(NULL);
 
    ctxt = xmlNewParserCtxt();
    if (ctxt == NULL)
    return(NULL);
 
    /* TODO: xmlParserInputBufferCreateStatic, requires some serious changes */
    buf = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
    if (buf == NULL) {
    xmlFreeParserCtxt(ctxt);
    return(NULL);
    }
 
    input = xmlNewInputStream(ctxt);
    if (input == NULL) {
    xmlFreeParserInputBuffer(buf);
    xmlFreeParserCtxt(ctxt);
    return(NULL);
    }
 
    input->filename = NULL;
    input->buf = buf;
    xmlBufResetInput(input->buf->buffer, input);
 
    inputPush(ctxt, input);
    return(ctxt);
}

Referenced by xmlCreateDocParserCtxt(), xmlParseBalancedChunkMemoryInternal(), xmlParseInNodeContext(), and xmlReadMemory().

xmlCreateURLParserCtxt()

xmlParserCtxtPtr xmlCreateURLParserCtxt	(	const char *	filename,
		int	options
	)

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

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

Returns the new parser context or NULL

Definition at line 14051 of file parser.c.

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

Referenced by xmlCreateFileParserCtxt(), and xmlReadFile().

xmlCtxtGrowAttrs()

static int xmlCtxtGrowAttrs ( xmlParserCtxtPtr  ctxt, int  nr  )

static

Definition at line 1702 of file parser.c.

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

Referenced by xmlParseStartTag2().

xmlCtxtReadDoc()

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

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

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

Returns the resulting document tree

Definition at line 15368 of file parser.c.

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

xmlCtxtReadFd()

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

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

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

Returns the resulting document tree

Definition at line 15471 of file parser.c.

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

xmlCtxtReadFile()

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

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

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

Returns the resulting document tree

Definition at line 15390 of file parser.c.

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

Referenced by parseAndPrintFile().

xmlCtxtReadIO()

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

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

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

Returns the resulting document tree

Definition at line 15515 of file parser.c.

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

Referenced by parseAndPrintFile().

xmlCtxtReadMemory()

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

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

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

Returns the resulting document tree

Definition at line 15426 of file parser.c.

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

Referenced by parseAndPrintFile(), and xmlCtxtReadDoc().

xmlCtxtReset()

void xmlCtxtReset

(

xmlParserCtxtPtr

ctxt

)

xmlCtxtReset: @ctxt: an XML parser context

Reset a parser context

Definition at line 14801 of file parser.c.

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

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

xmlCtxtResetPush()

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

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

Reset a push parser context

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

Definition at line 14907 of file parser.c.

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

xmlCtxtUseOptions()

int xmlCtxtUseOptions	(	xmlParserCtxtPtr	ctxt,
		int	options
	)

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

Applies the options to the parser context

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

Definition at line 15141 of file parser.c.

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

Referenced by parseAndPrintFile(), and xsltDocDefaultLoaderFunc().

xmlCtxtUseOptionsInternal()

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

static

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

Applies the options to the parser context

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

Definition at line 15000 of file parser.c.

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

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

xmlDetectSAX2()

static void xmlDetectSAX2 ( xmlParserCtxtPtr  ctxt )

static

xmlDetectSAX2: @ctxt: an XML parser context

Do the SAX2 detection and specific initialization

Definition at line 1094 of file parser.c.

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

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

xmlDoRead()

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

static

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

Common front-end for the xmlRead functions

Returns the resulting document tree or NULL

Definition at line 15159 of file parser.c.

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

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

xmlErrAttributeDup()

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

static

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

Handle a redefinition of attribute error

Definition at line 342 of file parser.c.

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

Referenced by xmlParseStartTag2().

xmlFatalErr()

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

static

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

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

Definition at line 378 of file parser.c.

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

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

xmlGenericErrorDefaultFunc()

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

Referenced by xmlInitParser().

xmlGetNamespace()

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

static

Definition at line 8760 of file parser.c.

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

Referenced by xmlParseInNodeContext(), and xmlParseStartTag2().

xmlGROW()

static void xmlGROW ( xmlParserCtxtPtr  ctxt )

static

Definition at line 2121 of file parser.c.

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

xmlHaltParser()

static void xmlHaltParser ( xmlParserCtxtPtr  ctxt )

static

xmlHaltParser: @ctxt: an XML parser context

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

Definition at line 12549 of file parser.c.

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

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

xmlHasFeature()

int xmlHasFeature

(

xmlFeature

feature

)

xmlHasFeature: @feature: the feature to be examined

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

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

Definition at line 874 of file parser.c.

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

Referenced by showVersion().

xmlInitParser()

void xmlInitParser

(

void

)

xmlInitParser:

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

Definition at line 14676 of file parser.c.

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

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

xmlIsNameChar()

static int xmlIsNameChar ( xmlParserCtxtPtr  ctxt, int  c  )

static

Definition at line 3161 of file parser.c.

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

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

xmlIsNameStartChar()

static int xmlIsNameStartChar ( xmlParserCtxtPtr  ctxt, int  c  )

static

Definition at line 3130 of file parser.c.

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

Referenced by xmlParseNCNameComplex(), and xmlParseStringName().

xmlLoadEntityContent()

static int xmlLoadEntityContent ( xmlParserCtxtPtr  ctxt, xmlEntityPtr  entity  )

static

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

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

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

Definition at line 8060 of file parser.c.

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

Referenced by xmlStringLenDecodeEntities().

xmlParseAttribute2()

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

static

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

parse an attribute in the new SAX2 framework.

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

Definition at line 9125 of file parser.c.

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

Referenced by xmlParseStartTag2().

xmlParseAttributeListDecl()

void xmlParseAttributeListDecl

(

xmlParserCtxtPtr

ctxt

)

xmlParseAttributeListDecl: @ctxt: an XML parser context

: parse the Attribute list def for an element

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

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

Definition at line 5976 of file parser.c.

                                                 {
    const xmlChar *elemName;
    const xmlChar *attrName;
    xmlEnumerationPtr tree;
 
    if (CMP9(CUR_PTR, '<', '!', 'A', 'T', 'T', 'L', 'I', 'S', 'T')) {
    int inputid = ctxt->input->id;
 
    SKIP(9);
    if (SKIP_BLANKS == 0) {
        xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
                         "Space required after '<!ATTLIST'\n");
    }
        elemName = xmlParseName(ctxt);
    if (elemName == NULL) {
        xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
               "ATTLIST: no name for Element\n");
        return;
    }
    SKIP_BLANKS;
    GROW;
    while ((RAW != '>') && (ctxt->instate != XML_PARSER_EOF)) {
        int type;
        int def;
        xmlChar *defaultValue = NULL;
 
        GROW;
            tree = NULL;
        attrName = xmlParseName(ctxt);
        if (attrName == NULL) {
        xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
                   "ATTLIST: no name for Attribute\n");
        break;
        }
        GROW;
        if (SKIP_BLANKS == 0) {
        xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
                "Space required after the attribute name\n");
        break;
        }
 
        type = xmlParseAttributeType(ctxt, &tree);
        if (type <= 0) {
            break;
        }
 
        GROW;
        if (SKIP_BLANKS == 0) {
        xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
                   "Space required after the attribute type\n");
            if (tree != NULL)
            xmlFreeEnumeration(tree);
        break;
        }
 
        def = xmlParseDefaultDecl(ctxt, &defaultValue);
        if (def <= 0) {
                if (defaultValue != NULL)
            xmlFree(defaultValue);
            if (tree != NULL)
            xmlFreeEnumeration(tree);
            break;
        }
        if ((type !=