parser.h

/*

 * Summary: the core parser module

 * Description: Interfaces, constants and types related to the XML parser

 *

 * Copy: See Copyright for the status of this software.

 *

 * Author: Daniel Veillard

 */



#ifndef __XML_PARSER_H__

#define __XML_PARSER_H__



#include <stdarg.h>



#include <libxml/xmlversion.h>

#include <libxml/tree.h>

#include <libxml/dict.h>

#include <libxml/hash.h>

#include <libxml/valid.h>

#include <libxml/entities.h>

#include <libxml/xmlerror.h>

#include <libxml/xmlstring.h>



#ifdef __cplusplus

extern "C" {

#endif



#define XML_DEFAULT_VERSION     "1.0"



typedef void (* xmlParserInputDeallocate)(xmlChar *str);



struct _xmlParserInput {

    /* Input buffer */

    xmlParserInputBufferPtr buf;      /* UTF-8 encoded buffer */



    const char *filename;             /* The file analyzed, if any */

    const char *directory;            /* the directory/base of the file */

    const xmlChar *base;              /* Base of the array to parse */

    const xmlChar *cur;               /* Current char being parsed */

    const xmlChar *end;               /* end of the array to parse */

    int length;                       /* length if known */

    int line;                         /* Current line */

    int col;                          /* Current column */

    /*

     * NOTE: consumed is only tested for equality in the parser code,

     *       so even if there is an overflow this should not give troubles

     *       for parsing very large instances.

     */

    unsigned long consumed;           /* How many xmlChars already consumed */

    xmlParserInputDeallocate free;    /* function to deallocate the base */

    const xmlChar *encoding;          /* the encoding string for entity */

    const xmlChar *version;           /* the version string for entity */

    int standalone;                   /* Was that entity marked standalone */

    int id;                           /* an unique identifier for the entity */

};



typedef struct _xmlParserNodeInfo xmlParserNodeInfo;

typedef xmlParserNodeInfo *xmlParserNodeInfoPtr;



struct _xmlParserNodeInfo {

  const struct _xmlNode* node;

  /* Position & line # that text that created the node begins & ends on */

  unsigned long begin_pos;

  unsigned long begin_line;

  unsigned long end_pos;

  unsigned long end_line;

};



typedef struct _xmlParserNodeInfoSeq xmlParserNodeInfoSeq;

typedef xmlParserNodeInfoSeq *xmlParserNodeInfoSeqPtr;

struct _xmlParserNodeInfoSeq {

  unsigned long maximum;

  unsigned long length;

  xmlParserNodeInfo* buffer;

};



typedef enum {

    XML_PARSER_EOF = -1,        /* nothing is to be parsed */

    XML_PARSER_START = 0,       /* nothing has been parsed */

    XML_PARSER_MISC,            /* Misc* before int subset */

    XML_PARSER_PI,              /* Within a processing instruction */

    XML_PARSER_DTD,             /* within some DTD content */

    XML_PARSER_PROLOG,          /* Misc* after internal subset */

    XML_PARSER_COMMENT,         /* within a comment */

    XML_PARSER_START_TAG,       /* within a start tag */

    XML_PARSER_CONTENT,         /* within the content */

    XML_PARSER_CDATA_SECTION,   /* within a CDATA section */

    XML_PARSER_END_TAG,         /* within a closing tag */

    XML_PARSER_ENTITY_DECL,     /* within an entity declaration */

    XML_PARSER_ENTITY_VALUE,    /* within an entity value in a decl */

    XML_PARSER_ATTRIBUTE_VALUE, /* within an attribute value */

    XML_PARSER_SYSTEM_LITERAL,  /* within a SYSTEM value */

    XML_PARSER_EPILOG,          /* the Misc* after the last end tag */

    XML_PARSER_IGNORE,          /* within an IGNORED section */

    XML_PARSER_PUBLIC_LITERAL   /* within a PUBLIC value */

} xmlParserInputState;



#define XML_DETECT_IDS          2



#define XML_COMPLETE_ATTRS      4



#define XML_SKIP_IDS            8



typedef enum {

    XML_PARSE_UNKNOWN = 0,

    XML_PARSE_DOM = 1,

    XML_PARSE_SAX = 2,

    XML_PARSE_PUSH_DOM = 3,

    XML_PARSE_PUSH_SAX = 4,

    XML_PARSE_READER = 5

} xmlParserMode;



struct _xmlParserCtxt {

    struct _xmlSAXHandler *sax;       /* The SAX handler */

    void            *userData;        /* For SAX interface only, used by DOM build */

    xmlDocPtr           myDoc;        /* the document being built */

    int            wellFormed;        /* is the document well formed */

    int       replaceEntities;        /* shall we replace entities ? */

    const xmlChar    *version;        /* the XML version string */

    const xmlChar   *encoding;        /* the declared encoding, if any */

    int            standalone;        /* standalone document */

    int                  html;        /* an HTML(1)/Docbook(2) document */



    /* Input stream stack */

    xmlParserInputPtr  input;         /* Current input stream */

    int                inputNr;       /* Number of current input streams */

    int                inputMax;      /* Max number of input streams */

    xmlParserInputPtr *inputTab;      /* stack of inputs */



    /* Node analysis stack only used for DOM building */

    xmlNodePtr         node;          /* Current parsed Node */

    int                nodeNr;        /* Depth of the parsing stack */

    int                nodeMax;       /* Max depth of the parsing stack */

    xmlNodePtr        *nodeTab;       /* array of nodes */



    int record_info;                  /* Whether node info should be kept */

    xmlParserNodeInfoSeq node_seq;    /* info about each node parsed */



    int errNo;                        /* error code */



    int     hasExternalSubset;        /* reference and external subset */

    int             hasPErefs;        /* the internal subset has PE refs */

    int              external;        /* are we parsing an external entity */



    int                 valid;        /* is the document valid */

    int              validate;        /* shall we try to validate ? */

    xmlValidCtxt        vctxt;        /* The validity context */



    xmlParserInputState instate;      /* current type of input */

    int                 token;        /* next char look-ahead */    



    char           *directory;        /* the data directory */



    /* Node name stack */

    const xmlChar     *name;          /* Current parsed Node */

    int                nameNr;        /* Depth of the parsing stack */

    int                nameMax;       /* Max depth of the parsing stack */

    const xmlChar *   *nameTab;       /* array of nodes */



    long               nbChars;       /* number of xmlChar processed */

    long            checkIndex;       /* used by progressive parsing lookup */

    int             keepBlanks;       /* ugly but ... */

    int             disableSAX;       /* SAX callbacks are disabled */

    int               inSubset;       /* Parsing is in int 1/ext 2 subset */

    const xmlChar *    intSubName;    /* name of subset */

    xmlChar *          extSubURI;     /* URI of external subset */

    xmlChar *          extSubSystem;  /* SYSTEM ID of external subset */



    /* xml:space values */

    int *              space;         /* Should the parser preserve spaces */

    int                spaceNr;       /* Depth of the parsing stack */

    int                spaceMax;      /* Max depth of the parsing stack */

    int *              spaceTab;      /* array of space infos */



    int                depth;         /* to prevent entity substitution loops */

    xmlParserInputPtr  entity;        /* used to check entities boundaries */

    int                charset;       /* encoding of the in-memory content

                                         actually an xmlCharEncoding */

    int                nodelen;       /* Those two fields are there to */

    int                nodemem;       /* Speed up large node parsing */

    int                pedantic;      /* signal pedantic warnings */

    void              *_private;      /* For user data, libxml won't touch it */



    int                loadsubset;    /* should the external subset be loaded */

    int                linenumbers;   /* set line number in element content */

    void              *catalogs;      /* document's own catalog */

    int                recovery;      /* run in recovery mode */

    int                progressive;   /* is this a progressive parsing */

    xmlDictPtr         dict;          /* dictionnary for the parser */

    const xmlChar *   *atts;          /* array for the attributes callbacks */

    int                maxatts;       /* the size of the array */

    int                docdict;       /* use strings from dict to build tree */



    /*

     * pre-interned strings

     */

    const xmlChar *str_xml;

    const xmlChar *str_xmlns;

    const xmlChar *str_xml_ns;



    /*

     * Everything below is used only by the new SAX mode

     */

    int                sax2;          /* operating in the new SAX mode */

    int                nsNr;          /* the number of inherited namespaces */

    int                nsMax;         /* the size of the arrays */

    const xmlChar *   *nsTab;         /* the array of prefix/namespace name */

    int               *attallocs;     /* which attribute were allocated */

    void *            *pushTab;       /* array of data for push */

    xmlHashTablePtr    attsDefault;   /* defaulted attributes if any */

    xmlHashTablePtr    attsSpecial;   /* non-CDATA attributes if any */

    int                nsWellFormed;  /* is the document XML Nanespace okay */

    int                options;       /* Extra options */



    /*

     * Those fields are needed only for treaming parsing so far

     */

    int               dictNames;    /* Use dictionary names for the tree */

    int               freeElemsNr;  /* number of freed element nodes */

    xmlNodePtr        freeElems;    /* List of freed element nodes */

    int               freeAttrsNr;  /* number of freed attributes nodes */

    xmlAttrPtr        freeAttrs;    /* List of freed attributes nodes */



    /*

     * the complete error informations for the last error.

     */

    xmlError          lastError;

    xmlParserMode     parseMode;    /* the parser mode */

};



struct _xmlSAXLocator {

    const xmlChar *(*getPublicId)(void *ctx);

    const xmlChar *(*getSystemId)(void *ctx);

    int (*getLineNumber)(void *ctx);

    int (*getColumnNumber)(void *ctx);

};



typedef xmlParserInputPtr (*resolveEntitySAXFunc) (void *ctx,

                                const xmlChar *publicId,

                                const xmlChar *systemId);

typedef void (*internalSubsetSAXFunc) (void *ctx,

                                const xmlChar *name,

                                const xmlChar *ExternalID,

                                const xmlChar *SystemID);

typedef void (*externalSubsetSAXFunc) (void *ctx,

                                const xmlChar *name,

                                const xmlChar *ExternalID,

                                const xmlChar *SystemID);

typedef xmlEntityPtr (*getEntitySAXFunc) (void *ctx,

                                const xmlChar *name);

typedef xmlEntityPtr (*getParameterEntitySAXFunc) (void *ctx,

                                const xmlChar *name);

typedef void (*entityDeclSAXFunc) (void *ctx,

                                const xmlChar *name,

                                int type,

                                const xmlChar *publicId,

                                const xmlChar *systemId,

                                xmlChar *content);

typedef void (*notationDeclSAXFunc)(void *ctx,

                                const xmlChar *name,

                                const xmlChar *publicId,

                                const xmlChar *systemId);

typedef void (*attributeDeclSAXFunc)(void *ctx,

                                const xmlChar *elem,

                                const xmlChar *fullname,

                                int type,

                                int def,

                                const xmlChar *defaultValue,

                                xmlEnumerationPtr tree);

typedef void (*elementDeclSAXFunc)(void *ctx,

                                const xmlChar *name,

                                int type,

                                xmlElementContentPtr content);

typedef void (*unparsedEntityDeclSAXFunc)(void *ctx,

                                const xmlChar *name,

                                const xmlChar *publicId,

                                const xmlChar *systemId,

                                const xmlChar *notationName);

typedef void (*setDocumentLocatorSAXFunc) (void *ctx,

                                xmlSAXLocatorPtr loc);

typedef void (*startDocumentSAXFunc) (void *ctx);

typedef void (*endDocumentSAXFunc) (void *ctx);

typedef void (*startElementSAXFunc) (void *ctx,

                                const xmlChar *name,

                                const xmlChar **atts);

typedef void (*endElementSAXFunc) (void *ctx,

                                const xmlChar *name);

typedef void (*attributeSAXFunc) (void *ctx,

                                const xmlChar *name,

                                const xmlChar *value);

typedef void (*referenceSAXFunc) (void *ctx,

                                const xmlChar *name);

typedef void (*charactersSAXFunc) (void *ctx,

                                const xmlChar *ch,

                                int len);

typedef void (*ignorableWhitespaceSAXFunc) (void *ctx,

                                const xmlChar *ch,

                                int len);

typedef void (*processingInstructionSAXFunc) (void *ctx,

                                const xmlChar *target,

                                const xmlChar *data);

typedef void (*commentSAXFunc) (void *ctx,

                                const xmlChar *value);

typedef void (*cdataBlockSAXFunc) (

                                void *ctx,

                                const xmlChar *value,

                                int len);

typedef void (*warningSAXFunc) (void *ctx,

                                const char *msg, ...);

typedef void (*errorSAXFunc) (void *ctx,

                                const char *msg, ...);

typedef void (*fatalErrorSAXFunc) (void *ctx,

                                const char *msg, ...);

typedef int (*isStandaloneSAXFunc) (void *ctx);

typedef int (*hasInternalSubsetSAXFunc) (void *ctx);



typedef int (*hasExternalSubsetSAXFunc) (void *ctx);



/************************************************************************

 *                                                                      *

 *                      The SAX version 2 API extensions                *

 *                                                                      *

 ************************************************************************/

#define XML_SAX2_MAGIC 0xDEEDBEAF



typedef void (*startElementNsSAX2Func) (void *ctx,

                                        const xmlChar *localname,

                                        const xmlChar *prefix,

                                        const xmlChar *URI,

                                        int nb_namespaces,

                                        const xmlChar **namespaces,

                                        int nb_attributes,

                                        int nb_defaulted,

                                        const xmlChar **attributes);

 

typedef void (*endElementNsSAX2Func)   (void *ctx,

                                        const xmlChar *localname,

                                        const xmlChar *prefix,

                                        const xmlChar *URI);





struct _xmlSAXHandler {

    internalSubsetSAXFunc internalSubset;

    isStandaloneSAXFunc isStandalone;

    hasInternalSubsetSAXFunc hasInternalSubset;

    hasExternalSubsetSAXFunc hasExternalSubset;

    resolveEntitySAXFunc resolveEntity;

    getEntitySAXFunc getEntity;

    entityDeclSAXFunc entityDecl;

    notationDeclSAXFunc notationDecl;

    attributeDeclSAXFunc attributeDecl;

    elementDeclSAXFunc elementDecl;

    unparsedEntityDeclSAXFunc unparsedEntityDecl;

    setDocumentLocatorSAXFunc setDocumentLocator;

    startDocumentSAXFunc startDocument;

    endDocumentSAXFunc endDocument;

    startElementSAXFunc startElement;

    endElementSAXFunc endElement;

    referenceSAXFunc reference;

    charactersSAXFunc characters;

    ignorableWhitespaceSAXFunc ignorableWhitespace;

    processingInstructionSAXFunc processingInstruction;

    commentSAXFunc comment;

    warningSAXFunc warning;

    errorSAXFunc error;

    fatalErrorSAXFunc fatalError; /* unused error() get all the errors */

    getParameterEntitySAXFunc getParameterEntity;

    cdataBlockSAXFunc cdataBlock;

    externalSubsetSAXFunc externalSubset;

    unsigned int initialized;

    /* The following fields are extensions available only on version 2 */

    void *_private;

    startElementNsSAX2Func startElementNs;

    endElementNsSAX2Func endElementNs;

    xmlStructuredErrorFunc serror;

};



/*

 * SAX Version 1

 */

typedef struct _xmlSAXHandlerV1 xmlSAXHandlerV1;

typedef xmlSAXHandlerV1 *xmlSAXHandlerV1Ptr;

struct _xmlSAXHandlerV1 {

    internalSubsetSAXFunc internalSubset;

    isStandaloneSAXFunc isStandalone;

    hasInternalSubsetSAXFunc hasInternalSubset;

    hasExternalSubsetSAXFunc hasExternalSubset;

    resolveEntitySAXFunc resolveEntity;

    getEntitySAXFunc getEntity;

    entityDeclSAXFunc entityDecl;

    notationDeclSAXFunc notationDecl;

    attributeDeclSAXFunc attributeDecl;

    elementDeclSAXFunc elementDecl;

    unparsedEntityDeclSAXFunc unparsedEntityDecl;

    setDocumentLocatorSAXFunc setDocumentLocator;

    startDocumentSAXFunc startDocument;

    endDocumentSAXFunc endDocument;

    startElementSAXFunc startElement;

    endElementSAXFunc endElement;

    referenceSAXFunc reference;

    charactersSAXFunc characters;

    ignorableWhitespaceSAXFunc ignorableWhitespace;

    processingInstructionSAXFunc processingInstruction;

    commentSAXFunc comment;

    warningSAXFunc warning;

    errorSAXFunc error;

    fatalErrorSAXFunc fatalError; /* unused error() get all the errors */

    getParameterEntitySAXFunc getParameterEntity;

    cdataBlockSAXFunc cdataBlock;

    externalSubsetSAXFunc externalSubset;

    unsigned int initialized;

};





typedef xmlParserInputPtr (*xmlExternalEntityLoader) (const char *URL,

                                         const char *ID,

                                         xmlParserCtxtPtr context);



#ifdef __cplusplus

}

