Gnome XML Library Reference Manual
<<< Previous Page | Home | Up | Next Page >>>

# parserInternals

## Name

parserInternals —

## Synopsis

    #define     XML_MAX_NAMELEN
    typedef     CHARVAL;
    #define     NEXTCHARVAL                     (p)
    #define     SKIPCHARVAL                     (p)
    #define     IS_CHAR                         (c)
    #define     IS_BLANK                        (c)
    #define     IS_BASECHAR                     (c)
    #define     IS_DIGIT                        (c)
    #define     IS_COMBINING                    (c)
    #define     IS_EXTENDER                     (c)
    #define     IS_IDEOGRAPHIC                  (c)
    #define     IS_LETTER                       (c)
    #define     IS_PUBIDCHAR                    (c)
    #define     SKIP_EOL                        (p)
    #define     MOVETO_ENDTAG                   (p)
    #define     MOVETO_STARTTAG                 (p)
    xmlParserCtxtPtr xmlCreateDocParserCtxt     (xmlChar *cur);
    xmlParserCtxtPtr xmlCreateFileParserCtxt    (const char *filename);
    xmlParserCtxtPtr xmlCreateMemoryParserCtxt  (char *buffer,
                                                 int size);
    void        xmlFreeParserCtxt               (xmlParserCtxtPtr ctxt);
    xmlParserCtxtPtr xmlNewParserCtxt           (void);
    void        xmlSwitchEncoding               (xmlParserCtxtPtr ctxt,
                                                 xmlCharEncoding enc);
    void        xmlHandleEntity                 (xmlParserCtxtPtr ctxt,
                                                 xmlEntityPtr entity);
    xmlParserInputPtr xmlNewEntityInputStream   (xmlParserCtxtPtr ctxt,
                                                 xmlEntityPtr entity);
    void        xmlPushInput                    (xmlParserCtxtPtr ctxt,
                                                 xmlParserInputPtr input);
    xmlChar     xmlPopInput                     (xmlParserCtxtPtr ctxt);
    void        xmlFreeInputStream              (xmlParserInputPtr input);
    xmlParserInputPtr xmlNewInputFromFile       (xmlParserCtxtPtr ctxt,
                                                 const char *filename);
    xmlChar*    xmlSplitQName                   (const xmlChar *name,
                                                 xmlChar **prefix);
    xmlChar*    xmlNamespaceParseNCName         (xmlParserCtxtPtr ctxt);
    xmlChar*    xmlNamespaceParseQName          (xmlParserCtxtPtr ctxt,
                                                 xmlChar **prefix);
    xmlChar*    xmlNamespaceParseNSDef          (xmlParserCtxtPtr ctxt);
    xmlChar*    xmlParseQuotedString            (xmlParserCtxtPtr ctxt);
    void        xmlParseNamespace               (xmlParserCtxtPtr ctxt);
    xmlChar*    xmlScanName                     (xmlParserCtxtPtr ctxt);
    xmlChar*    xmlParseName                    (xmlParserCtxtPtr ctxt);
    xmlChar*    xmlParseNmtoken                 (xmlParserCtxtPtr ctxt);
    xmlChar*    xmlParseEntityValue             (xmlParserCtxtPtr ctxt,
                                                 xmlChar **orig);
    xmlChar*    xmlParseAttValue                (xmlParserCtxtPtr ctxt);
    xmlChar*    xmlParseSystemLiteral           (xmlParserCtxtPtr ctxt);
    xmlChar*    xmlParsePubidLiteral            (xmlParserCtxtPtr ctxt);
    void        xmlParseCharData                (xmlParserCtxtPtr ctxt,
                                                 int cdata);
    xmlChar*    xmlParseExternalID              (xmlParserCtxtPtr ctxt,
                                                 xmlChar **publicID,
                                                 int strict);
    void        xmlParseComment                 (xmlParserCtxtPtr ctxt);
    xmlChar*    xmlParsePITarget                (xmlParserCtxtPtr ctxt);
    void        xmlParsePI                      (xmlParserCtxtPtr ctxt);
    void        xmlParseNotationDecl            (xmlParserCtxtPtr ctxt);
    void        xmlParseEntityDecl              (xmlParserCtxtPtr ctxt);
    int         xmlParseDefaultDecl             (xmlParserCtxtPtr ctxt,
                                                 xmlChar **value);
    xmlEnumerationPtr xmlParseNotationType      (xmlParserCtxtPtr ctxt);
    xmlEnumerationPtr xmlParseEnumerationType   (xmlParserCtxtPtr ctxt);
    int         xmlParseEnumeratedType          (xmlParserCtxtPtr ctxt,
                                                 xmlEnumerationPtr *tree);
    int         xmlParseAttributeType           (xmlParserCtxtPtr ctxt,
                                                 xmlEnumerationPtr *tree);
    void        xmlParseAttributeListDecl       (xmlParserCtxtPtr ctxt);
    xmlElementContentPtr xmlParseElementMixedContentDecl
                                                (xmlParserCtxtPtr ctxt);
    xmlElementContentPtr xmlParseElementChildrenContentDecl
                                                (xmlParserCtxtPtr ctxt);
    int         xmlParseElementContentDecl      (xmlParserCtxtPtr ctxt,
                                                 xmlChar *name,
                                                 xmlElementContentPtr *result);
    int         xmlParseElementDecl             (xmlParserCtxtPtr ctxt);
    void        xmlParseMarkupDecl              (xmlParserCtxtPtr ctxt);
    int         xmlParseCharRef                 (xmlParserCtxtPtr ctxt);
    xmlEntityPtr xmlParseEntityRef              (xmlParserCtxtPtr ctxt);
    void        xmlParseReference               (xmlParserCtxtPtr ctxt);
    void        xmlParsePEReference             (xmlParserCtxtPtr ctxt);
    void        xmlParseDocTypeDecl             (xmlParserCtxtPtr ctxt);
    xmlChar*    xmlParseAttribute               (xmlParserCtxtPtr ctxt,
                                                 xmlChar **value);
    xmlChar*    xmlParseStartTag                (xmlParserCtxtPtr ctxt);
    void        xmlParseEndTag                  (xmlParserCtxtPtr ctxt);
    void        xmlParseCDSect                  (xmlParserCtxtPtr ctxt);
    void        xmlParseContent                 (xmlParserCtxtPtr ctxt);
    void        xmlParseElement                 (xmlParserCtxtPtr ctxt);
    xmlChar*    xmlParseVersionNum              (xmlParserCtxtPtr ctxt);
    xmlChar*    xmlParseVersionInfo             (xmlParserCtxtPtr ctxt);
    xmlChar*    xmlParseEncName                 (xmlParserCtxtPtr ctxt);
    xmlChar*    xmlParseEncodingDecl            (xmlParserCtxtPtr ctxt);
    int         xmlParseSDDecl                  (xmlParserCtxtPtr ctxt);
    void        xmlParseXMLDecl                 (xmlParserCtxtPtr ctxt);
    void        xmlParseMisc                    (xmlParserCtxtPtr ctxt);
    void        xmlParseExternalSubset          (xmlParserCtxtPtr ctxt,
                                                 const xmlChar *ExternalID,
                                                 const xmlChar *SystemID);
    #define     XML_SUBSTITUTE_NONE
    #define     XML_SUBSTITUTE_REF
    #define     XML_SUBSTITUTE_PEREF
    #define     XML_SUBSTITUTE_BOTH
    xmlChar*    xmlDecodeEntities               (xmlParserCtxtPtr ctxt,
                                                 int len,
                                                 int what,
                                                 xmlChar end,
                                                 xmlChar end2,
                                                 xmlChar end3);
    int         nodePush                        (xmlParserCtxtPtr ctxt,
                                                 xmlNodePtr value);
    xmlNodePtr  nodePop                         (xmlParserCtxtPtr ctxt);
    int         inputPush                       (xmlParserCtxtPtr ctxt,
                                                 xmlParserInputPtr value);
    xmlParserInputPtr inputPop                  (xmlParserCtxtPtr ctxt);

