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

# parser

## Name

parser —

## Synopsis

    #define     XML_DEFAULT_VERSION
    void        (*xmlParserInputDeallocate)     (xmlChar*);
    typedef     xmlParserInputPtr;
    xmlParserInputPtr (*xmlExternalEntityLoader)
                                                (const char *URL,
                                                 const char *ID,
                                                 xmlParserInputPtr context);
    typedef     xmlParserNodeInfo;
    typedef     xmlParserNodeInfoSeq;
    typedef     xmlParserNodeInfoSeqPtr;
    enum        xmlParserInputState;
    typedef     xmlParserCtxt;
    typedef     xmlParserCtxtPtr;
    typedef     xmlSAXLocator;
    typedef     xmlSAXLocatorPtr;
    xmlParserInputPtr (*resolveEntitySAXFunc)   (void *ctx,
                                                 const xmlChar *publicId,
                                                 const xmlChar *systemId);
    void        (*internalSubsetSAXFunc)        (void *ctx,
                                                 const xmlChar *name,
                                                 const xmlChar *ExternalID,
                                                 const xmlChar *SystemID);
    xmlEntityPtr (*getEntitySAXFunc)            (void *ctx,
                                                 const xmlChar *name);
    xmlEntityPtr (*getParameterEntitySAXFunc)   (void *ctx,
                                                 const xmlChar *name);
    void        (*entityDeclSAXFunc)            (void *ctx,
                                                 const xmlChar *name,
                                                 int type,
                                                 const xmlChar *publicId,
                                                 const xmlChar *systemId,
                                                 xmlChar *content);
    void        (*notationDeclSAXFunc)          (void *ctx,
                                                 const xmlChar *name,
                                                 const xmlChar *publicId,
                                                 const xmlChar *systemId);
    void        (*attributeDeclSAXFunc)         (void *ctx,
                                                 const xmlChar *elem,
                                                 const xmlChar *name,
                                                 int type,
                                                 int def,
                                                 const xmlChar *defaultValue,
                                                 xmlEnumerationPtr tree);
    void        (*elementDeclSAXFunc)           (void *ctx,
                                                 const xmlChar *name,
                                                 int type,
                                                 xmlElementContentPtr content);
    void        (*unparsedEntityDeclSAXFunc)    (void *ctx,
                                                 const xmlChar *name,
                                                 const xmlChar *publicId,
                                                 const xmlChar *systemId,
                                                 const xmlChar *notationName);
    void        (*setDocumentLocatorSAXFunc)    (void *ctx,
                                                 xmlSAXLocatorPtr loc);
    void        (*startDocumentSAXFunc)         (void *ctx);
    void        (*endDocumentSAXFunc)           (void *ctx);
    void        (*startElementSAXFunc)          (void *ctx,
                                                 const xmlChar *name,
                                                 const xmlChar **atts);
    void        (*endElementSAXFunc)            (void *ctx,
                                                 const xmlChar *name);
    void        (*attributeSAXFunc)             (void *ctx,
                                                 const xmlChar *name,
                                                 const xmlChar *value);
    void        (*referenceSAXFunc)             (void *ctx,
                                                 const xmlChar *name);
    void        (*charactersSAXFunc)            (void *ctx,
                                                 const xmlChar *ch,
                                                 int len);
    void        (*ignorableWhitespaceSAXFunc)   (void *ctx,
                                                 const xmlChar *ch,
                                                 int len);
    void        (*processingInstructionSAXFunc) (void *ctx,
                                                 const xmlChar *target,
                                                 const xmlChar *data);
    void        (*commentSAXFunc)               (void *ctx,
                                                 const xmlChar *value);
    void        (*cdataBlockSAXFunc)            (void *ctx,
                                                 const xmlChar *value,
                                                 int len);
    void        (*warningSAXFunc)               (void *ctx,
                                                 const char *msg,
                                                 ...);
    void        (*errorSAXFunc)                 (void *ctx,
                                                 const char *msg,
                                                 ...);
    void        (*fatalErrorSAXFunc)            (void *ctx,
                                                 const char *msg,
                                                 ...);
    int         (*isStandaloneSAXFunc)          (void *ctx);
    int         (*hasInternalSubsetSAXFunc)     (void *ctx);
    int         (*hasExternalSubsetSAXFunc)     (void *ctx);
    typedef     xmlSAXHandlerPtr;
    extern      const char *xmlParserVersion;
    extern      xmlSAXLocator xmlDefaultSAXLocator;
    extern      xmlSAXHandler xmlDefaultSAXHandler;
    extern      xmlSAXHandler htmlDefaultSAXHandler;
    extern      int xmlSubstituteEntitiesDefaultValue;
    void        xmlCleanupParser                (void);
    int         xmlParserInputRead              (xmlParserInputPtr in,
                                                 int len);
    int         xmlParserInputGrow              (xmlParserInputPtr in,
                                                 int len);
    xmlChar*    xmlStrdup                       (const xmlChar *cur);
    xmlChar*    xmlStrndup                      (const xmlChar *cur,
                                                 int len);
    xmlChar*    xmlStrsub                       (const xmlChar *str,
                                                 int start,
                                                 int len);
    const xmlChar* xmlStrchr                    (const xmlChar *str,
                                                 xmlChar val);
    const xmlChar* xmlStrstr                    (const xmlChar *str,
                                                 xmlChar *val);
    int         xmlStrcmp                       (const xmlChar *str1,
                                                 const xmlChar *str2);
    int         xmlStrncmp                      (const xmlChar *str1,
                                                 const xmlChar *str2,
                                                 int len);
    int         xmlStrlen                       (const xmlChar *str);
    xmlChar*    xmlStrcat                       (xmlChar *cur,
                                                 const xmlChar *add);
    xmlChar*    xmlStrncat                      (xmlChar *cur,
                                                 const xmlChar *add,
                                                 int len);
    xmlDocPtr   xmlParseDoc                     (xmlChar *cur);
    xmlDocPtr   xmlParseMemory                  (char *buffer,
                                                 int size);
    xmlDocPtr   xmlParseFile                    (const char *filename);
    int         xmlSubstituteEntitiesDefault    (int val);
    xmlDocPtr   xmlRecoverDoc                   (xmlChar *cur);
    xmlDocPtr   xmlRecoverMemory                (char *buffer,
                                                 int size);
    xmlDocPtr   xmlRecoverFile                  (const char *filename);
    int         xmlParseDocument                (xmlParserCtxtPtr ctxt);
    xmlDocPtr   xmlSAXParseDoc                  (xmlSAXHandlerPtr sax,
                                                 xmlChar *cur,
                                                 int recovery);
    int         xmlSAXUserParseFile             (xmlSAXHandlerPtr sax,
                                                 void *user_data,
                                                 const char *filename);
    int         xmlSAXUserParseMemory           (xmlSAXHandlerPtr sax,
                                                 void *user_data,
                                                 char *buffer,
                                                 int size);
    xmlDocPtr   xmlSAXParseMemory               (xmlSAXHandlerPtr sax,
                                                 char *buffer,
                                                 int size,
                                                 int recovery);
    xmlDocPtr   xmlSAXParseFile                 (xmlSAXHandlerPtr sax,
                                                 const char *filename,
                                                 int recovery);
    xmlDtdPtr   xmlParseDTD                     (const xmlChar *ExternalID,
                                                 const xmlChar *SystemID);
    xmlDtdPtr   xmlSAXParseDTD                  (xmlSAXHandlerPtr sax,
                                                 const xmlChar *ExternalID,
                                                 const xmlChar *SystemID);
    void        xmlInitParserCtxt               (xmlParserCtxtPtr ctxt);
    void        xmlClearParserCtxt              (xmlParserCtxtPtr ctxt);
    void        xmlSetupParserForBuffer         (xmlParserCtxtPtr ctxt,
                                                 const xmlChar *buffer,
                                                 const char *filename);
    void        xmlDefaultSAXHandlerInit        (void);
    void        htmlDefaultSAXHandlerInit       (void);
    const xmlParserNodeInfo* xmlParserFindNodeInfo
                                                (const xmlParserCtxt *ctxt,
                                                 const xmlNode *node);
    void        xmlInitNodeInfoSeq              (xmlParserNodeInfoSeqPtr seq);
    void        xmlClearNodeInfoSeq             (xmlParserNodeInfoSeqPtr seq);
    unsigned long xmlParserFindNodeInfoIndex    (const xmlParserNodeInfoSeq *seq,
                                                 const xmlNode *node);
    void        xmlParserAddNodeInfo            (xmlParserCtxtPtr ctxt,
                                                 const xmlParserNodeInfo *info);
    void        xmlSetExternalEntityLoader      (xmlExternalEntityLoader f);
    xmlExternalEntityLoader xmlGetExternalEntityLoader
                                                (void);
    xmlParserInputPtr xmlLoadExternalEntity     (const char *URL,
                                                 const char *ID,
                                                 xmlParserInputPtr context);