#endif



#include <libxml/encoding.h>

#include <libxml/xmlIO.h>

#include <libxml/globals.h>



#ifdef __cplusplus

extern "C" {

#endif





/*

 * Init/Cleanup

 */

XMLPUBFUN void XMLCALL          

                xmlInitParser           (void);

XMLPUBFUN void XMLCALL          

                xmlCleanupParser        (void);



/*

 * Input functions

 */

XMLPUBFUN int XMLCALL           

                xmlParserInputRead      (xmlParserInputPtr in,

                                         int len);

XMLPUBFUN int XMLCALL           

                xmlParserInputGrow      (xmlParserInputPtr in,

                                         int len);



/*

 * Basic parsing Interfaces

 */

#ifdef LIBXML_SAX1_ENABLED

XMLPUBFUN xmlDocPtr XMLCALL     

                xmlParseDoc             (xmlChar *cur);

XMLPUBFUN xmlDocPtr XMLCALL     

                xmlParseFile            (const char *filename);

XMLPUBFUN xmlDocPtr XMLCALL     

                xmlParseMemory          (const char *buffer,

                                         int size);

#endif /* LIBXML_SAX1_ENABLED */

XMLPUBFUN int XMLCALL           

                xmlSubstituteEntitiesDefault(int val);

XMLPUBFUN int XMLCALL           

                xmlKeepBlanksDefault    (int val);

#ifdef LIBXML_PUSH_ENABLED

XMLPUBFUN void XMLCALL          

                xmlStopParser           (xmlParserCtxtPtr ctxt);

#endif /* LIBXML_PUSH_ENABLED */

XMLPUBFUN int XMLCALL           

                xmlPedanticParserDefault(int val);

XMLPUBFUN int XMLCALL           

                xmlLineNumbersDefault   (int val);



#ifdef LIBXML_SAX1_ENABLED

/*

 * Recovery mode 

 */

XMLPUBFUN xmlDocPtr XMLCALL     

                xmlRecoverDoc           (xmlChar *cur);

XMLPUBFUN xmlDocPtr XMLCALL     

                xmlRecoverMemory        (const char *buffer,

                                         int size);

XMLPUBFUN xmlDocPtr XMLCALL     

                xmlRecoverFile          (const char *filename);

#endif /* LIBXML_SAX1_ENABLED */



/*

 * Less common routines and SAX interfaces

 */

XMLPUBFUN int XMLCALL           

                xmlParseDocument        (xmlParserCtxtPtr ctxt);

XMLPUBFUN int XMLCALL           

                xmlParseExtParsedEnt    (xmlParserCtxtPtr ctxt);

#ifdef LIBXML_SAX1_ENABLED

XMLPUBFUN int XMLCALL           

                xmlSAXUserParseFile     (xmlSAXHandlerPtr sax,

                                         void *user_data,

                                         const char *filename);

XMLPUBFUN int XMLCALL           

                xmlSAXUserParseMemory   (xmlSAXHandlerPtr sax,

                                         void *user_data,

                                         const char *buffer,

                                         int size);

XMLPUBFUN xmlDocPtr XMLCALL     

                xmlSAXParseDoc          (xmlSAXHandlerPtr sax,

                                         xmlChar *cur,

                                         int recovery);

XMLPUBFUN xmlDocPtr XMLCALL     

                xmlSAXParseMemory       (xmlSAXHandlerPtr sax,

                                         const char *buffer,

                                         int size,

                                         int recovery);

XMLPUBFUN xmlDocPtr XMLCALL     

                xmlSAXParseMemoryWithData (xmlSAXHandlerPtr sax,

                                         const char *buffer,

                                         int size,

                                         int recovery,

                                         void *data);

XMLPUBFUN xmlDocPtr XMLCALL     

                xmlSAXParseFile         (xmlSAXHandlerPtr sax,

                                         const char *filename,

                                         int recovery);

XMLPUBFUN xmlDocPtr XMLCALL     

                xmlSAXParseFileWithData (xmlSAXHandlerPtr sax,

                                         const char *filename,

                                         int recovery,

                                         void *data);

XMLPUBFUN xmlDocPtr XMLCALL     

                xmlSAXParseEntity       (xmlSAXHandlerPtr sax,

                                         const char *filename);

XMLPUBFUN xmlDocPtr XMLCALL     

                xmlParseEntity          (const char *filename);

#endif /* LIBXML_SAX1_ENABLED */



#ifdef LIBXML_VALID_ENABLED

XMLPUBFUN xmlDtdPtr XMLCALL     

                xmlSAXParseDTD          (xmlSAXHandlerPtr sax,

                                         const xmlChar *ExternalID,

                                         const xmlChar *SystemID);

XMLPUBFUN xmlDtdPtr XMLCALL     

                xmlParseDTD             (const xmlChar *ExternalID,

                                         const xmlChar *SystemID);

XMLPUBFUN xmlDtdPtr XMLCALL     

                xmlIOParseDTD           (xmlSAXHandlerPtr sax,

                                         xmlParserInputBufferPtr input,

                                         xmlCharEncoding enc);

#endif /* LIBXML_VALID_ENABLE */

#ifdef LIBXML_SAX1_ENABLED

XMLPUBFUN int XMLCALL   

                xmlParseBalancedChunkMemory(xmlDocPtr doc,

                                         xmlSAXHandlerPtr sax,

                                         void *user_data,

                                         int depth,

                                         const xmlChar *string,

                                         xmlNodePtr *lst);

#endif /* LIBXML_SAX1_ENABLED */

XMLPUBFUN xmlParserErrors XMLCALL

                xmlParseInNodeContext   (xmlNodePtr node,

                                         const char *data,

                                         int datalen,

                                         int options,

                                         xmlNodePtr *lst);

#ifdef LIBXML_SAX1_ENABLED

XMLPUBFUN int XMLCALL          

                xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc,

                     xmlSAXHandlerPtr sax,

                     void *user_data,

                     int depth,

                     const xmlChar *string,

                     xmlNodePtr *lst,

                     int recover);