## Description

## Details

### XML_MAX_NAMELEN

    #define XML_MAX_NAMELEN 1000

### CHARVAL

### NEXTCHARVAL()

    #define     NEXTCHARVAL(p)

`p` : |

### SKIPCHARVAL()

    #define SKIPCHARVAL(p) (p)++;

`p` : |

### IS_CHAR()

    #define     IS_CHAR(c)

`c` : |

### IS_BLANK()

    #define     IS_BLANK(c)

`c` : |

### IS_BASECHAR()

    #define     IS_BASECHAR(c)

`c` : |

### IS_DIGIT()

    #define     IS_DIGIT(c)

`c` : |

### IS_COMBINING()

    #define     IS_COMBINING(c)

`c` : |

### IS_EXTENDER()

    #define     IS_EXTENDER(c)

`c` : |

### IS_IDEOGRAPHIC()

    #define     IS_IDEOGRAPHIC(c)

`c` : |

### IS_LETTER()

    #define     IS_LETTER(c)

`c` : |

### IS_PUBIDCHAR()

    #define     IS_PUBIDCHAR(c)

`c` : |

### SKIP_EOL()

    #define     SKIP_EOL(p)

`p` : |

### MOVETO_ENDTAG()

    #define     MOVETO_ENDTAG(p)

`p` : |

### MOVETO_STARTTAG()

    #define     MOVETO_STARTTAG(p)

`p` : |