## Description

## Details

### XML_DEFAULT_VERSION

    #define     XML_DEFAULT_VERSION

### xmlParserInputDeallocate ()

    void        (*xmlParserInputDeallocate)     (xmlChar*);

`Param1` : |

### xmlParserInputPtr

### xmlExternalEntityLoader ()

    xmlParserInputPtr (*xmlExternalEntityLoader)
                                                (const char *URL,
                                                 const char *ID,
                                                 xmlParserInputPtr context);

`URL` : |
`ID` : |
`context` : |
Returns : |

### xmlParserNodeInfo

### xmlParserNodeInfoSeq

### xmlParserNodeInfoSeqPtr

### enum xmlParserInputState

    typedef enum {
        XML_PARSER_EOF = 0,
        XML_PARSER_PROLOG,
        XML_PARSER_CONTENT,
        XML_PARSER_ENTITY_DECL,
        XML_PARSER_ENTITY_VALUE,
        XML_PARSER_ATTRIBUTE_VALUE,
        XML_PARSER_DTD,
        XML_PARSER_EPILOG,
        XML_PARSER_COMMENT,
        XML_PARSER_CDATA_SECTION
    } xmlParserInputState;

### xmlParserCtxt

### xmlParserCtxtPtr

### xmlSAXLocator

### xmlSAXLocatorPtr