XMLPUBFUN int XMLCALL           

                xmlParseExternalEntity  (xmlDocPtr doc,

                                         xmlSAXHandlerPtr sax,

                                         void *user_data,

                                         int depth,

                                         const xmlChar *URL,

                                         const xmlChar *ID,

                                         xmlNodePtr *lst);

#endif /* LIBXML_SAX1_ENABLED */

XMLPUBFUN int XMLCALL           

                xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx,

                                         const xmlChar *URL,

                                         const xmlChar *ID,

                                         xmlNodePtr *lst);



/*

 * Parser contexts handling.

 */

XMLPUBFUN xmlParserCtxtPtr XMLCALL      

                xmlNewParserCtxt        (void);

XMLPUBFUN int XMLCALL           

                xmlInitParserCtxt       (xmlParserCtxtPtr ctxt);

XMLPUBFUN void XMLCALL          

                xmlClearParserCtxt      (xmlParserCtxtPtr ctxt);

XMLPUBFUN void XMLCALL          

                xmlFreeParserCtxt       (xmlParserCtxtPtr ctxt);

#ifdef LIBXML_SAX1_ENABLED

XMLPUBFUN void XMLCALL          

                xmlSetupParserForBuffer (xmlParserCtxtPtr ctxt,

                                         const xmlChar* buffer,

                                         const char *filename);