### xmlCreateDocParserCtxt ()

    xmlParserCtxtPtr xmlCreateDocParserCtxt     (xmlChar *cur);

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

`cur` : |
Returns : |

### 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.

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

### xmlCreateMemoryParserCtxt ()

    xmlParserCtxtPtr xmlCreateMemoryParserCtxt  (char *buffer,
                                                 int size);

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

`buffer` : | an pointer to a zero terminated char array
`size` : | the size of the array (without the trailing 0)
Returns : | the new parser context or NULL

### xmlFreeParserCtxt ()

    void        xmlFreeParserCtxt               (xmlParserCtxtPtr ctxt);

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

`ctxt` : |

### xmlNewParserCtxt ()

    xmlParserCtxtPtr xmlNewParserCtxt           (void);

Allocate and initialize a new parser context.

Returns : | the xmlParserCtxtPtr or NULL

### xmlSwitchEncoding ()

    void        xmlSwitchEncoding               (xmlParserCtxtPtr ctxt,
                                                 xmlCharEncoding enc);

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

`ctxt` : | the parser context
`enc` : | the encoding value (number)

### 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 ?

OBSOLETE: to be removed at some point.

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

### xmlNewEntityInputStream ()

    xmlParserInputPtr xmlNewEntityInputStream   (xmlParserCtxtPtr ctxt,
                                                 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

### xmlPushInput ()

    void        xmlPushInput                    (xmlParserCtxtPtr ctxt,
                                                 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 ...).

### xmlPopInput ()

    xmlChar     xmlPopInput                     (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

### xmlFreeInputStream ()

    void        xmlFreeInputStream              (xmlParserInputPtr input);

Free up an input stream.

`input` : | an xmlParserInputPtr

### xmlNewInputFromFile ()

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

Create a new input stream based on a file.

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

### xmlSplitQName ()

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

parse an XML qualified name string

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

[NS 6] Prefix ::= NCName

[NS 7] LocalPart ::= NCName

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

### xmlNamespaceParseNCName ()

    xmlChar*    xmlNamespaceParseNCName         (xmlParserCtxtPtr ctxt);

parse an XML namespace name.

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

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

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

### xmlNamespaceParseQName ()

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

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.

### xmlNamespaceParseNSDef ()

    xmlChar*    xmlNamespaceParseNSDef          (xmlParserCtxtPtr ctxt);

parse a namespace prefix declaration

[NS 1] NSDef ::= PrefixDef Eq SystemLiteral

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

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

### xmlParseQuotedString ()

    xmlChar*    xmlParseQuotedString            (xmlParserCtxtPtr ctxt);

[OLD] Parse and return a string between quotes or doublequotes To be removed at next drop of binary compatibility

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

### 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 it was declared on the root of the Tree:-(

To be removed at next drop of binary compatibility

`ctxt` : | an XML parser context

### xmlScanName ()

    xmlChar*    xmlScanName                     (xmlParserCtxtPtr ctxt);

Trickery: parse an XML name but without consuming the input flow Needed for rollback cases.

[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

### xmlParseName ()

    xmlChar*    xmlParseName                    (xmlParserCtxtPtr ctxt);

parse an XML name.

[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

### xmlParseNmtoken ()

    xmlChar*    xmlParseNmtoken                 (xmlParserCtxtPtr ctxt);

parse an XML Nmtoken.

[7] Nmtoken ::= (NameChar)+

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

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

### xmlParseEntityValue ()

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

parse a value for ENTITY decl.

[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 substitued or NULL

### xmlParseAttValue ()

    xmlChar*    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

[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.

### xmlParseSystemLiteral ()

    xmlChar*    xmlParseSystemLiteral           (xmlParserCtxtPtr ctxt);

parse an XML Literal

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

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

### xmlParsePubidLiteral ()

    xmlChar*    xmlParsePubidLiteral            (xmlParserCtxtPtr ctxt);

parse an XML public literal

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

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

### 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 ::= [^<&]* - ([^<&]* ']]>' [^<&]*)

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

### xmlParseExternalID ()

    xmlChar*    xmlParseExternalID              (xmlParserCtxtPtr ctxt,
                                                 xmlChar **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

`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.

### xmlParseComment ()

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

### xmlParsePITarget ()

    xmlChar*    xmlParsePITarget                (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

### 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.

`ctxt` : | an XML parser context

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

`ctxt` : | an XML parser context

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

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

`ctxt` : | an XML parser context

### xmlParseDefaultDecl ()

    int         xmlParseDefaultDecl             (xmlParserCtxtPtr ctxt,
                                                 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.

### xmlParseNotationType ()

    xmlEnumerationPtr xmlParseNotationType      (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

### xmlParseEnumerationType ()

    xmlEnumerationPtr xmlParseEnumerationType   (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

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

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

### 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'

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

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

`ctxt` : | an XML parser context

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

[ 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
Returns : | the list of the xmlElementContentPtr describing the element choices

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

[ VC: Proper Group/PE Nesting ] applies to [49] and [50] TODO Parameter-entity replacement text must be properly nested with parenthetized 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
Returns : | the tree of xmlElementContentPtr describing the element hierarchy.

### xmlParseElementContentDecl ()

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

`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

### xmlParseElementDecl ()

    int         xmlParseElementDecl             (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

### xmlParseMarkupDecl ()

    void        xmlParseMarkupDecl              (xmlParserCtxtPtr ctxt);

parse Markup declarations

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

[ VC: Proper Declaration/PE Nesting ] TODO 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

### xmlParseCharRef ()

    int         xmlParseCharRef                 (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

### xmlParseEntityRef ()

    xmlEntityPtr xmlParseEntityRef              (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.

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

`ctxt` : | an XML parser context

### 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 ';'

[ WFC: No Recursion ] TODO 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

### xmlParseDocTypeDecl ()

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

### xmlParseAttribute ()

    xmlChar*    xmlParseAttribute               (xmlParserCtxtPtr ctxt,
                                                 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 "&lt;") 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.

### xmlParseStartTag ()

    xmlChar*    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? '>'

[ 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? '/>'

Returne the element name parsed

`ctxt` : | an XML parser context
Returns : |

### xmlParseEndTag ()

    void        xmlParseEndTag                  (xmlParserCtxtPtr ctxt);

parse an end of tag

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

With namespace

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

`ctxt` : | an XML parser context

### 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 ::= ']]>'

`ctxt` : | an XML parser context

### xmlParseContent ()

    void        xmlParseContent                 (xmlParserCtxtPtr ctxt);

Parse a content:

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

`ctxt` : | an XML parser context

### xmlParseElement ()

    void        xmlParseElement                 (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.

[ VC: Element Valid ] An element is valid if there is a declaration matching elementdecl where the Name matches the element type and one of the following holds: - The declaration matches EMPTY and the element has no content. - The declaration matches children and the sequence of child elements belongs to the language generated by the regular expression in the content model, with optional white space (characters matching the nonterminal S) between each pair of child elements. - The declaration matches Mixed and the content consists of character data and child elements whose types match names in the content model. - The declaration matches ANY, and the types of any child elements have been declared.

`ctxt` : | an XML parser context

### xmlParseVersionNum ()

    xmlChar*    xmlParseVersionNum              (xmlParserCtxtPtr ctxt);

parse the XML version value.

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

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

### xmlParseVersionInfo ()

    xmlChar*    xmlParseVersionInfo             (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"

### xmlParseEncName ()

    xmlChar*    xmlParseEncName                 (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

### xmlParseEncodingDecl ()

    xmlChar*    xmlParseEncodingDecl            (xmlParserCtxtPtr ctxt);

parse the XML encoding declaration

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

TODO: this should setup the conversion filters.

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

### xmlParseSDDecl ()

    int         xmlParseSDDecl                  (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, 0 otherwise

### xmlParseXMLDecl ()

    void        xmlParseXMLDecl                 (xmlParserCtxtPtr ctxt);

parse an XML declaration header

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

`ctxt` : | an XML parser context

### xmlParseMisc ()

    void        xmlParseMisc                    (xmlParserCtxtPtr ctxt);

parse an XML Misc* optionnal field.

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

`ctxt` : | an XML parser context

### xmlParseExternalSubset ()

    void        xmlParseExternalSubset          (xmlParserCtxtPtr ctxt,
                                                 const xmlChar *ExternalID,
                                                 const 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)

### XML_SUBSTITUTE_NONE

    #define XML_SUBSTITUTE_NONE	0

### XML_SUBSTITUTE_REF

    #define XML_SUBSTITUTE_REF	1

### XML_SUBSTITUTE_PEREF

    #define XML_SUBSTITUTE_PEREF	2

### XML_SUBSTITUTE_BOTH

    #define XML_SUBSTITUTE_BOTH 	3

### xmlDecodeEntities ()

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

[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 !

### nodePush ()

    int         nodePush                        (xmlParserCtxtPtr ctxt,
                                                 xmlNodePtr value);

`ctxt` : |
`value` : |
Returns : |

### nodePop ()

    xmlNodePtr  nodePop                         (xmlParserCtxtPtr ctxt);

`ctxt` : |
Returns : |

### inputPush ()

    int         inputPush                       (xmlParserCtxtPtr ctxt,
                                                 xmlParserInputPtr value);

`ctxt` : |
`value` : |
Returns : |

### inputPop ()

    xmlParserInputPtr inputPop                  (xmlParserCtxtPtr ctxt);

`ctxt` : |
Returns : |

<<< Previous Page | Home | Up | Next Page >>>
xmlIO | encoding