### resolveEntitySAXFunc ()

    xmlParserInputPtr (*resolveEntitySAXFunc)   (void *ctx,
                                                 const xmlChar *publicId,
                                                 const xmlChar *systemId);

`ctx` : |
`publicId` : |
`systemId` : |
Returns : |

### internalSubsetSAXFunc ()

    void        (*internalSubsetSAXFunc)        (void *ctx,
                                                 const xmlChar *name,
                                                 const xmlChar *ExternalID,
                                                 const xmlChar *SystemID);

`ctx` : |
`name` : |
`ExternalID` : |
`SystemID` : |

### getEntitySAXFunc ()

    xmlEntityPtr (*getEntitySAXFunc)            (void *ctx,
                                                 const xmlChar *name);

`ctx` : |
`name` : |
Returns : |

### getParameterEntitySAXFunc ()

    xmlEntityPtr (*getParameterEntitySAXFunc)   (void *ctx,
                                                 const xmlChar *name);

`ctx` : |
`name` : |
Returns : |

### entityDeclSAXFunc ()

    void        (*entityDeclSAXFunc)            (void *ctx,
                                                 const xmlChar *name,
                                                 int type,
                                                 const xmlChar *publicId,
                                                 const xmlChar *systemId,
                                                 xmlChar *content);

`ctx` : |
`name` : |
`type` : |
`publicId` : |
`systemId` : |
`content` : |