#endif /* LIBXML_SAX1_ENABLED */

XMLPUBFUN xmlParserCtxtPtr XMLCALL 

                xmlCreateDocParserCtxt  (const xmlChar *cur);



#ifdef LIBXML_LEGACY_ENABLED

/*

 * Reading/setting optional parsing features.

 */

XMLPUBFUN int XMLCALL           

                xmlGetFeaturesList      (int *len,

                                         const char **result);

XMLPUBFUN int XMLCALL           

                xmlGetFeature           (xmlParserCtxtPtr ctxt,

                                         const char *name,

                                         void *result);

XMLPUBFUN int XMLCALL           

                xmlSetFeature           (xmlParserCtxtPtr ctxt,

                                         const char *name,

                                         void *value);

#endif /* LIBXML_LEGACY_ENABLED */



#ifdef LIBXML_PUSH_ENABLED

/*

 * Interfaces for the Push mode.

 */

XMLPUBFUN xmlParserCtxtPtr XMLCALL 

                xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax,

                                         void *user_data,

                                         const char *chunk,

                                         int size,

                                         const char *filename);

XMLPUBFUN int XMLCALL            

                xmlParseChunk           (xmlParserCtxtPtr ctxt,

                                         const char *chunk,

                                         int size,

                                         int terminate);

