ContextQMD
Back to Turicreate

Module parserInternals from libxml2

deps/src/libxml2-2.9.1/doc/html/libxml-parserInternals.html

6.4.173.6 KB
Original Source

| |

|

|

|

Module parserInternals from libxml2

|

|

|

|

|

|

| API Menu | |

|

| API Indexes | |

|

| Related links | |

|

|

|

|

|

|

| | parser | | API documentation | | The XML C parser and toolkit of Gnome | pattern | |

this module exports a number of internal parsing routines they are not really all intended for applications but can prove useful doing low level processing.

Table of Contents

#define[INPUT\_CHUNK](#INPUT_CHUNK)

#define[IS\_ASCII\_DIGIT](#IS_ASCII_DIGIT)

#define[IS\_ASCII\_LETTER](#IS_ASCII_LETTER)

#define[IS\_BASECHAR](#IS_BASECHAR)

#define[IS\_BLANK](#IS_BLANK)

#define[IS\_BLANK\_CH](#IS_BLANK_CH)

#define[IS\_BYTE\_CHAR](#IS_BYTE_CHAR)

#define[IS\_CHAR](#IS_CHAR)

#define[IS\_CHAR\_CH](#IS_CHAR_CH)

#define[IS\_COMBINING](#IS_COMBINING)

#define[IS\_COMBINING\_CH](#IS_COMBINING_CH)

#define[IS\_DIGIT](#IS_DIGIT)

#define[IS\_DIGIT\_CH](#IS_DIGIT_CH)

#define[IS\_EXTENDER](#IS_EXTENDER)

#define[IS\_EXTENDER\_CH](#IS_EXTENDER_CH)

#define[IS\_IDEOGRAPHIC](#IS_IDEOGRAPHIC)

#define[IS\_LETTER](#IS_LETTER)

#define[IS\_LETTER\_CH](#IS_LETTER_CH)

#define[IS\_PUBIDCHAR](#IS_PUBIDCHAR)

#define[IS\_PUBIDCHAR\_CH](#IS_PUBIDCHAR_CH)

#define[MOVETO\_ENDTAG](#MOVETO_ENDTAG)

#define[MOVETO\_STARTTAG](#MOVETO_STARTTAG)

#define[SKIP\_EOL](#SKIP_EOL)

#define[XML\_MAX\_DICTIONARY\_LIMIT](#XML_MAX_DICTIONARY_LIMIT)

#define[XML\_MAX\_LOOKUP\_LIMIT](#XML_MAX_LOOKUP_LIMIT)

#define[XML\_MAX\_NAMELEN](#XML_MAX_NAMELEN)

#define[XML\_MAX\_NAME\_LENGTH](#XML_MAX_NAME_LENGTH)

#define[XML\_MAX\_TEXT\_LENGTH](#XML_MAX_TEXT_LENGTH)

#define[XML\_SUBSTITUTE\_BOTH](#XML_SUBSTITUTE_BOTH)

#define[XML\_SUBSTITUTE\_NONE](#XML_SUBSTITUTE_NONE)

#define[XML\_SUBSTITUTE\_PEREF](#XML_SUBSTITUTE_PEREF)

#define[XML\_SUBSTITUTE\_REF](#XML_SUBSTITUTE_REF)

[htmlParserCtxtPtr](libxml-HTMLparser.html#htmlParserCtxtPtr)[htmlCreateFileParserCtxt](#htmlCreateFileParserCtxt)(const char * filename,
const char * encoding)

