parserInternals

IS_CHAR()

#define     IS_CHAR(c)

IS_BLANK()

#define     IS_BLANK(c)

IS_BASECHAR()

#define     IS_BASECHAR(c)

IS_DIGIT()

#define     IS_DIGIT(c)

IS_COMBINING()

#define     IS_COMBINING(c)

IS_EXTENDER()

#define     IS_EXTENDER(c)

IS_IDEOGRAPHIC()

#define     IS_IDEOGRAPHIC(c)

IS_LETTER()

#define     IS_LETTER(c)

IS_PUBIDCHAR()

#define     IS_PUBIDCHAR(c)

SKIP_EOL()

#define     SKIP_EOL(p)

MOVETO_ENDTAG()

#define     MOVETO_ENDTAG(p)

MOVETO_STARTTAG()

#define     MOVETO_STARTTAG(p)

xmlCreateDocParserCtxt ()

xmlParserCtxtPtr xmlCreateDocParserCtxt     (CHAR *cur);

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

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->myDoc 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 an xmlEntityPtr

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.

xmlNewInputFromFile ()

xmlParserInputPtr xmlNewInputFromFile       (xmlParserCtxtPtr ctxt,
                                             const char *filename);

Create a new input stream based on a file.

xmlSplitQName ()

CHAR*       xmlSplitQName                   (const CHAR *name,
                                             CHAR **prefix);

parse an XML qualified name string

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

[NS 6] Prefix ::= NCName

[NS 7] LocalPart ::= NCName

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,
                                             CHAR **orig);

parse a value for ENTITY decl.

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

xmlParseAttValue ()

CHAR*       xmlParseAttValue                (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, unless it was asked for ctxt->replaceEntities != 0

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

void        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 - '-')))* '-->'

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

int         xmlParseCharRef                 (xmlParserCtxtPtr ctxt);

parse Reference declarations

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

xmlParseEntityRef ()

xmlEntityPtr xmlParseEntityRef              (xmlParserCtxtPtr ctxt);

parse ENTITY references declarations

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

xmlParseReference ()

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

xmlParsePEReference ()

void        xmlParsePEReference             (xmlParserCtxtPtr ctxt);

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

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

CHAR*       xmlParseAttribute               (xmlParserCtxtPtr ctxt,
                                             CHAR **value);

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

CHAR*       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,
                                             CHAR *tagname);

parse an end of tag

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

With namespace

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

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

void        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

XML_SUBSTITUTE_NONE

#define     XML_SUBSTITUTE_NONE

XML_SUBSTITUTE_REF

#define     XML_SUBSTITUTE_REF

XML_SUBSTITUTE_PEREF

#define     XML_SUBSTITUTE_PEREF

XML_SUBSTITUTE_BOTH

#define     XML_SUBSTITUTE_BOTH

xmlDecodeEntities ()

CHAR*       xmlDecodeEntities               (xmlParserCtxtPtr ctxt,
                                             int len,
                                             int what,
                                             CHAR end,
                                             CHAR end2,
                                             CHAR end3);

[67] Reference ::= EntityRef | CharRef

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

nodePush ()

int         nodePush                        (xmlParserCtxtPtr ctxt,
                                             xmlNodePtr value);

nodePop ()

xmlNodePtr  nodePop                         (xmlParserCtxtPtr ctxt);

inputPush ()

int         inputPush                       (xmlParserCtxtPtr ctxt,
                                             xmlParserInputPtr value);

inputPop ()

xmlParserInputPtr inputPop                  (xmlParserCtxtPtr ctxt);