### notationDeclSAXFunc ()

    void        (*notationDeclSAXFunc)          (void *ctx,
                                                 const xmlChar *name,
                                                 const xmlChar *publicId,
                                                 const xmlChar *systemId);

`ctx` : |
`name` : |
`publicId` : |
`systemId` : |

### attributeDeclSAXFunc ()

    void        (*attributeDeclSAXFunc)         (void *ctx,
                                                 const xmlChar *elem,
                                                 const xmlChar *name,
                                                 int type,
                                                 int def,
                                                 const xmlChar *defaultValue,
                                                 xmlEnumerationPtr tree);

`ctx` : |
`elem` : |
`name` : |
`type` : |
`def` : |
`defaultValue` : |
`tree` : |

### elementDeclSAXFunc ()

    void        (*elementDeclSAXFunc)           (void *ctx,
                                                 const xmlChar *name,
                                                 int type,
                                                 xmlElementContentPtr content);

`ctx` : |
`name` : |
`type` : |
`content` : |

### unparsedEntityDeclSAXFunc ()

    void        (*unparsedEntityDeclSAXFunc)    (void *ctx,
                                                 const xmlChar *name,
                                                 const xmlChar *publicId,
                                                 const xmlChar *systemId,
                                                 const xmlChar *notationName);

`ctx` : |
`name` : |
`publicId` : |
`systemId` : |
`notationName` : |

### setDocumentLocatorSAXFunc ()

    void        (*setDocumentLocatorSAXFunc)    (void *ctx,
                                                 xmlSAXLocatorPtr loc);

`ctx` : |
`loc` : |

### startDocumentSAXFunc ()

    void        (*startDocumentSAXFunc)         (void *ctx);

`ctx` : |

### endDocumentSAXFunc ()

    void        (*endDocumentSAXFunc)           (void *ctx);

`ctx` : |

### startElementSAXFunc ()

    void        (*startElementSAXFunc)          (void *ctx,
                                                 const xmlChar *name,
                                                 const xmlChar **atts);

`ctx` : |
`name` : |
`atts` : |

### endElementSAXFunc ()

    void        (*endElementSAXFunc)            (void *ctx,
                                                 const xmlChar *name);

`ctx` : |
`name` : |

### attributeSAXFunc ()

    void        (*attributeSAXFunc)             (void *ctx,
                                                 const xmlChar *name,
                                                 const xmlChar *value);

`ctx` : |
`name` : |
`value` : |

### referenceSAXFunc ()

    void        (*referenceSAXFunc)             (void *ctx,
                                                 const xmlChar *name);

`ctx` : |
`name` : |

### charactersSAXFunc ()

    void        (*charactersSAXFunc)            (void *ctx,
                                                 const xmlChar *ch,
                                                 int len);

`ctx` : |
`ch` : |
`len` : |

### ignorableWhitespaceSAXFunc ()

    void        (*ignorableWhitespaceSAXFunc)   (void *ctx,
                                                 const xmlChar *ch,
                                                 int len);

`ctx` : |
`ch` : |
`len` : |

### processingInstructionSAXFunc ()

    void        (*processingInstructionSAXFunc) (void *ctx,
                                                 const xmlChar *target,
                                                 const xmlChar *data);

`ctx` : |
`target` : |
`data` : |

### commentSAXFunc ()

    void        (*commentSAXFunc)               (void *ctx,
                                                 const xmlChar *value);

`ctx` : |
`value` : |

### cdataBlockSAXFunc ()

    void        (*cdataBlockSAXFunc)            (void *ctx,
                                                 const xmlChar *value,
                                                 int len);

`ctx` : |
`value` : |
`len` : |

### warningSAXFunc ()

    void        (*warningSAXFunc)               (void *ctx,
                                                 const char *msg,
                                                 ...);

`ctx` : |
`msg` : |
`...` : |

### errorSAXFunc ()

    void        (*errorSAXFunc)                 (void *ctx,
                                                 const char *msg,
                                                 ...);

`ctx` : |
`msg` : |
`...` : |

