mirror of https://github.com/axmolengine/axmol.git
1230 lines
38 KiB
C
1230 lines
38 KiB
C
/*
|
|
* 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
|
|
|
|
/**
|
|
* XML_DEFAULT_VERSION:
|
|
*
|
|
* The default version of XML used: 1.0
|
|
*/
|
|
#define XML_DEFAULT_VERSION "1.0"
|
|
|
|
/**
|
|
* xmlParserInput:
|
|
*
|
|
* An xmlParserInput is an input flow for the XML processor.
|
|
* Each entity parsed is associated an xmlParserInput (except the
|
|
* few predefined ones). This is the case both for internal entities
|
|
* - in which case the flow is already completely in memory - or
|
|
* external entities - in which case we use the buf structure for
|
|
* progressive reading and I18N conversions to the internal UTF-8 format.
|
|
*/
|
|
|
|
/**
|
|
* xmlParserInputDeallocate:
|
|
* @str: the string to deallocate
|
|
*
|
|
* Callback for freeing some parser input allocations.
|
|
*/
|
|
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 */
|
|
};
|
|
|
|
/**
|
|
* xmlParserNodeInfo:
|
|
*
|
|
* The parser can be asked to collect Node informations, i.e. at what
|
|
* place in the file they were detected.
|
|
* NOTE: This is off by default and not very well tested.
|
|
*/
|
|
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;
|
|
};
|
|
|
|
/**
|
|
* xmlParserInputState:
|
|
*
|
|
* The parser is now working also as a state based parser.
|
|
* The recursive one use the state info for entities processing.
|
|
*/
|
|
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;
|
|
|
|
/**
|
|
* XML_DETECT_IDS:
|
|
*
|
|
* Bit in the loadsubset context field to tell to do ID/REFs lookups.
|
|
* Use it to initialize xmlLoadExtDtdDefaultValue.
|
|
*/
|
|
#define XML_DETECT_IDS 2
|
|
|
|
/**
|
|
* XML_COMPLETE_ATTRS:
|
|
*
|
|
* Bit in the loadsubset context field to tell to do complete the
|
|
* elements attributes lists with the ones defaulted from the DTDs.
|
|
* Use it to initialize xmlLoadExtDtdDefaultValue.
|
|
*/
|
|
#define XML_COMPLETE_ATTRS 4
|
|
|
|
/**
|
|
* XML_SKIP_IDS:
|
|
*
|
|
* Bit in the loadsubset context field to tell to not do ID/REFs registration.
|
|
* Used to initialize xmlLoadExtDtdDefaultValue in some special cases.
|
|
*/
|
|
#define XML_SKIP_IDS 8
|
|
|
|
/**
|
|
* xmlParserMode:
|
|
*
|
|
* A parser can operate in various modes
|
|
*/
|
|
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;
|
|
|
|
/**
|
|
* xmlParserCtxt:
|
|
*
|
|
* The parser context.
|
|
* NOTE This doesn't completely define the parser state, the (current ?)
|
|
* design of the parser uses recursive function calls since this allow
|
|
* and easy mapping from the production rules of the specification
|
|
* to the actual code. The drawback is that the actual function call
|
|
* also reflect the parser state. However most of the parsing routines
|
|
* takes as the only argument the parser context pointer, so migrating
|
|
* to a state based parser for progressive parsing shouldn't be too hard.
|
|
*/
|
|
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
|
|
* 3 is HTML after <head>
|
|
* 10 is HTML after <body>
|
|
*/
|
|
|
|
/* 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 */
|
|
unsigned long nbentities; /* number of entities references */
|
|
unsigned long sizeentities; /* size of parsed entities */
|
|
};
|
|
|
|
/**
|
|
* xmlSAXLocator:
|
|
*
|
|
* A SAX Locator.
|
|
*/
|
|
struct _xmlSAXLocator {
|
|
const xmlChar *(*getPublicId)(void *ctx);
|
|
const xmlChar *(*getSystemId)(void *ctx);
|
|
int (*getLineNumber)(void *ctx);
|
|
int (*getColumnNumber)(void *ctx);
|
|
};
|
|
|
|
/**
|
|
* xmlSAXHandler:
|
|
*
|
|
* A SAX handler is bunch of callbacks called by the parser when processing
|
|
* of the input generate data or structure informations.
|
|
*/
|
|
|
|
/**
|
|
* resolveEntitySAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
* @publicId: The public ID of the entity
|
|
* @systemId: The system ID of the entity
|
|
*
|
|
* Callback:
|
|
* The entity loader, to control the loading of external entities,
|
|
* the application can either:
|
|
* - override this resolveEntity() callback in the SAX block
|
|
* - or better use the xmlSetExternalEntityLoader() function to
|
|
* set up it's own entity resolution routine
|
|
*
|
|
* Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
|
|
*/
|
|
typedef xmlParserInputPtr (*resolveEntitySAXFunc) (void *ctx,
|
|
const xmlChar *publicId,
|
|
const xmlChar *systemId);
|
|
/**
|
|
* internalSubsetSAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
* @name: the root element name
|
|
* @ExternalID: the external ID
|
|
* @SystemID: the SYSTEM ID (e.g. filename or URL)
|
|
*
|
|
* Callback on internal subset declaration.
|
|
*/
|
|
typedef void (*internalSubsetSAXFunc) (void *ctx,
|
|
const xmlChar *name,
|
|
const xmlChar *ExternalID,
|
|
const xmlChar *SystemID);
|
|
/**
|
|
* externalSubsetSAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
* @name: the root element name
|
|
* @ExternalID: the external ID
|
|
* @SystemID: the SYSTEM ID (e.g. filename or URL)
|
|
*
|
|
* Callback on external subset declaration.
|
|
*/
|
|
typedef void (*externalSubsetSAXFunc) (void *ctx,
|
|
const xmlChar *name,
|
|
const xmlChar *ExternalID,
|
|
const xmlChar *SystemID);
|
|
/**
|
|
* getEntitySAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
* @name: The entity name
|
|
*
|
|
* Get an entity by name.
|
|
*
|
|
* Returns the xmlEntityPtr if found.
|
|
*/
|
|
typedef xmlEntityPtr (*getEntitySAXFunc) (void *ctx,
|
|
const xmlChar *name);
|
|
/**
|
|
* getParameterEntitySAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
* @name: The entity name
|
|
*
|
|
* Get a parameter entity by name.
|
|
*
|
|
* Returns the xmlEntityPtr if found.
|
|
*/
|
|
typedef xmlEntityPtr (*getParameterEntitySAXFunc) (void *ctx,
|
|
const xmlChar *name);
|
|
/**
|
|
* entityDeclSAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
* @name: the entity name
|
|
* @type: the entity type
|
|
* @publicId: The public ID of the entity
|
|
* @systemId: The system ID of the entity
|
|
* @content: the entity value (without processing).
|
|
*
|
|
* An entity definition has been parsed.
|
|
*/
|
|
typedef void (*entityDeclSAXFunc) (void *ctx,
|
|
const xmlChar *name,
|
|
int type,
|
|
const xmlChar *publicId,
|
|
const xmlChar *systemId,
|
|
xmlChar *content);
|
|
/**
|
|
* notationDeclSAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
* @name: The name of the notation
|
|
* @publicId: The public ID of the entity
|
|
* @systemId: The system ID of the entity
|
|
*
|
|
* What to do when a notation declaration has been parsed.
|
|
*/
|
|
typedef void (*notationDeclSAXFunc)(void *ctx,
|
|
const xmlChar *name,
|
|
const xmlChar *publicId,
|
|
const xmlChar *systemId);
|
|
/**
|
|
* attributeDeclSAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
* @elem: the name of the element
|
|
* @fullname: the attribute name
|
|
* @type: the attribute type
|
|
* @def: the type of default value
|
|
* @defaultValue: the attribute default value
|
|
* @tree: the tree of enumerated value set
|
|
*
|
|
* An attribute definition has been parsed.
|
|
*/
|
|
typedef void (*attributeDeclSAXFunc)(void *ctx,
|
|
const xmlChar *elem,
|
|
const xmlChar *fullname,
|
|
int type,
|
|
int def,
|
|
const xmlChar *defaultValue,
|
|
xmlEnumerationPtr tree);
|
|
/**
|
|
* elementDeclSAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
* @name: the element name
|
|
* @type: the element type
|
|
* @content: the element value tree
|
|
*
|
|
* An element definition has been parsed.
|
|
*/
|
|
typedef void (*elementDeclSAXFunc)(void *ctx,
|
|
const xmlChar *name,
|
|
int type,
|
|
xmlElementContentPtr content);
|
|
/**
|
|
* unparsedEntityDeclSAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
* @name: The name of the entity
|
|
* @publicId: The public ID of the entity
|
|
* @systemId: The system ID of the entity
|
|
* @notationName: the name of the notation
|
|
*
|
|
* What to do when an unparsed entity declaration is parsed.
|
|
*/
|
|
typedef void (*unparsedEntityDeclSAXFunc)(void *ctx,
|
|
const xmlChar *name,
|
|
const xmlChar *publicId,
|
|
const xmlChar *systemId,
|
|
const xmlChar *notationName);
|
|
/**
|
|
* setDocumentLocatorSAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
* @loc: A SAX Locator
|
|
*
|
|
* Receive the document locator at startup, actually xmlDefaultSAXLocator.
|
|
* Everything is available on the context, so this is useless in our case.
|
|
*/
|
|
typedef void (*setDocumentLocatorSAXFunc) (void *ctx,
|
|
xmlSAXLocatorPtr loc);
|
|
/**
|
|
* startDocumentSAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
*
|
|
* Called when the document start being processed.
|
|
*/
|
|
typedef void (*startDocumentSAXFunc) (void *ctx);
|
|
/**
|
|
* endDocumentSAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
*
|
|
* Called when the document end has been detected.
|
|
*/
|
|
typedef void (*endDocumentSAXFunc) (void *ctx);
|
|
/**
|
|
* startElementSAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
* @name: The element name, including namespace prefix
|
|
* @atts: An array of name/value attributes pairs, NULL terminated
|
|
*
|
|
* Called when an opening tag has been processed.
|
|
*/
|
|
typedef void (*startElementSAXFunc) (void *ctx,
|
|
const xmlChar *name,
|
|
const xmlChar **atts);
|
|
/**
|
|
* endElementSAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
* @name: The element name
|
|
*
|
|
* Called when the end of an element has been detected.
|
|
*/
|
|
typedef void (*endElementSAXFunc) (void *ctx,
|
|
const xmlChar *name);
|
|
/**
|
|
* attributeSAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
* @name: The attribute name, including namespace prefix
|
|
* @value: The attribute value
|
|
*
|
|
* Handle an attribute that has been read by the parser.
|
|
* The default handling is to convert the attribute into an
|
|
* DOM subtree and past it in a new xmlAttr element added to
|
|
* the element.
|
|
*/
|
|
typedef void (*attributeSAXFunc) (void *ctx,
|
|
const xmlChar *name,
|
|
const xmlChar *value);
|
|
/**
|
|
* referenceSAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
* @name: The entity name
|
|
*
|
|
* Called when an entity reference is detected.
|
|
*/
|
|
typedef void (*referenceSAXFunc) (void *ctx,
|
|
const xmlChar *name);
|
|
/**
|
|
* charactersSAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
* @ch: a xmlChar string
|
|
* @len: the number of xmlChar
|
|
*
|
|
* Receiving some chars from the parser.
|
|
*/
|
|
typedef void (*charactersSAXFunc) (void *ctx,
|
|
const xmlChar *ch,
|
|
int len);
|
|
/**
|
|
* ignorableWhitespaceSAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
* @ch: a xmlChar string
|
|
* @len: the number of xmlChar
|
|
*
|
|
* Receiving some ignorable whitespaces from the parser.
|
|
* UNUSED: by default the DOM building will use characters.
|
|
*/
|
|
typedef void (*ignorableWhitespaceSAXFunc) (void *ctx,
|
|
const xmlChar *ch,
|
|
int len);
|
|
/**
|
|
* processingInstructionSAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
* @target: the target name
|
|
* @data: the PI data's
|
|
*
|
|
* A processing instruction has been parsed.
|
|
*/
|
|
typedef void (*processingInstructionSAXFunc) (void *ctx,
|
|
const xmlChar *target,
|
|
const xmlChar *data);
|
|
/**
|
|
* commentSAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
* @value: the comment content
|
|
*
|
|
* A comment has been parsed.
|
|
*/
|
|
typedef void (*commentSAXFunc) (void *ctx,
|
|
const xmlChar *value);
|
|
/**
|
|
* cdataBlockSAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
* @value: The pcdata content
|
|
* @len: the block length
|
|
*
|
|
* Called when a pcdata block has been parsed.
|
|
*/
|
|
typedef void (*cdataBlockSAXFunc) (
|
|
void *ctx,
|
|
const xmlChar *value,
|
|
int len);
|
|
/**
|
|
* warningSAXFunc:
|
|
* @ctx: an XML parser context
|
|
* @msg: the message to display/transmit
|
|
* @...: extra parameters for the message display
|
|
*
|
|
* Display and format a warning messages, callback.
|
|
*/
|
|
typedef void (XMLCDECL *warningSAXFunc) (void *ctx,
|
|
const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
|
|
/**
|
|
* errorSAXFunc:
|
|
* @ctx: an XML parser context
|
|
* @msg: the message to display/transmit
|
|
* @...: extra parameters for the message display
|
|
*
|
|
* Display and format an error messages, callback.
|
|
*/
|
|
typedef void (XMLCDECL *errorSAXFunc) (void *ctx,
|
|
const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
|
|
/**
|
|
* fatalErrorSAXFunc:
|
|
* @ctx: an XML parser context
|
|
* @msg: the message to display/transmit
|
|
* @...: extra parameters for the message display
|
|
*
|
|
* Display and format fatal error messages, callback.
|
|
* Note: so far fatalError() SAX callbacks are not used, error()
|
|
* get all the callbacks for errors.
|
|
*/
|
|
typedef void (XMLCDECL *fatalErrorSAXFunc) (void *ctx,
|
|
const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
|
|
/**
|
|
* isStandaloneSAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
*
|
|
* Is this document tagged standalone?
|
|
*
|
|
* Returns 1 if true
|
|
*/
|
|
typedef int (*isStandaloneSAXFunc) (void *ctx);
|
|
/**
|
|
* hasInternalSubsetSAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
*
|
|
* Does this document has an internal subset.
|
|
*
|
|
* Returns 1 if true
|
|
*/
|
|
typedef int (*hasInternalSubsetSAXFunc) (void *ctx);
|
|
|
|
/**
|
|
* hasExternalSubsetSAXFunc:
|
|
* @ctx: the user data (XML parser context)
|
|
*
|
|
* Does this document has an external subset?
|
|
*
|
|
* Returns 1 if true
|
|
*/
|
|
typedef int (*hasExternalSubsetSAXFunc) (void *ctx);
|
|
|
|
/************************************************************************
|
|
* *
|
|
* The SAX version 2 API extensions *
|
|
* *
|
|
************************************************************************/
|
|
/**
|
|
* XML_SAX2_MAGIC:
|
|
*
|
|
* Special constant found in SAX2 blocks initialized fields
|
|
*/
|
|
#define XML_SAX2_MAGIC 0xDEEDBEAF
|
|
|
|
/**
|
|
* startElementNsSAX2Func:
|
|
* @ctx: the user data (XML parser context)
|
|
* @localname: the local name of the element
|
|
* @prefix: the element namespace prefix if available
|
|
* @URI: the element namespace name if available
|
|
* @nb_namespaces: number of namespace definitions on that node
|
|
* @namespaces: pointer to the array of prefix/URI pairs namespace definitions
|
|
* @nb_attributes: the number of attributes on that node
|
|
* @nb_defaulted: the number of defaulted attributes. The defaulted
|
|
* ones are at the end of the array
|
|
* @attributes: pointer to the array of (localname/prefix/URI/value/end)
|
|
* attribute values.
|
|
*
|
|
* SAX2 callback when an element start has been detected by the parser.
|
|
* It provides the namespace informations for the element, as well as
|
|
* the new namespace declarations on the element.
|
|
*/
|
|
|
|
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);
|
|
|
|
/**
|
|
* endElementNsSAX2Func:
|
|
* @ctx: the user data (XML parser context)
|
|
* @localname: the local name of the element
|
|
* @prefix: the element namespace prefix if available
|
|
* @URI: the element namespace name if available
|
|
*
|
|
* SAX2 callback when an element end has been detected by the parser.
|
|
* It provides the namespace informations for the element.
|
|
*/
|
|
|
|
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;
|
|
};
|
|
|
|
|
|
/**
|
|
* xmlExternalEntityLoader:
|
|
* @URL: The System ID of the resource requested
|
|
* @ID: The Public ID of the resource requested
|
|
* @context: the XML parser context
|
|
*
|
|
* External entity loaders types.
|
|
*
|
|
* Returns the entity input parser.
|
|
*/
|
|
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 (const 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);
|
|
XMLPUBFUN void XMLCALL
|
|
xmlStopParser (xmlParserCtxtPtr ctxt);
|
|
XMLPUBFUN int XMLCALL
|
|
xmlPedanticParserDefault(int val);
|
|
XMLPUBFUN int XMLCALL
|
|
xmlLineNumbersDefault (int val);
|
|
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
/*
|
|
* Recovery mode
|
|
*/
|
|
XMLPUBFUN xmlDocPtr XMLCALL
|
|
xmlRecoverDoc (const 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,
|
|
const 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
|
|
*/
|
|
/**
|
|
* xmlParserOption:
|
|
*
|
|
* This is the set of XML parser options that can be passed down
|
|
* to the xmlReadDoc() and similar calls.
|
|
*/
|
|
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 */
|
|
XML_PARSE_COMPACT = 1<<16,/* compact small text nodes; no modification of
|
|
the tree allowed afterwards (will possibly
|
|
crash if you try to modify the tree) */
|
|
XML_PARSE_OLD10 = 1<<17,/* parse using XML-1.0 before update 5 */
|
|
XML_PARSE_NOBASEFIX = 1<<18,/* do not fixup XINCLUDE xml:base uris */
|
|
XML_PARSE_HUGE = 1<<19, /* relax any hardcoded limit from the parser */
|
|
XML_PARSE_OLDSAX = 1<<20 /* parse using SAX2 interface from before 2.7.0 */
|
|
} 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);
|
|
|
|
/*
|
|
* Library wide options
|
|
*/
|
|
/**
|
|
* xmlFeature:
|
|
*
|
|
* Used to examine the existance of features that can be enabled
|
|
* or disabled at compile-time.
|
|
* They used to be called XML_FEATURE_xxx but this clashed with Expat
|
|
*/
|
|
typedef enum {
|
|
XML_WITH_THREAD = 1,
|
|
XML_WITH_TREE = 2,
|
|
XML_WITH_OUTPUT = 3,
|
|
XML_WITH_PUSH = 4,
|
|
XML_WITH_READER = 5,
|
|
XML_WITH_PATTERN = 6,
|
|
XML_WITH_WRITER = 7,
|
|
XML_WITH_SAX1 = 8,
|
|
XML_WITH_FTP = 9,
|
|
XML_WITH_HTTP = 10,
|
|
XML_WITH_VALID = 11,
|
|
XML_WITH_HTML = 12,
|
|
XML_WITH_LEGACY = 13,
|
|
XML_WITH_C14N = 14,
|
|
XML_WITH_CATALOG = 15,
|
|
XML_WITH_XPATH = 16,
|
|
XML_WITH_XPTR = 17,
|
|
XML_WITH_XINCLUDE = 18,
|
|
XML_WITH_ICONV = 19,
|
|
XML_WITH_ISO8859X = 20,
|
|
XML_WITH_UNICODE = 21,
|
|
XML_WITH_REGEXP = 22,
|
|
XML_WITH_AUTOMATA = 23,
|
|
XML_WITH_EXPR = 24,
|
|
XML_WITH_SCHEMAS = 25,
|
|
XML_WITH_SCHEMATRON = 26,
|
|
XML_WITH_MODULES = 27,
|
|
XML_WITH_DEBUG = 28,
|
|
XML_WITH_DEBUG_MEM = 29,
|
|
XML_WITH_DEBUG_RUN = 30,
|
|
XML_WITH_ZLIB = 31,
|
|
XML_WITH_NONE = 99999 /* just to be sure of allocation size */
|
|
} xmlFeature;
|
|
|
|
XMLPUBFUN int XMLCALL
|
|
xmlHasFeature (xmlFeature feature);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
#endif /* __XML_PARSER_H__ */
|
|
|