#endif /* LIBXML_PUSH_ENABLED */



/*

 * Special I/O mode.

 */



XMLPUBFUN xmlParserCtxtPtr XMLCALL 

                xmlCreateIOParserCtxt   (xmlSAXHandlerPtr sax,

                                         void *user_data,

                                         xmlInputReadCallback   ioread,

                                         xmlInputCloseCallback  ioclose,

                                         void *ioctx,

                                         xmlCharEncoding enc);



XMLPUBFUN xmlParserInputPtr XMLCALL 

                xmlNewIOInputStream     (xmlParserCtxtPtr ctxt,

                                         xmlParserInputBufferPtr input,

                                         xmlCharEncoding enc);



/*

 * Node infos.

 */

XMLPUBFUN const xmlParserNodeInfo* XMLCALL

                xmlParserFindNodeInfo   (const xmlParserCtxtPtr ctxt,

                                         const xmlNodePtr node);

XMLPUBFUN void XMLCALL          

                xmlInitNodeInfoSeq      (xmlParserNodeInfoSeqPtr seq);

XMLPUBFUN void XMLCALL          

                xmlClearNodeInfoSeq     (xmlParserNodeInfoSeqPtr seq);

XMLPUBFUN unsigned long XMLCALL 

                xmlParserFindNodeInfoIndex(const xmlParserNodeInfoSeqPtr seq,

                                         const xmlNodePtr node);