### fatalErrorSAXFunc ()

    void        (*fatalErrorSAXFunc)            (void *ctx,
                                                 const char *msg,
                                                 ...);

`ctx` : |
`msg` : |
`...` : |

### isStandaloneSAXFunc ()

    int         (*isStandaloneSAXFunc)          (void *ctx);

`ctx` : |
Returns : |

### hasInternalSubsetSAXFunc ()

    int         (*hasInternalSubsetSAXFunc)     (void *ctx);

`ctx` : |
Returns : |

### hasExternalSubsetSAXFunc ()

    int         (*hasExternalSubsetSAXFunc)     (void *ctx);

`ctx` : |
Returns : |

### xmlSAXHandlerPtr

### xmlParserVersion

    extern const char *xmlParserVersion;

### xmlDefaultSAXLocator

    extern xmlSAXLocator xmlDefaultSAXLocator;

### xmlDefaultSAXHandler

    extern xmlSAXHandler xmlDefaultSAXHandler;

### htmlDefaultSAXHandler

    extern xmlSAXHandler htmlDefaultSAXHandler;

### xmlSubstituteEntitiesDefaultValue

    extern int xmlSubstituteEntitiesDefaultValue;

### xmlCleanupParser ()

    void        xmlCleanupParser                (void);

Cleanup function for the XML parser. It tries to reclaim all parsing related global memory allocated for the parser processing. It doesn't deallocate any document related memory. Calling this function should not prevent reusing the parser.

### xmlParserInputRead ()

    int         xmlParserInputRead              (xmlParserInputPtr in,
                                                 int len);

This function refresh the input for the parser. It doesn't try to preserve pointers to the input buffer, and discard already read data

`in` : |
`len` : |
Returns : |

### xmlParserInputGrow ()

    int         xmlParserInputGrow              (xmlParserInputPtr in,
                                                 int len);

This function increase the input for the parser. It tries to preserve pointers to the input buffer, and keep already read data

`in` : |
`len` : |
Returns : |

### xmlStrdup ()

    xmlChar*    xmlStrdup                       (const xmlChar *cur);

a strdup for array of xmlChar's

`cur` : |
Returns : |

### xmlStrndup ()

    xmlChar*    xmlStrndup                      (const xmlChar *cur,
                                                 int len);

a strndup for array of xmlChar's

`cur` : |
`len` : |
Returns : |

### xmlStrsub ()

    xmlChar*    xmlStrsub                       (const xmlChar *str,
                                                 int start,
                                                 int len);

Extract a substring of a given string

`str` : |
`start` : |
`len` : |
Returns : |

### xmlStrchr ()

    const xmlChar* xmlStrchr                    (const xmlChar *str,
                                                 xmlChar val);

a strchr for xmlChar's

`str` : |
`val` : |
Returns : |

### xmlStrstr ()

    const xmlChar* xmlStrstr                    (const xmlChar *str,
                                                 xmlChar *val);

a strstr for xmlChar's

`str` : |
`val` : |
Returns : |

### xmlStrcmp ()

    int         xmlStrcmp                       (const xmlChar *str1,
                                                 const xmlChar *str2);

a strcmp for xmlChar's

`str1` : |
`str2` : |
Returns : |

### xmlStrncmp ()

    int         xmlStrncmp                      (const xmlChar *str1,
                                                 const xmlChar *str2,
                                                 int len);

a strncmp for xmlChar's

`str1` : |
`str2` : |
`len` : |
Returns : |

### xmlStrlen ()

    int         xmlStrlen                       (const xmlChar *str);

length of a xmlChar's string

`str` : |
Returns : |

### xmlStrcat ()

    xmlChar*    xmlStrcat                       (xmlChar *cur,
                                                 const xmlChar *add);

a strcat for array of xmlChar's

`cur` : |
`add` : |
Returns : |

### xmlStrncat ()

    xmlChar*    xmlStrncat                      (xmlChar *cur,
                                                 const xmlChar *add,
                                                 int len);

