parserInternals

xmlCreateDocParserCtxt()

xmlParserCtxtPtr xmlCreateDocParserCtxt     (CHAR *cur);

xmlCreateFileParserCtxt()

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.

xmlCreateMemoryParserCtxt()

xmlParserCtxtPtr xmlCreateMemoryParserCtxt  (char *buffer,
                                             int size);

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

xmlFreeParserCtxt()

void        xmlFreeParserCtxt               (xmlParserCtxtPtr ctxt);

Free all the memory used by a parser context. However the parsed document in ctxt->doc is not freed.

xmlHandleEntity()

void        xmlHandleEntity                 (xmlParserCtxtPtr ctxt,
                                             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 ? TODO: we should call the SAX handler here and have it resolve the issue

xmlNewEntityInputStream()

xmlParserInputPtr xmlNewEntityInputStream   (xmlParserCtxtPtr ctxt,
                                             xmlEntityPtr entity);

Create a new input stream based on a memory buffer.

xmlPushInput()

void        xmlPushInput                    (xmlParserCtxtPtr ctxt,
                                             xmlParserInputPtr input);

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

xmlPopInput()

CHAR        xmlPopInput                     (xmlParserCtxtPtr ctxt);

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

TODO A deallocation of the popped Input structure is needed

xmlFreeInputStream()

void        xmlFreeInputStream              (xmlParserInputPtr input);

Free up an input stream.

xmlNamespaceParseNCName()

CHAR*       xmlNamespaceParseNCName         (xmlParserCtxtPtr ctxt);

parse an XML namespace name.

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

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

xmlNamespaceParseQName()

CHAR*       xmlNamespaceParseQName          (xmlParserCtxtPtr ctxt,
                                             CHAR **prefix);

parse an XML qualified name

[NS 5] QName ::= (Prefix ':')? LocalPart

[NS 6] Prefix ::= NCName

[NS 7] LocalPart ::= NCName

xmlNamespaceParseNSDef()

CHAR*       xmlNamespaceParseNSDef          (xmlParserCtxtPtr ctxt);

parse a namespace prefix declaration

[NS 1] NSDef ::= PrefixDef Eq SystemLiteral

[NS 2] PrefixDef ::= 'xmlns' (':' NCName)?

xmlParseQuotedString()

CHAR*       xmlParseQuotedString            (xmlParserCtxtPtr ctxt);

[OLD] Parse and return a string between quotes or doublequotes

xmlParseNamespace()

void        xmlParseNamespace               (xmlParserCtxtPtr ctxt);

[OLD] 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 ot was declared on the root of the Tree:-(

xmlParseName()

CHAR*       xmlParseName                    (xmlParserCtxtPtr ctxt);

parse an XML name.

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

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

[6] Names ::= Name (S Name)*

xmlParseNmtoken()

CHAR*       xmlParseNmtoken                 (xmlParserCtxtPtr ctxt);

parse an XML Nmtoken.

[7] Nmtoken ::= (NameChar)+

[8] Nmtokens ::= Nmtoken (S Nmtoken)*

xmlParseEntityValue()

CHAR*       xmlParseEntityValue             (xmlParserCtxtPtr ctxt);

parse a value for ENTITY decl.

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

xmlParseAttValue()

CHAR*       xmlParseAttValue                (xmlParserCtxtPtr ctxt);

parse a value for an attribute

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

xmlParseSystemLiteral()

CHAR*       xmlParseSystemLiteral           (xmlParserCtxtPtr ctxt);

parse an XML Literal

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

xmlParsePubidLiteral()

CHAR*       xmlParsePubidLiteral            (xmlParserCtxtPtr ctxt);

parse an XML public literal

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

xmlParseCharData()

void        xmlParseCharData                (xmlParserCtxtPtr ctxt,
                                             int cdata);

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

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

xmlParseExternalID()

CHAR*       xmlParseExternalID              (xmlParserCtxtPtr ctxt,
                                             CHAR **publicID,
                                             int strict);

Parse an External ID or a Public ID

NOTE: Productions [75] and [83] interract 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

xmlParseComment()

xmlNodePtr  xmlParseComment                 (xmlParserCtxtPtr ctxt,
                                             int create);

Skip an XML (SGML) comment <!-- .... --> This may or may not create a node (depending on the context) The spec says that "For compatibility, the string "--" (double-hyphen) must not occur within comments. "

[15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'

TODO: this should call a SAX function which will handle (or not) the creation of the comment !

xmlParsePITarget()

CHAR*       xmlParsePITarget                (xmlParserCtxtPtr ctxt);

parse the name of a PI

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

xmlParsePI()

void        xmlParsePI                      (xmlParserCtxtPtr ctxt);

parse an XML Processing Instruction.

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

The processing is transfered to SAX once parsed.

xmlParseNotationDecl()

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

xmlParseEntityDecl()

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

xmlParseDefaultDecl()

int         xmlParseDefaultDecl             (xmlParserCtxtPtr ctxt,
                                             CHAR **value);

Parse an attribute default declaration

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

xmlParseNotationType()

xmlEnumerationPtr xmlParseNotationType      (xmlParserCtxtPtr ctxt);

parse an Notation attribute type.

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

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

xmlParseEnumerationType()

xmlEnumerationPtr xmlParseEnumerationType   (xmlParserCtxtPtr ctxt);

parse an Enumeration attribute type.

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

xmlParseEnumeratedType()

int         xmlParseEnumeratedType          (xmlParserCtxtPtr ctxt,
                                             xmlEnumerationPtr *tree);

parse an Enumerated attribute type.

[57] EnumeratedType ::= NotationType | Enumeration

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

xmlParseAttributeType()

int         xmlParseAttributeType           (xmlParserCtxtPtr ctxt,
                                             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'

xmlParseAttributeListDecl()

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

xmlParseElementMixedContentDecl()

xmlElementContentPtr xmlParseElementMixedContentDecl
                                            (xmlParserCtxtPtr ctxt);

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? ')'

xmlParseElementChildrenContentDecl()

xmlElementContentPtr xmlParseElementChildrenContentDecl
                                            (xmlParserCtxtPtr ctxt);

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? ')'

xmlParseElementContentDecl()

int         xmlParseElementContentDecl      (xmlParserCtxtPtr ctxt,
                                             CHAR *name,
                                             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

xmlParseElementDecl()

int         xmlParseElementDecl             (xmlParserCtxtPtr ctxt);

parse an Element declaration.

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

TODO There is a check [ VC: Unique Element Type Declaration ]

xmlParseMarkupDecl()

void        xmlParseMarkupDecl              (xmlParserCtxtPtr ctxt);

parse Markup declarations

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

TODO There is a check [ VC: Proper Declaration/PE Nesting ]

xmlParseCharRef()

CHAR*       xmlParseCharRef                 (xmlParserCtxtPtr ctxt);

parse Reference declarations

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

xmlParseEntityRef()

CHAR*       xmlParseEntityRef               (xmlParserCtxtPtr ctxt);

parse ENTITY references declarations

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

xmlParseReference()

CHAR*       xmlParseReference               (xmlParserCtxtPtr ctxt);

parse Reference declarations

[67] Reference ::= EntityRef | CharRef

xmlParsePEReference()

CHAR*       xmlParsePEReference             (xmlParserCtxtPtr ctxt);

parse PEReference declarations

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

xmlParseDocTypeDecl()

void        xmlParseDocTypeDecl             (xmlParserCtxtPtr ctxt);

parse a DOCTYPE declaration

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

xmlParseAttribute()

xmlAttrPtr  xmlParseAttribute               (xmlParserCtxtPtr ctxt,
                                             xmlNodePtr node);

parse an attribute

[41] Attribute ::= Name Eq AttValue

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

With namespace:

[NS 11] Attribute ::= QName Eq AttValue

Also the case QName == xmlns:??? is handled independently as a namespace definition.

xmlParseStartTag()

xmlNodePtr  xmlParseStartTag                (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? '>'

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

With namespace:

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

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

xmlParseEndTag()

void        xmlParseEndTag                  (xmlParserCtxtPtr ctxt,
                                             xmlNsPtr *nsPtr,
                                             CHAR **tagPtr);

parse an end of tag

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

With namespace

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

tagPtr receive the tag name just read

xmlParseCDSect()

void        xmlParseCDSect                  (xmlParserCtxtPtr ctxt);

Parse escaped pure raw content.

[18] CDSect ::= CDStart CData CDEnd

[19] CDStart ::= '<![CDATA['

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

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

xmlParseContent()

void        xmlParseContent                 (xmlParserCtxtPtr ctxt);

Parse a content:

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

xmlParseElement()

xmlNodePtr  xmlParseElement                 (xmlParserCtxtPtr ctxt);

parse an XML element, this is highly recursive

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

[41] Attribute ::= Name Eq AttValue

xmlParseVersionNum()

CHAR*       xmlParseVersionNum              (xmlParserCtxtPtr ctxt);

parse the XML version value.

[26] VersionNum ::= ([a-zA-Z0-9_.:] | '-')+

xmlParseVersionInfo()

CHAR*       xmlParseVersionInfo             (xmlParserCtxtPtr ctxt);

parse the XML version.

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

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

xmlParseEncName()

CHAR*       xmlParseEncName                 (xmlParserCtxtPtr ctxt);

parse the XML encoding name

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

xmlParseEncodingDecl()

CHAR*       xmlParseEncodingDecl            (xmlParserCtxtPtr ctxt);

parse the XML encoding declaration

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

TODO: this should setup the conversion filters.

xmlParseSDDecl()

int         xmlParseSDDecl                  (xmlParserCtxtPtr ctxt);

parse the XML standalone declaration

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

xmlParseXMLDecl()

void        xmlParseXMLDecl                 (xmlParserCtxtPtr ctxt);

parse an XML declaration header

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

xmlParseMisc()

void        xmlParseMisc                    (xmlParserCtxtPtr ctxt);

parse an XML Misc* optionnal field.

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