XMLPUBFUN void XMLCALL          

                xmlParserAddNodeInfo    (xmlParserCtxtPtr ctxt,

                                         const xmlParserNodeInfoPtr info);



/*

 * External entities handling actually implemented in xmlIO.

 */



XMLPUBFUN void XMLCALL          

                xmlSetExternalEntityLoader(xmlExternalEntityLoader f);

XMLPUBFUN xmlExternalEntityLoader XMLCALL

                xmlGetExternalEntityLoader(void);

XMLPUBFUN xmlParserInputPtr XMLCALL

                xmlLoadExternalEntity   (const char *URL,

                                         const char *ID,

                                         xmlParserCtxtPtr ctxt);



/*

 * Index lookup, actually implemented in the encoding module

 */

XMLPUBFUN long XMLCALL

                xmlByteConsumed         (xmlParserCtxtPtr ctxt);



/*

 * New set of simpler/more flexible APIs

 */

typedef enum {

    XML_PARSE_RECOVER   = 1<<0, /* recover on errors */

    XML_PARSE_NOENT     = 1<<1, /* substitute entities */

    XML_PARSE_DTDLOAD   = 1<<2, /* load the external subset */

    XML_PARSE_DTDATTR   = 1<<3, /* default DTD attributes */

    XML_PARSE_DTDVALID  = 1<<4, /* validate with the DTD */

    XML_PARSE_NOERROR   = 1<<5, /* suppress error reports */

    XML_PARSE_NOWARNING = 1<<6, /* suppress warning reports */

    XML_PARSE_PEDANTIC  = 1<<7, /* pedantic error reporting */

    XML_PARSE_NOBLANKS  = 1<<8, /* remove blank nodes */

    XML_PARSE_SAX1      = 1<<9, /* use the SAX1 interface internally */

    XML_PARSE_XINCLUDE  = 1<<10,/* Implement XInclude substitition  */

    XML_PARSE_NONET     = 1<<11,/* Forbid network access */

    XML_PARSE_NODICT    = 1<<12,/* Do not reuse the context dictionnary */

    XML_PARSE_NSCLEAN   = 1<<13,/* remove redundant namespaces declarations */

    XML_PARSE_NOCDATA   = 1<<14,/* merge CDATA as text nodes */

    XML_PARSE_NOXINCNODE= 1<<15 /* do not generate XINCLUDE START/END nodes */

} xmlParserOption;