a strncat for array of xmlChar's

`cur` : |
`add` : |
`len` : |
Returns : |

### xmlParseDoc ()

    xmlDocPtr   xmlParseDoc                     (xmlChar *cur);

parse an XML in-memory document and build a tree.

`cur` : |
Returns : |

### xmlParseMemory ()

    xmlDocPtr   xmlParseMemory                  (char *buffer,
                                                 int size);

parse an XML in-memory block and build a tree.

`buffer` : |
`size` : |
Returns : |

### xmlParseFile ()

    xmlDocPtr   xmlParseFile                    (const char *filename);

parse an XML file and build a tree. Automatic support for ZLIB/Compress compressed document is provided by default if found at compile-time.

`filename` : |
Returns : |

### xmlSubstituteEntitiesDefault ()

    int         xmlSubstituteEntitiesDefault    (int val);

Set and return the previous value for default entity support. Initially the parser always keep entity references instead of substituting entity values in the output. This function has to be used to change the default parser behaviour SAX::subtituteEntities() has to be used for changing that on a file by file basis.

`val` : |
Returns : |

### xmlRecoverDoc ()

    xmlDocPtr   xmlRecoverDoc                   (xmlChar *cur);

parse an XML in-memory document and build a tree. In the case the document is not Well Formed, a tree is built anyway

`cur` : |
Returns : |

### xmlRecoverMemory ()

    xmlDocPtr   xmlRecoverMemory                (char *buffer,
                                                 int size);

parse an XML in-memory block and build a tree. In the case the document is not Well Formed, a tree is built anyway

`buffer` : |
`size` : |
Returns : |

### xmlRecoverFile ()

    xmlDocPtr   xmlRecoverFile                  (const char *filename);

parse an XML file and build a tree. Automatic support for ZLIB/Compress compressed document is provided by default if found at compile-time. In the case the document is not Well Formed, a tree is built anyway

`filename` : |
Returns : |

### xmlParseDocument ()

    int         xmlParseDocument                (xmlParserCtxtPtr ctxt);

parse an XML document (and build a tree if using the standard SAX interface).

[1] document ::= prolog element Misc*

[22] prolog ::= XMLDecl? Misc* (doctypedecl Misc*)?

`ctxt` : |
Returns : |

### xmlSAXParseDoc ()

    xmlDocPtr   xmlSAXParseDoc                  (xmlSAXHandlerPtr sax,
                                                 xmlChar *cur,
                                                 int recovery);

parse an XML in-memory document and build a tree. It use the given SAX function block to handle the parsing callback. If sax is NULL, fallback to the default DOM tree building routines.

`sax` : |
`cur` : |
`recovery` : |
Returns : |

### xmlSAXUserParseFile ()

    int         xmlSAXUserParseFile             (xmlSAXHandlerPtr sax,
                                                 void *user_data,
                                                 const char *filename);

parse an XML file and call the given SAX handler routines. Automatic support for ZLIB/Compress compressed document is provided

`sax` : |
`user_data` : |
`filename` : |
Returns : |

### xmlSAXUserParseMemory ()

    int         xmlSAXUserParseMemory           (xmlSAXHandlerPtr sax,
                                                 void *user_data,
                                                 char *buffer,
                                                 int size);

A better SAX parsing routine. parse an XML in-memory buffer and call the given SAX handler routines.

`sax` : |
`user_data` : |
`buffer` : |
`size` : |
Returns : |

### xmlSAXParseMemory ()

    xmlDocPtr   xmlSAXParseMemory               (xmlSAXHandlerPtr sax,
                                                 char *buffer,
                                                 int size,
                                                 int recovery);

parse an XML in-memory block and use the given SAX function block to handle the parsing callback. If sax is NULL, fallback to the default DOM tree building routines.

`sax` : |
`buffer` : |
`size` : |
`recovery` : |
Returns : |

### xmlSAXParseFile ()

    xmlDocPtr   xmlSAXParseFile                 (xmlSAXHandlerPtr sax,
                                                 const char *filename,
                                                 int recovery);