void[htmlInitAutoClose](#htmlInitAutoClose)(void)

[xmlParserInputPtr](libxml-tree.html#xmlParserInputPtr)[inputPop](#inputPop)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

int[inputPush](#inputPush)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlParserInputPtr](libxml-tree.html#xmlParserInputPtr)value)

const[xmlChar](libxml-xmlstring.html#xmlChar)*[namePop](#namePop)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

int[namePush](#namePush)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
const[xmlChar](libxml-xmlstring.html#xmlChar)* value)

[xmlNodePtr](libxml-tree.html#xmlNodePtr)[nodePop](#nodePop)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

int[nodePush](#nodePush)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlNodePtr](libxml-tree.html#xmlNodePtr)value)

int[xmlCheckLanguageID](#xmlCheckLanguageID)(const[xmlChar](libxml-xmlstring.html#xmlChar)* lang)

int[xmlCopyChar](#xmlCopyChar)(int len,
[xmlChar](libxml-xmlstring.html#xmlChar)* out,
int val)

int[xmlCopyCharMultiByte](#xmlCopyCharMultiByte)([xmlChar](libxml-xmlstring.html#xmlChar)* out,
int val)

[xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)[xmlCreateEntityParserCtxt](#xmlCreateEntityParserCtxt)(const[xmlChar](libxml-xmlstring.html#xmlChar)* URL,
const[xmlChar](libxml-xmlstring.html#xmlChar)* ID,
const[xmlChar](libxml-xmlstring.html#xmlChar)* base)

[xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)[xmlCreateFileParserCtxt](#xmlCreateFileParserCtxt)(const char * filename)

[xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)[xmlCreateMemoryParserCtxt](#xmlCreateMemoryParserCtxt)(const char * buffer,
int size)

[xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)[xmlCreateURLParserCtxt](#xmlCreateURLParserCtxt)(const char * filename,
int options)

int[xmlCurrentChar](#xmlCurrentChar)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
int * len)

[xmlChar](libxml-xmlstring.html#xmlChar)*[xmlDecodeEntities](#xmlDecodeEntities)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
int len,
int what,
[xmlChar](libxml-xmlstring.html#xmlChar)end,
[xmlChar](libxml-xmlstring.html#xmlChar)end2,
[xmlChar](libxml-xmlstring.html#xmlChar)end3)

Function type:[xmlEntityReferenceFunc](#xmlEntityReferenceFunc)void[xmlEntityReferenceFunc](#xmlEntityReferenceFunc)([xmlEntityPtr](libxml-tree.html#xmlEntityPtr)ent,
[xmlNodePtr](libxml-tree.html#xmlNodePtr)firstNode,
[xmlNodePtr](libxml-tree.html#xmlNodePtr)lastNode)

void[xmlErrMemory](#xmlErrMemory)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
const char * extra)

void[xmlFreeInputStream](#xmlFreeInputStream)([xmlParserInputPtr](libxml-tree.html#xmlParserInputPtr)input)

void[xmlHandleEntity](#xmlHandleEntity)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlEntityPtr](libxml-tree.html#xmlEntityPtr)entity)

int[xmlIsLetter](#xmlIsLetter)(int c)

[xmlChar](libxml-xmlstring.html#xmlChar)*[xmlNamespaceParseNCName](#xmlNamespaceParseNCName)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

[xmlChar](libxml-xmlstring.html#xmlChar)*[xmlNamespaceParseNSDef](#xmlNamespaceParseNSDef)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

[xmlChar](libxml-xmlstring.html#xmlChar)*[xmlNamespaceParseQName](#xmlNamespaceParseQName)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlChar](libxml-xmlstring.html#xmlChar)** prefix)

[xmlParserInputPtr](libxml-tree.html#xmlParserInputPtr)[xmlNewEntityInputStream](#xmlNewEntityInputStream)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlEntityPtr](libxml-tree.html#xmlEntityPtr)entity)

[xmlParserInputPtr](libxml-tree.html#xmlParserInputPtr)[xmlNewInputFromFile](#xmlNewInputFromFile)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
const char * filename)

[xmlParserInputPtr](libxml-tree.html#xmlParserInputPtr)[xmlNewInputStream](#xmlNewInputStream)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

[xmlParserInputPtr](libxml-tree.html#xmlParserInputPtr)[xmlNewStringInputStream](#xmlNewStringInputStream)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
const[xmlChar](libxml-xmlstring.html#xmlChar)* buffer)

void[xmlNextChar](#xmlNextChar)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

[xmlChar](libxml-xmlstring.html#xmlChar)*[xmlParseAttValue](#xmlParseAttValue)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

const[xmlChar](libxml-xmlstring.html#xmlChar)*[xmlParseAttribute](#xmlParseAttribute)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlChar](libxml-xmlstring.html#xmlChar)** value)

void[xmlParseAttributeListDecl](#xmlParseAttributeListDecl)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

int[xmlParseAttributeType](#xmlParseAttributeType)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlEnumerationPtr](libxml-tree.html#xmlEnumerationPtr)* tree)

void[xmlParseCDSect](#xmlParseCDSect)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

void[xmlParseCharData](#xmlParseCharData)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
int cdata)

int[xmlParseCharRef](#xmlParseCharRef)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

void[xmlParseComment](#xmlParseComment)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

void[xmlParseContent](#xmlParseContent)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

int[xmlParseDefaultDecl](#xmlParseDefaultDecl)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlChar](libxml-xmlstring.html#xmlChar)** value)

void[xmlParseDocTypeDecl](#xmlParseDocTypeDecl)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

void[xmlParseElement](#xmlParseElement)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

[xmlElementContentPtr](libxml-tree.html#xmlElementContentPtr)[xmlParseElementChildrenContentDecl](#xmlParseElementChildrenContentDecl)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
int inputchk)

int[xmlParseElementContentDecl](#xmlParseElementContentDecl)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
const[xmlChar](libxml-xmlstring.html#xmlChar)* name,
[xmlElementContentPtr](libxml-tree.html#xmlElementContentPtr)* result)

int[xmlParseElementDecl](#xmlParseElementDecl)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

[xmlElementContentPtr](libxml-tree.html#xmlElementContentPtr)[xmlParseElementMixedContentDecl](#xmlParseElementMixedContentDecl)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
int inputchk)

[xmlChar](libxml-xmlstring.html#xmlChar)*[xmlParseEncName](#xmlParseEncName)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

const[xmlChar](libxml-xmlstring.html#xmlChar)*[xmlParseEncodingDecl](#xmlParseEncodingDecl)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

void[xmlParseEndTag](#xmlParseEndTag)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

void[xmlParseEntityDecl](#xmlParseEntityDecl)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

[xmlEntityPtr](libxml-tree.html#xmlEntityPtr)[xmlParseEntityRef](#xmlParseEntityRef)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

[xmlChar](libxml-xmlstring.html#xmlChar)*[xmlParseEntityValue](#xmlParseEntityValue)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlChar](libxml-xmlstring.html#xmlChar)** orig)

int[xmlParseEnumeratedType](#xmlParseEnumeratedType)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlEnumerationPtr](libxml-tree.html#xmlEnumerationPtr)* tree)

[xmlEnumerationPtr](libxml-tree.html#xmlEnumerationPtr)[xmlParseEnumerationType](#xmlParseEnumerationType)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

[xmlChar](libxml-xmlstring.html#xmlChar)*[xmlParseExternalID](#xmlParseExternalID)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlChar](libxml-xmlstring.html#xmlChar)** publicID,
int strict)

void[xmlParseExternalSubset](#xmlParseExternalSubset)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
const[xmlChar](libxml-xmlstring.html#xmlChar)* ExternalID,
const[xmlChar](libxml-xmlstring.html#xmlChar)* SystemID)

void[xmlParseMarkupDecl](#xmlParseMarkupDecl)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

void[xmlParseMisc](#xmlParseMisc)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

const[xmlChar](libxml-xmlstring.html#xmlChar)*[xmlParseName](#xmlParseName)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

void[xmlParseNamespace](#xmlParseNamespace)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

[xmlChar](libxml-xmlstring.html#xmlChar)*[xmlParseNmtoken](#xmlParseNmtoken)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

void[xmlParseNotationDecl](#xmlParseNotationDecl)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

[xmlEnumerationPtr](libxml-tree.html#xmlEnumerationPtr)[xmlParseNotationType](#xmlParseNotationType)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

void[xmlParsePEReference](#xmlParsePEReference)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

void[xmlParsePI](#xmlParsePI)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

const[xmlChar](libxml-xmlstring.html#xmlChar)*[xmlParsePITarget](#xmlParsePITarget)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

[xmlChar](libxml-xmlstring.html#xmlChar)*[xmlParsePubidLiteral](#xmlParsePubidLiteral)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

[xmlChar](libxml-xmlstring.html#xmlChar)*[xmlParseQuotedString](#xmlParseQuotedString)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

void[xmlParseReference](#xmlParseReference)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

int[xmlParseSDDecl](#xmlParseSDDecl)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

const[xmlChar](libxml-xmlstring.html#xmlChar)*[xmlParseStartTag](#xmlParseStartTag)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

[xmlChar](libxml-xmlstring.html#xmlChar)*[xmlParseSystemLiteral](#xmlParseSystemLiteral)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

void[xmlParseTextDecl](#xmlParseTextDecl)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

[xmlChar](libxml-xmlstring.html#xmlChar)*[xmlParseVersionInfo](#xmlParseVersionInfo)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

[xmlChar](libxml-xmlstring.html#xmlChar)*[xmlParseVersionNum](#xmlParseVersionNum)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

void[xmlParseXMLDecl](#xmlParseXMLDecl)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

void[xmlParserHandlePEReference](#xmlParserHandlePEReference)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

void[xmlParserHandleReference](#xmlParserHandleReference)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

void[xmlParserInputShrink](#xmlParserInputShrink)([xmlParserInputPtr](libxml-tree.html#xmlParserInputPtr)in)

[xmlChar](libxml-xmlstring.html#xmlChar)[xmlPopInput](#xmlPopInput)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

int[xmlPushInput](#xmlPushInput)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlParserInputPtr](libxml-tree.html#xmlParserInputPtr)input)

[xmlChar](libxml-xmlstring.html#xmlChar)*[xmlScanName](#xmlScanName)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

void[xmlSetEntityReferenceFunc](#xmlSetEntityReferenceFunc)([xmlEntityReferenceFunc](libxml-parserInternals.html#xmlEntityReferenceFunc)func)

int[xmlSkipBlankChars](#xmlSkipBlankChars)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

[xmlChar](libxml-xmlstring.html#xmlChar)*[xmlSplitQName](#xmlSplitQName)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
const[xmlChar](libxml-xmlstring.html#xmlChar)* name,
[xmlChar](libxml-xmlstring.html#xmlChar)** prefix)

int[xmlStringCurrentChar](#xmlStringCurrentChar)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
const[xmlChar](libxml-xmlstring.html#xmlChar)* cur,
int * len)

[xmlChar](libxml-xmlstring.html#xmlChar)*[xmlStringDecodeEntities](#xmlStringDecodeEntities)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
const[xmlChar](libxml-xmlstring.html#xmlChar)* str,
int what,
[xmlChar](libxml-xmlstring.html#xmlChar)end,
[xmlChar](libxml-xmlstring.html#xmlChar)end2,
[xmlChar](libxml-xmlstring.html#xmlChar)end3)

[xmlChar](libxml-xmlstring.html#xmlChar)*[xmlStringLenDecodeEntities](#xmlStringLenDecodeEntities)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
const[xmlChar](libxml-xmlstring.html#xmlChar)* str,
int len,
int what,
[xmlChar](libxml-xmlstring.html#xmlChar)end,
[xmlChar](libxml-xmlstring.html#xmlChar)end2,
[xmlChar](libxml-xmlstring.html#xmlChar)end3)

int[xmlSwitchEncoding](#xmlSwitchEncoding)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlCharEncoding](libxml-encoding.html#xmlCharEncoding)enc)

int[xmlSwitchInputEncoding](#xmlSwitchInputEncoding)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlParserInputPtr](libxml-tree.html#xmlParserInputPtr)input,
[xmlCharEncodingHandlerPtr](libxml-encoding.html#xmlCharEncodingHandlerPtr)handler)

int[xmlSwitchToEncoding](#xmlSwitchToEncoding)([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlCharEncodingHandlerPtr](libxml-encoding.html#xmlCharEncodingHandlerPtr)handler)

Description

Macro: INPUT_CHUNK

#define INPUT_CHUNK

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

Macro: IS_ASCII_DIGIT

#define IS_ASCII_DIGIT

Macro to check [0-9]

Macro: IS_ASCII_LETTER

#define IS_ASCII_LETTER

Macro to check [a-zA-Z]

Macro: IS_BASECHAR

#define IS_BASECHAR

Macro to check the following production in the XML spec: [85] BaseChar ::= ... long list see REC ...

Macro: IS_BLANK

#define IS_BLANK

Macro to check the following production in the XML spec: [3] S ::= (#x20 | #x9 | #xD | #xA)+

Macro: IS_BLANK_CH

#define IS_BLANK_CH

Behaviour same as IS_BLANK

Macro: IS_BYTE_CHAR

#define IS_BYTE_CHAR

Macro to check the following production in the XML spec: [2] Char ::= #x9 | #xA | #xD | [#x20...] any byte character in the accepted range

Macro: IS_CHAR

#define IS_CHAR

Macro to check the following production in the XML spec: [2] Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF] any Unicode character, excluding the surrogate blocks, FFFE, and FFFF.

Macro: IS_CHAR_CH

#define IS_CHAR_CH

Behaves like IS_CHAR on single-byte value

Macro: IS_COMBINING

#define IS_COMBINING

Macro to check the following production in the XML spec: [87] CombiningChar ::= ... long list see REC ...

Macro: IS_COMBINING_CH

#define IS_COMBINING_CH

Always false (all combining chars > 0xff)

Macro: IS_DIGIT

#define IS_DIGIT

Macro to check the following production in the XML spec: [88] Digit ::= ... long list see REC ...

Macro: IS_DIGIT_CH

#define IS_DIGIT_CH

Behaves like IS_DIGIT but with a single byte argument

Macro: IS_EXTENDER

#define IS_EXTENDER

Macro to check the following production in the XML spec: [89] Extender ::= #x00B7 | #x02D0 | #x02D1 | #x0387 | #x0640 | #x0E46 | #x0EC6 | #x3005 | [#x3031-#x3035] | [#x309D-#x309E] | [#x30FC-#x30FE]

Macro: IS_EXTENDER_CH

#define IS_EXTENDER_CH

Behaves like IS_EXTENDER but with a single-byte argument

Macro: IS_IDEOGRAPHIC

#define IS_IDEOGRAPHIC

Macro to check the following production in the XML spec: [86] Ideographic ::= [#x4E00-#x9FA5] | #x3007 | [#x3021-#x3029]

Macro: IS_LETTER

#define IS_LETTER

Macro to check the following production in the XML spec: [84] Letter ::= BaseChar | Ideographic

Macro: IS_LETTER_CH

#define IS_LETTER_CH

Macro behaves like IS_LETTER, but only check base chars

Macro: IS_PUBIDCHAR

#define IS_PUBIDCHAR

Macro to check the following production in the XML spec: [13] PubidChar ::= #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%]

Macro: IS_PUBIDCHAR_CH

#define IS_PUBIDCHAR_CH

Same as IS_PUBIDCHAR but for single-byte value

Macro: MOVETO_ENDTAG

#define MOVETO_ENDTAG

Skips to the next '>' char.

Macro: MOVETO_STARTTAG

#define MOVETO_STARTTAG

Skips to the next '<' char.

Macro: SKIP_EOL

#define SKIP_EOL

Skips the end of line chars.

Macro: XML_MAX_DICTIONARY_LIMIT

#define XML_MAX_DICTIONARY_LIMIT

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

Macro: XML_MAX_LOOKUP_LIMIT

#define XML_MAX_LOOKUP_LIMIT

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

Macro: XML_MAX_NAMELEN

#define XML_MAX_NAMELEN

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

Macro: XML_MAX_NAME_LENGTH

#define XML_MAX_NAME_LENGTH

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

Macro: XML_MAX_TEXT_LENGTH

#define XML_MAX_TEXT_LENGTH

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

Macro: XML_SUBSTITUTE_BOTH

#define XML_SUBSTITUTE_BOTH

Both general and parameter entities need to be substituted.

Macro: XML_SUBSTITUTE_NONE

#define XML_SUBSTITUTE_NONE

If no entities need to be substituted.

Macro: XML_SUBSTITUTE_PEREF

#define XML_SUBSTITUTE_PEREF

Whether parameter entities need to be substituted.

Macro: XML_SUBSTITUTE_REF

#define XML_SUBSTITUTE_REF

Whether general entities need to be substituted.

Function: htmlCreateFileParserCtxt

[htmlParserCtxtPtr](libxml-HTMLparser.html#htmlParserCtxtPtr)htmlCreateFileParserCtxt	(const char * filename,
const char * encoding)

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

| filename: | the filename | | encoding: | a free form C string describing the HTML document encoding, or NULL | | Returns: | the new parser context or NULL |

Function: htmlInitAutoClose

void	htmlInitAutoClose (void)

Initialize the htmlStartCloseIndex for fast lookup of closing tags names. This is not reentrant. Call xmlInitParser() once before processing in case of use in multithreaded programs.

Function: inputPop

[xmlParserInputPtr](libxml-tree.html#xmlParserInputPtr)inputPop	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

Pops the top parser input from the input stack

| ctxt: | an XML parser context | | Returns: | the input just removed |

Function: inputPush

int	inputPush ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlParserInputPtr](libxml-tree.html#xmlParserInputPtr)value)

Pushes a new parser input on top of the input stack

| ctxt: | an XML parser context | | value: | the parser input | | Returns: | -1 in case of error, the index in the stack otherwise |

Function: namePop

const[xmlChar](libxml-xmlstring.html#xmlChar)*	namePop ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

Pops the top element name from the name stack

| ctxt: | an XML parser context | | Returns: | the name just removed |

Function: namePush

int	namePush ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
const[xmlChar](libxml-xmlstring.html#xmlChar)* value)

Pushes a new element name on top of the name stack

| ctxt: | an XML parser context | | value: | the element name | | Returns: | -1 in case of error, the index in the stack otherwise |

Function: nodePop

[xmlNodePtr](libxml-tree.html#xmlNodePtr)nodePop ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

Pops the top element node from the node stack

| ctxt: | an XML parser context | | Returns: | the node just removed |

Function: nodePush

int	nodePush ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlNodePtr](libxml-tree.html#xmlNodePtr)value)

Pushes a new element node on top of the node stack

| ctxt: | an XML parser context | | value: | the element node | | Returns: | -1 in case of error, the index in the stack otherwise |

Function: xmlCheckLanguageID

int	xmlCheckLanguageID (const[xmlChar](libxml-xmlstring.html#xmlChar)* lang)

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

| lang: | pointer to the string value | | Returns: | 1 if correct 0 otherwise |

Function: xmlCopyChar

int	xmlCopyChar (int len,
[xmlChar](libxml-xmlstring.html#xmlChar)* out,
int val)

append the char value in the array

| len: | Ignored, compatibility | | out: | pointer to an array of xmlChar | | val: | the char value | | Returns: | the number of xmlChar written |

Function: xmlCopyCharMultiByte

int	xmlCopyCharMultiByte ([xmlChar](libxml-xmlstring.html#xmlChar)* out,
int val)

append the char value in the array

| out: | pointer to an array of xmlChar | | val: | the char value | | Returns: | the number of xmlChar written |

Function: xmlCreateEntityParserCtxt

[xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)xmlCreateEntityParserCtxt	(const[xmlChar](libxml-xmlstring.html#xmlChar)* URL,
const[xmlChar](libxml-xmlstring.html#xmlChar)* ID,
const[xmlChar](libxml-xmlstring.html#xmlChar)* base)

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

| URL: | the entity URL | | ID: | the entity PUBLIC ID | | base: | a possible base for the target URI | | Returns: | the new parser context or NULL |

Function: xmlCreateFileParserCtxt

[xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)xmlCreateFileParserCtxt	(const char * 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.

| filename: | the filename | | Returns: | the new parser context or NULL |

Function: xmlCreateMemoryParserCtxt

[xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)xmlCreateMemoryParserCtxt	(const char * buffer,
int size)

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

| buffer: | a pointer to a char array | | size: | the size of the array | | Returns: | the new parser context or NULL |

Function: xmlCreateURLParserCtxt

[xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)xmlCreateURLParserCtxt	(const char * filename,
int options)

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

| filename: | the filename or URL | | options: | a combination of xmlParserOption | | Returns: | the new parser context or NULL |

Function: xmlCurrentChar

int	xmlCurrentChar ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
int * len)

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

| ctxt: | the XML parser context | | len: | pointer to the length of the char read | | Returns: | the current char value and its length |

Function: xmlDecodeEntities

[xmlChar](libxml-xmlstring.html#xmlChar)*	xmlDecodeEntities	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
int len,
int what,
[xmlChar](libxml-xmlstring.html#xmlChar)end,
[xmlChar](libxml-xmlstring.html#xmlChar)end2,
[xmlChar](libxml-xmlstring.html#xmlChar)end3)

This function is deprecated, we now always process entities content through xmlStringDecodeEntities TODO: remove it in next major release. [67] Reference ::= EntityRef | CharRef [69] PEReference ::= '%' Name ';'

| ctxt: | the parser context | | len: | the len to decode (in bytes !), -1 for no size limit | | what: | combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF | | end: | an end marker xmlChar, 0 if none | | end2: | an end marker xmlChar, 0 if none | | end3: | an end marker xmlChar, 0 if none | | Returns: | A newly allocated string with the substitution done. The caller must deallocate it ! |

Function type: xmlEntityReferenceFunc

Function type: xmlEntityReferenceFunc
void	xmlEntityReferenceFunc ([xmlEntityPtr](libxml-tree.html#xmlEntityPtr)ent,
[xmlNodePtr](libxml-tree.html#xmlNodePtr)firstNode,
[xmlNodePtr](libxml-tree.html#xmlNodePtr)lastNode)

Callback function used when one needs to be able to track back the provenance of a chunk of nodes inherited from an entity replacement.

| ent: | the entity | | firstNode: | the fist node in the chunk | | lastNode: | the last nod in the chunk |

Function: xmlErrMemory

void	xmlErrMemory ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
const char * extra)

Handle a redefinition of attribute error

| ctxt: | an XML parser context | | extra: | extra informations |

Function: xmlFreeInputStream

void	xmlFreeInputStream ([xmlParserInputPtr](libxml-tree.html#xmlParserInputPtr)input)

Free up an input stream.

| input: | an xmlParserInputPtr |

Function: xmlHandleEntity

void	xmlHandleEntity ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlEntityPtr](libxml-tree.html#xmlEntityPtr)entity)

Default handling of defined entities, when should we define a new input stream ? When do we just handle that as a set of chars ? OBSOLETE: to be removed at some point.

| ctxt: | an XML parser context | | entity: | an XML entity pointer. |

Function: xmlIsLetter

int	xmlIsLetter (int c)

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

| c: | an unicode character (int) | | Returns: | 0 if not, non-zero otherwise |

Function: xmlNamespaceParseNCName

[xmlChar](libxml-xmlstring.html#xmlChar)*	xmlNamespaceParseNCName	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse an XML namespace name. TODO: this seems not in use anymore, the namespace handling is done on top of the SAX interfaces, i.e. not on raw input. [NS 3] NCName ::= (Letter | '_') (NCNameChar)* [NS 4] NCNameChar ::= Letter | Digit | '.' | '-' | '_' | CombiningChar | Extender

| ctxt: | an XML parser context | | Returns: | the namespace name or NULL |

Function: xmlNamespaceParseNSDef

[xmlChar](libxml-xmlstring.html#xmlChar)*	xmlNamespaceParseNSDef	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse a namespace prefix declaration TODO: this seems not in use anymore, the namespace handling is done on top of the SAX interfaces, i.e. not on raw input. [NS 1] NSDef ::= PrefixDef Eq SystemLiteral [NS 2] PrefixDef ::= 'xmlns' (':' NCName)?

| ctxt: | an XML parser context | | Returns: | the namespace name |

Function: xmlNamespaceParseQName

[xmlChar](libxml-xmlstring.html#xmlChar)*	xmlNamespaceParseQName	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlChar](libxml-xmlstring.html#xmlChar)** prefix)

TODO: this seems not in use anymore, the namespace handling is done on top of the SAX interfaces, i.e. not on raw input. parse an XML qualified name [NS 5] QName ::= (Prefix ':')? LocalPart [NS 6] Prefix ::= NCName [NS 7] LocalPart ::= NCName

| ctxt: | an XML parser context | | prefix: | a xmlChar ** | | Returns: | the local part, and prefix is updated to get the Prefix if any. |

Function: xmlNewEntityInputStream

[xmlParserInputPtr](libxml-tree.html#xmlParserInputPtr)xmlNewEntityInputStream	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlEntityPtr](libxml-tree.html#xmlEntityPtr)entity)

Create a new input stream based on an xmlEntityPtr

| ctxt: | an XML parser context | | entity: | an Entity pointer | | Returns: | the new input stream or NULL |

Function: xmlNewInputFromFile

[xmlParserInputPtr](libxml-tree.html#xmlParserInputPtr)xmlNewInputFromFile	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
const char * filename)

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

| ctxt: | an XML parser context | | filename: | the filename to use as entity | | Returns: | the new input stream or NULL in case of error |

Function: xmlNewInputStream

[xmlParserInputPtr](libxml-tree.html#xmlParserInputPtr)xmlNewInputStream	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

Create a new input stream structure.

| ctxt: | an XML parser context | | Returns: | the new input stream or NULL |

Function: xmlNewStringInputStream

[xmlParserInputPtr](libxml-tree.html#xmlParserInputPtr)xmlNewStringInputStream	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
const[xmlChar](libxml-xmlstring.html#xmlChar)* buffer)

Create a new input stream based on a memory buffer.

| ctxt: | an XML parser context | | buffer: | an memory buffer | | Returns: | the new input stream |

Function: xmlNextChar

void	xmlNextChar ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

Skip to the next char input char.

| ctxt: | the XML parser context |

Function: xmlParseAttValue

[xmlChar](libxml-xmlstring.html#xmlChar)*	xmlParseAttValue	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse a value for an attribute Note: the parser won't do substitution of entities here, this will be handled later in xmlStringGetNodeList [10] AttValue ::= '"' ([^<&"] | Reference)* '"' | "'" ([^<&'] | Reference)* "'" 3.3.3 Attribute-Value Normalization: Before the value of an attribute is passed to the application or checked for validity, the XML processor must normalize it as follows: - a character reference is processed by appending the referenced character to the attribute value - an entity reference is processed by recursively processing the replacement text of the entity - a whitespace character (#x20, #xD, #xA, #x9) is processed by appending #x20 to the normalized value, except that only a single #x20 is appended for a "#xD#xA" sequence that is part of an external parsed entity or the literal entity value of an internal parsed entity - other characters are processed by appending them to the normalized value If the declared value is not CDATA, then the XML processor must further process the normalized attribute value by discarding any leading and trailing space (#x20) characters, and by replacing sequences of space (#x20) characters by a single space (#x20) character. All attributes for which no declaration has been read should be treated by a non-validating parser as if declared CDATA.

| ctxt: | an XML parser context | | Returns: | the AttValue parsed or NULL. The value has to be freed by the caller. |

Function: xmlParseAttribute

const[xmlChar](libxml-xmlstring.html#xmlChar)*	xmlParseAttribute	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlChar](libxml-xmlstring.html#xmlChar)** value)

parse an attribute [41] Attribute ::= Name Eq AttValue [WFC: No External Entity References] Attribute values cannot contain direct or indirect entity references to external entities. [WFC: No < in Attribute Values] The replacement text of any entity referred to directly or indirectly in an attribute value (other than "<") must not contain a <. [VC: Attribute Value Type] The attribute must have been declared; the value must be of the type declared for it. [25] Eq ::= S? '=' S? With namespace: [NS 11] Attribute ::= QName Eq AttValue Also the case QName == xmlns:??? is handled independently as a namespace definition.

| ctxt: | an XML parser context | | value: | a xmlChar ** used to store the value of the attribute | | Returns: | the attribute name, and the value in *value. |

Function: xmlParseAttributeListDecl

void	xmlParseAttributeListDecl	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

: parse the Attribute list def for an element [52] AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>' [53] AttDef ::= S Name S AttType S DefaultDecl

| ctxt: | an XML parser context |

Function: xmlParseAttributeType

int	xmlParseAttributeType ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlEnumerationPtr](libxml-tree.html#xmlEnumerationPtr)* tree)

parse the Attribute list def for an element [54] AttType ::= StringType | TokenizedType | EnumeratedType [55] StringType ::= 'CDATA' [56] TokenizedType ::= 'ID' | 'IDREF' | 'IDREFS' | 'ENTITY' | 'ENTITIES' | 'NMTOKEN' | 'NMTOKENS' Validity constraints for attribute values syntax are checked in xmlValidateAttributeValue() [VC: ID] Values of type ID must match the Name production. A name must not appear more than once in an XML document as a value of this type; i.e., ID values must uniquely identify the elements which bear them. [VC: One ID per Element Type] No element type may have more than one ID attribute specified. [VC: ID Attribute Default] An ID attribute must have a declared default of #IMPLIED or #REQUIRED. [VC: IDREF] Values of type IDREF must match the Name production, and values of type IDREFS must match Names; each IDREF Name must match the value of an ID attribute on some element in the XML document; i.e. IDREF values must match the value of some ID attribute. [VC: Entity Name] Values of type ENTITY must match the Name production, values of type ENTITIES must match Names; each Entity Name must match the name of an unparsed entity declared in the DTD. [VC: Name Token] Values of type NMTOKEN must match the Nmtoken production; values of type NMTOKENS must match Nmtokens.

| ctxt: | an XML parser context | | tree: | the enumeration tree built while parsing | | Returns: | the attribute type |

Function: xmlParseCDSect

void	xmlParseCDSect ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

Parse escaped pure raw content. [18] CDSect ::= CDStart CData CDEnd [19] CDStart ::= '<![CDATA[' [20] Data ::= (Char* - (Char* ']]>' Char*)) [21] CDEnd ::= ']]>'

| ctxt: | an XML parser context |

Function: xmlParseCharData

void	xmlParseCharData ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
int cdata)

parse a CharData section. if we are within a CDATA section ']]>' marks an end of section. The right angle bracket (>) may be represented using the string ">", and must, for compatibility, be escaped using ">" or a character reference when it appears in the string "]]>" in content, when that string is not marking the end of a CDATA section. [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)

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

Function: xmlParseCharRef

int	xmlParseCharRef ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse Reference declarations [66] CharRef ::= '&#' [0-9]+ ';' | '&#x' [0-9a-fA-F]+ ';' [WFC: Legal Character] Characters referred to using character references must match the production for Char.

| ctxt: | an XML parser context | | Returns: | the value parsed (as an int), 0 in case of error |

Function: xmlParseComment

void	xmlParseComment ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

Skip an XML (SGML) comment <!-- .... --> The spec says that "For compatibility, the string "--" (double-hyphen) must not occur within comments. " [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'

| ctxt: | an XML parser context |

Function: xmlParseContent

void	xmlParseContent ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

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

| ctxt: | an XML parser context |

Function: xmlParseDefaultDecl

int	xmlParseDefaultDecl ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlChar](libxml-xmlstring.html#xmlChar)** value)

Parse an attribute default declaration [60] DefaultDecl ::= '#REQUIRED' | '#IMPLIED' | (('#FIXED' S)? AttValue) [VC: Required Attribute] if the default declaration is the keyword #REQUIRED, then the attribute must be specified for all elements of the type in the attribute-list declaration. [VC: Attribute Default Legal] The declared default value must meet the lexical constraints of the declared attribute type c.f. xmlValidateAttributeDecl() [VC: Fixed Attribute Default] if an attribute has a default value declared with the #FIXED keyword, instances of that attribute must match the default value. [WFC: No < in Attribute Values] handled in xmlParseAttValue()

| ctxt: | an XML parser context | | value: | Receive a possible fixed default value for the attribute | | Returns: | XML_ATTRIBUTE_NONE, XML_ATTRIBUTE_REQUIRED, XML_ATTRIBUTE_IMPLIED or XML_ATTRIBUTE_FIXED. |

Function: xmlParseDocTypeDecl

void	xmlParseDocTypeDecl ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse a DOCTYPE declaration [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S? ('[' (markupdecl | PEReference | S)* ']' S?)? '>' [VC: Root Element Type] The Name in the document type declaration must match the element type of the root element.

| ctxt: | an XML parser context |

Function: xmlParseElement

void	xmlParseElement ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse an XML element, this is highly recursive [39] element ::= EmptyElemTag | STag content ETag [WFC: Element Type Match] The Name in an element's end-tag must match the element type in the start-tag.

| ctxt: | an XML parser context |

Function: xmlParseElementChildrenContentDecl

[xmlElementContentPtr](libxml-tree.html#xmlElementContentPtr)xmlParseElementChildrenContentDecl	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
int inputchk)

parse the declaration for a Mixed Element content The leading '(' and spaces have been skipped in xmlParseElementContentDecl [47] children ::= (choice | seq) ('?' | '*' | '+')? [48] cp ::= (Name | choice | seq) ('?' | '*' | '+')? [49] choice ::= '(' S? cp ( S? '|' S? cp )* S? ')' [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')' [VC: Proper Group/PE Nesting] applies to [49] and [50] TODO Parameter-entity replacement text must be properly nested with parenthesized groups. That is to say, if either of the opening or closing parentheses in a choice, seq, or Mixed construct is contained in the replacement text for a parameter entity, both must be contained in the same replacement text. For interoperability, if a parameter-entity reference appears in a choice, seq, or Mixed construct, its replacement text should not be empty, and neither the first nor last non-blank character of the replacement text should be a connector (| or ,).

| ctxt: | an XML parser context | | inputchk: | the input used for the current entity, needed for boundary checks | | Returns: | the tree of xmlElementContentPtr describing the element hierarchy. |

Function: xmlParseElementContentDecl

int	xmlParseElementContentDecl	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
const[xmlChar](libxml-xmlstring.html#xmlChar)* name,
[xmlElementContentPtr](libxml-tree.html#xmlElementContentPtr)* result)

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

| ctxt: | an XML parser context | | name: | the name of the element being defined. | | result: | the Element Content pointer will be stored here if any | | Returns: | the type of element content XML_ELEMENT_TYPE_xxx |

Function: xmlParseElementDecl

int	xmlParseElementDecl ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse an Element declaration. [45] elementdecl ::= '<!ELEMENT' S Name S contentspec S? '>' [VC: Unique Element Type Declaration] No element type may be declared more than once

| ctxt: | an XML parser context | | Returns: | the type of the element, or -1 in case of error |

Function: xmlParseElementMixedContentDecl

[xmlElementContentPtr](libxml-tree.html#xmlElementContentPtr)xmlParseElementMixedContentDecl	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
int inputchk)

parse the declaration for a Mixed Element content The leading '(' and spaces have been skipped in xmlParseElementContentDecl [51] Mixed ::= '(' S? '#PCDATA' (S? '|' S? Name)* S? ')*' | '(' S? '#PCDATA' S? ')' [VC: Proper Group/PE Nesting] applies to [51] too (see [49]) [VC: No Duplicate Types] The same name must not appear more than once in a single mixed-content declaration.

| ctxt: | an XML parser context | | inputchk: | the input used for the current entity, needed for boundary checks | | Returns: | the list of the xmlElementContentPtr describing the element choices |

Function: xmlParseEncName

[xmlChar](libxml-xmlstring.html#xmlChar)*	xmlParseEncName ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse the XML encoding name [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')*

| ctxt: | an XML parser context | | Returns: | the encoding name value or NULL |

Function: xmlParseEncodingDecl

const[xmlChar](libxml-xmlstring.html#xmlChar)*	xmlParseEncodingDecl	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse the XML encoding declaration [80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' | "'" EncName "'") this setups the conversion filters.

| ctxt: | an XML parser context | | Returns: | the encoding value or NULL |

Function: xmlParseEndTag

void	xmlParseEndTag ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse an end of tag [42] ETag ::= '</' Name S? '>' With namespace [NS 9] ETag ::= '</' QName S? '>'

| ctxt: | an XML parser context |

Function: xmlParseEntityDecl

void	xmlParseEntityDecl ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse <!ENTITY declarations [70] EntityDecl ::= GEDecl | PEDecl [71] GEDecl ::= '<!ENTITY' S Name S EntityDef S? '>' [72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>' [73] EntityDef ::= EntityValue | (ExternalID NDataDecl?) [74] PEDef ::= EntityValue | ExternalID [76] NDataDecl ::= S 'NDATA' S Name [VC: Notation Declared] The Name must match the declared name of a notation.

| ctxt: | an XML parser context |

Function: xmlParseEntityRef

[xmlEntityPtr](libxml-tree.html#xmlEntityPtr)xmlParseEntityRef	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

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

| ctxt: | an XML parser context | | Returns: | the xmlEntityPtr if found, or NULL otherwise. |

Function: xmlParseEntityValue

[xmlChar](libxml-xmlstring.html#xmlChar)*	xmlParseEntityValue	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlChar](libxml-xmlstring.html#xmlChar)** orig)

parse a value for ENTITY declarations [9] EntityValue ::= '"' ([^%&"] | PEReference | Reference)* '"' | "'" ([^%&'] | PEReference | Reference)* "'"

| ctxt: | an XML parser context | | orig: | if non-NULL store a copy of the original entity value | | Returns: | the EntityValue parsed with reference substituted or NULL |

Function: xmlParseEnumeratedType

int	xmlParseEnumeratedType ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlEnumerationPtr](libxml-tree.html#xmlEnumerationPtr)* tree)

parse an Enumerated attribute type. [57] EnumeratedType ::= NotationType | Enumeration [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'

| ctxt: | an XML parser context | | tree: | the enumeration tree built while parsing | | Returns: | XML_ATTRIBUTE_ENUMERATION or XML_ATTRIBUTE_NOTATION |

Function: xmlParseEnumerationType

[xmlEnumerationPtr](libxml-tree.html#xmlEnumerationPtr)xmlParseEnumerationType	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse an Enumeration attribute type. [59] Enumeration ::= '(' S? Nmtoken (S? '|' S? Nmtoken)* S? ')' [VC: Enumeration] Values of this type must match one of the Nmtoken tokens in the declaration

| ctxt: | an XML parser context | | Returns: | the enumeration attribute tree built while parsing |

Function: xmlParseExternalID

[xmlChar](libxml-xmlstring.html#xmlChar)*	xmlParseExternalID	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlChar](libxml-xmlstring.html#xmlChar)** publicID,
int strict)

Parse an External ID or a Public ID NOTE: Productions [75] and [83] interact badly since [75] can generate 'PUBLIC' S PubidLiteral S SystemLiteral [75] ExternalID ::= 'SYSTEM' S SystemLiteral | 'PUBLIC' S PubidLiteral S SystemLiteral [83] PublicID ::= 'PUBLIC' S PubidLiteral

| ctxt: | an XML parser context | | publicID: | a xmlChar** receiving PubidLiteral | | strict: | indicate whether we should restrict parsing to only production [75], see NOTE below | | Returns: | the function returns SystemLiteral and in the second case publicID receives PubidLiteral, is strict is off it is possible to return NULL and have publicID set. |

Function: xmlParseExternalSubset

void	xmlParseExternalSubset ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
const[xmlChar](libxml-xmlstring.html#xmlChar)* ExternalID,
const[xmlChar](libxml-xmlstring.html#xmlChar)* SystemID)

parse Markup declarations from an external subset [30] extSubset ::= textDecl? extSubsetDecl [31] extSubsetDecl ::= (markupdecl | conditionalSect | PEReference | S) *

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

Function: xmlParseMarkupDecl

void	xmlParseMarkupDecl ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse Markup declarations [29] markupdecl ::= elementdecl | AttlistDecl | EntityDecl | NotationDecl | PI | Comment [VC: Proper Declaration/PE Nesting] Parameter-entity replacement text must be properly nested with markup declarations. That is to say, if either the first character or the last character of a markup declaration (markupdecl above) is contained in the replacement text for a parameter-entity reference, both must be contained in the same replacement text. [WFC: PEs in Internal Subset] In the internal DTD subset, parameter-entity references can occur only where markup declarations can occur, not within markup declarations. (This does not apply to references that occur in external parameter entities or to the external subset.)

| ctxt: | an XML parser context |

Function: xmlParseMisc

void	xmlParseMisc ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse an XML Misc* optional field. [27] Misc ::= Comment | PI | S

| ctxt: | an XML parser context |

Function: xmlParseName

const[xmlChar](libxml-xmlstring.html#xmlChar)*	xmlParseName ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse an XML name. [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' | CombiningChar | Extender [5] Name ::= (Letter | '_' | ':') (NameChar)* [6] Names ::= Name (#x20 Name)*

| ctxt: | an XML parser context | | Returns: | the Name parsed or NULL |

Function: xmlParseNamespace

void	xmlParseNamespace ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

xmlParseNamespace: parse specific PI '<?namespace ...' constructs. This is what the older xml-name Working Draft specified, a bunch of other stuff may still rely on it, so support is still here as if it was declared on the root of the Tree:-( TODO: remove from library To be removed at next drop of binary compatibility

| ctxt: | an XML parser context |

Function: xmlParseNmtoken

[xmlChar](libxml-xmlstring.html#xmlChar)*	xmlParseNmtoken ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse an XML Nmtoken. [7] Nmtoken ::= (NameChar)+ [8] Nmtokens ::= Nmtoken (#x20 Nmtoken)*

| ctxt: | an XML parser context | | Returns: | the Nmtoken parsed or NULL |

Function: xmlParseNotationDecl

void	xmlParseNotationDecl ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse a notation declaration [82] NotationDecl ::= '<!NOTATION' S Name S (ExternalID | PublicID) S? '>' Hence there is actually 3 choices: 'PUBLIC' S PubidLiteral 'PUBLIC' S PubidLiteral S SystemLiteral and 'SYSTEM' S SystemLiteral See the NOTE on xmlParseExternalID().

| ctxt: | an XML parser context |

Function: xmlParseNotationType

[xmlEnumerationPtr](libxml-tree.html#xmlEnumerationPtr)xmlParseNotationType	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse an Notation attribute type. Note: the leading 'NOTATION' S part has already being parsed... [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')' [VC: Notation Attributes] Values of this type must match one of the notation names included in the declaration; all notation names in the declaration must be declared.

| ctxt: | an XML parser context | | Returns: | the notation attribute tree built while parsing |

Function: xmlParsePEReference

void	xmlParsePEReference ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse PEReference declarations The entity content is handled directly by pushing it's content as a new input stream. [69] PEReference ::= '%' Name ';' [WFC: No Recursion] A parsed entity must not contain a recursive reference to itself, either directly or indirectly. [WFC: Entity Declared] In a document without any DTD, a document with only an internal DTD subset which contains no parameter entity references, or a document with "standalone='yes'", ... ... The declaration of a parameter entity must precede any reference to it... [VC: Entity Declared] In a document with an external subset or external parameter entities with "standalone='no'", ... ... The declaration of a parameter entity must precede any reference to it... [WFC: In DTD] Parameter-entity references may only appear in the DTD. NOTE: misleading but this is handled.

| ctxt: | an XML parser context |

Function: xmlParsePI

void	xmlParsePI ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse an XML Processing Instruction. [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>' The processing is transfered to SAX once parsed.

| ctxt: | an XML parser context |

Function: xmlParsePITarget

const[xmlChar](libxml-xmlstring.html#xmlChar)*	xmlParsePITarget	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse the name of a PI [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l'))

| ctxt: | an XML parser context | | Returns: | the PITarget name or NULL |

Function: xmlParsePubidLiteral

[xmlChar](libxml-xmlstring.html#xmlChar)*	xmlParsePubidLiteral	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse an XML public literal [12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'"

| ctxt: | an XML parser context | | Returns: | the PubidLiteral parsed or NULL. |

Function: xmlParseQuotedString

[xmlChar](libxml-xmlstring.html#xmlChar)*	xmlParseQuotedString	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

Parse and return a string between quotes or doublequotes TODO: Deprecated, to be removed at next drop of binary compatibility

| ctxt: | an XML parser context | | Returns: | the string parser or NULL. |

Function: xmlParseReference

void	xmlParseReference ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

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

| ctxt: | an XML parser context |

Function: xmlParseSDDecl

int	xmlParseSDDecl ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse the XML standalone declaration [32] SDDecl ::= S 'standalone' Eq (("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no')'"')) [VC: Standalone Document Declaration] TODO The standalone document declaration must have the value "no" if any external markup declarations contain declarations of: - attributes with default values, if elements to which these attributes apply appear in the document without specifications of values for these attributes, or - entities (other than amp, lt, gt, apos, quot), if references to those entities appear in the document, or - attributes with values subject to normalization, where the attribute appears in the document with a value which will change as a result of normalization, or - element types with element content, if white space occurs directly within any instance of those types.

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

Function: xmlParseStartTag

const[xmlChar](libxml-xmlstring.html#xmlChar)*	xmlParseStartTag	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse a start of tag either for rule element or EmptyElement. In both case we don't parse the tag closing chars. [40] STag ::= '<' Name (S Attribute)* S? '>' [WFC: Unique Att Spec] No attribute name may appear more than once in the same start-tag or empty-element tag. [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>' [WFC: Unique Att Spec] No attribute name may appear more than once in the same start-tag or empty-element tag. With namespace: [NS 8] STag ::= '<' QName (S Attribute)* S? '>' [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'

| ctxt: | an XML parser context | | Returns: | the element name parsed |

Function: xmlParseSystemLiteral

[xmlChar](libxml-xmlstring.html#xmlChar)*	xmlParseSystemLiteral	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse an XML Literal [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'")

| ctxt: | an XML parser context | | Returns: | the SystemLiteral parsed or NULL |

Function: xmlParseTextDecl

void	xmlParseTextDecl ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse an XML declaration header for external entities [77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>'

| ctxt: | an XML parser context |

Function: xmlParseVersionInfo

[xmlChar](libxml-xmlstring.html#xmlChar)*	xmlParseVersionInfo	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse the XML version. [24] VersionInfo ::= S 'version' Eq (' VersionNum ' | " VersionNum ") [25] Eq ::= S? '=' S?

| ctxt: | an XML parser context | | Returns: | the version string, e.g. "1.0" |

Function: xmlParseVersionNum

[xmlChar](libxml-xmlstring.html#xmlChar)*	xmlParseVersionNum	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse the XML version value. [26] VersionNum ::= '1.' [0-9]+ In practice allow [0-9].[0-9]+ at that level

| ctxt: | an XML parser context | | Returns: | the string giving the XML version number, or NULL |

Function: xmlParseXMLDecl

void	xmlParseXMLDecl ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

parse an XML declaration header [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'

| ctxt: | an XML parser context |

Function: xmlParserHandlePEReference

void	xmlParserHandlePEReference	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

[69] PEReference ::= '%' Name ';' [WFC: No Recursion] A parsed entity must not contain a recursive reference to itself, either directly or indirectly. [WFC: Entity Declared] In a document without any DTD, a document with only an internal DTD subset which contains no parameter entity references, or a document with "standalone='yes'", ... ... The declaration of a parameter entity must precede any reference to it... [VC: Entity Declared] In a document with an external subset or external parameter entities with "standalone='no'", ... ... The declaration of a parameter entity must precede any reference to it... [WFC: In DTD] Parameter-entity references may only appear in the DTD. NOTE: misleading but this is handled. A PEReference may have been detected in the current input stream the handling is done accordingly to http://www.w3.org/TR/REC-xml#entproc i.e. - Included in literal in entity values - Included as Parameter Entity reference within DTDs

| ctxt: | the parser context |

Function: xmlParserHandleReference

void	xmlParserHandleReference	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

TODO: Remove, now deprecated ... the test is done directly in the content parsing routines. [67] Reference ::= EntityRef | CharRef [68] EntityRef ::= '&' Name ';' [WFC: Entity Declared] the Name given in the entity reference must match that in an entity declaration, except that well-formed documents need not declare any of the following entities: amp, lt, gt, apos, quot. [WFC: Parsed Entity] An entity reference must not contain the name of an unparsed entity [66] CharRef ::= '&#' [0-9]+ ';' | '&#x' [0-9a-fA-F]+ ';' A PEReference may have been detected in the current input stream the handling is done accordingly to http://www.w3.org/TR/REC-xml#entproc

| ctxt: | the parser context |

Function: xmlParserInputShrink

void	xmlParserInputShrink ([xmlParserInputPtr](libxml-tree.html#xmlParserInputPtr)in)

This function removes used input for the parser.

| in: | an XML parser input |

Function: xmlPopInput

[xmlChar](libxml-xmlstring.html#xmlChar)xmlPopInput ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

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

| ctxt: | an XML parser context | | Returns: | the current xmlChar in the parser context |

Function: xmlPushInput

int	xmlPushInput ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlParserInputPtr](libxml-tree.html#xmlParserInputPtr)input)

xmlPushInput: switch to a new input stream which is stacked on top of the previous one(s).

| ctxt: | an XML parser context | | input: | an XML parser input fragment (entity, XML fragment ...). | | Returns: | -1 in case of error or the index in the input stack |

Function: xmlScanName

[xmlChar](libxml-xmlstring.html#xmlChar)*	xmlScanName ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

Trickery: parse an XML name but without consuming the input flow Needed for rollback cases. Used only when parsing entities references. TODO: seems deprecated now, only used in the default part of xmlParserHandleReference [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' | CombiningChar | Extender [5] Name ::= (Letter | '_' | ':') (NameChar)* [6] Names ::= Name (S Name)*

| ctxt: | an XML parser context | | Returns: | the Name parsed or NULL |

Function: xmlSetEntityReferenceFunc

void	xmlSetEntityReferenceFunc	([xmlEntityReferenceFunc](libxml-parserInternals.html#xmlEntityReferenceFunc)func)

Set the function to call call back when a xml reference has been made

| func: | A valid function |

Function: xmlSkipBlankChars

int	xmlSkipBlankChars ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt)

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

| ctxt: | the XML parser context | | Returns: | the number of space chars skipped |

Function: xmlSplitQName

[xmlChar](libxml-xmlstring.html#xmlChar)*	xmlSplitQName ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
const[xmlChar](libxml-xmlstring.html#xmlChar)* name,
[xmlChar](libxml-xmlstring.html#xmlChar)** prefix)

parse an UTF8 encoded XML qualified name string [NS 5] QName ::= (Prefix ':')? LocalPart [NS 6] Prefix ::= NCName [NS 7] LocalPart ::= NCName

| ctxt: | an XML parser context | | name: | an XML parser context | | prefix: | a xmlChar ** | | Returns: | the local part, and prefix is updated to get the Prefix if any. |

Function: xmlStringCurrentChar

int	xmlStringCurrentChar ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
const[xmlChar](libxml-xmlstring.html#xmlChar)* cur,
int * len)

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

| ctxt: | the XML parser context | | cur: | pointer to the beginning of the char | | len: | pointer to the length of the char read | | Returns: | the current char value and its length |

Function: xmlStringDecodeEntities

[xmlChar](libxml-xmlstring.html#xmlChar)*	xmlStringDecodeEntities	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
const[xmlChar](libxml-xmlstring.html#xmlChar)* str,
int what,
[xmlChar](libxml-xmlstring.html#xmlChar)end,
[xmlChar](libxml-xmlstring.html#xmlChar)end2,
[xmlChar](libxml-xmlstring.html#xmlChar)end3)

Takes a entity string content and process to do the adequate substitutions. [67] Reference ::= EntityRef | CharRef [69] PEReference ::= '%' Name ';'

| ctxt: | the parser context | | str: | the input string | | what: | combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF | | end: | an end marker xmlChar, 0 if none | | end2: | an end marker xmlChar, 0 if none | | end3: | an end marker xmlChar, 0 if none | | Returns: | A newly allocated string with the substitution done. The caller must deallocate it ! |

Function: xmlStringLenDecodeEntities

[xmlChar](libxml-xmlstring.html#xmlChar)*	xmlStringLenDecodeEntities	([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
const[xmlChar](libxml-xmlstring.html#xmlChar)* str,
int len,
int what,
[xmlChar](libxml-xmlstring.html#xmlChar)end,
[xmlChar](libxml-xmlstring.html#xmlChar)end2,
[xmlChar](libxml-xmlstring.html#xmlChar)end3)

Takes a entity string content and process to do the adequate substitutions. [67] Reference ::= EntityRef | CharRef [69] PEReference ::= '%' Name ';'

| ctxt: | the parser context | | str: | the input string | | len: | the string length | | what: | combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF | | end: | an end marker xmlChar, 0 if none | | end2: | an end marker xmlChar, 0 if none | | end3: | an end marker xmlChar, 0 if none | | Returns: | A newly allocated string with the substitution done. The caller must deallocate it ! |

Function: xmlSwitchEncoding

int	xmlSwitchEncoding ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlCharEncoding](libxml-encoding.html#xmlCharEncoding)enc)

change the input functions when discovering the character encoding of a given entity.

| ctxt: | the parser context | | enc: | the encoding value (number) | | Returns: | 0 in case of success, -1 otherwise |

Function: xmlSwitchInputEncoding

int	xmlSwitchInputEncoding ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlParserInputPtr](libxml-tree.html#xmlParserInputPtr)input,
[xmlCharEncodingHandlerPtr](libxml-encoding.html#xmlCharEncodingHandlerPtr)handler)

change the input functions when discovering the character encoding of a given entity.

| ctxt: | the parser context | | input: | the input stream | | handler: | the encoding handler | | Returns: | 0 in case of success, -1 otherwise |

Function: xmlSwitchToEncoding

int	xmlSwitchToEncoding ([xmlParserCtxtPtr](libxml-tree.html#xmlParserCtxtPtr)ctxt,
[xmlCharEncodingHandlerPtr](libxml-encoding.html#xmlCharEncodingHandlerPtr)handler)

change the input functions when discovering the character encoding of a given entity.

| ctxt: | the parser context | | handler: | the encoding handler | | Returns: | 0 in case of success, -1 otherwise |

Daniel Veillard

|

|

|

|

|