XMLPUBFUN void XMLCALL

                xmlCtxtReset            (xmlParserCtxtPtr ctxt);

XMLPUBFUN int XMLCALL

                xmlCtxtResetPush        (xmlParserCtxtPtr ctxt,

                                         const char *chunk,

                                         int size,

                                         const char *filename,

                                         const char *encoding);

XMLPUBFUN int XMLCALL

                xmlCtxtUseOptions       (xmlParserCtxtPtr ctxt,

                                         int options);

XMLPUBFUN xmlDocPtr XMLCALL

                xmlReadDoc              (const xmlChar *cur,

                                         const char *URL,

                                         const char *encoding,

                                         int options);

XMLPUBFUN xmlDocPtr XMLCALL

                xmlReadFile             (const char *URL,

                                         const char *encoding,

                                         int options);

XMLPUBFUN xmlDocPtr XMLCALL

                xmlReadMemory           (const char *buffer,

                                         int size,

                                         const char *URL,

                                         const char *encoding,

                                         int options);

XMLPUBFUN xmlDocPtr XMLCALL

                xmlReadFd               (int fd,

                                         const char *URL,

                                         const char *encoding,

                                         int options);

XMLPUBFUN xmlDocPtr XMLCALL

                xmlReadIO               (xmlInputReadCallback ioread,

                                         xmlInputCloseCallback ioclose,

                                         void *ioctx,

                                         const char *URL,

                                         const char *encoding,

                                         int options);