parse an XML file and build a tree. Automatic support for ZLIB/Compress compressed document is provided by default if found at compile-time. It use the given SAX function block to handle the parsing callback. If sax is NULL, fallback to the default DOM tree building routines.

`sax` : |
`filename` : |
`recovery` : |
Returns : |

### xmlParseDTD ()

    xmlDtdPtr   xmlParseDTD                     (const xmlChar *ExternalID,
                                                 const xmlChar *SystemID);

Load and parse an external subset.

`ExternalID` : |
`SystemID` : |
Returns : |

### xmlSAXParseDTD ()

    xmlDtdPtr   xmlSAXParseDTD                  (xmlSAXHandlerPtr sax,
                                                 const xmlChar *ExternalID,
                                                 const xmlChar *SystemID);

Load and parse an external subset.

`sax` : |
`ExternalID` : |
`SystemID` : |
Returns : |

### xmlInitParserCtxt ()

    void        xmlInitParserCtxt               (xmlParserCtxtPtr ctxt);

Initialize a parser context

`ctxt` : |

### xmlClearParserCtxt ()

    void        xmlClearParserCtxt              (xmlParserCtxtPtr ctxt);

Clear (release owned resources) and reinitialize a parser context

`ctxt` : |

### xmlSetupParserForBuffer ()

    void        xmlSetupParserForBuffer         (xmlParserCtxtPtr ctxt,
                                                 const xmlChar *buffer,
                                                 const char *filename);

Setup the parser context to parse a new buffer; Clears any prior contents from the parser context. The buffer parameter must not be NULL, but the filename parameter can be

`ctxt` : |
`buffer` : |
`filename` : |

### xmlDefaultSAXHandlerInit ()

    void        xmlDefaultSAXHandlerInit        (void);

Initialize the default SAX handler

### htmlDefaultSAXHandlerInit ()

    void        htmlDefaultSAXHandlerInit       (void);

Initialize the default SAX handler

### xmlParserFindNodeInfo ()

    const xmlParserNodeInfo* xmlParserFindNodeInfo
                                                (const xmlParserCtxt *ctxt,
                                                 const xmlNode *node);

Find the parser node info struct for a given node

`ctxt` : |
`node` : |
Returns : |

### xmlInitNodeInfoSeq ()

    void        xmlInitNodeInfoSeq              (xmlParserNodeInfoSeqPtr seq);

-- Initialize (set to initial state) node info sequence

`seq` : |

### xmlClearNodeInfoSeq ()

    void        xmlClearNodeInfoSeq             (xmlParserNodeInfoSeqPtr seq);

-- Clear (release memory and reinitialize) node info sequence

`seq` : |

### xmlParserFindNodeInfoIndex ()

    unsigned long xmlParserFindNodeInfoIndex    (const xmlParserNodeInfoSeq *seq,
                                                 const xmlNode *node);

xmlParserFindNodeInfoIndex : Find the index that the info record for the given node is or should be at in a sorted sequence

`seq` : |
`node` : |
Returns : |

### xmlParserAddNodeInfo ()

    void        xmlParserAddNodeInfo            (xmlParserCtxtPtr ctxt,
                                                 const xmlParserNodeInfo *info);

Insert node info record into the sorted sequence

`ctxt` : |
`info` : |

### xmlSetExternalEntityLoader ()

    void        xmlSetExternalEntityLoader      (xmlExternalEntityLoader f);

`f` : |

### xmlGetExternalEntityLoader ()

    xmlExternalEntityLoader xmlGetExternalEntityLoader
                                                (void);

Returns : |

### xmlLoadExternalEntity ()

    xmlParserInputPtr xmlLoadExternalEntity     (const char *URL,
                                                 const char *ID,
                                                 xmlParserInputPtr context);

`URL` : |
`ID` : |
`context` : |
Returns : |

<<< Previous Page | Home | Up | Next Page >>>
Libxml Library Reference | SAX