XMLPUBFUN xmlDocPtr XMLCALL

                xmlCtxtReadDoc          (xmlParserCtxtPtr ctxt,

                                         const xmlChar *cur,

                                         const char *URL,

                                         const char *encoding,

                                         int options);

XMLPUBFUN xmlDocPtr XMLCALL

                xmlCtxtReadFile         (xmlParserCtxtPtr ctxt,

                                         const char *filename,

                                         const char *encoding,

                                         int options);

XMLPUBFUN xmlDocPtr XMLCALL

                xmlCtxtReadMemory               (xmlParserCtxtPtr ctxt,

                                         const char *buffer,

                                         int size,

                                         const char *URL,

                                         const char *encoding,

                                         int options);

XMLPUBFUN xmlDocPtr XMLCALL

                xmlCtxtReadFd           (xmlParserCtxtPtr ctxt,

                                         int fd,

                                         const char *URL,

                                         const char *encoding,

                                         int options);

XMLPUBFUN xmlDocPtr XMLCALL

                xmlCtxtReadIO           (xmlParserCtxtPtr ctxt,

                                         xmlInputReadCallback ioread,

                                         xmlInputCloseCallback ioclose,

                                         void *ioctx,

                                         const char *URL,

                                         const char *encoding,

                                         int options);



#ifdef __cplusplus

}

#endif

#endif /* __XML_PARSER_H__ */

---