19.2. Data Definitions for libxml2

This section defines global identifiers and their values that are associated with interfaces contained in libxml2. These definitions are organized into groups that correspond to system headers. This convention is used as a convenience for the reader, and does not imply the existence of these headers, or their content. Where an interface is defined as requiring a particular system header file all of the data definitions for that system header file presented here shall be in effect.

This section gives data definitions to promote binary application portability, not to repeat source interface definitions available elsewhere. System providers and application developers should use this ABI to supplement - not to replace - source interface definition specifications.

This specification uses the ISO C (1999) C Language as the reference programming language, and data definitions are specified in ISO C format. The C language is used here as a convenient notation. Using a C language description of these data objects does not preclude their use by other programming languages.

19.2.1. libxml2/libxml/HTMLparser.h


#define htmlElementAllowedHereDesc(parent,elt)	 \
	htmlElementAllowedHere((parent), (elt)->name)
#define htmlRequiredAttrs(elt)	(elt)->attrs_req
#define htmlDefaultSubelement(elt)	elt->defaultsubelt

typedef enum {
    HTML_NA = 0,
    HTML_INVALID = 1,
    HTML_DEPRECATED = 2,
    HTML_VALID = 4,
    HTML_REQUIRED = 12
} htmlStatus;
typedef struct _htmlElemDesc {
    const char *name;
    char startTag;
    char endTag;
    char saveEndTag;
    char empty;
    char depr;
    char dtd;
    char isinline;
    const char *desc;
    const char **subelts;
    const char *defaultsubelt;
    const char **attrs_opt;
    const char **attrs_depr;
    const char **attrs_req;
} htmlElemDesc;
typedef xmlDocPtr htmlDocPtr;
typedef xmlSAXHandlerPtr htmlSAXHandlerPtr;
typedef xmlParserCtxtPtr htmlParserCtxtPtr;
typedef struct _htmlEntityDesc {
    unsigned int value;
    const char *name;
    const char *desc;
} htmlEntityDesc;
typedef xmlNodePtr htmlNodePtr;
typedef enum {
    HTML_PARSE_RECOVER = 1 << 0,
    HTML_PARSE_NOERROR = 1 << 5,
    HTML_PARSE_NOWARNING = 1 << 6,
    HTML_PARSE_PEDANTIC = 1 << 7,
    HTML_PARSE_NOBLANKS = 1 << 8,
    HTML_PARSE_NONET = 1 << 11,
    HTML_PARSE_COMPACT = 1 << 16
} htmlParserOption;
typedef xmlParserInputPtr htmlParserInputPtr;
typedef htmlElemDesc *htmlElemDescPtr;
typedef htmlEntityDesc *htmlEntityDescPtr;
typedef xmlParserInput htmlParserInput;
extern int UTF8ToHtml(unsigned char *out, int *outlen,
		      const unsigned char *in, int *inlen);
extern htmlStatus htmlAttrAllowed(const htmlElemDesc *, const xmlChar *,
				  int);
extern int htmlAutoCloseTag(htmlDocPtr doc, const xmlChar * name,
			    htmlNodePtr elem);
extern htmlParserCtxtPtr htmlCreateMemoryParserCtxt(const char *buffer,
						    int size);
extern htmlParserCtxtPtr htmlCreatePushParserCtxt(htmlSAXHandlerPtr sax,
						  void *user_data,
						  const char *chunk,
						  int size,
						  const char *filename,
						  xmlCharEncoding enc);
extern htmlDocPtr htmlCtxtReadDoc(htmlParserCtxtPtr ctxt,
				  const xmlChar * cur, const char *URL,
				  const char *encoding, int options);
extern htmlDocPtr htmlCtxtReadFd(htmlParserCtxtPtr ctxt, int fd,
				 const char *URL, const char *encoding,
				 int options);
extern htmlDocPtr htmlCtxtReadFile(htmlParserCtxtPtr ctxt,
				   const char *filename,
				   const char *encoding, int options);
extern htmlDocPtr htmlCtxtReadIO(htmlParserCtxtPtr ctxt,
				 xmlInputReadCallback ioread,
				 xmlInputCloseCallback ioclose,
				 void *ioctx, const char *URL,
				 const char *encoding, int options);
extern htmlDocPtr htmlCtxtReadMemory(htmlParserCtxtPtr ctxt,
				     const char *buffer, int size,
				     const char *URL, const char *encoding,
				     int options);
extern void htmlCtxtReset(htmlParserCtxtPtr ctxt);
extern int htmlCtxtUseOptions(htmlParserCtxtPtr ctxt, int options);
extern int htmlElementAllowedHere(const htmlElemDesc *, const xmlChar *);
extern htmlStatus htmlElementStatusHere(const htmlElemDesc *,
					const htmlElemDesc *);
extern int htmlEncodeEntities(unsigned char *out, int *outlen,
			      const unsigned char *in, int *inlen,
			      int quoteChar);
extern const htmlEntityDesc *htmlEntityLookup(const xmlChar * name);
extern const htmlEntityDesc *htmlEntityValueLookup(unsigned int value);
extern void htmlFreeParserCtxt(htmlParserCtxtPtr ctxt);
extern int htmlHandleOmittedElem(int val);
extern int htmlIsAutoClosed(htmlDocPtr doc, htmlNodePtr elem);
extern int htmlIsScriptAttribute(const xmlChar * name);
extern int htmlParseCharRef(htmlParserCtxtPtr ctxt);
extern int htmlParseChunk(htmlParserCtxtPtr ctxt, const char *chunk,
			  int size, int terminate);
extern htmlDocPtr htmlParseDoc(xmlChar * cur, const char *encoding);
extern int htmlParseDocument(htmlParserCtxtPtr ctxt);
extern void htmlParseElement(htmlParserCtxtPtr ctxt);
extern const htmlEntityDesc *htmlParseEntityRef(htmlParserCtxtPtr ctxt,
						const xmlChar * *str);
extern htmlDocPtr htmlParseFile(const char *filename,
				const char *encoding);
extern htmlDocPtr htmlReadDoc(const xmlChar * cur, const char *URL,
			      const char *encoding, int options);
extern htmlDocPtr htmlReadFd(int fd, const char *URL, const char *encoding,
			     int options);
extern htmlDocPtr htmlReadFile(const char *URL, const char *encoding,
			       int options);
extern htmlDocPtr htmlReadIO(xmlInputReadCallback ioread,
			     xmlInputCloseCallback ioclose, void *ioctx,
			     const char *URL, const char *encoding,
			     int options);
extern htmlDocPtr htmlReadMemory(const char *buffer, int size,
				 const char *URL, const char *encoding,
				 int options);
extern htmlDocPtr htmlSAXParseDoc(xmlChar * cur, const char *encoding,
				  htmlSAXHandlerPtr sax, void *userData);
extern htmlDocPtr htmlSAXParseFile(const char *filename,
				   const char *encoding,
				   htmlSAXHandlerPtr sax, void *userData);
extern const htmlElemDesc *htmlTagLookup(const xmlChar * tag);

19.2.2. libxml2/libxml/HTMLtree.h


#define HTML_PRESERVE_NODE	XML_CDATA_SECTION_NODE
#define HTML_COMMENT_NODE	XML_COMMENT_NODE
#define HTML_ENTITY_REF_NODE	XML_ENTITY_REF_NODE
#define HTML_PI_NODE	XML_PI_NODE
#define HTML_TEXT_NODE	XML_TEXT_NODE

extern void htmlDocContentDumpFormatOutput(xmlOutputBufferPtr buf,
					   xmlDocPtr cur,
					   const char *encoding,
					   int format);
extern void htmlDocContentDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr cur,
				     const char *encoding);
extern int htmlDocDump(FILE * f, xmlDocPtr cur);
extern void htmlDocDumpMemory(xmlDocPtr cur, xmlChar * *mem, int *size);
extern const xmlChar *htmlGetMetaEncoding(htmlDocPtr doc);
extern int htmlIsBooleanAttr(const xmlChar * name);
extern htmlDocPtr htmlNewDoc(const xmlChar * URI,
			     const xmlChar * ExternalID);
extern htmlDocPtr htmlNewDocNoDtD(const xmlChar * URI,
				  const xmlChar * ExternalID);
extern int htmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur);
extern void htmlNodeDumpFile(FILE * out, xmlDocPtr doc, xmlNodePtr cur);
extern int htmlNodeDumpFileFormat(FILE * out, xmlDocPtr doc,
				  xmlNodePtr cur, const char *encoding,
				  int format);
extern void htmlNodeDumpFormatOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
				     xmlNodePtr cur, const char *encoding,
				     int format);
extern void htmlNodeDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
			       xmlNodePtr cur, const char *encoding);
extern int htmlSaveFile(const char *filename, xmlDocPtr cur);
extern int htmlSaveFileEnc(const char *filename, xmlDocPtr cur,
			   const char *encoding);
extern int htmlSaveFileFormat(const char *filename, xmlDocPtr cur,
			      const char *encoding, int format);
extern int htmlSetMetaEncoding(htmlDocPtr doc, const xmlChar * encoding);

19.2.3. libxml2/libxml/SAX2.h


typedef void (*internalSubsetSAXFunc) (void *, const xmlChar *,
				       const xmlChar *, const xmlChar *);
typedef int (*isStandaloneSAXFunc) (void *);
typedef int (*hasInternalSubsetSAXFunc) (void *);
typedef int (*hasExternalSubsetSAXFunc) (void *);
typedef xmlParserInputPtr(*resolveEntitySAXFunc) (void *, const xmlChar *,
						  const xmlChar *);
typedef xmlEntityPtr(*getEntitySAXFunc) (void *, const xmlChar *);
typedef void (*entityDeclSAXFunc) (void *, const xmlChar *, int,
				   const xmlChar *, const xmlChar *,
				   xmlChar *);
typedef void (*notationDeclSAXFunc) (void *, const xmlChar *,
				     const xmlChar *, const xmlChar *);
typedef struct _xmlEnumeration {
    struct _xmlEnumeration *next;
    const xmlChar *name;
} xmlEnumeration;
typedef xmlEnumeration *xmlEnumerationPtr;
typedef void (*attributeDeclSAXFunc) (void *, const xmlChar *,
				      const xmlChar *, int, int,
				      const xmlChar *, xmlEnumerationPtr);
typedef enum {
    XML_ELEMENT_CONTENT_PCDATA = 1,
    XML_ELEMENT_CONTENT_ELEMENT = 2,
    XML_ELEMENT_CONTENT_SEQ = 3,
    XML_ELEMENT_CONTENT_OR = 4
} xmlElementContentType;
typedef enum {
    XML_ELEMENT_CONTENT_ONCE = 1,
    XML_ELEMENT_CONTENT_OPT = 2,
    XML_ELEMENT_CONTENT_MULT = 3,
    XML_ELEMENT_CONTENT_PLUS = 4
} xmlElementContentOccur;
typedef struct _xmlElementContent {
    xmlElementContentType type;
    xmlElementContentOccur ocur;
    const xmlChar *name;
    struct _xmlElementContent *c1;
    struct _xmlElementContent *c2;
    struct _xmlElementContent *parent;
    const xmlChar *prefix;
} xmlElementContent;
typedef xmlElementContent *xmlElementContentPtr;
typedef void (*elementDeclSAXFunc) (void *, const xmlChar *, int,
				    xmlElementContentPtr);
typedef void (*unparsedEntityDeclSAXFunc) (void *, const xmlChar *,
					   const xmlChar *,
					   const xmlChar *,
					   const xmlChar *);
typedef struct _xmlSAXLocator {
    const xmlChar *(*getPublicId) (void *);
    const xmlChar *(*getSystemId) (void *);
    int (*getLineNumber) (void *);
    int (*getColumnNumber) (void *);
} xmlSAXLocator;
typedef xmlSAXLocator *xmlSAXLocatorPtr;
typedef void (*setDocumentLocatorSAXFunc) (void *, xmlSAXLocatorPtr);
typedef void (*startDocumentSAXFunc) (void *);
typedef void (*endDocumentSAXFunc) (void *);
typedef void (*startElementSAXFunc) (void *, const xmlChar *,
				     const xmlChar * *);
typedef void (*endElementSAXFunc) (void *, const xmlChar *);
typedef void (*referenceSAXFunc) (void *, const xmlChar *);
typedef void (*charactersSAXFunc) (void *, const xmlChar *, int);
typedef void (*ignorableWhitespaceSAXFunc) (void *, const xmlChar *, int);
typedef void (*processingInstructionSAXFunc) (void *, const xmlChar *,
					      const xmlChar *);
typedef void (*commentSAXFunc) (void *, const xmlChar *);
typedef void (*warningSAXFunc) (void *, const char *, ...);
typedef void (*errorSAXFunc) (void *, const char *, ...);
typedef void (*fatalErrorSAXFunc) (void *, const char *, ...);
typedef xmlEntityPtr(*getParameterEntitySAXFunc) (void *, const xmlChar *);
typedef void (*cdataBlockSAXFunc) (void *, const xmlChar *, int);
typedef void (*externalSubsetSAXFunc) (void *, const xmlChar *,
				       const xmlChar *, const xmlChar *);
typedef void (*startElementNsSAX2Func) (void *, const xmlChar *,
					const xmlChar *, const xmlChar *,
					int, const xmlChar * *, int, int,
					const xmlChar * *);
typedef void (*endElementNsSAX2Func) (void *, const xmlChar *,
				      const xmlChar *, const xmlChar *);
typedef 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;
    getParameterEntitySAXFunc getParameterEntity;
    cdataBlockSAXFunc cdataBlock;
    externalSubsetSAXFunc externalSubset;
    unsigned int initialized;
    void *_private;
    startElementNsSAX2Func startElementNs;
    endElementNsSAX2Func endElementNs;
    xmlStructuredErrorFunc serror;
} xmlSAXHandler;
extern void docbDefaultSAXHandlerInit(void);
extern void htmlDefaultSAXHandlerInit(void);
extern void xmlDefaultSAXHandlerInit(void);
extern void xmlSAX2AttributeDecl(void *ctx, const xmlChar * elem,
				 const xmlChar * fullname, int type,
				 int def, const xmlChar * defaultValue,
				 xmlEnumerationPtr tree);
extern void xmlSAX2CDataBlock(void *ctx, const xmlChar * value, int len);
extern void xmlSAX2Characters(void *ctx, const xmlChar * ch, int len);
extern void xmlSAX2Comment(void *ctx, const xmlChar * value);
extern void xmlSAX2ElementDecl(void *ctx, const xmlChar * name, int type,
			       xmlElementContentPtr content);
extern void xmlSAX2EndDocument(void *ctx);
extern void xmlSAX2EndElement(void *ctx, const xmlChar * name);
extern void xmlSAX2EndElementNs(void *ctx, const xmlChar * localname,
				const xmlChar * prefix,
				const xmlChar * URI);
extern void xmlSAX2EntityDecl(void *ctx, const xmlChar * name, int type,
			      const xmlChar * publicId,
			      const xmlChar * systemId, xmlChar * content);
extern void xmlSAX2ExternalSubset(void *ctx, const xmlChar * name,
				  const xmlChar * ExternalID,
				  const xmlChar * SystemID);
extern int xmlSAX2GetColumnNumber(void *ctx);
extern xmlEntityPtr xmlSAX2GetEntity(void *ctx, const xmlChar * name);
extern int xmlSAX2GetLineNumber(void *ctx);
extern xmlEntityPtr xmlSAX2GetParameterEntity(void *ctx,
					      const xmlChar * name);
extern const xmlChar *xmlSAX2GetPublicId(void *ctx);
extern const xmlChar *xmlSAX2GetSystemId(void *ctx);
extern int xmlSAX2HasExternalSubset(void *ctx);
extern int xmlSAX2HasInternalSubset(void *ctx);
extern void xmlSAX2IgnorableWhitespace(void *ctx, const xmlChar * ch,
				       int len);
extern void xmlSAX2InitDefaultSAXHandler(xmlSAXHandler * hdlr,
					 int warning);
extern void xmlSAX2InitDocbDefaultSAXHandler(xmlSAXHandler * hdlr);
extern void xmlSAX2InitHtmlDefaultSAXHandler(xmlSAXHandler * hdlr);
extern void xmlSAX2InternalSubset(void *ctx, const xmlChar * name,
				  const xmlChar * ExternalID,
				  const xmlChar * SystemID);
extern int xmlSAX2IsStandalone(void *ctx);
extern void xmlSAX2NotationDecl(void *ctx, const xmlChar * name,
				const xmlChar * publicId,
				const xmlChar * systemId);
extern void xmlSAX2ProcessingInstruction(void *ctx, const xmlChar * target,
					 const xmlChar * data);
extern void xmlSAX2Reference(void *ctx, const xmlChar * name);
extern xmlParserInputPtr xmlSAX2ResolveEntity(void *ctx,
					      const xmlChar * publicId,
					      const xmlChar * systemId);
extern void xmlSAX2SetDocumentLocator(void *ctx, xmlSAXLocatorPtr loc);
extern void xmlSAX2StartDocument(void *ctx);
extern void xmlSAX2StartElement(void *ctx, const xmlChar * fullname,
				const xmlChar * *atts);
extern void xmlSAX2StartElementNs(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);
extern void xmlSAX2UnparsedEntityDecl(void *ctx, const xmlChar * name,
				      const xmlChar * publicId,
				      const xmlChar * systemId,
				      const xmlChar * notationName);
extern int xmlSAXDefaultVersion(int version);
extern int xmlSAXVersion(xmlSAXHandler * hdlr, int version);

19.2.4. libxml2/libxml/c14n.h


typedef int (*xmlC14NIsVisibleCallback) (void *, xmlNodePtr, xmlNodePtr);
extern int xmlC14NDocDumpMemory(xmlDocPtr, xmlNodeSetPtr, int, xmlChar * *,
				int, xmlChar * *);
extern int xmlC14NDocSave(xmlDocPtr, xmlNodeSetPtr, int, xmlChar * *, int,
			  const char *, int);
extern int xmlC14NDocSaveTo(xmlDocPtr, xmlNodeSetPtr, int, xmlChar * *,
			    int, xmlOutputBufferPtr);
extern int xmlC14NExecute(xmlDocPtr, xmlC14NIsVisibleCallback, void *, int,
			  xmlChar * *, int, xmlOutputBufferPtr);

19.2.5. libxml2/libxml/catalog.h


#define XML_CATALOGS_NAMESPACE	 \
	(const xmlChar *) "urn:oasis:names:tc:entity:xmlns:xml:catalog"
#define XML_CATALOG_PI	(const xmlChar *) "oasis-xml-catalog"

typedef enum {
    XML_CATA_ALLOW_NONE = 0,
    XML_CATA_ALLOW_GLOBAL = 1,
    XML_CATA_ALLOW_DOCUMENT = 2,
    XML_CATA_ALLOW_ALL = 3
} xmlCatalogAllow;
typedef struct _xmlCatalog xmlCatalog;
typedef xmlCatalog *xmlCatalogPtr;
typedef enum {
    XML_CATA_PREFER_NONE = 0,
    XML_CATA_PREFER_PUBLIC = 1,
    XML_CATA_PREFER_SYSTEM = 2
} xmlCatalogPrefer;
extern int xmlACatalogAdd(xmlCatalogPtr catal, const xmlChar * type,
			  const xmlChar * orig, const xmlChar * replace);
extern void xmlACatalogDump(xmlCatalogPtr catal, FILE * out);
extern int xmlACatalogRemove(xmlCatalogPtr catal, const xmlChar * value);
extern xmlChar *xmlACatalogResolve(xmlCatalogPtr catal,
				   const xmlChar * pubID,
				   const xmlChar * sysID);
extern xmlChar *xmlACatalogResolvePublic(xmlCatalogPtr catal,
					 const xmlChar * pubID);
extern xmlChar *xmlACatalogResolveSystem(xmlCatalogPtr catal,
					 const xmlChar * sysID);
extern xmlChar *xmlACatalogResolveURI(xmlCatalogPtr catal,
				      const xmlChar * URI);
extern int xmlCatalogAdd(const xmlChar * type, const xmlChar * orig,
			 const xmlChar * replace);
extern void *xmlCatalogAddLocal(void *catalogs, const xmlChar * URL);
extern void xmlCatalogCleanup(void);
extern int xmlCatalogConvert(void);
extern void xmlCatalogDump(FILE * out);
extern void xmlCatalogFreeLocal(void *catalogs);
extern xmlCatalogAllow xmlCatalogGetDefaults(void);
extern int xmlCatalogIsEmpty(xmlCatalogPtr catal);
extern xmlChar *xmlCatalogLocalResolve(void *catalogs,
				       const xmlChar * pubID,
				       const xmlChar * sysID);
extern xmlChar *xmlCatalogLocalResolveURI(void *catalogs,
					  const xmlChar * URI);
extern int xmlCatalogRemove(const xmlChar * value);
extern xmlChar *xmlCatalogResolve(const xmlChar * pubID,
				  const xmlChar * sysID);
extern xmlChar *xmlCatalogResolvePublic(const xmlChar * pubID);
extern xmlChar *xmlCatalogResolveSystem(const xmlChar * sysID);
extern xmlChar *xmlCatalogResolveURI(const xmlChar * URI);
extern int xmlCatalogSetDebug(int level);
extern xmlCatalogPrefer xmlCatalogSetDefaultPrefer(xmlCatalogPrefer
						   prefer);
extern void xmlCatalogSetDefaults(xmlCatalogAllow allow);
extern int xmlConvertSGMLCatalog(xmlCatalogPtr catal);
extern void xmlFreeCatalog(xmlCatalogPtr catal);
extern void xmlInitializeCatalog(void);
extern xmlCatalogPtr xmlLoadACatalog(const char *filename);
extern int xmlLoadCatalog(const char *filename);
extern void xmlLoadCatalogs(const char *paths);
extern xmlCatalogPtr xmlLoadSGMLSuperCatalog(const char *filename);
extern xmlCatalogPtr xmlNewCatalog(int sgml);
extern xmlDocPtr xmlParseCatalogFile(const char *filename);

19.2.6. libxml2/libxml/debugXML.h


typedef char *(*xmlShellReadlineFunc) (char *);
typedef struct _xmlShellCtxt {
    char *filename;
    xmlDocPtr doc;
    xmlNodePtr node;
    xmlXPathContextPtr pctxt;
    int loaded;
    FILE *output;
    xmlShellReadlineFunc input;
} xmlShellCtxt;
typedef xmlShellCtxt *xmlShellCtxtPtr;
typedef int (*xmlShellCmd) (xmlShellCtxtPtr, char *, xmlNodePtr,
			    xmlNodePtr);
extern const char *xmlBoolToText(int boolval);
extern int xmlDebugCheckDocument(FILE * output, xmlDocPtr doc);
extern void xmlDebugDumpAttr(FILE * output, xmlAttrPtr attr, int depth);
extern void xmlDebugDumpAttrList(FILE * output, xmlAttrPtr attr,
				 int depth);
extern void xmlDebugDumpDTD(FILE * output, xmlDtdPtr dtd);
extern void xmlDebugDumpDocument(FILE * output, xmlDocPtr doc);
extern void xmlDebugDumpDocumentHead(FILE * output, xmlDocPtr doc);
extern void xmlDebugDumpEntities(FILE * output, xmlDocPtr doc);
extern void xmlDebugDumpNode(FILE * output, xmlNodePtr node, int depth);
extern void xmlDebugDumpNodeList(FILE * output, xmlNodePtr node,
				 int depth);
extern void xmlDebugDumpOneNode(FILE * output, xmlNodePtr node, int depth);
extern void xmlDebugDumpString(FILE * output, const xmlChar * str);
extern int xmlLsCountNode(xmlNodePtr node);
extern void xmlLsOneNode(FILE * output, xmlNodePtr node);
extern void xmlShell(xmlDocPtr doc, char *filename,
		     xmlShellReadlineFunc input, FILE * output);
extern int xmlShellBase(xmlShellCtxtPtr ctxt, char *arg, xmlNodePtr node,
			xmlNodePtr node2);
extern int xmlShellCat(xmlShellCtxtPtr ctxt, char *arg, xmlNodePtr node,
		       xmlNodePtr node2);
extern int xmlShellDir(xmlShellCtxtPtr ctxt, char *arg, xmlNodePtr node,
		       xmlNodePtr node2);
extern int xmlShellDu(xmlShellCtxtPtr ctxt, char *arg, xmlNodePtr tree,
		      xmlNodePtr node2);
extern int xmlShellList(xmlShellCtxtPtr ctxt, char *arg, xmlNodePtr node,
			xmlNodePtr node2);
extern int xmlShellLoad(xmlShellCtxtPtr ctxt, char *filename,
			xmlNodePtr node, xmlNodePtr node2);
extern void xmlShellPrintNode(xmlNodePtr node);
extern void xmlShellPrintXPathError(int errorType, const char *arg);
extern void xmlShellPrintXPathResult(xmlXPathObjectPtr list);
extern int xmlShellPwd(xmlShellCtxtPtr ctxt, char *buffer, xmlNodePtr node,
		       xmlNodePtr node2);
extern int xmlShellSave(xmlShellCtxtPtr ctxt, char *filename,
			xmlNodePtr node, xmlNodePtr node2);
extern int xmlShellValidate(xmlShellCtxtPtr ctxt, char *dtd,
			    xmlNodePtr node, xmlNodePtr node2);
extern int xmlShellWrite(xmlShellCtxtPtr ctxt, char *filename,
			 xmlNodePtr node, xmlNodePtr node2);

19.2.7. libxml2/libxml/dict.h


typedef struct _xmlDict xmlDict;
typedef xmlDict *xmlDictPtr;
extern void xmlDictCleanup(void);
extern xmlDictPtr xmlDictCreate(void);
extern xmlDictPtr xmlDictCreateSub(xmlDictPtr);
extern const xmlChar *xmlDictExists(xmlDictPtr, const xmlChar *, int);
extern void xmlDictFree(xmlDictPtr);
extern const xmlChar *xmlDictLookup(xmlDictPtr, const xmlChar *, int);
extern int xmlDictOwns(xmlDictPtr, const xmlChar *);
extern const xmlChar *xmlDictQLookup(xmlDictPtr, const xmlChar *,
				     const xmlChar *);
extern int xmlDictReference(xmlDictPtr);
extern int xmlDictSize(xmlDictPtr);

19.2.8. libxml2/libxml/encoding.h


typedef enum {
    XML_CHAR_ENCODING_ERROR = -1,
    XML_CHAR_ENCODING_NONE = 0,
    XML_CHAR_ENCODING_UTF8 = 1,
    XML_CHAR_ENCODING_UTF16LE = 2,
    XML_CHAR_ENCODING_UTF16BE = 3,
    XML_CHAR_ENCODING_UCS4LE = 4,
    XML_CHAR_ENCODING_UCS4BE = 5,
    XML_CHAR_ENCODING_EBCDIC = 6,
    XML_CHAR_ENCODING_UCS4_2143 = 7,
    XML_CHAR_ENCODING_UCS4_3412 = 8,
    XML_CHAR_ENCODING_UCS2 = 9,
    XML_CHAR_ENCODING_8859_1 = 10,
    XML_CHAR_ENCODING_8859_2 = 11,
    XML_CHAR_ENCODING_8859_3 = 12,
    XML_CHAR_ENCODING_8859_4 = 13,
    XML_CHAR_ENCODING_8859_5 = 14,
    XML_CHAR_ENCODING_8859_6 = 15,
    XML_CHAR_ENCODING_8859_7 = 16,
    XML_CHAR_ENCODING_8859_8 = 17,
    XML_CHAR_ENCODING_8859_9 = 18,
    XML_CHAR_ENCODING_2022_JP = 19,
    XML_CHAR_ENCODING_SHIFT_JIS = 20,
    XML_CHAR_ENCODING_EUC_JP = 21,
    XML_CHAR_ENCODING_ASCII = 22
} xmlCharEncoding;
extern int UTF8Toisolat1(unsigned char *out, int *outlen,
			 const unsigned char *in, int *inlen);
extern int isolat1ToUTF8(unsigned char *out, int *outlen,
			 const unsigned char *in, int *inlen);
extern int xmlAddEncodingAlias(const char *name, const char *alias);
extern int xmlCharEncCloseFunc(xmlCharEncodingHandler * handler);
extern int xmlCharEncFirstLine(xmlCharEncodingHandler * handler,
			       xmlBufferPtr out, xmlBufferPtr in);
extern int xmlCharEncInFunc(xmlCharEncodingHandler * handler,
			    xmlBufferPtr out, xmlBufferPtr in);
extern int xmlCharEncOutFunc(xmlCharEncodingHandler * handler,
			     xmlBufferPtr out, xmlBufferPtr in);
extern void xmlCleanupCharEncodingHandlers(void);
extern void xmlCleanupEncodingAliases(void);
extern int xmlDelEncodingAlias(const char *alias);
extern xmlCharEncoding xmlDetectCharEncoding(const unsigned char *in,
					     int len);
extern xmlCharEncodingHandlerPtr xmlFindCharEncodingHandler(const char
							    *name);
extern xmlCharEncodingHandlerPtr xmlGetCharEncodingHandler(xmlCharEncoding
							   enc);
extern const char *xmlGetCharEncodingName(xmlCharEncoding enc);
extern const char *xmlGetEncodingAlias(const char *alias);
extern void xmlInitCharEncodingHandlers(void);
extern xmlCharEncodingHandlerPtr xmlNewCharEncodingHandler(const char
							   *name,
							   xmlCharEncodingInputFunc
							   input,
							   xmlCharEncodingOutputFunc
							   output);
extern xmlCharEncoding xmlParseCharEncoding(const char *name);
extern void xmlRegisterCharEncodingHandler(xmlCharEncodingHandlerPtr
					   handler);

19.2.9. libxml2/libxml/entities.h


typedef enum {
    XML_INTERNAL_GENERAL_ENTITY = 1,
    XML_EXTERNAL_GENERAL_PARSED_ENTITY = 2,
    XML_EXTERNAL_GENERAL_UNPARSED_ENTITY = 3,
    XML_INTERNAL_PARAMETER_ENTITY = 4,
    XML_EXTERNAL_PARAMETER_ENTITY = 5,
    XML_INTERNAL_PREDEFINED_ENTITY = 6
} xmlEntityType;
typedef struct _xmlEntity {
    void *_private;
    xmlElementType type;
    const xmlChar *name;
    struct _xmlNode *children;
    struct _xmlNode *last;
    struct _xmlDtd *parent;
    struct _xmlNode *next;
    struct _xmlNode *prev;
    struct _xmlDoc *doc;
    xmlChar *orig;
    xmlChar *content;
    int length;
    xmlEntityType etype;
    const xmlChar *ExternalID;
    const xmlChar *SystemID;
    struct _xmlEntity *nexte;
    const xmlChar *URI;
    int owner;
} xmlEntity;
typedef xmlEntity *xmlEntityPtr;
typedef struct _xmlHashTable xmlEntitiesTable;
typedef xmlEntitiesTable *xmlEntitiesTablePtr;
extern xmlEntityPtr xmlAddDocEntity(xmlDocPtr doc, const xmlChar * name,
				    int type, const xmlChar * ExternalID,
				    const xmlChar * SystemID,
				    const xmlChar * content);
extern xmlEntityPtr xmlAddDtdEntity(xmlDocPtr doc, const xmlChar * name,
				    int type, const xmlChar * ExternalID,
				    const xmlChar * SystemID,
				    const xmlChar * content);
extern xmlEntitiesTablePtr xmlCopyEntitiesTable(xmlEntitiesTablePtr table);
extern void xmlDumpEntitiesTable(xmlBufferPtr buf,
				 xmlEntitiesTablePtr table);
extern void xmlDumpEntityDecl(xmlBufferPtr buf, xmlEntityPtr ent);
extern xmlChar *xmlEncodeEntitiesReentrant(xmlDocPtr doc,
					   const xmlChar * input);
extern xmlChar *xmlEncodeSpecialChars(xmlDocPtr doc,
				      const xmlChar * input);
extern void xmlFreeEntitiesTable(xmlEntitiesTablePtr table);
extern xmlEntityPtr xmlGetDocEntity(xmlDocPtr doc, const xmlChar * name);
extern xmlEntityPtr xmlGetDtdEntity(xmlDocPtr doc, const xmlChar * name);
extern xmlEntityPtr xmlGetParameterEntity(xmlDocPtr doc,
					  const xmlChar * name);
extern xmlEntityPtr xmlGetPredefinedEntity(const xmlChar * name);

19.2.10. libxml2/libxml/globals.h


#define xmlDeregisterNodeDefaultValue	 \
	(*(__xmlDeregisterNodeDefaultValue()))
#define xmlDoValidityCheckingDefaultValue	 \
	(*(__xmlDoValidityCheckingDefaultValue()))
#define xmlOutputBufferCreateFilenameValue	 \
	(*(__xmlOutputBufferCreateFilenameValue()))
#define xmlParserInputBufferCreateFilenameValue	 \
	(*(__xmlParserInputBufferCreateFilenameValue()))
#define xmlPedanticParserDefaultValue	 \
	(*(__xmlPedanticParserDefaultValue()))
#define xmlSubstituteEntitiesDefaultValue	 \
	(*(__xmlSubstituteEntitiesDefaultValue()))
#define docbDefaultSAXHandler	(*(__docbDefaultSAXHandler()))
#define htmlDefaultSAXHandler	(*(__htmlDefaultSAXHandler()))
#define oldXMLWDcompatibility	(*(__oldXMLWDcompatibility()))
#define xmlBufferAllocScheme	(*(__xmlBufferAllocScheme()))
#define xmlDefaultBufferSize	(*(__xmlDefaultBufferSize()))
#define xmlDefaultSAXHandler	(*(__xmlDefaultSAXHandler()))
#define xmlDefaultSAXLocator	(*(__xmlDefaultSAXLocator()))
#define xmlGenericError	(*(__xmlGenericError()))
#define xmlGenericErrorContext	(*(__xmlGenericErrorContext()))
#define xmlGetWarningsDefaultValue	(*(__xmlGetWarningsDefaultValue()))
#define xmlIndentTreeOutput	(*(__xmlIndentTreeOutput()))
#define xmlKeepBlanksDefaultValue	(*(__xmlKeepBlanksDefaultValue()))
#define xmlLastError	(*(__xmlLastError()))
#define xmlLineNumbersDefaultValue	(*(__xmlLineNumbersDefaultValue()))
#define xmlLoadExtDtdDefaultValue	(*(__xmlLoadExtDtdDefaultValue()))
#define xmlParserDebugEntities	(*(__xmlParserDebugEntities()))
#define xmlParserVersion	(*(__xmlParserVersion()))
#define xmlRegisterNodeDefaultValue	(*(__xmlRegisterNodeDefaultValue()))
#define xmlSaveNoEmptyTags	(*(__xmlSaveNoEmptyTags()))
#define xmlStructuredError	(*(__xmlStructuredError()))
#define xmlTreeIndentString	(*(__xmlTreeIndentString()))

typedef xmlOutputBufferPtr(*xmlOutputBufferCreateFilenameFunc) (const char
								*,
								xmlCharEncodingHandlerPtr,
								int);
typedef void (*xmlRegisterNodeFunc) (xmlNodePtr);
typedef
xmlParserInputBufferPtr(*xmlParserInputBufferCreateFilenameFunc) (const
								  char *,
								  xmlCharEncoding);
typedef 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;
    getParameterEntitySAXFunc getParameterEntity;
    cdataBlockSAXFunc cdataBlock;
    externalSubsetSAXFunc externalSubset;
    unsigned int initialized;
} xmlSAXHandlerV1;
typedef void (*xmlDeregisterNodeFunc) (xmlNodePtr);
typedef struct _xmlGlobalState xmlGlobalState;
typedef xmlGlobalState *xmlGlobalStatePtr;
extern xmlSAXHandlerV1 *__docbDefaultSAXHandler(void);
extern xmlSAXHandlerV1 *__htmlDefaultSAXHandler(void);
extern int *__oldXMLWDcompatibility(void);
extern xmlBufferAllocationScheme *__xmlBufferAllocScheme(void);
extern int *__xmlDefaultBufferSize(void);
extern xmlSAXHandlerV1 *__xmlDefaultSAXHandler(void);
extern xmlSAXLocator *__xmlDefaultSAXLocator(void);
extern xmlDeregisterNodeFunc *__xmlDeregisterNodeDefaultValue(void);
extern int *__xmlDoValidityCheckingDefaultValue(void);
extern xmlGenericErrorFunc *__xmlGenericError(void);
extern void **__xmlGenericErrorContext(void);
extern int *__xmlGetWarningsDefaultValue(void);
extern int *__xmlIndentTreeOutput(void);
extern int *__xmlKeepBlanksDefaultValue(void);
extern xmlError *__xmlLastError(void);
extern int *__xmlLineNumbersDefaultValue(void);
extern int *__xmlLoadExtDtdDefaultValue(void);
extern xmlOutputBufferCreateFilenameFunc
    *__xmlOutputBufferCreateFilenameValue(void);
extern int *__xmlParserDebugEntities(void);
extern xmlParserInputBufferCreateFilenameFunc
    *__xmlParserInputBufferCreateFilenameValue(void);
extern const char **__xmlParserVersion(void);
extern int *__xmlPedanticParserDefaultValue(void);
extern xmlRegisterNodeFunc *__xmlRegisterNodeDefaultValue(void);
extern int *__xmlSaveNoEmptyTags(void);
extern xmlStructuredErrorFunc *__xmlStructuredError(void);
extern int *__xmlSubstituteEntitiesDefaultValue(void);
extern const char **__xmlTreeIndentString(void);
extern void xmlCleanupGlobals(void);
extern xmlDeregisterNodeFunc xmlDeregisterNodeDefault(xmlDeregisterNodeFunc
						      func);
extern xmlFreeFunc xmlFree;
extern void xmlInitGlobals(void);
extern void xmlInitializeGlobalState(xmlGlobalStatePtr gs);
extern xmlMallocFunc xmlMalloc;
extern xmlMallocFunc xmlMallocAtomic;
extern xmlStrdupFunc xmlMemStrdup;
extern xmlOutputBufferCreateFilenameFunc
xmlOutputBufferCreateFilenameDefault(xmlOutputBufferCreateFilenameFunc
				     func);
extern xmlParserInputBufferPtr xmlParserInputBufferCreateFilename(const
								  char
								  *URI,
								  xmlCharEncoding
								  enc);
extern xmlParserInputBufferCreateFilenameFunc
xmlParserInputBufferCreateFilenameDefault
(xmlParserInputBufferCreateFilenameFunc func);
extern xmlReallocFunc xmlRealloc;
extern xmlRegisterNodeFunc xmlRegisterNodeDefault(xmlRegisterNodeFunc
						  func);
extern xmlBufferAllocationScheme
xmlThrDefBufferAllocScheme(xmlBufferAllocationScheme v);
extern int xmlThrDefDefaultBufferSize(int v);
extern xmlDeregisterNodeFunc
xmlThrDefDeregisterNodeDefault(xmlDeregisterNodeFunc func);
extern int xmlThrDefDoValidityCheckingDefaultValue(int v);
extern int xmlThrDefGetWarningsDefaultValue(int v);
extern int xmlThrDefIndentTreeOutput(int v);
extern int xmlThrDefKeepBlanksDefaultValue(int v);
extern int xmlThrDefLineNumbersDefaultValue(int v);
extern int xmlThrDefLoadExtDtdDefaultValue(int v);
extern xmlOutputBufferCreateFilenameFunc
xmlThrDefOutputBufferCreateFilenameDefault
(xmlOutputBufferCreateFilenameFunc func);
extern int xmlThrDefParserDebugEntities(int v);
extern xmlParserInputBufferCreateFilenameFunc
xmlThrDefParserInputBufferCreateFilenameDefault
(xmlParserInputBufferCreateFilenameFunc func);
extern int xmlThrDefPedanticParserDefaultValue(int v);
extern xmlRegisterNodeFunc xmlThrDefRegisterNodeDefault(xmlRegisterNodeFunc
							func);
extern int xmlThrDefSaveNoEmptyTags(int v);
extern void xmlThrDefSetGenericErrorFunc(void *ctx,
					 xmlGenericErrorFunc handler);
extern void xmlThrDefSetStructuredErrorFunc(void *ctx,
					    xmlStructuredErrorFunc
					    handler);
extern int xmlThrDefSubstituteEntitiesDefaultValue(int v);
extern const char *xmlThrDefTreeIndentString(const char *v);

19.2.11. libxml2/libxml/hash.h


#define XML_CAST_FPTR(fptr)	fptr

typedef struct _xmlHashTable xmlHashTable;
typedef xmlHashTable *xmlHashTablePtr;
typedef void (*xmlHashDeallocator) (void *, xmlChar *);
typedef void (*xmlHashScannerFull) (void *, void *, const xmlChar *,
				    const xmlChar *, const xmlChar *);
typedef void *(*xmlHashCopier) (void *, xmlChar *);
typedef void (*xmlHashScanner) (void *, void *, xmlChar *);
extern int xmlHashAddEntry(xmlHashTablePtr table, const xmlChar * name,
			   void *userdata);
extern int xmlHashAddEntry2(xmlHashTablePtr table, const xmlChar * name,
			    const xmlChar * name2, void *userdata);
extern int xmlHashAddEntry3(xmlHashTablePtr table, const xmlChar * name,
			    const xmlChar * name2, const xmlChar * name3,
			    void *userdata);
extern xmlHashTablePtr xmlHashCopy(xmlHashTablePtr table, xmlHashCopier f);
extern xmlHashTablePtr xmlHashCreate(int size);
extern xmlHashTablePtr xmlHashCreateDict(int size, xmlDictPtr dict);
extern void xmlHashFree(xmlHashTablePtr table, xmlHashDeallocator f);
extern void *xmlHashLookup(xmlHashTablePtr table, const xmlChar * name);
extern void *xmlHashLookup2(xmlHashTablePtr table, const xmlChar * name,
			    const xmlChar * name2);
extern void *xmlHashLookup3(xmlHashTablePtr table, const xmlChar * name,
			    const xmlChar * name2, const xmlChar * name3);
extern void *xmlHashQLookup(xmlHashTablePtr table, const xmlChar * name,
			    const xmlChar * prefix);
extern void *xmlHashQLookup2(xmlHashTablePtr table, const xmlChar * name,
			     const xmlChar * prefix, const xmlChar * name2,
			     const xmlChar * prefix2);
extern void *xmlHashQLookup3(xmlHashTablePtr table, const xmlChar * name,
			     const xmlChar * prefix, const xmlChar * name2,
			     const xmlChar * prefix2,
			     const xmlChar * name3,
			     const xmlChar * prefix3);
extern int xmlHashRemoveEntry(xmlHashTablePtr table, const xmlChar * name,
			      xmlHashDeallocator f);
extern int xmlHashRemoveEntry2(xmlHashTablePtr table, const xmlChar * name,
			       const xmlChar * name2,
			       xmlHashDeallocator f);
extern int xmlHashRemoveEntry3(xmlHashTablePtr table, const xmlChar * name,
			       const xmlChar * name2,
			       const xmlChar * name3,
			       xmlHashDeallocator f);
extern void xmlHashScan(xmlHashTablePtr table, xmlHashScanner f,
			void *data);
extern void xmlHashScan3(xmlHashTablePtr table, const xmlChar * name,
			 const xmlChar * name2, const xmlChar * name3,
			 xmlHashScanner f, void *data);
extern void xmlHashScanFull(xmlHashTablePtr table, xmlHashScannerFull f,
			    void *data);
extern void xmlHashScanFull3(xmlHashTablePtr table, const xmlChar * name,
			     const xmlChar * name2, const xmlChar * name3,
			     xmlHashScannerFull f, void *data);
extern int xmlHashSize(xmlHashTablePtr table);
extern int xmlHashUpdateEntry(xmlHashTablePtr table, const xmlChar * name,
			      void *userdata, xmlHashDeallocator f);
extern int xmlHashUpdateEntry2(xmlHashTablePtr table, const xmlChar * name,
			       const xmlChar * name2, void *userdata,
			       xmlHashDeallocator f);
extern int xmlHashUpdateEntry3(xmlHashTablePtr table, const xmlChar * name,
			       const xmlChar * name2,
			       const xmlChar * name3, void *userdata,
			       xmlHashDeallocator f);

19.2.12. libxml2/libxml/list.h


typedef struct _xmlList xmlList;
typedef xmlList *xmlListPtr;
typedef struct _xmlLink xmlLink;
typedef xmlLink *xmlLinkPtr;
typedef int (*xmlListWalker) (const void *, const void *);
typedef void (*xmlListDeallocator) (xmlLinkPtr);
typedef int (*xmlListDataCompare) (const void *, const void *);
extern void *xmlLinkGetData(xmlLinkPtr lk);
extern int xmlListAppend(xmlListPtr l, void *data);
extern void xmlListClear(xmlListPtr l);
extern int xmlListCopy(xmlListPtr cur, const xmlListPtr old);
extern xmlListPtr xmlListCreate(xmlListDeallocator deallocator,
				xmlListDataCompare compare);
extern void xmlListDelete(xmlListPtr l);
extern xmlListPtr xmlListDup(const xmlListPtr old);
extern int xmlListEmpty(xmlListPtr l);
extern xmlLinkPtr xmlListEnd(xmlListPtr l);
extern xmlLinkPtr xmlListFront(xmlListPtr l);
extern int xmlListInsert(xmlListPtr l, void *data);
extern void xmlListMerge(xmlListPtr l1, xmlListPtr l2);
extern void xmlListPopBack(xmlListPtr l);
extern void xmlListPopFront(xmlListPtr l);
extern int xmlListPushBack(xmlListPtr l, void *data);
extern int xmlListPushFront(xmlListPtr l, void *data);
extern int xmlListRemoveAll(xmlListPtr l, void *data);
extern int xmlListRemoveFirst(xmlListPtr l, void *data);
extern int xmlListRemoveLast(xmlListPtr l, void *data);
extern void xmlListReverse(xmlListPtr l);
extern void *xmlListReverseSearch(xmlListPtr l, void *data);
extern void xmlListReverseWalk(xmlListPtr l, xmlListWalker walker,
			       const void *user);
extern void *xmlListSearch(xmlListPtr l, void *data);
extern int xmlListSize(xmlListPtr l);
extern void xmlListSort(xmlListPtr l);
extern void xmlListWalk(xmlListPtr l, xmlListWalker walker,
			const void *user);

19.2.13. libxml2/libxml/parser.h


#define XML_DEFAULT_VERSION	"1.0"
#define XML_SAX2_MAGIC	0xDEEDBEAF
#define XML_DETECT_IDS	2
#define XML_COMPLETE_ATTRS	4
#define XML_SKIP_IDS	8

typedef xmlSAXHandler *xmlSAXHandlerPtr;
typedef xmlParserNodeInfoSeq *xmlParserNodeInfoSeqPtr;
typedef xmlParserInputPtr(*xmlExternalEntityLoader) (const char *,
						     const char *,
						     xmlParserCtxtPtr);
typedef xmlParserNodeInfo *xmlParserNodeInfoPtr;
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_NONE = 99999
} xmlFeature;
typedef enum {
    XML_PARSE_RECOVER = 1 << 0,
    XML_PARSE_NOENT = 1 << 1,
    XML_PARSE_DTDLOAD = 1 << 2,
    XML_PARSE_DTDATTR = 1 << 3,
    XML_PARSE_DTDVALID = 1 << 4,
    XML_PARSE_NOERROR = 1 << 5,
    XML_PARSE_NOWARNING = 1 << 6,
    XML_PARSE_PEDANTIC = 1 << 7,
    XML_PARSE_NOBLANKS = 1 << 8,
    XML_PARSE_SAX1 = 1 << 9,
    XML_PARSE_XINCLUDE = 1 << 10,
    XML_PARSE_NONET = 1 << 11,
    XML_PARSE_NODICT = 1 << 12,
    XML_PARSE_NSCLEAN = 1 << 13,
    XML_PARSE_NOCDATA = 1 << 14,
    XML_PARSE_NOXINCNODE = 1 << 15,
    XML_PARSE_COMPACT = 1 << 16
} xmlParserOption;
extern long int xmlByteConsumed(xmlParserCtxtPtr ctxt);
extern void xmlCleanupParser(void);
extern void xmlClearNodeInfoSeq(xmlParserNodeInfoSeqPtr seq);
extern void xmlClearParserCtxt(xmlParserCtxtPtr ctxt);
extern xmlParserCtxtPtr xmlCreateDocParserCtxt(const xmlChar * cur);
extern xmlParserCtxtPtr xmlCreateIOParserCtxt(xmlSAXHandlerPtr sax,
					      void *user_data,
					      xmlInputReadCallback ioread,
					      xmlInputCloseCallback
					      ioclose, void *ioctx,
					      xmlCharEncoding enc);
extern xmlParserCtxtPtr xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax,
						void *user_data,
						const char *chunk,
						int size,
						const char *filename);
extern xmlDocPtr xmlCtxtReadDoc(xmlParserCtxtPtr ctxt, const xmlChar * cur,
				const char *URL, const char *encoding,
				int options);
extern xmlDocPtr xmlCtxtReadFd(xmlParserCtxtPtr ctxt, int fd,
			       const char *URL, const char *encoding,
			       int options);
extern xmlDocPtr xmlCtxtReadFile(xmlParserCtxtPtr ctxt,
				 const char *filename,
				 const char *encoding, int options);
extern xmlDocPtr xmlCtxtReadIO(xmlParserCtxtPtr ctxt,
			       xmlInputReadCallback ioread,
			       xmlInputCloseCallback ioclose, void *ioctx,
			       const char *URL, const char *encoding,
			       int options);
extern xmlDocPtr xmlCtxtReadMemory(xmlParserCtxtPtr ctxt,
				   const char *buffer, int size,
				   const char *URL, const char *encoding,
				   int options);
extern void xmlCtxtReset(xmlParserCtxtPtr ctxt);
extern int xmlCtxtResetPush(xmlParserCtxtPtr ctxt, const char *chunk,
			    int size, const char *filename,
			    const char *encoding);
extern int xmlCtxtUseOptions(xmlParserCtxtPtr ctxt, int options);
extern void xmlFreeParserCtxt(xmlParserCtxtPtr ctxt);
extern xmlExternalEntityLoader xmlGetExternalEntityLoader(void);
extern int xmlHasFeature(xmlFeature feature);
extern xmlDtdPtr xmlIOParseDTD(xmlSAXHandlerPtr sax,
			       xmlParserInputBufferPtr input,
			       xmlCharEncoding enc);
extern void xmlInitNodeInfoSeq(xmlParserNodeInfoSeqPtr seq);
extern void xmlInitParser(void);
extern int xmlInitParserCtxt(xmlParserCtxtPtr ctxt);
extern int xmlKeepBlanksDefault(int val);
extern int xmlLineNumbersDefault(int val);
extern xmlParserInputPtr xmlLoadExternalEntity(const char *URL,
					       const char *ID,
					       xmlParserCtxtPtr ctxt);
extern xmlParserInputPtr xmlNewIOInputStream(xmlParserCtxtPtr ctxt,
					     xmlParserInputBufferPtr input,
					     xmlCharEncoding enc);
extern xmlParserCtxtPtr xmlNewParserCtxt(void);
extern int xmlParseBalancedChunkMemory(xmlDocPtr doc, xmlSAXHandlerPtr sax,
				       void *user_data, int depth,
				       const xmlChar * string,
				       xmlNodePtr * lst);
extern int xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc,
					      xmlSAXHandlerPtr sax,
					      void *user_data, int depth,
					      const xmlChar * string,
					      xmlNodePtr * lst,
					      int recover);
extern int xmlParseChunk(xmlParserCtxtPtr ctxt, const char *chunk,
			 int size, int terminate);
extern int xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx,
				      const xmlChar * URL,
				      const xmlChar * ID,
				      xmlNodePtr * lst);
extern xmlDtdPtr xmlParseDTD(const xmlChar * ExternalID,
			     const xmlChar * SystemID);
extern xmlDocPtr xmlParseDoc(const xmlChar * cur);
extern int xmlParseDocument(xmlParserCtxtPtr ctxt);
extern xmlDocPtr xmlParseEntity(const char *filename);
extern int xmlParseExtParsedEnt(xmlParserCtxtPtr ctxt);
extern int xmlParseExternalEntity(xmlDocPtr doc, xmlSAXHandlerPtr sax,
				  void *user_data, int depth,
				  const xmlChar * URL, const xmlChar * ID,
				  xmlNodePtr * lst);
extern xmlDocPtr xmlParseFile(const char *filename);
extern xmlParserErrors xmlParseInNodeContext(xmlNodePtr node,
					     const char *data, int datalen,
					     int options,
					     xmlNodePtr * lst);
extern xmlDocPtr xmlParseMemory(const char *buffer, int size);
extern void xmlParserAddNodeInfo(xmlParserCtxtPtr ctxt,
				 const xmlParserNodeInfoPtr info);
extern const xmlParserNodeInfo *xmlParserFindNodeInfo(const
						      xmlParserCtxtPtr
						      ctxt,
						      const xmlNodePtr
						      node);
extern long unsigned int xmlParserFindNodeInfoIndex(const
						    xmlParserNodeInfoSeqPtr
						    seq,
						    const xmlNodePtr node);
extern int xmlParserInputGrow(xmlParserInputPtr in, int len);
extern int xmlParserInputRead(xmlParserInputPtr in, int len);
extern int xmlPedanticParserDefault(int val);
extern xmlDocPtr xmlReadDoc(const xmlChar * cur, const char *URL,
			    const char *encoding, int options);
extern xmlDocPtr xmlReadFd(int fd, const char *URL, const char *encoding,
			   int options);
extern xmlDocPtr xmlReadFile(const char *URL, const char *encoding,
			     int options);
extern xmlDocPtr xmlReadIO(xmlInputReadCallback ioread,
			   xmlInputCloseCallback ioclose, void *ioctx,
			   const char *URL, const char *encoding,
			   int options);
extern xmlDocPtr xmlReadMemory(const char *buffer, int size,
			       const char *URL, const char *encoding,
			       int options);
extern xmlDocPtr xmlRecoverDoc(xmlChar * cur);
extern xmlDocPtr xmlRecoverFile(const char *filename);
extern xmlDocPtr xmlRecoverMemory(const char *buffer, int size);
extern xmlDtdPtr xmlSAXParseDTD(xmlSAXHandlerPtr sax,
				const xmlChar * ExternalID,
				const xmlChar * SystemID);
extern xmlDocPtr xmlSAXParseDoc(xmlSAXHandlerPtr sax, const xmlChar * cur,
				int recovery);
extern xmlDocPtr xmlSAXParseEntity(xmlSAXHandlerPtr sax,
				   const char *filename);
extern xmlDocPtr xmlSAXParseFile(xmlSAXHandlerPtr sax,
				 const char *filename, int recovery);
extern xmlDocPtr xmlSAXParseFileWithData(xmlSAXHandlerPtr sax,
					 const char *filename,
					 int recovery, void *data);
extern xmlDocPtr xmlSAXParseMemory(xmlSAXHandlerPtr sax,
				   const char *buffer, int size,
				   int recovery);
extern xmlDocPtr xmlSAXParseMemoryWithData(xmlSAXHandlerPtr sax,
					   const char *buffer, int size,
					   int recovery, void *data);
extern int xmlSAXUserParseFile(xmlSAXHandlerPtr sax, void *user_data,
			       const char *filename);
extern int xmlSAXUserParseMemory(xmlSAXHandlerPtr sax, void *user_data,
				 const char *buffer, int size);
extern void xmlSetExternalEntityLoader(xmlExternalEntityLoader f);
extern void xmlSetupParserForBuffer(xmlParserCtxtPtr ctxt,
				    const xmlChar * buffer,
				    const char *filename);
extern void xmlStopParser(xmlParserCtxtPtr ctxt);
extern int xmlSubstituteEntitiesDefault(int val);

19.2.14. libxml2/libxml/parserInternals.h


#define IS_ASCII_LETTER(c)	 \
	(((0x41 <= (c)) && ((c) <= 0x5a)) || ((0x61 <= (c)) && ((c) <= \
	0x7a)))
#define SKIP_EOL(p)	 \
	if (*(p) == 0x13) { p++ ; if (*(p) == 0x10) p++; } if (*(p) == 0x10) \
	{ p++ ; if (*(p) == 0x13) p++; }
#define IS_ASCII_DIGIT(c)	((0x30 <= (c)) && ((c) <= 0x39))
#define IS_LETTER(c)	(IS_BASECHAR(c) || IS_IDEOGRAPHIC(c))
#define IS_COMBINING_CH(c)	0
#define XML_SUBSTITUTE_NONE	0
#define XML_SUBSTITUTE_REF	1
#define XML_MAX_NAMELEN	100
#define XML_SUBSTITUTE_PEREF	2
#define INPUT_CHUNK	250
#define XML_SUBSTITUTE_BOTH	3
#define MOVETO_STARTTAG(p)	while ((*p) && (*(p) != '<')) (p)++
#define MOVETO_ENDTAG(p)	while ((*p) && (*(p) != '>')) (p)++
#define IS_BASECHAR(c)	xmlIsBaseCharQ(c)
#define IS_LETTER_CH(c)	xmlIsBaseChar_ch(c)
#define IS_BLANK(c)	xmlIsBlankQ(c)
#define IS_BLANK_CH(c)	xmlIsBlank_ch(c)
#define IS_CHAR(c)	xmlIsCharQ(c)
#define IS_BYTE_CHAR(c)	xmlIsChar_ch(c)
#define IS_CHAR_CH(c)	xmlIsChar_ch(c)
#define IS_COMBINING(c)	xmlIsCombiningQ(c)
#define IS_DIGIT(c)	xmlIsDigitQ(c)
#define IS_DIGIT_CH(c)	xmlIsDigit_ch(c)
#define IS_EXTENDER(c)	xmlIsExtenderQ(c)
#define IS_EXTENDER_CH(c)	xmlIsExtender_ch(c)
#define IS_IDEOGRAPHIC(c)	xmlIsIdeographicQ(c)
#define IS_PUBIDCHAR(c)	xmlIsPubidCharQ(c)
#define IS_PUBIDCHAR_CH(c)	xmlIsPubidChar_ch(c)

typedef void (*xmlEntityReferenceFunc) (xmlEntityPtr, xmlNodePtr,
					xmlNodePtr);
extern htmlParserCtxtPtr htmlCreateFileParserCtxt(const char *filename,
						  const char *encoding);
extern void htmlInitAutoClose(void);
extern xmlParserInputPtr inputPop(xmlParserCtxtPtr ctxt);
extern int inputPush(xmlParserCtxtPtr ctxt, xmlParserInputPtr value);
extern const xmlChar *namePop(xmlParserCtxtPtr ctxt);
extern int namePush(xmlParserCtxtPtr ctxt, const xmlChar * value);
extern xmlNodePtr nodePop(xmlParserCtxtPtr ctxt);
extern int nodePush(xmlParserCtxtPtr ctxt, xmlNodePtr value);
extern int xmlCopyChar(int len, xmlChar * out, int val);
extern int xmlCopyCharMultiByte(xmlChar * out, int val);
extern xmlParserCtxtPtr xmlCreateEntityParserCtxt(const xmlChar * URL,
						  const xmlChar * ID,
						  const xmlChar * base);
extern xmlParserCtxtPtr xmlCreateFileParserCtxt(const char *filename);
extern xmlParserCtxtPtr xmlCreateMemoryParserCtxt(const char *buffer,
						  int size);
extern xmlParserCtxtPtr xmlCreateURLParserCtxt(const char *filename,
					       int options);
extern int xmlCurrentChar(xmlParserCtxtPtr ctxt, int *len);
extern void xmlFreeInputStream(xmlParserInputPtr input);
extern int xmlIsLetter(int c);
extern xmlParserInputPtr xmlNewEntityInputStream(xmlParserCtxtPtr ctxt,
						 xmlEntityPtr entity);
extern xmlParserInputPtr xmlNewInputFromFile(xmlParserCtxtPtr ctxt,
					     const char *filename);
extern xmlParserInputPtr xmlNewInputStream(xmlParserCtxtPtr ctxt);
extern xmlParserInputPtr xmlNewStringInputStream(xmlParserCtxtPtr ctxt,
						 const xmlChar * buffer);
extern void xmlNextChar(xmlParserCtxtPtr ctxt);
extern xmlChar *xmlParseAttValue(xmlParserCtxtPtr ctxt);
extern const xmlChar *xmlParseAttribute(xmlParserCtxtPtr ctxt,
					xmlChar * *value);
extern void xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt);
extern int xmlParseAttributeType(xmlParserCtxtPtr ctxt,
				 xmlEnumerationPtr * tree);
extern void xmlParseCDSect(xmlParserCtxtPtr ctxt);
extern void xmlParseCharData(xmlParserCtxtPtr ctxt, int cdata);
extern int xmlParseCharRef(xmlParserCtxtPtr ctxt);
extern void xmlParseComment(xmlParserCtxtPtr ctxt);
extern void xmlParseContent(xmlParserCtxtPtr ctxt);
extern int xmlParseDefaultDecl(xmlParserCtxtPtr ctxt, xmlChar * *value);
extern void xmlParseDocTypeDecl(xmlParserCtxtPtr ctxt);
extern void xmlParseElement(xmlParserCtxtPtr ctxt);
extern xmlElementContentPtr
xmlParseElementChildrenContentDecl(xmlParserCtxtPtr ctxt, int inputchk);
extern int xmlParseElementContentDecl(xmlParserCtxtPtr ctxt,
				      const xmlChar * name,
				      xmlElementContentPtr * result);
extern int xmlParseElementDecl(xmlParserCtxtPtr ctxt);
extern xmlElementContentPtr
xmlParseElementMixedContentDecl(xmlParserCtxtPtr ctxt, int inputchk);
extern xmlChar *xmlParseEncName(xmlParserCtxtPtr ctxt);
extern const xmlChar *xmlParseEncodingDecl(xmlParserCtxtPtr ctxt);
extern void xmlParseEndTag(xmlParserCtxtPtr ctxt);
extern void xmlParseEntityDecl(xmlParserCtxtPtr ctxt);
extern xmlEntityPtr xmlParseEntityRef(xmlParserCtxtPtr ctxt);
extern xmlChar *xmlParseEntityValue(xmlParserCtxtPtr ctxt,
				    xmlChar * *orig);
extern int xmlParseEnumeratedType(xmlParserCtxtPtr ctxt,
				  xmlEnumerationPtr * tree);
extern xmlEnumerationPtr xmlParseEnumerationType(xmlParserCtxtPtr ctxt);
extern xmlChar *xmlParseExternalID(xmlParserCtxtPtr ctxt,
				   xmlChar * *publicID, int strict);
extern void xmlParseExternalSubset(xmlParserCtxtPtr ctxt,
				   const xmlChar * ExternalID,
				   const xmlChar * SystemID);
extern void xmlParseMarkupDecl(xmlParserCtxtPtr ctxt);
extern void xmlParseMisc(xmlParserCtxtPtr ctxt);
extern const xmlChar *xmlParseName(xmlParserCtxtPtr ctxt);
extern xmlChar *xmlParseNmtoken(xmlParserCtxtPtr ctxt);
extern void xmlParseNotationDecl(xmlParserCtxtPtr ctxt);
extern xmlEnumerationPtr xmlParseNotationType(xmlParserCtxtPtr ctxt);
extern void xmlParsePEReference(xmlParserCtxtPtr ctxt);
extern void xmlParsePI(xmlParserCtxtPtr ctxt);
extern const xmlChar *xmlParsePITarget(xmlParserCtxtPtr ctxt);
extern xmlChar *xmlParsePubidLiteral(xmlParserCtxtPtr ctxt);
extern void xmlParseReference(xmlParserCtxtPtr ctxt);
extern int xmlParseSDDecl(xmlParserCtxtPtr ctxt);
extern const xmlChar *xmlParseStartTag(xmlParserCtxtPtr ctxt);
extern xmlChar *xmlParseSystemLiteral(xmlParserCtxtPtr ctxt);
extern void xmlParseTextDecl(xmlParserCtxtPtr ctxt);
extern xmlChar *xmlParseVersionInfo(xmlParserCtxtPtr ctxt);
extern xmlChar *xmlParseVersionNum(xmlParserCtxtPtr ctxt);
extern void xmlParseXMLDecl(xmlParserCtxtPtr ctxt);
extern void xmlParserHandlePEReference(xmlParserCtxtPtr ctxt);
extern void xmlParserInputShrink(xmlParserInputPtr in);
extern unsigned int xmlParserMaxDepth;
extern xmlChar xmlPopInput(xmlParserCtxtPtr ctxt);
extern void xmlPushInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr input);
extern void xmlSetEntityReferenceFunc(xmlEntityReferenceFunc func);
extern int xmlSkipBlankChars(xmlParserCtxtPtr ctxt);
extern xmlChar *xmlSplitQName(xmlParserCtxtPtr ctxt, const xmlChar * name,
			      xmlChar * *prefix);
extern const xmlChar const xmlStringComment[];
extern int xmlStringCurrentChar(xmlParserCtxtPtr ctxt, const xmlChar * cur,
				int *len);
extern xmlChar *xmlStringDecodeEntities(xmlParserCtxtPtr ctxt,
					const xmlChar * str, int what,
					xmlChar end, xmlChar end2,
					xmlChar end3);
extern xmlChar *xmlStringLenDecodeEntities(xmlParserCtxtPtr ctxt,
					   const xmlChar * str, int len,
					   int what, xmlChar end,
					   xmlChar end2, xmlChar end3);
extern const xmlChar const xmlStringText[];
extern const xmlChar const xmlStringTextNoenc[];
extern int xmlSwitchEncoding(xmlParserCtxtPtr ctxt, xmlCharEncoding enc);
extern int xmlSwitchInputEncoding(xmlParserCtxtPtr ctxt,
				  xmlParserInputPtr input,
				  xmlCharEncodingHandlerPtr handler);
extern int xmlSwitchToEncoding(xmlParserCtxtPtr ctxt,
			       xmlCharEncodingHandlerPtr handler);

19.2.15. libxml2/libxml/pattern.h


typedef struct _xmlStreamCtxt xmlStreamCtxt;
typedef xmlStreamCtxt *xmlStreamCtxtPtr;
typedef struct _xmlPattern xmlPattern;
typedef xmlPattern *xmlPatternPtr;
typedef enum {
    XML_PATTERN_DEFAULT = 0,
    XML_PATTERN_XPATH = 1 << 0,
    XML_PATTERN_XSSEL = 1 << 1,
    XML_PATTERN_XSFIELD = 1 << 2
} xmlPatternFlags;
extern void xmlFreePattern(xmlPatternPtr comp);
extern void xmlFreePatternList(xmlPatternPtr comp);
extern void xmlFreeStreamCtxt(xmlStreamCtxtPtr stream);
extern int xmlPatternFromRoot(xmlPatternPtr comp);
extern xmlStreamCtxtPtr xmlPatternGetStreamCtxt(xmlPatternPtr comp);
extern int xmlPatternMatch(xmlPatternPtr comp, xmlNodePtr node);
extern int xmlPatternMaxDepth(xmlPatternPtr comp);
extern int xmlPatternMinDepth(xmlPatternPtr comp);
extern int xmlPatternStreamable(xmlPatternPtr comp);
extern xmlPatternPtr xmlPatterncompile(const xmlChar * pattern,
				       xmlDict * dict, int flags,
				       const xmlChar * *namespaces);
extern int xmlStreamPop(xmlStreamCtxtPtr stream);
extern int xmlStreamPush(xmlStreamCtxtPtr stream, const xmlChar * name,
			 const xmlChar * ns);
extern int xmlStreamPushAttr(xmlStreamCtxtPtr stream, const xmlChar * name,
			     const xmlChar * ns);

19.2.16. libxml2/libxml/relaxng.h


typedef struct _xmlRelaxNGParserCtxt xmlRelaxNGParserCtxt;
typedef xmlRelaxNGParserCtxt *xmlRelaxNGParserCtxtPtr;
typedef struct _xmlRelaxNGValidCtxt xmlRelaxNGValidCtxt;
typedef xmlRelaxNGValidCtxt *xmlRelaxNGValidCtxtPtr;
typedef struct _xmlRelaxNG xmlRelaxNG;
typedef xmlRelaxNG *xmlRelaxNGPtr;
typedef void (*xmlRelaxNGValidityErrorFunc) (void *, const char *, ...);
typedef void (*xmlRelaxNGValidityWarningFunc) (void *, const char *, ...);
typedef enum {
    XML_RELAXNG_OK = 0,
    XML_RELAXNG_ERR_MEMORY,
    XML_RELAXNG_ERR_TYPE,
    XML_RELAXNG_ERR_TYPEVAL,
    XML_RELAXNG_ERR_DUPID,
    XML_RELAXNG_ERR_TYPECMP,
    XML_RELAXNG_ERR_NOSTATE,
    XML_RELAXNG_ERR_NODEFINE,
    XML_RELAXNG_ERR_LISTEXTRA,
    XML_RELAXNG_ERR_LISTEMPTY,
    XML_RELAXNG_ERR_INTERNODATA,
    XML_RELAXNG_ERR_INTERSEQ,
    XML_RELAXNG_ERR_INTEREXTRA,
    XML_RELAXNG_ERR_ELEMNAME,
    XML_RELAXNG_ERR_ATTRNAME,
    XML_RELAXNG_ERR_ELEMNONS,
    XML_RELAXNG_ERR_ATTRNONS,
    XML_RELAXNG_ERR_ELEMWRONGNS,
    XML_RELAXNG_ERR_ATTRWRONGNS,
    XML_RELAXNG_ERR_ELEMEXTRANS,
    XML_RELAXNG_ERR_ATTREXTRANS,
    XML_RELAXNG_ERR_ELEMNOTEMPTY,
    XML_RELAXNG_ERR_NOELEM,
    XML_RELAXNG_ERR_NOTELEM,
    XML_RELAXNG_ERR_ATTRVALID,
    XML_RELAXNG_ERR_CONTENTVALID,
    XML_RELAXNG_ERR_EXTRACONTENT,
    XML_RELAXNG_ERR_INVALIDATTR,
    XML_RELAXNG_ERR_DATAELEM,
    XML_RELAXNG_ERR_VALELEM,
    XML_RELAXNG_ERR_LISTELEM,
    XML_RELAXNG_ERR_DATATYPE,
    XML_RELAXNG_ERR_VALUE,
    XML_RELAXNG_ERR_LIST,
    XML_RELAXNG_ERR_NOGRAMMAR,
    XML_RELAXNG_ERR_EXTRADATA,
    XML_RELAXNG_ERR_LACKDATA,
    XML_RELAXNG_ERR_INTERNAL,
    XML_RELAXNG_ERR_ELEMWRONG,
    XML_RELAXNG_ERR_TEXTWRONG
} xmlRelaxNGValidErr;
typedef enum {
    XML_RELAXNGP_NONE = 0,
    XML_RELAXNGP_FREE_DOC = 1,
    XML_RELAXNGP_CRNG = 2
} xmlRelaxNGParserFlag;
extern void xmlRelaxNGCleanupTypes(void);
extern void xmlRelaxNGDump(FILE * output, xmlRelaxNGPtr schema);
extern void xmlRelaxNGDumpTree(FILE * output, xmlRelaxNGPtr schema);
extern void xmlRelaxNGFree(xmlRelaxNGPtr schema);
extern void xmlRelaxNGFreeParserCtxt(xmlRelaxNGParserCtxtPtr ctxt);
extern void xmlRelaxNGFreeValidCtxt(xmlRelaxNGValidCtxtPtr ctxt);
extern int xmlRelaxNGGetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
				     xmlRelaxNGValidityErrorFunc * err,
				     xmlRelaxNGValidityWarningFunc * warn,
				     void **ctx);
extern int xmlRelaxNGGetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
				    xmlRelaxNGValidityErrorFunc * err,
				    xmlRelaxNGValidityWarningFunc * warn,
				    void **ctx);
extern int xmlRelaxNGInitTypes(void);
extern xmlRelaxNGParserCtxtPtr xmlRelaxNGNewDocParserCtxt(xmlDocPtr doc);
extern xmlRelaxNGParserCtxtPtr xmlRelaxNGNewMemParserCtxt(const char
							  *buffer,
							  int size);
extern xmlRelaxNGParserCtxtPtr xmlRelaxNGNewParserCtxt(const char *URL);
extern xmlRelaxNGValidCtxtPtr xmlRelaxNGNewValidCtxt(xmlRelaxNGPtr schema);
extern xmlRelaxNGPtr xmlRelaxNGParse(xmlRelaxNGParserCtxtPtr ctxt);
extern void xmlRelaxNGSetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
				      xmlRelaxNGValidityErrorFunc err,
				      xmlRelaxNGValidityWarningFunc warn,
				      void *ctx);
extern void xmlRelaxNGSetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
				     xmlRelaxNGValidityErrorFunc err,
				     xmlRelaxNGValidityWarningFunc warn,
				     void *ctx);
extern void xmlRelaxNGSetValidStructuredErrors(xmlRelaxNGValidCtxtPtr ctxt,
					       xmlStructuredErrorFunc
					       serror, void *ctx);
extern int xmlRelaxNGValidateDoc(xmlRelaxNGValidCtxtPtr ctxt,
				 xmlDocPtr doc);
extern int xmlRelaxNGValidateFullElement(xmlRelaxNGValidCtxtPtr ctxt,
					 xmlDocPtr doc, xmlNodePtr elem);
extern int xmlRelaxNGValidatePopElement(xmlRelaxNGValidCtxtPtr ctxt,
					xmlDocPtr doc, xmlNodePtr elem);
extern int xmlRelaxNGValidatePushCData(xmlRelaxNGValidCtxtPtr ctxt,
				       const xmlChar * data, int len);
extern int xmlRelaxNGValidatePushElement(xmlRelaxNGValidCtxtPtr ctxt,
					 xmlDocPtr doc, xmlNodePtr elem);
extern int xmlRelaxParserSetFlag(xmlRelaxNGParserCtxtPtr ctxt, int flag);

19.2.17. libxml2/libxml/schematron.h


typedef struct _xmlSchematronValidCtxt xmlSchematronValidCtxt;
typedef xmlSchematronValidCtxt *xmlSchematronValidCtxtPtr;
typedef struct _xmlSchematron xmlSchematron;
typedef xmlSchematron *xmlSchematronPtr;
typedef struct _xmlSchematronParserCtxt xmlSchematronParserCtxt;
typedef xmlSchematronParserCtxt *xmlSchematronParserCtxtPtr;
typedef enum {
    XML_SCHEMATRON_OUT_QUIET = 1 << 0,
    XML_SCHEMATRON_OUT_TEXT = 1 << 1,
    XML_SCHEMATRON_OUT_XML = 1 << 2,
    XML_SCHEMATRON_OUT_FILE = 1 << 8,
    XML_SCHEMATRON_OUT_BUFFER = 1 << 9,
    XML_SCHEMATRON_OUT_IO = 1 << 10
} xmlSchematronValidOptions;
extern void xmlSchematronFree(xmlSchematronPtr schema);
extern void xmlSchematronFreeParserCtxt(xmlSchematronParserCtxtPtr ctxt);
extern void xmlSchematronFreeValidCtxt(xmlSchematronValidCtxtPtr ctxt);
extern xmlSchematronParserCtxtPtr xmlSchematronNewDocParserCtxt(xmlDocPtr
								doc);
extern xmlSchematronParserCtxtPtr xmlSchematronNewMemParserCtxt(const char
								*buffer,
								int size);
extern xmlSchematronParserCtxtPtr xmlSchematronNewParserCtxt(const char
							     *URL);
extern xmlSchematronValidCtxtPtr xmlSchematronNewValidCtxt(xmlSchematronPtr
							   schema,
							   int options);
extern xmlSchematronPtr xmlSchematronParse(xmlSchematronParserCtxtPtr
					   ctxt);
extern int xmlSchematronValidateDoc(xmlSchematronValidCtxtPtr ctxt,
				    xmlDocPtr instance);

19.2.18. libxml2/libxml/threads.h


typedef struct _xmlRMutex xmlRMutex;
typedef xmlRMutex *xmlRMutexPtr;
typedef struct _xmlMutex xmlMutex;
typedef xmlMutex *xmlMutexPtr;
extern void xmlCleanupThreads(void);
extern void xmlFreeMutex(xmlMutexPtr tok);
extern void xmlFreeRMutex(xmlRMutexPtr tok);
extern xmlGlobalStatePtr xmlGetGlobalState(void);
extern int xmlGetThreadId(void);
extern void xmlInitThreads(void);
extern int xmlIsMainThread(void);
extern void xmlLockLibrary(void);
extern void xmlMutexLock(xmlMutexPtr tok);
extern void xmlMutexUnlock(xmlMutexPtr tok);
extern xmlMutexPtr xmlNewMutex(void);
extern xmlRMutexPtr xmlNewRMutex(void);
extern void xmlRMutexLock(xmlRMutexPtr tok);
extern void xmlRMutexUnlock(xmlRMutexPtr tok);
extern void xmlUnlockLibrary(void);

19.2.19. libxml2/libxml/tree.h


#define XML_GET_CONTENT(n)	 \
	((n)->type == XML_ELEMENT_NODE ? NULL : (n)->content)
#define XML_XML_NAMESPACE	 \
	(const xmlChar *) "http://www.w3.org/XML/1998/namespace"
#define XML_XML_ID	(const xmlChar *) "xml:id"
#define XML_GET_LINE(n)	(xmlGetLineNo(n))
#define BASE_BUFFER_SIZE	4096
#define xmlChildrenNode	children
#define xmlRootNode	children
#define XML_LOCAL_NAMESPACE	XML_NAMESPACE_DECL

typedef enum {
    XML_BUFFER_ALLOC_DOUBLEIT = 0,
    XML_BUFFER_ALLOC_EXACT = 1,
    XML_BUFFER_ALLOC_IMMUTABLE = 2
} xmlBufferAllocationScheme;
typedef struct _xmlBuffer {
    xmlChar *content;
    unsigned int use;
    unsigned int size;
    xmlBufferAllocationScheme alloc;
} xmlBuffer;
typedef xmlBuffer *xmlBufferPtr;
typedef enum {
    XML_ELEMENT_NODE = 1,
    XML_ATTRIBUTE_NODE = 2,
    XML_TEXT_NODE = 3,
    XML_CDATA_SECTION_NODE = 4,
    XML_ENTITY_REF_NODE = 5,
    XML_ENTITY_NODE = 6,
    XML_PI_NODE = 7,
    XML_COMMENT_NODE = 8,
    XML_DOCUMENT_NODE = 9,
    XML_DOCUMENT_TYPE_NODE = 10,
    XML_DOCUMENT_FRAG_NODE = 11,
    XML_NOTATION_NODE = 12,
    XML_HTML_DOCUMENT_NODE = 13,
    XML_DTD_NODE = 14,
    XML_ELEMENT_DECL = 15,
    XML_ATTRIBUTE_DECL = 16,
    XML_ENTITY_DECL = 17,
    XML_NAMESPACE_DECL = 18,
    XML_XINCLUDE_START = 19,
    XML_XINCLUDE_END = 20,
    XML_DOCB_DOCUMENT_NODE = 21
} xmlElementType;
typedef xmlElementType xmlNsType;
typedef struct _xmlNs {
    struct _xmlNs *next;
    xmlNsType type;
    const xmlChar *href;
    const xmlChar *prefix;
    void *_private;
} xmlNs;
typedef enum {
    XML_ATTRIBUTE_CDATA = 1,
    XML_ATTRIBUTE_ID = 2,
    XML_ATTRIBUTE_IDREF = 3,
    XML_ATTRIBUTE_IDREFS = 4,
    XML_ATTRIBUTE_ENTITY = 5,
    XML_ATTRIBUTE_ENTITIES = 6,
    XML_ATTRIBUTE_NMTOKEN = 7,
    XML_ATTRIBUTE_NMTOKENS = 8,
    XML_ATTRIBUTE_ENUMERATION = 9,
    XML_ATTRIBUTE_NOTATION = 10
} xmlAttributeType;
typedef struct _xmlNode {
    void *_private;
    xmlElementType type;
    const xmlChar *name;
    struct _xmlNode *children;
    struct _xmlNode *last;
    struct _xmlNode *parent;
    struct _xmlNode *next;
    struct _xmlNode *prev;
    struct _xmlDoc *doc;
    xmlNs *ns;
    xmlChar *content;
    struct _xmlAttr *properties;
    xmlNs *nsDef;
    void *psvi;
    unsigned short line;
    unsigned short extra;
} xmlNode;
typedef xmlNode *xmlNodePtr;
typedef struct _xmlDoc {
    void *_private;
    xmlElementType type;
    char *name;
    struct _xmlNode *children;
    struct _xmlNode *last;
    struct _xmlNode *parent;
    struct _xmlNode *next;
    struct _xmlNode *prev;
    struct _xmlDoc *doc;
    int compression;
    int standalone;
    struct _xmlDtd *intSubset;
    struct _xmlDtd *extSubset;
    struct _xmlNs *oldNs;
    const xmlChar *version;
    const xmlChar *encoding;
    void *ids;
    void *refs;
    const xmlChar *URL;
    int charset;
    struct _xmlDict *dict;
    void *psvi;
} xmlDoc;
typedef xmlDoc *xmlDocPtr;
typedef xmlNs *xmlNsPtr;
typedef struct _xmlDtd {
    void *_private;
    xmlElementType type;
    const xmlChar *name;
    struct _xmlNode *children;
    struct _xmlNode *last;
    struct _xmlDoc *parent;
    struct _xmlNode *next;
    struct _xmlNode *prev;
    struct _xmlDoc *doc;
    void *notations;
    void *elements;
    void *attributes;
    void *entities;
    const xmlChar *ExternalID;
    const xmlChar *SystemID;
    void *pentities;
} xmlDtd;
typedef xmlDtd *xmlDtdPtr;
typedef struct _xmlDOMWrapCtxt {
    void *_private;
} xmlDOMWrapCtxt;
typedef xmlDOMWrapCtxt *xmlDOMWrapCtxtPtr;
typedef struct _xmlAttr {
    void *_private;
    xmlElementType type;
    const xmlChar *name;
    struct _xmlNode *children;
    struct _xmlNode *last;
    struct _xmlNode *parent;
    struct _xmlAttr *next;
    struct _xmlAttr *prev;
    struct _xmlDoc *doc;
    xmlNs *ns;
    xmlAttributeType atype;
    void *psvi;
} xmlAttr;
typedef xmlAttr *xmlAttrPtr;
typedef int (*xmlOutputWriteCallback) (void *, const char *, int);
typedef int (*xmlOutputCloseCallback) (void *);
typedef int (*xmlCharEncodingInputFunc) (unsigned char *, int *,
					 const unsigned char *, int *);
typedef int (*xmlCharEncodingOutputFunc) (unsigned char *, int *,
					  const unsigned char *, int *);
typedef struct _xmlCharEncodingHandler {
    char *name;
    xmlCharEncodingInputFunc input;
    xmlCharEncodingOutputFunc output;
    iconv_t iconv_in;
    iconv_t iconv_out;
} xmlCharEncodingHandler;
typedef xmlCharEncodingHandler *xmlCharEncodingHandlerPtr;
typedef struct _xmlOutputBuffer {
    void *context;
    xmlOutputWriteCallback writecallback;
    xmlOutputCloseCallback closecallback;
    xmlCharEncodingHandlerPtr encoder;
    xmlBufferPtr buffer;
    xmlBufferPtr conv;
    int written;
    int error;
} xmlOutputBuffer;
typedef xmlOutputBuffer *xmlOutputBufferPtr;
extern xmlNodePtr xmlAddChild(xmlNodePtr parent, xmlNodePtr cur);
extern xmlNodePtr xmlAddChildList(xmlNodePtr parent, xmlNodePtr cur);
extern xmlNodePtr xmlAddNextSibling(xmlNodePtr cur, xmlNodePtr elem);
extern xmlNodePtr xmlAddPrevSibling(xmlNodePtr cur, xmlNodePtr elem);
extern xmlNodePtr xmlAddSibling(xmlNodePtr cur, xmlNodePtr elem);
extern void xmlAttrSerializeTxtContent(xmlBufferPtr buf, xmlDocPtr doc,
				       xmlAttrPtr attr,
				       const xmlChar * string);
extern int xmlBufferAdd(xmlBufferPtr buf, const xmlChar * str, int len);
extern int xmlBufferAddHead(xmlBufferPtr buf, const xmlChar * str,
			    int len);
extern int xmlBufferCCat(xmlBufferPtr buf, const char *str);
extern int xmlBufferCat(xmlBufferPtr buf, const xmlChar * str);
extern const xmlChar *xmlBufferContent(const xmlBufferPtr buf);
extern xmlBufferPtr xmlBufferCreate(void);
extern xmlBufferPtr xmlBufferCreateSize(size_t size);
extern xmlBufferPtr xmlBufferCreateStatic(void *mem, size_t size);
extern int xmlBufferDump(FILE * file, xmlBufferPtr buf);
extern void xmlBufferEmpty(xmlBufferPtr buf);
extern void xmlBufferFree(xmlBufferPtr buf);
extern int xmlBufferGrow(xmlBufferPtr buf, unsigned int len);
extern int xmlBufferLength(const xmlBufferPtr buf);
extern int xmlBufferResize(xmlBufferPtr buf, unsigned int size);
extern void xmlBufferSetAllocationScheme(xmlBufferPtr buf,
					 xmlBufferAllocationScheme scheme);
extern int xmlBufferShrink(xmlBufferPtr buf, unsigned int len);
extern void xmlBufferWriteCHAR(xmlBufferPtr buf, const xmlChar * string);
extern void xmlBufferWriteChar(xmlBufferPtr buf, const char *string);
extern void xmlBufferWriteQuotedString(xmlBufferPtr buf,
				       const xmlChar * string);
extern xmlChar *xmlBuildQName(const xmlChar * ncname,
			      const xmlChar * prefix, xmlChar * memory,
			      int len);
extern xmlDocPtr xmlCopyDoc(xmlDocPtr doc, int recursive);
extern xmlDtdPtr xmlCopyDtd(xmlDtdPtr dtd);
extern xmlNsPtr xmlCopyNamespace(xmlNsPtr cur);
extern xmlNsPtr xmlCopyNamespaceList(xmlNsPtr cur);
extern xmlNodePtr xmlCopyNode(const xmlNodePtr node, int recursive);
extern xmlNodePtr xmlCopyNodeList(const xmlNodePtr node);
extern xmlAttrPtr xmlCopyProp(xmlNodePtr target, xmlAttrPtr cur);
extern xmlAttrPtr xmlCopyPropList(xmlNodePtr target, xmlAttrPtr cur);
extern xmlDtdPtr xmlCreateIntSubset(xmlDocPtr doc, const xmlChar * name,
				    const xmlChar * ExternalID,
				    const xmlChar * SystemID);
extern void xmlDOMWrapFreeCtxt(xmlDOMWrapCtxtPtr ctxt);
extern xmlDOMWrapCtxtPtr xmlDOMWrapNewCtxt(void);
extern xmlNodePtr xmlDocCopyNode(const xmlNodePtr node, xmlDocPtr doc,
				 int recursive);
extern xmlNodePtr xmlDocCopyNodeList(xmlDocPtr doc, const xmlNodePtr node);
extern int xmlDocDump(FILE * f, xmlDocPtr cur);
extern void xmlDocDumpFormatMemory(xmlDocPtr cur, xmlChar * *mem,
				   int *size, int format);
extern void xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc,
				      xmlChar * *doc_txt_ptr,
				      int *doc_txt_len,
				      const char *txt_encoding,
				      int format);
extern void xmlDocDumpMemory(xmlDocPtr cur, xmlChar * *mem, int *size);
extern void xmlDocDumpMemoryEnc(xmlDocPtr out_doc, xmlChar * *doc_txt_ptr,
				int *doc_txt_len,
				const char *txt_encoding);
extern int xmlDocFormatDump(FILE * f, xmlDocPtr cur, int format);
extern xmlNodePtr xmlDocGetRootElement(xmlDocPtr doc);
extern xmlNodePtr xmlDocSetRootElement(xmlDocPtr doc, xmlNodePtr root);
extern void xmlElemDump(FILE * f, xmlDocPtr doc, xmlNodePtr cur);
extern void xmlFreeDoc(xmlDocPtr cur);
extern void xmlFreeDtd(xmlDtdPtr cur);
extern void xmlFreeNode(xmlNodePtr cur);
extern void xmlFreeNodeList(xmlNodePtr cur);
extern void xmlFreeNs(xmlNsPtr cur);
extern void xmlFreeNsList(xmlNsPtr cur);
extern void xmlFreeProp(xmlAttrPtr cur);
extern void xmlFreePropList(xmlAttrPtr cur);
extern xmlBufferAllocationScheme xmlGetBufferAllocationScheme(void);
extern int xmlGetCompressMode(void);
extern int xmlGetDocCompressMode(xmlDocPtr doc);
extern xmlDtdPtr xmlGetIntSubset(xmlDocPtr doc);
extern xmlNodePtr xmlGetLastChild(xmlNodePtr parent);
extern long int xmlGetLineNo(xmlNodePtr node);
extern xmlChar *xmlGetNoNsProp(xmlNodePtr node, const xmlChar * name);
extern xmlChar *xmlGetNodePath(xmlNodePtr node);
extern xmlNsPtr *xmlGetNsList(xmlDocPtr doc, xmlNodePtr node);
extern xmlChar *xmlGetNsProp(xmlNodePtr node, const xmlChar * name,
			     const xmlChar * nameSpace);
extern xmlChar *xmlGetProp(xmlNodePtr node, const xmlChar * name);
extern xmlAttrPtr xmlHasNsProp(xmlNodePtr node, const xmlChar * name,
			       const xmlChar * nameSpace);
extern xmlAttrPtr xmlHasProp(xmlNodePtr node, const xmlChar * name);
extern int xmlIsBlankNode(xmlNodePtr node);
extern int xmlIsXHTML(const xmlChar * systemID, const xmlChar * publicID);
extern xmlNodePtr xmlNewCDataBlock(xmlDocPtr doc, const xmlChar * content,
				   int len);
extern xmlNodePtr xmlNewCharRef(xmlDocPtr doc, const xmlChar * name);
extern xmlNodePtr xmlNewChild(xmlNodePtr parent, xmlNsPtr ns,
			      const xmlChar * name,
			      const xmlChar * content);
extern xmlNodePtr xmlNewComment(const xmlChar * content);
extern xmlDocPtr xmlNewDoc(const xmlChar * version);
extern xmlNodePtr xmlNewDocComment(xmlDocPtr doc, const xmlChar * content);
extern xmlNodePtr xmlNewDocFragment(xmlDocPtr doc);
extern xmlNodePtr xmlNewDocNode(xmlDocPtr doc, xmlNsPtr ns,
				const xmlChar * name,
				const xmlChar * content);
extern xmlNodePtr xmlNewDocNodeEatName(xmlDocPtr doc, xmlNsPtr ns,
				       xmlChar * name,
				       const xmlChar * content);
extern xmlNodePtr xmlNewDocPI(xmlDocPtr doc, const xmlChar * name,
			      const xmlChar * content);
extern xmlAttrPtr xmlNewDocProp(xmlDocPtr doc, const xmlChar * name,
				const xmlChar * value);
extern xmlNodePtr xmlNewDocRawNode(xmlDocPtr doc, xmlNsPtr ns,
				   const xmlChar * name,
				   const xmlChar * content);
extern xmlNodePtr xmlNewDocText(xmlDocPtr doc, const xmlChar * content);
extern xmlNodePtr xmlNewDocTextLen(xmlDocPtr doc, const xmlChar * content,
				   int len);
extern xmlDtdPtr xmlNewDtd(xmlDocPtr doc, const xmlChar * name,
			   const xmlChar * ExternalID,
			   const xmlChar * SystemID);
extern xmlNodePtr xmlNewNode(xmlNsPtr ns, const xmlChar * name);
extern xmlNodePtr xmlNewNodeEatName(xmlNsPtr ns, xmlChar * name);
extern xmlNsPtr xmlNewNs(xmlNodePtr node, const xmlChar * href,
			 const xmlChar * prefix);
extern xmlAttrPtr xmlNewNsProp(xmlNodePtr node, xmlNsPtr ns,
			       const xmlChar * name,
			       const xmlChar * value);
extern xmlAttrPtr xmlNewNsPropEatName(xmlNodePtr node, xmlNsPtr ns,
				      xmlChar * name,
				      const xmlChar * value);
extern xmlNodePtr xmlNewPI(const xmlChar * name, const xmlChar * content);
extern xmlAttrPtr xmlNewProp(xmlNodePtr node, const xmlChar * name,
			     const xmlChar * value);
extern xmlNodePtr xmlNewReference(xmlDocPtr doc, const xmlChar * name);
extern xmlNodePtr xmlNewText(const xmlChar * content);
extern xmlNodePtr xmlNewTextChild(xmlNodePtr parent, xmlNsPtr ns,
				  const xmlChar * name,
				  const xmlChar * content);
extern xmlNodePtr xmlNewTextLen(const xmlChar * content, int len);
extern void xmlNodeAddContent(xmlNodePtr cur, const xmlChar * content);
extern void xmlNodeAddContentLen(xmlNodePtr cur, const xmlChar * content,
				 int len);
extern int xmlNodeBufGetContent(xmlBufferPtr buffer, xmlNodePtr cur);
extern int xmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur,
		       int level, int format);
extern void xmlNodeDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
			      xmlNodePtr cur, int level, int format,
			      const char *encoding);
extern xmlChar *xmlNodeGetBase(xmlDocPtr doc, xmlNodePtr cur);
extern xmlChar *xmlNodeGetContent(xmlNodePtr cur);
extern xmlChar *xmlNodeGetLang(xmlNodePtr cur);
extern int xmlNodeGetSpacePreserve(xmlNodePtr cur);
extern int xmlNodeIsText(xmlNodePtr node);
extern xmlChar *xmlNodeListGetRawString(xmlDocPtr doc, xmlNodePtr list,
					int inLine);
extern xmlChar *xmlNodeListGetString(xmlDocPtr doc, xmlNodePtr list,
				     int inLine);
extern void xmlNodeSetBase(xmlNodePtr cur, const xmlChar * uri);
extern void xmlNodeSetContent(xmlNodePtr cur, const xmlChar * content);
extern void xmlNodeSetContentLen(xmlNodePtr cur, const xmlChar * content,
				 int len);
extern void xmlNodeSetLang(xmlNodePtr cur, const xmlChar * lang);
extern void xmlNodeSetName(xmlNodePtr cur, const xmlChar * name);
extern void xmlNodeSetSpacePreserve(xmlNodePtr cur, int val);
extern int xmlReconciliateNs(xmlDocPtr doc, xmlNodePtr tree);
extern int xmlRemoveProp(xmlAttrPtr cur);
extern xmlNodePtr xmlReplaceNode(xmlNodePtr old, xmlNodePtr cur);
extern int xmlSaveFile(const char *filename, xmlDocPtr cur);
extern int xmlSaveFileEnc(const char *filename, xmlDocPtr cur,
			  const char *encoding);
extern int xmlSaveFileTo(xmlOutputBufferPtr buf, xmlDocPtr cur,
			 const char *encoding);
extern int xmlSaveFormatFile(const char *filename, xmlDocPtr cur,
			     int format);
extern int xmlSaveFormatFileEnc(const char *filename, xmlDocPtr cur,
				const char *encoding, int format);
extern int xmlSaveFormatFileTo(xmlOutputBufferPtr buf, xmlDocPtr cur,
			       const char *encoding, int format);
extern xmlNsPtr xmlSearchNs(xmlDocPtr doc, xmlNodePtr node,
			    const xmlChar * nameSpace);
extern xmlNsPtr xmlSearchNsByHref(xmlDocPtr doc, xmlNodePtr node,
				  const xmlChar * href);
extern void xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme);
extern void xmlSetCompressMode(int mode);
extern void xmlSetDocCompressMode(xmlDocPtr doc, int mode);
extern void xmlSetListDoc(xmlNodePtr list, xmlDocPtr doc);
extern void xmlSetNs(xmlNodePtr node, xmlNsPtr ns);
extern xmlAttrPtr xmlSetNsProp(xmlNodePtr node, xmlNsPtr ns,
			       const xmlChar * name,
			       const xmlChar * value);
extern xmlAttrPtr xmlSetProp(xmlNodePtr node, const xmlChar * name,
			     const xmlChar * value);
extern void xmlSetTreeDoc(xmlNodePtr tree, xmlDocPtr doc);
extern xmlChar *xmlSplitQName2(const xmlChar * name, xmlChar * *prefix);
extern const xmlChar *xmlSplitQName3(const xmlChar * name, int *len);
extern xmlNodePtr xmlStringGetNodeList(xmlDocPtr doc,
				       const xmlChar * value);
extern xmlNodePtr xmlStringLenGetNodeList(xmlDocPtr doc,
					  const xmlChar * value, int len);
extern int xmlTextConcat(xmlNodePtr node, const xmlChar * content,
			 int len);
extern xmlNodePtr xmlTextMerge(xmlNodePtr first, xmlNodePtr second);
extern void xmlUnlinkNode(xmlNodePtr cur);
extern int xmlUnsetNsProp(xmlNodePtr node, xmlNsPtr ns,
			  const xmlChar * name);
extern int xmlUnsetProp(xmlNodePtr node, const xmlChar * name);
extern int xmlValidateNCName(const xmlChar * value, int space);
extern int xmlValidateNMToken(const xmlChar * value, int space);
extern int xmlValidateName(const xmlChar * value, int space);
extern int xmlValidateQName(const xmlChar * value, int space);

19.2.20. libxml2/libxml/uri.h


typedef struct _xmlURI {
    char *scheme;
    char *opaque;
    char *authority;
    char *server;
    char *user;
    int port;
    char *path;
    char *query;
    char *fragment;
    int cleanup;
} xmlURI;
typedef xmlURI *xmlURIPtr;
extern xmlChar *xmlBuildRelativeURI(const xmlChar * URI,
				    const xmlChar * base);
extern xmlChar *xmlBuildURI(const xmlChar * URI, const xmlChar * base);
extern xmlChar *xmlCanonicPath(const xmlChar * path);
extern xmlURIPtr xmlCreateURI(void);
extern void xmlFreeURI(xmlURIPtr uri);
extern int xmlNormalizeURIPath(char *path);
extern xmlURIPtr xmlParseURI(const char *str);
extern xmlURIPtr xmlParseURIRaw(const char *str, int raw);
extern int xmlParseURIReference(xmlURIPtr uri, const char *str);
extern void xmlPrintURI(FILE * stream, xmlURIPtr uri);
extern xmlChar *xmlSaveUri(xmlURIPtr uri);
extern xmlChar *xmlURIEscape(const xmlChar * str);
extern xmlChar *xmlURIEscapeStr(const xmlChar * str, const xmlChar * list);
extern char *xmlURIUnescapeString(const char *str, int len, char *target);

19.2.21. libxml2/libxml/valid.h


typedef xmlValidCtxt *xmlValidCtxtPtr;
typedef struct _xmlHashTable xmlAttributeTable;
typedef xmlAttributeTable *xmlAttributeTablePtr;
typedef enum {
    XML_ELEMENT_TYPE_UNDEFINED = 0,
    XML_ELEMENT_TYPE_EMPTY = 1,
    XML_ELEMENT_TYPE_ANY = 2,
    XML_ELEMENT_TYPE_MIXED = 3,
    XML_ELEMENT_TYPE_ELEMENT = 4
} xmlElementTypeVal;
typedef enum {
    XML_ATTRIBUTE_NONE = 1,
    XML_ATTRIBUTE_REQUIRED = 2,
    XML_ATTRIBUTE_IMPLIED = 3,
    XML_ATTRIBUTE_FIXED = 4
} xmlAttributeDefault;
typedef struct _xmlAttribute {
    void *_private;
    xmlElementType type;
    const xmlChar *name;
    struct _xmlNode *children;
    struct _xmlNode *last;
    struct _xmlDtd *parent;
    struct _xmlNode *next;
    struct _xmlNode *prev;
    struct _xmlDoc *doc;
    struct _xmlAttribute *nexth;
    xmlAttributeType atype;
    xmlAttributeDefault def;
    const xmlChar *defaultValue;
    xmlEnumerationPtr tree;
    const xmlChar *prefix;
    const xmlChar *elem;
} xmlAttribute;
typedef xmlAttribute *xmlAttributePtr;
typedef struct _xmlElement {
    void *_private;
    xmlElementType type;
    const xmlChar *name;
    struct _xmlNode *children;
    struct _xmlNode *last;
    struct _xmlDtd *parent;
    struct _xmlNode *next;
    struct _xmlNode *prev;
    struct _xmlDoc *doc;
    xmlElementTypeVal etype;
    xmlElementContentPtr content;
    xmlAttributePtr attributes;
    const xmlChar *prefix;
    xmlRegexpPtr contModel;
} xmlElement;
typedef xmlElement *xmlElementPtr;
typedef struct _xmlHashTable xmlNotationTable;
typedef xmlNotationTable *xmlNotationTablePtr;
typedef struct _xmlNotation {
    const xmlChar *name;
    const xmlChar *PublicID;
    const xmlChar *SystemID;
} xmlNotation;
typedef xmlNotation *xmlNotationPtr;
typedef struct _xmlID {
    struct _xmlID *next;
    const xmlChar *value;
    xmlAttrPtr attr;
    const xmlChar *name;
    int lineno;
    struct _xmlDoc *doc;
} xmlID;
typedef xmlID *xmlIDPtr;
typedef struct _xmlRef {
    struct _xmlRef *next;
    const xmlChar *value;
    xmlAttrPtr attr;
    const xmlChar *name;
    int lineno;
} xmlRef;
typedef xmlRef *xmlRefPtr;
typedef struct _xmlHashTable xmlElementTable;
typedef xmlElementTable *xmlElementTablePtr;
typedef struct _xmlHashTable xmlIDTable;
typedef xmlIDTable *xmlIDTablePtr;
typedef struct _xmlHashTable xmlRefTable;
typedef xmlRefTable *xmlRefTablePtr;
extern xmlAttributePtr xmlAddAttributeDecl(xmlValidCtxtPtr, xmlDtdPtr,
					   const xmlChar *,
					   const xmlChar *,
					   const xmlChar *,
					   xmlAttributeType,
					   xmlAttributeDefault,
					   const xmlChar *,
					   xmlEnumerationPtr);
extern xmlElementPtr xmlAddElementDecl(xmlValidCtxtPtr, xmlDtdPtr,
				       const xmlChar *, xmlElementTypeVal,
				       xmlElementContentPtr);
extern xmlIDPtr xmlAddID(xmlValidCtxtPtr, xmlDocPtr, const xmlChar *,
			 xmlAttrPtr);
extern xmlNotationPtr xmlAddNotationDecl(xmlValidCtxtPtr, xmlDtdPtr,
					 const xmlChar *, const xmlChar *,
					 const xmlChar *);
extern xmlRefPtr xmlAddRef(xmlValidCtxtPtr, xmlDocPtr, const xmlChar *,
			   xmlAttrPtr);
extern xmlAttributeTablePtr xmlCopyAttributeTable(xmlAttributeTablePtr);
extern xmlElementContentPtr xmlCopyDocElementContent(xmlDocPtr,
						     xmlElementContentPtr);
extern xmlElementTablePtr xmlCopyElementTable(xmlElementTablePtr);
extern xmlEnumerationPtr xmlCopyEnumeration(xmlEnumerationPtr);
extern xmlNotationTablePtr xmlCopyNotationTable(xmlNotationTablePtr);
extern xmlEnumerationPtr xmlCreateEnumeration(const xmlChar *);
extern void xmlDumpAttributeDecl(xmlBufferPtr, xmlAttributePtr);
extern void xmlDumpAttributeTable(xmlBufferPtr, xmlAttributeTablePtr);
extern void xmlDumpElementDecl(xmlBufferPtr, xmlElementPtr);
extern void xmlDumpElementTable(xmlBufferPtr, xmlElementTablePtr);
extern void xmlDumpNotationDecl(xmlBufferPtr, xmlNotationPtr);
extern void xmlDumpNotationTable(xmlBufferPtr, xmlNotationTablePtr);
extern void xmlFreeAttributeTable(xmlAttributeTablePtr);
extern void xmlFreeDocElementContent(xmlDocPtr, xmlElementContentPtr);
extern void xmlFreeElementTable(xmlElementTablePtr);
extern void xmlFreeEnumeration(xmlEnumerationPtr);
extern void xmlFreeIDTable(xmlIDTablePtr);
extern void xmlFreeNotationTable(xmlNotationTablePtr);
extern void xmlFreeRefTable(xmlRefTablePtr);
extern void xmlFreeValidCtxt(xmlValidCtxtPtr);
extern xmlAttributePtr xmlGetDtdAttrDesc(xmlDtdPtr, const xmlChar *,
					 const xmlChar *);
extern xmlElementPtr xmlGetDtdElementDesc(xmlDtdPtr, const xmlChar *);
extern xmlNotationPtr xmlGetDtdNotationDesc(xmlDtdPtr, const xmlChar *);
extern xmlAttributePtr xmlGetDtdQAttrDesc(xmlDtdPtr, const xmlChar *,
					  const xmlChar *,
					  const xmlChar *);
extern xmlElementPtr xmlGetDtdQElementDesc(xmlDtdPtr, const xmlChar *,
					   const xmlChar *);
extern xmlAttrPtr xmlGetID(xmlDocPtr, const xmlChar *);
extern xmlListPtr xmlGetRefs(xmlDocPtr, const xmlChar *);
extern int xmlIsID(xmlDocPtr, xmlNodePtr, xmlAttrPtr);
extern int xmlIsMixedElement(xmlDocPtr, const xmlChar *);
extern int xmlIsRef(xmlDocPtr, xmlNodePtr, xmlAttrPtr);
extern xmlElementContentPtr xmlNewDocElementContent(xmlDocPtr,
						    const xmlChar *,
						    xmlElementContentType);
extern xmlValidCtxtPtr xmlNewValidCtxt(void);
extern int xmlRemoveID(xmlDocPtr, xmlAttrPtr);
extern int xmlRemoveRef(xmlDocPtr, xmlAttrPtr);
extern void xmlSnprintfElementContent(char *, int, xmlElementContentPtr,
				      int);
extern int xmlValidBuildContentModel(xmlValidCtxtPtr, xmlElementPtr);
extern xmlChar *xmlValidCtxtNormalizeAttributeValue(xmlValidCtxtPtr,
						    xmlDocPtr, xmlNodePtr,
						    const xmlChar *,
						    const xmlChar *);
extern int xmlValidGetPotentialChildren(xmlElementContent *,
					const xmlChar * *, int *, int);
extern int xmlValidGetValidElements(xmlNode *, xmlNode *,
				    const xmlChar * *, int);
extern xmlChar *xmlValidNormalizeAttributeValue(xmlDocPtr, xmlNodePtr,
						const xmlChar *,
						const xmlChar *);
extern int xmlValidateAttributeDecl(xmlValidCtxtPtr, xmlDocPtr,
				    xmlAttributePtr);
extern int xmlValidateAttributeValue(xmlAttributeType, const xmlChar *);
extern int xmlValidateDocument(xmlValidCtxtPtr, xmlDocPtr);
extern int xmlValidateDocumentFinal(xmlValidCtxtPtr, xmlDocPtr);
extern int xmlValidateDtd(xmlValidCtxtPtr, xmlDocPtr, xmlDtdPtr);
extern int xmlValidateDtdFinal(xmlValidCtxtPtr, xmlDocPtr);
extern int xmlValidateElement(xmlValidCtxtPtr, xmlDocPtr, xmlNodePtr);
extern int xmlValidateElementDecl(xmlValidCtxtPtr, xmlDocPtr,
				  xmlElementPtr);
extern int xmlValidateNameValue(const xmlChar *);
extern int xmlValidateNamesValue(const xmlChar *);
extern int xmlValidateNmtokenValue(const xmlChar *);
extern int xmlValidateNmtokensValue(const xmlChar *);
extern int xmlValidateNotationDecl(xmlValidCtxtPtr, xmlDocPtr,
				   xmlNotationPtr);
extern int xmlValidateNotationUse(xmlValidCtxtPtr, xmlDocPtr,
				  const xmlChar *);
extern int xmlValidateOneAttribute(xmlValidCtxtPtr, xmlDocPtr, xmlNodePtr,
				   xmlAttrPtr, const xmlChar *);
extern int xmlValidateOneElement(xmlValidCtxtPtr, xmlDocPtr, xmlNodePtr);
extern int xmlValidateOneNamespace(xmlValidCtxtPtr, xmlDocPtr, xmlNodePtr,
				   const xmlChar *, xmlNsPtr,
				   const xmlChar *);
extern int xmlValidatePopElement(xmlValidCtxtPtr, xmlDocPtr, xmlNodePtr,
				 const xmlChar *);
extern int xmlValidatePushCData(xmlValidCtxtPtr, const xmlChar *, int);
extern int xmlValidatePushElement(xmlValidCtxtPtr, xmlDocPtr, xmlNodePtr,
				  const xmlChar *);
extern int xmlValidateRoot(xmlValidCtxtPtr, xmlDocPtr);

19.2.22. libxml2/libxml/xinclude.h


#define XINCLUDE_PARSE_ENCODING	(const xmlChar *) "encoding"
#define XINCLUDE_FALLBACK	(const xmlChar *) "fallback"
#define XINCLUDE_HREF	(const xmlChar *) "href"
#define XINCLUDE_OLD_NS	(const xmlChar *) "http://www.w3.org/2001/XInclude"
#define XINCLUDE_NS	(const xmlChar *) "http://www.w3.org/2003/XInclude"
#define XINCLUDE_NODE	(const xmlChar *) "include"
#define XINCLUDE_PARSE	(const xmlChar *) "parse"
#define XINCLUDE_PARSE_TEXT	(const xmlChar *) "text"
#define XINCLUDE_PARSE_XML	(const xmlChar *) "xml"
#define XINCLUDE_PARSE_XPOINTER	(const xmlChar *) "xpointer"

typedef struct _xmlXIncludeCtxt xmlXIncludeCtxt;
typedef xmlXIncludeCtxt *xmlXIncludeCtxtPtr;
extern void xmlXIncludeFreeContext(xmlXIncludeCtxtPtr ctxt);
extern xmlXIncludeCtxtPtr xmlXIncludeNewContext(xmlDocPtr doc);
extern int xmlXIncludeProcess(xmlDocPtr doc);
extern int xmlXIncludeProcessFlags(xmlDocPtr doc, int flags);
extern int xmlXIncludeProcessNode(xmlXIncludeCtxtPtr ctxt,
				  xmlNodePtr tree);
extern int xmlXIncludeProcessTree(xmlNodePtr tree);
extern int xmlXIncludeProcessTreeFlags(xmlNodePtr tree, int flags);
extern int xmlXIncludeSetFlags(xmlXIncludeCtxtPtr ctxt, int flags);

19.2.23. libxml2/libxml/xmlIO.h


typedef int (*xmlOutputMatchCallback) (const char *);
typedef void *(*xmlOutputOpenCallback) (const char *);
typedef struct _xmlParserNodeInfo {
    const struct _xmlNode *node;
    long unsigned int begin_pos;
    long unsigned int begin_line;
    long unsigned int end_pos;
    long unsigned int end_line;
} xmlParserNodeInfo;
typedef struct _xmlParserNodeInfoSeq {
    long unsigned int maximum;
    long unsigned int length;
    xmlParserNodeInfo *buffer;
} xmlParserNodeInfoSeq;
typedef void (*xmlValidityErrorFunc) (void *, const char *, ...);
typedef void (*xmlValidityWarningFunc) (void *, const char *, ...);
typedef struct _xmlValidState xmlValidState;
typedef struct _xmlValidCtxt {
    void *userData;
    xmlValidityErrorFunc error;
    xmlValidityWarningFunc warning;
    xmlNodePtr node;
    int nodeNr;
    int nodeMax;
    xmlNodePtr *nodeTab;
    unsigned int finishDtd;
    xmlDocPtr doc;
    int valid;
    xmlValidState *vstate;
    int vstateNr;
    int vstateMax;
    xmlValidState *vstateTab;
    xmlAutomataPtr am;
    xmlAutomataStatePtr state;
} xmlValidCtxt;
typedef enum {
    XML_PARSER_EOF = -1,
    XML_PARSER_START = 0,
    XML_PARSER_MISC = 1,
    XML_PARSER_PI = 2,
    XML_PARSER_DTD = 3,
    XML_PARSER_PROLOG = 4,
    XML_PARSER_COMMENT = 5,
    XML_PARSER_START_TAG = 6,
    XML_PARSER_CONTENT = 7,
    XML_PARSER_CDATA_SECTION = 8,
    XML_PARSER_END_TAG = 9,
    XML_PARSER_ENTITY_DECL = 10,
    XML_PARSER_ENTITY_VALUE = 11,
    XML_PARSER_ATTRIBUTE_VALUE = 12,
    XML_PARSER_SYSTEM_LITERAL = 13,
    XML_PARSER_EPILOG = 14,
    XML_PARSER_IGNORE = 15,
    XML_PARSER_PUBLIC_LITERAL = 16
} xmlParserInputState;
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;
typedef struct _xmlParserCtxt {
    struct _xmlSAXHandler *sax;
    void *userData;
    xmlDocPtr myDoc;
    int wellFormed;
    int replaceEntities;
    const xmlChar *version;
    const xmlChar *encoding;
    int standalone;
    int html;
    xmlParserInputPtr input;
    int inputNr;
    int inputMax;
    xmlParserInputPtr *inputTab;
    xmlNodePtr node;
    int nodeNr;
    int nodeMax;
    xmlNodePtr *nodeTab;
    int record_info;
    xmlParserNodeInfoSeq node_seq;
    int errNo;
    int hasExternalSubset;
    int hasPErefs;
    int external;
    int valid;
    int validate;
    xmlValidCtxt vctxt;
    xmlParserInputState instate;
    int token;
    char *directory;
    const xmlChar *name;
    int nameNr;
    int nameMax;
    const xmlChar **nameTab;
    long int nbChars;
    long int checkIndex;
    int keepBlanks;
    int disableSAX;
    int inSubset;
    const xmlChar *intSubName;
    xmlChar *extSubURI;
    xmlChar *extSubSystem;
    int *space;
    int spaceNr;
    int spaceMax;
    int *spaceTab;
    int depth;
    xmlParserInputPtr entity;
    int charset;
    int nodelen;
    int nodemem;
    int pedantic;
    void *_private;
    int loadsubset;
    int linenumbers;
    void *catalogs;
    int recovery;
    int progressive;
    xmlDictPtr dict;
    const xmlChar **atts;
    int maxatts;
    int docdict;
    const xmlChar *str_xml;
    const xmlChar *str_xmlns;
    const xmlChar *str_xml_ns;
    int sax2;
    int nsNr;
    int nsMax;
    const xmlChar **nsTab;
    int *attallocs;
    void **pushTab;
    xmlHashTablePtr attsDefault;
    xmlHashTablePtr attsSpecial;
    int nsWellFormed;
    int options;
    int dictNames;
    int freeElemsNr;
    xmlNodePtr freeElems;
    int freeAttrsNr;
    xmlAttrPtr freeAttrs;
    xmlError lastError;
    xmlParserMode parseMode;
} xmlParserCtxt;
typedef xmlParserCtxt *xmlParserCtxtPtr;
typedef int (*xmlInputMatchCallback) (const char *);
typedef void *(*xmlInputOpenCallback) (const char *);
extern xmlOutputBufferPtr xmlAllocOutputBuffer(xmlCharEncodingHandlerPtr
					       encoder);
extern xmlParserInputBufferPtr xmlAllocParserInputBuffer(xmlCharEncoding
							 enc);
extern int xmlCheckFilename(const char *path);
extern xmlParserInputPtr xmlCheckHTTPInput(xmlParserCtxtPtr ctxt,
					   xmlParserInputPtr ret);
extern void xmlCleanupInputCallbacks(void);
extern void xmlCleanupOutputCallbacks(void);
extern int xmlFileClose(void *context);
extern int xmlFileMatch(const char *filename);
extern void *xmlFileOpen(const char *filename);
extern int xmlFileRead(void *context, char *buffer, int len);
extern void xmlFreeParserInputBuffer(xmlParserInputBufferPtr in);
extern int xmlIOFTPClose(void *context);
extern int xmlIOFTPMatch(const char *filename);
extern void *xmlIOFTPOpen(const char *filename);
extern int xmlIOFTPRead(void *context, char *buffer, int len);
extern int xmlIOHTTPClose(void *context);
extern int xmlIOHTTPMatch(const char *filename);
extern void *xmlIOHTTPOpen(const char *filename);
extern void *xmlIOHTTPOpenW(const char *post_uri, int compression);
extern int xmlIOHTTPRead(void *context, char *buffer, int len);
extern xmlParserInputPtr xmlNoNetExternalEntityLoader(const char *URL,
						      const char *ID,
						      xmlParserCtxtPtr
						      ctxt);
extern xmlChar *xmlNormalizeWindowsPath(const xmlChar * path);
extern int xmlOutputBufferClose(xmlOutputBufferPtr out);
extern xmlOutputBufferPtr xmlOutputBufferCreateFd(int fd,
						  xmlCharEncodingHandlerPtr
						  encoder);
extern xmlOutputBufferPtr xmlOutputBufferCreateFile(FILE * file,
						    xmlCharEncodingHandlerPtr
						    encoder);
extern xmlOutputBufferPtr xmlOutputBufferCreateFilename(const char *URI,
							xmlCharEncodingHandlerPtr
							encoder,
							int compression);
extern xmlOutputBufferPtr xmlOutputBufferCreateIO(xmlOutputWriteCallback
						  iowrite,
						  xmlOutputCloseCallback
						  ioclose, void *ioctx,
						  xmlCharEncodingHandlerPtr
						  encoder);
extern int xmlOutputBufferFlush(xmlOutputBufferPtr out);
extern int xmlOutputBufferWrite(xmlOutputBufferPtr out, int len,
				const char *buf);
extern int xmlOutputBufferWriteEscape(xmlOutputBufferPtr out,
				      const xmlChar * str,
				      xmlCharEncodingOutputFunc escaping);
extern int xmlOutputBufferWriteString(xmlOutputBufferPtr out,
				      const char *str);
extern char *xmlParserGetDirectory(const char *filename);
extern xmlParserInputBufferPtr xmlParserInputBufferCreateFd(int fd,
							    xmlCharEncoding
							    enc);
extern xmlParserInputBufferPtr xmlParserInputBufferCreateFile(FILE * file,
							      xmlCharEncoding
							      enc);
extern xmlParserInputBufferPtr
xmlParserInputBufferCreateIO(xmlInputReadCallback ioread,
			     xmlInputCloseCallback ioclose, void *ioctx,
			     xmlCharEncoding enc);
extern xmlParserInputBufferPtr xmlParserInputBufferCreateMem(const char
							     *mem,
							     int size,
							     xmlCharEncoding
							     enc);
extern xmlParserInputBufferPtr xmlParserInputBufferCreateStatic(const char
								*mem,
								int size,
								xmlCharEncoding
								enc);
extern int xmlParserInputBufferGrow(xmlParserInputBufferPtr in, int len);
extern int xmlParserInputBufferPush(xmlParserInputBufferPtr in, int len,
				    const char *buf);
extern int xmlParserInputBufferRead(xmlParserInputBufferPtr in, int len);
extern int xmlPopInputCallbacks(void);
extern void xmlRegisterDefaultInputCallbacks(void);
extern void xmlRegisterDefaultOutputCallbacks(void);
extern void xmlRegisterHTTPPostCallbacks(void);
extern int xmlRegisterInputCallbacks(xmlInputMatchCallback matchFunc,
				     xmlInputOpenCallback openFunc,
				     xmlInputReadCallback readFunc,
				     xmlInputCloseCallback closeFunc);
extern int xmlRegisterOutputCallbacks(xmlOutputMatchCallback matchFunc,
				      xmlOutputOpenCallback openFunc,
				      xmlOutputWriteCallback writeFunc,
				      xmlOutputCloseCallback closeFunc);

19.2.24. libxml2/libxml/xmlautomata.h


typedef struct _xmlAutomataState xmlAutomataState;
typedef xmlAutomataState *xmlAutomataStatePtr;
typedef struct _xmlAutomata xmlAutomata;
typedef xmlAutomata *xmlAutomataPtr;
extern xmlRegexpPtr xmlAutomataCompile(xmlAutomataPtr);
extern xmlAutomataStatePtr xmlAutomataGetInitState(xmlAutomataPtr);
extern int xmlAutomataIsDeterminist(xmlAutomataPtr);
extern xmlAutomataStatePtr xmlAutomataNewAllTrans(xmlAutomataPtr,
						  xmlAutomataStatePtr,
						  xmlAutomataStatePtr,
						  int);
extern xmlAutomataStatePtr xmlAutomataNewCountTrans(xmlAutomataPtr,
						    xmlAutomataStatePtr,
						    xmlAutomataStatePtr,
						    const xmlChar *, int,
						    int, void *);
extern xmlAutomataStatePtr xmlAutomataNewCountTrans2(xmlAutomataPtr,
						     xmlAutomataStatePtr,
						     xmlAutomataStatePtr,
						     const xmlChar *,
						     const xmlChar *, int,
						     int, void *);
extern xmlAutomataStatePtr xmlAutomataNewCountedTrans(xmlAutomataPtr,
						      xmlAutomataStatePtr,
						      xmlAutomataStatePtr,
						      int);
extern int xmlAutomataNewCounter(xmlAutomataPtr, int, int);
extern xmlAutomataStatePtr xmlAutomataNewCounterTrans(xmlAutomataPtr,
						      xmlAutomataStatePtr,
						      xmlAutomataStatePtr,
						      int);
extern xmlAutomataStatePtr xmlAutomataNewEpsilon(xmlAutomataPtr,
						 xmlAutomataStatePtr,
						 xmlAutomataStatePtr);
extern xmlAutomataStatePtr xmlAutomataNewNegTrans(xmlAutomataPtr,
						  xmlAutomataStatePtr,
						  xmlAutomataStatePtr,
						  const xmlChar *,
						  const xmlChar *, void *);
extern xmlAutomataStatePtr xmlAutomataNewOnceTrans(xmlAutomataPtr,
						   xmlAutomataStatePtr,
						   xmlAutomataStatePtr,
						   const xmlChar *, int,
						   int, void *);
extern xmlAutomataStatePtr xmlAutomataNewOnceTrans2(xmlAutomataPtr,
						    xmlAutomataStatePtr,
						    xmlAutomataStatePtr,
						    const xmlChar *,
						    const xmlChar *, int,
						    int, void *);
extern xmlAutomataStatePtr xmlAutomataNewState(xmlAutomataPtr);
extern xmlAutomataStatePtr xmlAutomataNewTransition(xmlAutomataPtr,
						    xmlAutomataStatePtr,
						    xmlAutomataStatePtr,
						    const xmlChar *,
						    void *);
extern xmlAutomataStatePtr xmlAutomataNewTransition2(xmlAutomataPtr,
						     xmlAutomataStatePtr,
						     xmlAutomataStatePtr,
						     const xmlChar *,
						     const xmlChar *,
						     void *);
extern int xmlAutomataSetFinalState(xmlAutomataPtr, xmlAutomataStatePtr);
extern void xmlFreeAutomata(xmlAutomataPtr);
extern xmlAutomataPtr xmlNewAutomata(void);

19.2.25. libxml2/libxml/xmlerror.h


typedef int (*xmlInputReadCallback) (void *, char *, int);
typedef int (*xmlInputCloseCallback) (void *);
typedef struct _xmlParserInputBuffer {
    void *context;
    xmlInputReadCallback readcallback;
    xmlInputCloseCallback closecallback;
    xmlCharEncodingHandlerPtr encoder;
    xmlBufferPtr buffer;
    xmlBufferPtr raw;
    int compressed;
    int error;
    long unsigned int rawconsumed;
} xmlParserInputBuffer;
typedef xmlParserInputBuffer *xmlParserInputBufferPtr;
typedef void (*xmlParserInputDeallocate) (xmlChar *);
typedef struct _xmlParserInput {
    xmlParserInputBufferPtr buf;
    const char *filename;
    const char *directory;
    const xmlChar *base;
    const xmlChar *cur;
    const xmlChar *end;
    int length;
    int line;
    int col;
    long unsigned int consumed;
    xmlParserInputDeallocate free;
    const xmlChar *encoding;
    const xmlChar *version;
    int standalone;
    int id;
} xmlParserInput;
typedef xmlParserInput *xmlParserInputPtr;
typedef void (*xmlGenericErrorFunc) (void *, const char *, ...);
typedef enum {
    XML_ERR_NONE = 0,
    XML_ERR_WARNING = 1,
    XML_ERR_ERROR = 2,
    XML_ERR_FATAL = 3
} xmlErrorLevel;
typedef struct _xmlError {
    int domain;
    int code;
    char *message;
    xmlErrorLevel level;
    char *file;
    int line;
    char *str1;
    char *str2;
    char *str3;
    int int1;
    int int2;
    void *ctxt;
    void *node;
} xmlError;
typedef xmlError *xmlErrorPtr;
typedef void (*xmlStructuredErrorFunc) (void *, xmlErrorPtr);
typedef enum {
    XML_FROM_NONE = 0,
    XML_FROM_PARSER,
    XML_FROM_TREE,
    XML_FROM_NAMESPACE,
    XML_FROM_DTD,
    XML_FROM_HTML,
    XML_FROM_MEMORY,
    XML_FROM_OUTPUT,
    XML_FROM_IO,
    XML_FROM_FTP,
    XML_FROM_HTTP,
    XML_FROM_XINCLUDE,
    XML_FROM_XPATH,
    XML_FROM_XPOINTER,
    XML_FROM_REGEXP,
    XML_FROM_DATATYPE,
    XML_FROM_SCHEMASP,
    XML_FROM_SCHEMASV,
    XML_FROM_RELAXNGP,
    XML_FROM_RELAXNGV,
    XML_FROM_CATALOG,
    XML_FROM_C14N,
    XML_FROM_XSLT,
    XML_FROM_VALID,
    XML_FROM_CHECK,
    XML_FROM_WRITER,
    XML_FROM_MODULE,
    XML_FROM_I18N
} xmlErrorDomain;
typedef enum {
    XML_ERR_OK = 0,
    XML_ERR_INTERNAL_ERROR,
    XML_ERR_NO_MEMORY,
    XML_ERR_DOCUMENT_START,
    XML_ERR_DOCUMENT_EMPTY,
    XML_ERR_DOCUMENT_END,
    XML_ERR_INVALID_HEX_CHARREF,
    XML_ERR_INVALID_DEC_CHARREF,
    XML_ERR_INVALID_CHARREF,
    XML_ERR_INVALID_CHAR,
    XML_ERR_CHARREF_AT_EOF,
    XML_ERR_CHARREF_IN_PROLOG,
    XML_ERR_CHARREF_IN_EPILOG,
    XML_ERR_CHARREF_IN_DTD,
    XML_ERR_ENTITYREF_AT_EOF,
    XML_ERR_ENTITYREF_IN_PROLOG,
    XML_ERR_ENTITYREF_IN_EPILOG,
    XML_ERR_ENTITYREF_IN_DTD,
    XML_ERR_PEREF_AT_EOF,
    XML_ERR_PEREF_IN_PROLOG,
    XML_ERR_PEREF_IN_EPILOG,
    XML_ERR_PEREF_IN_INT_SUBSET,
    XML_ERR_ENTITYREF_NO_NAME,
    XML_ERR_ENTITYREF_SEMICOL_MISSING,
    XML_ERR_PEREF_NO_NAME,
    XML_ERR_PEREF_SEMICOL_MISSING,
    XML_ERR_UNDECLARED_ENTITY,
    XML_WAR_UNDECLARED_ENTITY,
    XML_ERR_UNPARSED_ENTITY,
    XML_ERR_ENTITY_IS_EXTERNAL,
    XML_ERR_ENTITY_IS_PARAMETER,
    XML_ERR_UNKNOWN_ENCODING,
    XML_ERR_UNSUPPORTED_ENCODING,
    XML_ERR_STRING_NOT_STARTED,
    XML_ERR_STRING_NOT_CLOSED,
    XML_ERR_NS_DECL_ERROR,
    XML_ERR_ENTITY_NOT_STARTED,
    XML_ERR_ENTITY_NOT_FINISHED,
    XML_ERR_LT_IN_ATTRIBUTE,
    XML_ERR_ATTRIBUTE_NOT_STARTED,
    XML_ERR_ATTRIBUTE_NOT_FINISHED,
    XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
    XML_ERR_ATTRIBUTE_REDEFINED,
    XML_ERR_LITERAL_NOT_STARTED,
    XML_ERR_LITERAL_NOT_FINISHED,
    XML_ERR_COMMENT_NOT_FINISHED,
    XML_ERR_PI_NOT_STARTED,
    XML_ERR_PI_NOT_FINISHED,
    XML_ERR_NOTATION_NOT_STARTED,
    XML_ERR_NOTATION_NOT_FINISHED,
    XML_ERR_ATTLIST_NOT_STARTED,
    XML_ERR_ATTLIST_NOT_FINISHED,
    XML_ERR_MIXED_NOT_STARTED,
    XML_ERR_MIXED_NOT_FINISHED,
    XML_ERR_ELEMCONTENT_NOT_STARTED,
    XML_ERR_ELEMCONTENT_NOT_FINISHED,
    XML_ERR_XMLDECL_NOT_STARTED,
    XML_ERR_XMLDECL_NOT_FINISHED,
    XML_ERR_CONDSEC_NOT_STARTED,
    XML_ERR_CONDSEC_NOT_FINISHED,
    XML_ERR_EXT_SUBSET_NOT_FINISHED,
    XML_ERR_DOCTYPE_NOT_FINISHED,
    XML_ERR_MISPLACED_CDATA_END,
    XML_ERR_CDATA_NOT_FINISHED,
    XML_ERR_RESERVED_XML_NAME,
    XML_ERR_SPACE_REQUIRED,
    XML_ERR_SEPARATOR_REQUIRED,
    XML_ERR_NMTOKEN_REQUIRED,
    XML_ERR_NAME_REQUIRED,
    XML_ERR_PCDATA_REQUIRED,
    XML_ERR_URI_REQUIRED,
    XML_ERR_PUBID_REQUIRED,
    XML_ERR_LT_REQUIRED,
    XML_ERR_GT_REQUIRED,
    XML_ERR_LTSLASH_REQUIRED,
    XML_ERR_EQUAL_REQUIRED,
    XML_ERR_TAG_NAME_MISMATCH,
    XML_ERR_TAG_NOT_FINISHED,
    XML_ERR_STANDALONE_VALUE,
    XML_ERR_ENCODING_NAME,
    XML_ERR_HYPHEN_IN_COMMENT,
    XML_ERR_INVALID_ENCODING,
    XML_ERR_EXT_ENTITY_STANDALONE,
    XML_ERR_CONDSEC_INVALID,
    XML_ERR_VALUE_REQUIRED,
    XML_ERR_NOT_WELL_BALANCED,
    XML_ERR_EXTRA_CONTENT,
    XML_ERR_ENTITY_CHAR_ERROR,
    XML_ERR_ENTITY_PE_INTERNAL,
    XML_ERR_ENTITY_LOOP,
    XML_ERR_ENTITY_BOUNDARY,
    XML_ERR_INVALID_URI,
    XML_ERR_URI_FRAGMENT,
    XML_WAR_CATALOG_PI,
    XML_ERR_NO_DTD,
    XML_ERR_CONDSEC_INVALID_KEYWORD,
    XML_ERR_VERSION_MISSING,
    XML_WAR_UNKNOWN_VERSION,
    XML_WAR_LANG_VALUE,
    XML_WAR_NS_URI,
    XML_WAR_NS_URI_RELATIVE,
    XML_ERR_MISSING_ENCODING,
    XML_WAR_SPACE_VALUE,
    XML_ERR_NOT_STANDALONE,
    XML_ERR_ENTITY_PROCESSING,
    XML_ERR_NOTATION_PROCESSING,
    XML_WAR_NS_COLUMN,
    XML_WAR_ENTITY_REDEFINED,
    XML_NS_ERR_XML_NAMESPACE = 200,
    XML_NS_ERR_UNDEFINED_NAMESPACE,
    XML_NS_ERR_QNAME,
    XML_NS_ERR_ATTRIBUTE_REDEFINED,
    XML_NS_ERR_EMPTY,
    XML_DTD_ATTRIBUTE_DEFAULT = 500,
    XML_DTD_ATTRIBUTE_REDEFINED,
    XML_DTD_ATTRIBUTE_VALUE,
    XML_DTD_CONTENT_ERROR,
    XML_DTD_CONTENT_MODEL,
    XML_DTD_CONTENT_NOT_DETERMINIST,
    XML_DTD_DIFFERENT_PREFIX,
    XML_DTD_ELEM_DEFAULT_NAMESPACE,
    XML_DTD_ELEM_NAMESPACE,
    XML_DTD_ELEM_REDEFINED,
    XML_DTD_EMPTY_NOTATION,
    XML_DTD_ENTITY_TYPE,
    XML_DTD_ID_FIXED,
    XML_DTD_ID_REDEFINED,
    XML_DTD_ID_SUBSET,
    XML_DTD_INVALID_CHILD,
    XML_DTD_INVALID_DEFAULT,
    XML_DTD_LOAD_ERROR,
    XML_DTD_MISSING_ATTRIBUTE,
    XML_DTD_MIXED_CORRUPT,
    XML_DTD_MULTIPLE_ID,
    XML_DTD_NO_DOC,
    XML_DTD_NO_DTD,
    XML_DTD_NO_ELEM_NAME,
    XML_DTD_NO_PREFIX,
    XML_DTD_NO_ROOT,
    XML_DTD_NOTATION_REDEFINED,
    XML_DTD_NOTATION_VALUE,
    XML_DTD_NOT_EMPTY,
    XML_DTD_NOT_PCDATA,
    XML_DTD_NOT_STANDALONE,
    XML_DTD_ROOT_NAME,
    XML_DTD_STANDALONE_WHITE_SPACE,
    XML_DTD_UNKNOWN_ATTRIBUTE,
    XML_DTD_UNKNOWN_ELEM,
    XML_DTD_UNKNOWN_ENTITY,
    XML_DTD_UNKNOWN_ID,
    XML_DTD_UNKNOWN_NOTATION,
    XML_DTD_STANDALONE_DEFAULTED,
    XML_DTD_XMLID_VALUE,
    XML_DTD_XMLID_TYPE,
    XML_HTML_STRUCURE_ERROR = 800,
    XML_HTML_UNKNOWN_TAG,
    XML_RNGP_ANYNAME_ATTR_ANCESTOR = 1000,
    XML_RNGP_ATTR_CONFLICT,
    XML_RNGP_ATTRIBUTE_CHILDREN,
    XML_RNGP_ATTRIBUTE_CONTENT,
    XML_RNGP_ATTRIBUTE_EMPTY,
    XML_RNGP_ATTRIBUTE_NOOP,
    XML_RNGP_CHOICE_CONTENT,
    XML_RNGP_CHOICE_EMPTY,
    XML_RNGP_CREATE_FAILURE,
    XML_RNGP_DATA_CONTENT,
    XML_RNGP_DEF_CHOICE_AND_INTERLEAVE,
    XML_RNGP_DEFINE_CREATE_FAILED,
    XML_RNGP_DEFINE_EMPTY,
    XML_RNGP_DEFINE_MISSING,
    XML_RNGP_DEFINE_NAME_MISSING,
    XML_RNGP_ELEM_CONTENT_EMPTY,
    XML_RNGP_ELEM_CONTENT_ERROR,
    XML_RNGP_ELEMENT_EMPTY,
    XML_RNGP_ELEMENT_CONTENT,
    XML_RNGP_ELEMENT_NAME,
    XML_RNGP_ELEMENT_NO_CONTENT,
    XML_RNGP_ELEM_TEXT_CONFLICT,
    XML_RNGP_EMPTY,
    XML_RNGP_EMPTY_CONSTRUCT,
    XML_RNGP_EMPTY_CONTENT,
    XML_RNGP_EMPTY_NOT_EMPTY,
    XML_RNGP_ERROR_TYPE_LIB,
    XML_RNGP_EXCEPT_EMPTY,
    XML_RNGP_EXCEPT_MISSING,
    XML_RNGP_EXCEPT_MULTIPLE,
    XML_RNGP_EXCEPT_NO_CONTENT,
    XML_RNGP_EXTERNALREF_EMTPY,
    XML_RNGP_EXTERNAL_REF_FAILURE,
    XML_RNGP_EXTERNALREF_RECURSE,
    XML_RNGP_FORBIDDEN_ATTRIBUTE,
    XML_RNGP_FOREIGN_ELEMENT,
    XML_RNGP_GRAMMAR_CONTENT,
    XML_RNGP_GRAMMAR_EMPTY,
    XML_RNGP_GRAMMAR_MISSING,
    XML_RNGP_GRAMMAR_NO_START,
    XML_RNGP_GROUP_ATTR_CONFLICT,
    XML_RNGP_HREF_ERROR,
    XML_RNGP_INCLUDE_EMPTY,
    XML_RNGP_INCLUDE_FAILURE,
    XML_RNGP_INCLUDE_RECURSE,
    XML_RNGP_INTERLEAVE_ADD,
    XML_RNGP_INTERLEAVE_CREATE_FAILED,
    XML_RNGP_INTERLEAVE_EMPTY,
    XML_RNGP_INTERLEAVE_NO_CONTENT,
    XML_RNGP_INVALID_DEFINE_NAME,
    XML_RNGP_INVALID_URI,
    XML_RNGP_INVALID_VALUE,
    XML_RNGP_MISSING_HREF,
    XML_RNGP_NAME_MISSING,
    XML_RNGP_NEED_COMBINE,
    XML_RNGP_NOTALLOWED_NOT_EMPTY,
    XML_RNGP_NSNAME_ATTR_ANCESTOR,
    XML_RNGP_NSNAME_NO_NS,
    XML_RNGP_PARAM_FORBIDDEN,
    XML_RNGP_PARAM_NAME_MISSING,
    XML_RNGP_PARENTREF_CREATE_FAILED,
    XML_RNGP_PARENTREF_NAME_INVALID,
    XML_RNGP_PARENTREF_NO_NAME,
    XML_RNGP_PARENTREF_NO_PARENT,
    XML_RNGP_PARENTREF_NOT_EMPTY,
    XML_RNGP_PARSE_ERROR,
    XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME,
    XML_RNGP_PAT_ATTR_ATTR,
    XML_RNGP_PAT_ATTR_ELEM,
    XML_RNGP_PAT_DATA_EXCEPT_ATTR,
    XML_RNGP_PAT_DATA_EXCEPT_ELEM,
    XML_RNGP_PAT_DATA_EXCEPT_EMPTY,
    XML_RNGP_PAT_DATA_EXCEPT_GROUP,
    XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE,
    XML_RNGP_PAT_DATA_EXCEPT_LIST,
    XML_RNGP_PAT_DATA_EXCEPT_ONEMORE,
    XML_RNGP_PAT_DATA_EXCEPT_REF,
    XML_RNGP_PAT_DATA_EXCEPT_TEXT,
    XML_RNGP_PAT_LIST_ATTR,
    XML_RNGP_PAT_LIST_ELEM,
    XML_RNGP_PAT_LIST_INTERLEAVE,
    XML_RNGP_PAT_LIST_LIST,
    XML_RNGP_PAT_LIST_REF,
    XML_RNGP_PAT_LIST_TEXT,
    XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME,
    XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME,
    XML_RNGP_PAT_ONEMORE_GROUP_ATTR,
    XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR,
    XML_RNGP_PAT_START_ATTR,
    XML_RNGP_PAT_START_DATA,
    XML_RNGP_PAT_START_EMPTY,
    XML_RNGP_PAT_START_GROUP,
    XML_RNGP_PAT_START_INTERLEAVE,
    XML_RNGP_PAT_START_LIST,
    XML_RNGP_PAT_START_ONEMORE,
    XML_RNGP_PAT_START_TEXT,
    XML_RNGP_PAT_START_VALUE,
    XML_RNGP_PREFIX_UNDEFINED,
    XML_RNGP_REF_CREATE_FAILED,
    XML_RNGP_REF_CYCLE,
    XML_RNGP_REF_NAME_INVALID,
    XML_RNGP_REF_NO_DEF,
    XML_RNGP_REF_NO_NAME,
    XML_RNGP_REF_NOT_EMPTY,
    XML_RNGP_START_CHOICE_AND_INTERLEAVE,
    XML_RNGP_START_CONTENT,
    XML_RNGP_START_EMPTY,
    XML_RNGP_START_MISSING,
    XML_RNGP_TEXT_EXPECTED,
    XML_RNGP_TEXT_HAS_CHILD,
    XML_RNGP_TYPE_MISSING,
    XML_RNGP_TYPE_NOT_FOUND,
    XML_RNGP_TYPE_VALUE,
    XML_RNGP_UNKNOWN_ATTRIBUTE,
    XML_RNGP_UNKNOWN_COMBINE,
    XML_RNGP_UNKNOWN_CONSTRUCT,
    XML_RNGP_UNKNOWN_TYPE_LIB,
    XML_RNGP_URI_FRAGMENT,
    XML_RNGP_URI_NOT_ABSOLUTE,
    XML_RNGP_VALUE_EMPTY,
    XML_RNGP_VALUE_NO_CONTENT,
    XML_RNGP_XMLNS_NAME,
    XML_RNGP_XML_NS,
    XML_XPATH_EXPRESSION_OK = 1200,
    XML_XPATH_NUMBER_ERROR,
    XML_XPATH_UNFINISHED_LITERAL_ERROR,
    XML_XPATH_START_LITERAL_ERROR,
    XML_XPATH_VARIABLE_REF_ERROR,
    XML_XPATH_UNDEF_VARIABLE_ERROR,
    XML_XPATH_INVALID_PREDICATE_ERROR,
    XML_XPATH_EXPR_ERROR,
    XML_XPATH_UNCLOSED_ERROR,
    XML_XPATH_UNKNOWN_FUNC_ERROR,
    XML_XPATH_INVALID_OPERAND,
    XML_XPATH_INVALID_TYPE,
    XML_XPATH_INVALID_ARITY,
    XML_XPATH_INVALID_CTXT_SIZE,
    XML_XPATH_INVALID_CTXT_POSITION,
    XML_XPATH_MEMORY_ERROR,
    XML_XPTR_SYNTAX_ERROR,
    XML_XPTR_RESOURCE_ERROR,
    XML_XPTR_SUB_RESOURCE_ERROR,
    XML_XPATH_UNDEF_PREFIX_ERROR,
    XML_XPATH_ENCODING_ERROR,
    XML_XPATH_INVALID_CHAR_ERROR,
    XML_TREE_INVALID_HEX = 1300,
    XML_TREE_INVALID_DEC,
    XML_TREE_UNTERMINATED_ENTITY,
    XML_SAVE_NOT_UTF8 = 1400,
    XML_SAVE_CHAR_INVALID,
    XML_SAVE_NO_DOCTYPE,
    XML_SAVE_UNKNOWN_ENCODING,
    XML_REGEXP_COMPILE_ERROR = 1450,
    XML_IO_UNKNOWN = 1500,
    XML_IO_EACCES,
    XML_IO_EAGAIN,
    XML_IO_EBADF,
    XML_IO_EBADMSG,
    XML_IO_EBUSY,
    XML_IO_ECANCELED,
    XML_IO_ECHILD,
    XML_IO_EDEADLK,
    XML_IO_EDOM,
    XML_IO_EEXIST,
    XML_IO_EFAULT,
    XML_IO_EFBIG,
    XML_IO_EINPROGRESS,
    XML_IO_EINTR,
    XML_IO_EINVAL,
    XML_IO_EIO,
    XML_IO_EISDIR,
    XML_IO_EMFILE,
    XML_IO_EMLINK,
    XML_IO_EMSGSIZE,
    XML_IO_ENAMETOOLONG,
    XML_IO_ENFILE,
    XML_IO_ENODEV,
    XML_IO_ENOENT,
    XML_IO_ENOEXEC,
    XML_IO_ENOLCK,
    XML_IO_ENOMEM,
    XML_IO_ENOSPC,
    XML_IO_ENOSYS,
    XML_IO_ENOTDIR,
    XML_IO_ENOTEMPTY,
    XML_IO_ENOTSUP,
    XML_IO_ENOTTY,
    XML_IO_ENXIO,
    XML_IO_EPERM,
    XML_IO_EPIPE,
    XML_IO_ERANGE,
    XML_IO_EROFS,
    XML_IO_ESPIPE,
    XML_IO_ESRCH,
    XML_IO_ETIMEDOUT,
    XML_IO_EXDEV,
    XML_IO_NETWORK_ATTEMPT,
    XML_IO_ENCODER,
    XML_IO_FLUSH,
    XML_IO_WRITE,
    XML_IO_NO_INPUT,
    XML_IO_BUFFER_FULL,
    XML_IO_LOAD_ERROR,
    XML_IO_ENOTSOCK,
    XML_IO_EISCONN,
    XML_IO_ECONNREFUSED,
    XML_IO_ENETUNREACH,
    XML_IO_EADDRINUSE,
    XML_IO_EALREADY,
    XML_IO_EAFNOSUPPORT,
    XML_XINCLUDE_RECURSION = 1600,
    XML_XINCLUDE_PARSE_VALUE,
    XML_XINCLUDE_ENTITY_DEF_MISMATCH,
    XML_XINCLUDE_NO_HREF,
    XML_XINCLUDE_NO_FALLBACK,
    XML_XINCLUDE_HREF_URI,
    XML_XINCLUDE_TEXT_FRAGMENT,
    XML_XINCLUDE_TEXT_DOCUMENT,
    XML_XINCLUDE_INVALID_CHAR,
    XML_XINCLUDE_BUILD_FAILED,
    XML_XINCLUDE_UNKNOWN_ENCODING,
    XML_XINCLUDE_MULTIPLE_ROOT,
    XML_XINCLUDE_XPTR_FAILED,
    XML_XINCLUDE_XPTR_RESULT,
    XML_XINCLUDE_INCLUDE_IN_INCLUDE,
    XML_XINCLUDE_FALLBACKS_IN_INCLUDE,
    XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE,
    XML_XINCLUDE_DEPRECATED_NS,
    XML_XINCLUDE_FRAGMENT_ID,
    XML_CATALOG_MISSING_ATTR = 1650,
    XML_CATALOG_ENTRY_BROKEN,
    XML_CATALOG_PREFER_VALUE,
    XML_CATALOG_NOT_CATALOG,
    XML_CATALOG_RECURSION,
    XML_SCHEMAP_PREFIX_UNDEFINED = 1700,
    XML_SCHEMAP_ATTRFORMDEFAULT_VALUE,
    XML_SCHEMAP_ATTRGRP_NONAME_NOREF,
    XML_SCHEMAP_ATTR_NONAME_NOREF,
    XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF,
    XML_SCHEMAP_ELEMFORMDEFAULT_VALUE,
    XML_SCHEMAP_ELEM_NONAME_NOREF,
    XML_SCHEMAP_EXTENSION_NO_BASE,
    XML_SCHEMAP_FACET_NO_VALUE,
    XML_SCHEMAP_FAILED_BUILD_IMPORT,
    XML_SCHEMAP_GROUP_NONAME_NOREF,
    XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI,
    XML_SCHEMAP_IMPORT_REDEFINE_NSNAME,
    XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI,
    XML_SCHEMAP_INVALID_BOOLEAN,
    XML_SCHEMAP_INVALID_ENUM,
    XML_SCHEMAP_INVALID_FACET,
    XML_SCHEMAP_INVALID_FACET_VALUE,
    XML_SCHEMAP_INVALID_MAXOCCURS,
    XML_SCHEMAP_INVALID_MINOCCURS,
    XML_SCHEMAP_INVALID_REF_AND_SUBTYPE,
    XML_SCHEMAP_INVALID_WHITE_SPACE,
    XML_SCHEMAP_NOATTR_NOREF,
    XML_SCHEMAP_NOTATION_NO_NAME,
    XML_SCHEMAP_NOTYPE_NOREF,
    XML_SCHEMAP_REF_AND_SUBTYPE,
    XML_SCHEMAP_RESTRICTION_NONAME_NOREF,
    XML_SCHEMAP_SIMPLETYPE_NONAME,
    XML_SCHEMAP_TYPE_AND_SUBTYPE,
    XML_SCHEMAP_UNKNOWN_ALL_CHILD,
    XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD,
    XML_SCHEMAP_UNKNOWN_ATTR_CHILD,
    XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD,
    XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP,
    XML_SCHEMAP_UNKNOWN_BASE_TYPE,
    XML_SCHEMAP_UNKNOWN_CHOICE_CHILD,
    XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD,
    XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD,
    XML_SCHEMAP_UNKNOWN_ELEM_CHILD,
    XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD,
    XML_SCHEMAP_UNKNOWN_FACET_CHILD,
    XML_SCHEMAP_UNKNOWN_FACET_TYPE,
    XML_SCHEMAP_UNKNOWN_GROUP_CHILD,
    XML_SCHEMAP_UNKNOWN_IMPORT_CHILD,
    XML_SCHEMAP_UNKNOWN_LIST_CHILD,
    XML_SCHEMAP_UNKNOWN_NOTATION_CHILD,
    XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD,
    XML_SCHEMAP_UNKNOWN_REF,
    XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD,
    XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD,
    XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD,
    XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD,
    XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD,
    XML_SCHEMAP_UNKNOWN_TYPE,
    XML_SCHEMAP_UNKNOWN_UNION_CHILD,
    XML_SCHEMAP_ELEM_DEFAULT_FIXED,
    XML_SCHEMAP_REGEXP_INVALID,
    XML_SCHEMAP_FAILED_LOAD,
    XML_SCHEMAP_NOTHING_TO_PARSE,
    XML_SCHEMAP_NOROOT,
    XML_SCHEMAP_REDEFINED_GROUP,
    XML_SCHEMAP_REDEFINED_TYPE,
    XML_SCHEMAP_REDEFINED_ELEMENT,
    XML_SCHEMAP_REDEFINED_ATTRGROUP,
    XML_SCHEMAP_REDEFINED_ATTR,
    XML_SCHEMAP_REDEFINED_NOTATION,
    XML_SCHEMAP_FAILED_PARSE,
    XML_SCHEMAP_UNKNOWN_PREFIX,
    XML_SCHEMAP_DEF_AND_PREFIX,
    XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD,
    XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI,
    XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI,
    XML_SCHEMAP_NOT_SCHEMA,
    XML_SCHEMAP_UNKNOWN_MEMBER_TYPE,
    XML_SCHEMAP_INVALID_ATTR_USE,
    XML_SCHEMAP_RECURSIVE,
    XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE,
    XML_SCHEMAP_INVALID_ATTR_COMBINATION,
    XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION,
    XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD,
    XML_SCHEMAP_INVALID_ATTR_NAME,
    XML_SCHEMAP_REF_AND_CONTENT,
    XML_SCHEMAP_CT_PROPS_CORRECT_1,
    XML_SCHEMAP_CT_PROPS_CORRECT_2,
    XML_SCHEMAP_CT_PROPS_CORRECT_3,
    XML_SCHEMAP_CT_PROPS_CORRECT_4,
    XML_SCHEMAP_CT_PROPS_CORRECT_5,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3,
    XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER,
    XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE,
    XML_SCHEMAP_UNION_NOT_EXPRESSIBLE,
    XML_SCHEMAP_SRC_IMPORT_3_1,
    XML_SCHEMAP_SRC_IMPORT_3_2,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3,
    XML_SCHEMAP_COS_CT_EXTENDS_1_3,
    XML_SCHEMAV_NOROOT = 1801,
    XML_SCHEMAV_UNDECLAREDELEM,
    XML_SCHEMAV_NOTTOPLEVEL,
    XML_SCHEMAV_MISSING,
    XML_SCHEMAV_WRONGELEM,
    XML_SCHEMAV_NOTYPE,
    XML_SCHEMAV_NOROLLBACK,
    XML_SCHEMAV_ISABSTRACT,
    XML_SCHEMAV_NOTEMPTY,
    XML_SCHEMAV_ELEMCONT,
    XML_SCHEMAV_HAVEDEFAULT,
    XML_SCHEMAV_NOTNILLABLE,
    XML_SCHEMAV_EXTRACONTENT,
    XML_SCHEMAV_INVALIDATTR,
    XML_SCHEMAV_INVALIDELEM,
    XML_SCHEMAV_NOTDETERMINIST,
    XML_SCHEMAV_CONSTRUCT,
    XML_SCHEMAV_INTERNAL,
    XML_SCHEMAV_NOTSIMPLE,
    XML_SCHEMAV_ATTRUNKNOWN,
    XML_SCHEMAV_ATTRINVALID,
    XML_SCHEMAV_VALUE,
    XML_SCHEMAV_FACET,
    XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1,
    XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2,
    XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3,
    XML_SCHEMAV_CVC_TYPE_3_1_1,
    XML_SCHEMAV_CVC_TYPE_3_1_2,
    XML_SCHEMAV_CVC_FACET_VALID,
    XML_SCHEMAV_CVC_LENGTH_VALID,
    XML_SCHEMAV_CVC_MINLENGTH_VALID,
    XML_SCHEMAV_CVC_MAXLENGTH_VALID,
    XML_SCHEMAV_CVC_MININCLUSIVE_VALID,
    XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID,
    XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID,
    XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID,
    XML_SCHEMAV_CVC_TOTALDIGITS_VALID,
    XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID,
    XML_SCHEMAV_CVC_PATTERN_VALID,
    XML_SCHEMAV_CVC_ENUMERATION_VALID,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4,
    XML_SCHEMAV_CVC_ELT_1,
    XML_SCHEMAV_CVC_ELT_2,
    XML_SCHEMAV_CVC_ELT_3_1,
    XML_SCHEMAV_CVC_ELT_3_2_1,
    XML_SCHEMAV_CVC_ELT_3_2_2,
    XML_SCHEMAV_CVC_ELT_4_1,
    XML_SCHEMAV_CVC_ELT_4_2,
    XML_SCHEMAV_CVC_ELT_4_3,
    XML_SCHEMAV_CVC_ELT_5_1_1,
    XML_SCHEMAV_CVC_ELT_5_1_2,
    XML_SCHEMAV_CVC_ELT_5_2_1,
    XML_SCHEMAV_CVC_ELT_5_2_2_1,
    XML_SCHEMAV_CVC_ELT_5_2_2_2_1,
    XML_SCHEMAV_CVC_ELT_5_2_2_2_2,
    XML_SCHEMAV_CVC_ELT_6,
    XML_SCHEMAV_CVC_ELT_7,
    XML_SCHEMAV_CVC_ATTRIBUTE_1,
    XML_SCHEMAV_CVC_ATTRIBUTE_2,
    XML_SCHEMAV_CVC_ATTRIBUTE_3,
    XML_SCHEMAV_CVC_ATTRIBUTE_4,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_4,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2,
    XML_SCHEMAV_ELEMENT_CONTENT,
    XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_1,
    XML_SCHEMAV_CVC_AU,
    XML_SCHEMAV_CVC_TYPE_1,
    XML_SCHEMAV_CVC_TYPE_2,
    XML_SCHEMAV_CVC_IDC,
    XML_SCHEMAV_CVC_WILDCARD,
    XML_XPTR_UNKNOWN_SCHEME = 1900,
    XML_XPTR_CHILDSEQ_START,
    XML_XPTR_EVAL_FAILED,
    XML_XPTR_EXTRA_OBJECTS,
    XML_C14N_CREATE_CTXT = 1950,
    XML_C14N_REQUIRES_UTF8,
    XML_C14N_CREATE_STACK,
    XML_C14N_INVALID_NODE,
    XML_C14N_UNKNOW_NODE,
    XML_C14N_RELATIVE_NAMESPACE,
    XML_FTP_PASV_ANSWER = 2000,
    XML_FTP_EPSV_ANSWER,
    XML_FTP_ACCNT,
    XML_FTP_URL_SYNTAX,
    XML_HTTP_URL_SYNTAX = 2020,
    XML_HTTP_USE_IP,
    XML_HTTP_UNKNOWN_HOST,
    XML_SCHEMAP_SRC_SIMPLE_TYPE_1 = 3000,
    XML_SCHEMAP_SRC_SIMPLE_TYPE_2,
    XML_SCHEMAP_SRC_SIMPLE_TYPE_3,
    XML_SCHEMAP_SRC_SIMPLE_TYPE_4,
    XML_SCHEMAP_SRC_RESOLVE,
    XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE,
    XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE,
    XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES,
    XML_SCHEMAP_ST_PROPS_CORRECT_1,
    XML_SCHEMAP_ST_PROPS_CORRECT_2,
    XML_SCHEMAP_ST_PROPS_CORRECT_3,
    XML_SCHEMAP_COS_ST_RESTRICTS_1_1,
    XML_SCHEMAP_COS_ST_RESTRICTS_1_2,
    XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1,
    XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_1,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_1,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5,
    XML_SCHEMAP_COS_ST_DERIVED_OK_2_1,
    XML_SCHEMAP_COS_ST_DERIVED_OK_2_2,
    XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
    XML_SCHEMAP_S4S_ELEM_MISSING,
    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
    XML_SCHEMAP_S4S_ATTR_MISSING,
    XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
    XML_SCHEMAP_SRC_ELEMENT_1,
    XML_SCHEMAP_SRC_ELEMENT_2_1,
    XML_SCHEMAP_SRC_ELEMENT_2_2,
    XML_SCHEMAP_SRC_ELEMENT_3,
    XML_SCHEMAP_P_PROPS_CORRECT_1,
    XML_SCHEMAP_P_PROPS_CORRECT_2_1,
    XML_SCHEMAP_P_PROPS_CORRECT_2_2,
    XML_SCHEMAP_E_PROPS_CORRECT_2,
    XML_SCHEMAP_E_PROPS_CORRECT_3,
    XML_SCHEMAP_E_PROPS_CORRECT_4,
    XML_SCHEMAP_E_PROPS_CORRECT_5,
    XML_SCHEMAP_E_PROPS_CORRECT_6,
    XML_SCHEMAP_SRC_INCLUDE,
    XML_SCHEMAP_SRC_ATTRIBUTE_1,
    XML_SCHEMAP_SRC_ATTRIBUTE_2,
    XML_SCHEMAP_SRC_ATTRIBUTE_3_1,
    XML_SCHEMAP_SRC_ATTRIBUTE_3_2,
    XML_SCHEMAP_SRC_ATTRIBUTE_4,
    XML_SCHEMAP_NO_XMLNS,
    XML_SCHEMAP_NO_XSI,
    XML_SCHEMAP_COS_VALID_DEFAULT_1,
    XML_SCHEMAP_COS_VALID_DEFAULT_2_1,
    XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1,
    XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2,
    XML_SCHEMAP_CVC_SIMPLE_TYPE,
    XML_SCHEMAP_COS_CT_EXTENDS_1_1,
    XML_SCHEMAP_SRC_IMPORT_1_1,
    XML_SCHEMAP_SRC_IMPORT_1_2,
    XML_SCHEMAP_SRC_IMPORT_2,
    XML_SCHEMAP_SRC_IMPORT_2_1,
    XML_SCHEMAP_SRC_IMPORT_2_2,
    XML_SCHEMAP_INTERNAL,
    XML_SCHEMAP_NOT_DETERMINISTIC,
    XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1,
    XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2,
    XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3,
    XML_SCHEMAP_MG_PROPS_CORRECT_1,
    XML_SCHEMAP_MG_PROPS_CORRECT_2,
    XML_SCHEMAP_SRC_CT_1,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3,
    XML_SCHEMAP_AU_PROPS_CORRECT_2,
    XML_SCHEMAP_A_PROPS_CORRECT_2,
    XML_SCHEMAP_C_PROPS_CORRECT,
    XML_SCHEMAP_SRC_REDEFINE,
    XML_SCHEMAP_SRC_IMPORT,
    XML_SCHEMAP_WARN_SKIP_SCHEMA,
    XML_SCHEMAP_WARN_UNLOCATED_SCHEMA,
    XML_SCHEMAP_WARN_ATTR_REDECL_PROH,
    XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH,
    XML_MODULE_OPEN = 4900,
    XML_MODULE_CLOSE,
    XML_CHECK_FOUND_ELEMENT = 5000,
    XML_CHECK_FOUND_ATTRIBUTE,
    XML_CHECK_FOUND_TEXT,
    XML_CHECK_FOUND_CDATA,
    XML_CHECK_FOUND_ENTITYREF,
    XML_CHECK_FOUND_ENTITY,
    XML_CHECK_FOUND_PI,
    XML_CHECK_FOUND_COMMENT,
    XML_CHECK_FOUND_DOCTYPE,
    XML_CHECK_FOUND_FRAGMENT,
    XML_CHECK_FOUND_NOTATION,
    XML_CHECK_UNKNOWN_NODE,
    XML_CHECK_ENTITY_TYPE,
    XML_CHECK_NO_PARENT,
    XML_CHECK_NO_DOC,
    XML_CHECK_NO_NAME,
    XML_CHECK_NO_ELEM,
    XML_CHECK_WRONG_DOC,
    XML_CHECK_NO_PREV,
    XML_CHECK_WRONG_PREV,
    XML_CHECK_NO_NEXT,
    XML_CHECK_WRONG_NEXT,
    XML_CHECK_NOT_DTD,
    XML_CHECK_NOT_ATTR,
    XML_CHECK_NOT_ATTR_DECL,
    XML_CHECK_NOT_ELEM_DECL,
    XML_CHECK_NOT_ENTITY_DECL,
    XML_CHECK_NOT_NS_DECL,
    XML_CHECK_NO_HREF,
    XML_CHECK_WRONG_PARENT,
    XML_CHECK_NS_SCOPE,
    XML_CHECK_NS_ANCESTOR,
    XML_CHECK_NOT_UTF8,
    XML_CHECK_NO_DICT,
    XML_CHECK_NOT_NCNAME,
    XML_CHECK_OUTSIDE_DICT,
    XML_CHECK_WRONG_NAME,
    XML_CHECK_NAME_NOT_NULL,
    XML_I18N_NO_NAME = 6000,
    XML_I18N_NO_HANDLER,
    XML_I18N_EXCESS_HANDLER,
    XML_I18N_CONV_FAILED,
    XML_I18N_NO_OUTPUT
} xmlParserErrors;
extern void initGenericErrorDefaultFunc(xmlGenericErrorFunc * handler);
extern int xmlCopyError(xmlErrorPtr from, xmlErrorPtr to);
extern xmlErrorPtr xmlCtxtGetLastError(void *ctx);
extern void xmlCtxtResetLastError(void *ctx);
extern xmlErrorPtr xmlGetLastError(void);
extern void xmlParserError(void *ctx, const char *msg, ...);
extern void xmlParserPrintFileContext(xmlParserInputPtr input);
extern void xmlParserPrintFileInfo(xmlParserInputPtr input);
extern void xmlParserValidityError(void *ctx, const char *msg, ...);
extern void xmlParserValidityWarning(void *ctx, const char *msg, ...);
extern void xmlParserWarning(void *ctx, const char *msg, ...);
extern void xmlResetError(xmlErrorPtr err);
extern void xmlResetLastError(void);
extern void xmlSetGenericErrorFunc(void *ctx, xmlGenericErrorFunc handler);
extern void xmlSetStructuredErrorFunc(void *ctx,
				      xmlStructuredErrorFunc handler);

19.2.26. libxml2/libxml/xmlexports.h


#define XMLCALL
#define XMLCDECL
#define XMLPUBFUN
#define XMLPUBVAR	extern
#define LIBXML_DLL_IMPORT	XMLPUBVAR

19.2.27. libxml2/libxml/xmlmemory.h


typedef void (*xmlFreeFunc) (void *);
typedef void *(*xmlMallocFunc) (size_t);
typedef void *(*xmlReallocFunc) (void *, size_t);
typedef char *(*xmlStrdupFunc) (const char *);
extern void xmlCleanupMemory(void);
extern int xmlGcMemGet(xmlFreeFunc * freeFunc, xmlMallocFunc * mallocFunc,
		       xmlMallocFunc * mallocAtomicFunc,
		       xmlReallocFunc * reallocFunc,
		       xmlStrdupFunc * strdupFunc);
extern int xmlGcMemSetup(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc,
			 xmlMallocFunc mallocAtomicFunc,
			 xmlReallocFunc reallocFunc,
			 xmlStrdupFunc strdupFunc);
extern int xmlInitMemory(void);
extern void *xmlMallocAtomicLoc(size_t size, const char *file, int line);
extern void *xmlMallocLoc(size_t size, const char *file, int line);
extern int xmlMemBlocks(void);
extern void xmlMemDisplay(FILE * fp);
extern void xmlMemFree(void *ptr);
extern int xmlMemGet(xmlFreeFunc * freeFunc, xmlMallocFunc * mallocFunc,
		     xmlReallocFunc * reallocFunc,
		     xmlStrdupFunc * strdupFunc);
extern void *xmlMemMalloc(size_t size);
extern void *xmlMemRealloc(void *ptr, size_t size);
extern int xmlMemSetup(xmlFreeFunc freeFunc, xmlMallocFunc mallocFunc,
		       xmlReallocFunc reallocFunc,
		       xmlStrdupFunc strdupFunc);
extern void xmlMemShow(FILE * fp, int nr);
extern char *xmlMemStrdupLoc(const char *str, const char *file, int line);
extern int xmlMemUsed(void);
extern void xmlMemoryDump(void);
extern char *xmlMemoryStrdup(const char *str);
extern void *xmlReallocLoc(void *ptr, size_t size, const char *file,
			   int line);

19.2.28. libxml2/libxml/xmlmodule.h


typedef struct _xmlModule xmlModule;
typedef xmlModule *xmlModulePtr;
typedef enum {
    XML_MODULE_LAZY = 1,
    XML_MODULE_LOCAL = 2
} xmlModuleOption;
extern int xmlModuleClose(xmlModulePtr module);
extern int xmlModuleFree(xmlModulePtr module);
extern xmlModulePtr xmlModuleOpen(const char *filename, int options);
extern int xmlModuleSymbol(xmlModulePtr module, const char *name,
			   void **result);

19.2.29. libxml2/libxml/xmlreader.h


typedef struct _xmlTextReader xmlTextReader;
typedef xmlTextReader *xmlTextReaderPtr;
typedef enum {
    XML_PARSER_SEVERITY_VALIDITY_WARNING = 1,
    XML_PARSER_SEVERITY_VALIDITY_ERROR = 2,
    XML_PARSER_SEVERITY_WARNING = 3,
    XML_PARSER_SEVERITY_ERROR = 4
} xmlParserSeverities;
typedef void *xmlTextReaderLocatorPtr;
typedef void (*xmlTextReaderErrorFunc) (void *, const char *,
					xmlParserSeverities,
					xmlTextReaderLocatorPtr);
typedef enum {
    XML_PARSER_LOADDTD = 1,
    XML_PARSER_DEFAULTATTRS = 2,
    XML_PARSER_VALIDATE = 3,
    XML_PARSER_SUBST_ENTITIES = 4
} xmlParserProperties;
typedef enum {
    XML_READER_TYPE_NONE = 0,
    XML_READER_TYPE_ELEMENT = 1,
    XML_READER_TYPE_ATTRIBUTE = 2,
    XML_READER_TYPE_TEXT = 3,
    XML_READER_TYPE_CDATA = 4,
    XML_READER_TYPE_ENTITY_REFERENCE = 5,
    XML_READER_TYPE_ENTITY = 6,
    XML_READER_TYPE_PROCESSING_INSTRUCTION = 7,
    XML_READER_TYPE_COMMENT = 8,
    XML_READER_TYPE_DOCUMENT = 9,
    XML_READER_TYPE_DOCUMENT_TYPE = 10,
    XML_READER_TYPE_DOCUMENT_FRAGMENT = 11,
    XML_READER_TYPE_NOTATION = 12,
    XML_READER_TYPE_WHITESPACE = 13,
    XML_READER_TYPE_SIGNIFICANT_WHITESPACE = 14,
    XML_READER_TYPE_END_ELEMENT = 15,
    XML_READER_TYPE_END_ENTITY = 16,
    XML_READER_TYPE_XML_DECLARATION = 17
} xmlReaderTypes;
typedef enum {
    XML_TEXTREADER_MODE_INITIAL = 0,
    XML_TEXTREADER_MODE_INTERACTIVE = 1,
    XML_TEXTREADER_MODE_ERROR = 2,
    XML_TEXTREADER_MODE_EOF = 3,
    XML_TEXTREADER_MODE_CLOSED = 4,
    XML_TEXTREADER_MODE_READING = 5
} xmlTextReaderMode;
extern void xmlFreeTextReader(xmlTextReaderPtr reader);
extern xmlTextReaderPtr xmlNewTextReader(xmlParserInputBufferPtr input,
					 const char *URI);
extern xmlTextReaderPtr xmlNewTextReaderFilename(const char *URI);
extern xmlTextReaderPtr xmlReaderForDoc(const xmlChar * cur,
					const char *URL,
					const char *encoding, int options);
extern xmlTextReaderPtr xmlReaderForFd(int fd, const char *URL,
				       const char *encoding, int options);
extern xmlTextReaderPtr xmlReaderForFile(const char *filename,
					 const char *encoding,
					 int options);
extern xmlTextReaderPtr xmlReaderForIO(xmlInputReadCallback ioread,
				       xmlInputCloseCallback ioclose,
				       void *ioctx, const char *URL,
				       const char *encoding, int options);
extern xmlTextReaderPtr xmlReaderForMemory(const char *buffer, int size,
					   const char *URL,
					   const char *encoding,
					   int options);
extern int xmlReaderNewDoc(xmlTextReaderPtr reader, const xmlChar * cur,
			   const char *URL, const char *encoding,
			   int options);
extern int xmlReaderNewFd(xmlTextReaderPtr reader, int fd, const char *URL,
			  const char *encoding, int options);
extern int xmlReaderNewFile(xmlTextReaderPtr reader, const char *filename,
			    const char *encoding, int options);
extern int xmlReaderNewIO(xmlTextReaderPtr reader,
			  xmlInputReadCallback ioread,
			  xmlInputCloseCallback ioclose, void *ioctx,
			  const char *URL, const char *encoding,
			  int options);
extern int xmlReaderNewMemory(xmlTextReaderPtr reader, const char *buffer,
			      int size, const char *URL,
			      const char *encoding, int options);
extern int xmlReaderNewWalker(xmlTextReaderPtr reader, xmlDocPtr doc);
extern xmlTextReaderPtr xmlReaderWalker(xmlDocPtr doc);
extern int xmlTextReaderAttributeCount(xmlTextReaderPtr reader);
extern xmlChar *xmlTextReaderBaseUri(xmlTextReaderPtr reader);
extern long int xmlTextReaderByteConsumed(xmlTextReaderPtr reader);
extern int xmlTextReaderClose(xmlTextReaderPtr reader);
extern const xmlChar *xmlTextReaderConstBaseUri(xmlTextReaderPtr reader);
extern const xmlChar *xmlTextReaderConstEncoding(xmlTextReaderPtr reader);
extern const xmlChar *xmlTextReaderConstLocalName(xmlTextReaderPtr reader);
extern const xmlChar *xmlTextReaderConstName(xmlTextReaderPtr reader);
extern const xmlChar *xmlTextReaderConstNamespaceUri(xmlTextReaderPtr
						     reader);
extern const xmlChar *xmlTextReaderConstPrefix(xmlTextReaderPtr reader);
extern const xmlChar *xmlTextReaderConstString(xmlTextReaderPtr reader,
					       const xmlChar * str);
extern const xmlChar *xmlTextReaderConstValue(xmlTextReaderPtr reader);
extern const xmlChar *xmlTextReaderConstXmlLang(xmlTextReaderPtr reader);
extern const xmlChar *xmlTextReaderConstXmlVersion(xmlTextReaderPtr
						   reader);
extern xmlDocPtr xmlTextReaderCurrentDoc(xmlTextReaderPtr reader);
extern xmlNodePtr xmlTextReaderCurrentNode(xmlTextReaderPtr reader);
extern int xmlTextReaderDepth(xmlTextReaderPtr reader);
extern xmlNodePtr xmlTextReaderExpand(xmlTextReaderPtr reader);
extern xmlChar *xmlTextReaderGetAttribute(xmlTextReaderPtr reader,
					  const xmlChar * name);
extern xmlChar *xmlTextReaderGetAttributeNo(xmlTextReaderPtr reader,
					    int no);
extern xmlChar *xmlTextReaderGetAttributeNs(xmlTextReaderPtr reader,
					    const xmlChar * localName,
					    const xmlChar * namespaceURI);
extern void xmlTextReaderGetErrorHandler(xmlTextReaderPtr reader,
					 xmlTextReaderErrorFunc * f,
					 void **arg);
extern int xmlTextReaderGetParserColumnNumber(xmlTextReaderPtr reader);
extern int xmlTextReaderGetParserLineNumber(xmlTextReaderPtr reader);
extern int xmlTextReaderGetParserProp(xmlTextReaderPtr reader, int prop);
extern xmlParserInputBufferPtr xmlTextReaderGetRemainder(xmlTextReaderPtr
							 reader);
extern int xmlTextReaderHasAttributes(xmlTextReaderPtr reader);
extern int xmlTextReaderHasValue(xmlTextReaderPtr reader);
extern int xmlTextReaderIsDefault(xmlTextReaderPtr reader);
extern int xmlTextReaderIsEmptyElement(xmlTextReaderPtr reader);
extern int xmlTextReaderIsNamespaceDecl(xmlTextReaderPtr reader);
extern int xmlTextReaderIsValid(xmlTextReaderPtr reader);
extern xmlChar *xmlTextReaderLocalName(xmlTextReaderPtr reader);
extern xmlChar *xmlTextReaderLocatorBaseURI(xmlTextReaderLocatorPtr
					    locator);
extern int xmlTextReaderLocatorLineNumber(xmlTextReaderLocatorPtr locator);
extern xmlChar *xmlTextReaderLookupNamespace(xmlTextReaderPtr reader,
					     const xmlChar * prefix);
extern int xmlTextReaderMoveToAttribute(xmlTextReaderPtr reader,
					const xmlChar * name);
extern int xmlTextReaderMoveToAttributeNo(xmlTextReaderPtr reader, int no);
extern int xmlTextReaderMoveToAttributeNs(xmlTextReaderPtr reader,
					  const xmlChar * localName,
					  const xmlChar * namespaceURI);
extern int xmlTextReaderMoveToElement(xmlTextReaderPtr reader);
extern int xmlTextReaderMoveToFirstAttribute(xmlTextReaderPtr reader);
extern int xmlTextReaderMoveToNextAttribute(xmlTextReaderPtr reader);
extern xmlChar *xmlTextReaderName(xmlTextReaderPtr reader);
extern xmlChar *xmlTextReaderNamespaceUri(xmlTextReaderPtr reader);
extern int xmlTextReaderNext(xmlTextReaderPtr reader);
extern int xmlTextReaderNextSibling(xmlTextReaderPtr reader);
extern int xmlTextReaderNodeType(xmlTextReaderPtr reader);
extern int xmlTextReaderNormalization(xmlTextReaderPtr reader);
extern xmlChar *xmlTextReaderPrefix(xmlTextReaderPtr reader);
extern xmlNodePtr xmlTextReaderPreserve(xmlTextReaderPtr reader);
extern int xmlTextReaderPreservePattern(xmlTextReaderPtr reader,
					const xmlChar * pattern,
					const xmlChar * *namespaces);
extern int xmlTextReaderQuoteChar(xmlTextReaderPtr reader);
extern int xmlTextReaderRead(xmlTextReaderPtr reader);
extern int xmlTextReaderReadAttributeValue(xmlTextReaderPtr reader);
extern xmlChar *xmlTextReaderReadInnerXml(xmlTextReaderPtr reader);
extern xmlChar *xmlTextReaderReadOuterXml(xmlTextReaderPtr reader);
extern int xmlTextReaderReadState(xmlTextReaderPtr reader);
extern xmlChar *xmlTextReaderReadString(xmlTextReaderPtr reader);
extern int xmlTextReaderRelaxNGSetSchema(xmlTextReaderPtr reader,
					 xmlRelaxNGPtr schema);
extern int xmlTextReaderRelaxNGValidate(xmlTextReaderPtr reader,
					const char *rng);
extern int xmlTextReaderSchemaValidate(xmlTextReaderPtr reader,
				       const char *xsd);
extern void xmlTextReaderSetErrorHandler(xmlTextReaderPtr reader,
					 xmlTextReaderErrorFunc f,
					 void *arg);
extern int xmlTextReaderSetParserProp(xmlTextReaderPtr reader, int prop,
				      int value);
extern int xmlTextReaderSetSchema(xmlTextReaderPtr reader,
				  xmlSchemaPtr schema);
extern void xmlTextReaderSetStructuredErrorHandler(xmlTextReaderPtr reader,
						   xmlStructuredErrorFunc
						   f, void *arg);
extern int xmlTextReaderStandalone(xmlTextReaderPtr reader);
extern xmlChar *xmlTextReaderValue(xmlTextReaderPtr reader);
extern xmlChar *xmlTextReaderXmlLang(xmlTextReaderPtr reader);

19.2.30. libxml2/libxml/xmlregexp.h


typedef struct _xmlRegexp xmlRegexp;
typedef xmlRegexp *xmlRegexpPtr;
typedef struct _xmlRegExecCtxt xmlRegExecCtxt;
typedef xmlRegExecCtxt *xmlRegExecCtxtPtr;
typedef struct _xmlExpNode xmlExpNode;
typedef xmlExpNode *xmlExpNodePtr;
typedef void (*xmlRegExecCallbacks) (xmlRegExecCtxtPtr, const xmlChar *,
				     void *, void *);
typedef struct _xmlExpCtxt xmlExpCtxt;
typedef xmlExpCtxt *xmlExpCtxtPtr;
typedef enum {
    XML_EXP_EMPTY = 0,
    XML_EXP_FORBID = 1,
    XML_EXP_ATOM = 2,
    XML_EXP_SEQ = 3,
    XML_EXP_OR = 4,
    XML_EXP_COUNT = 5
} xmlExpNodeType;
extern xmlExpNodePtr emptyExp;
extern xmlExpNodePtr forbiddenExp;
extern int xmlExpCtxtNbCons(xmlExpCtxtPtr ctxt);
extern int xmlExpCtxtNbNodes(xmlExpCtxtPtr ctxt);
extern void xmlExpDump(xmlBufferPtr buf, xmlExpNodePtr expr);
extern xmlExpNodePtr xmlExpExpDerive(xmlExpCtxtPtr ctxt,
				     xmlExpNodePtr expr,
				     xmlExpNodePtr sub);
extern void xmlExpFree(xmlExpCtxtPtr ctxt, xmlExpNodePtr expr);
extern void xmlExpFreeCtxt(xmlExpCtxtPtr ctxt);
extern int xmlExpGetLanguage(xmlExpCtxtPtr ctxt, xmlExpNodePtr expr,
			     const xmlChar * *langList, int len);
extern int xmlExpGetStart(xmlExpCtxtPtr ctxt, xmlExpNodePtr expr,
			  const xmlChar * *tokList, int len);
extern int xmlExpIsNillable(xmlExpNodePtr expr);
extern int xmlExpMaxToken(xmlExpNodePtr expr);
extern xmlExpNodePtr xmlExpNewAtom(xmlExpCtxtPtr ctxt,
				   const xmlChar * name, int len);
extern xmlExpCtxtPtr xmlExpNewCtxt(int maxNodes, xmlDictPtr dict);
extern xmlExpNodePtr xmlExpNewOr(xmlExpCtxtPtr ctxt, xmlExpNodePtr left,
				 xmlExpNodePtr right);
extern xmlExpNodePtr xmlExpNewRange(xmlExpCtxtPtr ctxt,
				    xmlExpNodePtr subset, int min,
				    int max);
extern xmlExpNodePtr xmlExpNewSeq(xmlExpCtxtPtr ctxt, xmlExpNodePtr left,
				  xmlExpNodePtr right);
extern xmlExpNodePtr xmlExpParse(xmlExpCtxtPtr ctxt, const char *expr);
extern void xmlExpRef(xmlExpNodePtr expr);
extern xmlExpNodePtr xmlExpStringDerive(xmlExpCtxtPtr ctxt,
					xmlExpNodePtr expr,
					const xmlChar * str, int len);
extern int xmlExpSubsume(xmlExpCtxtPtr ctxt, xmlExpNodePtr expr,
			 xmlExpNodePtr sub);
extern int xmlRegExecErrInfo(xmlRegExecCtxtPtr exec,
			     const xmlChar * *string, int *nbval,
			     int *nbneg, xmlChar * *values, int *terminal);
extern int xmlRegExecNextValues(xmlRegExecCtxtPtr exec, int *nbval,
				int *nbneg, xmlChar * *values,
				int *terminal);
extern int xmlRegExecPushString(xmlRegExecCtxtPtr exec,
				const xmlChar * value, void *data);
extern int xmlRegExecPushString2(xmlRegExecCtxtPtr exec,
				 const xmlChar * value,
				 const xmlChar * value2, void *data);
extern void xmlRegFreeExecCtxt(xmlRegExecCtxtPtr exec);
extern void xmlRegFreeRegexp(xmlRegexpPtr regexp);
extern xmlRegExecCtxtPtr xmlRegNewExecCtxt(xmlRegexpPtr comp,
					   xmlRegExecCallbacks callback,
					   void *data);
extern xmlRegexpPtr xmlRegexpCompile(const xmlChar * regexp);
extern int xmlRegexpExec(xmlRegexpPtr comp, const xmlChar * value);
extern int xmlRegexpIsDeterminist(xmlRegexpPtr comp);
extern void xmlRegexpPrint(FILE * output, xmlRegexpPtr regexp);

19.2.31. libxml2/libxml/xmlsave.h


typedef struct _xmlSaveCtxt xmlSaveCtxt;
typedef xmlSaveCtxt *xmlSaveCtxtPtr;
typedef enum {
    XML_SAVE_FORMAT = 1 << 0,
    XML_SAVE_NO_DECL = 1 << 1,
    XML_SAVE_NO_EMPTY = 1 << 2,
    XML_SAVE_NO_XHTML = 1 << 3
} xmlSaveOption;
extern int xmlSaveClose(xmlSaveCtxtPtr ctxt);
extern long int xmlSaveDoc(xmlSaveCtxtPtr ctxt, xmlDocPtr doc);
extern int xmlSaveFlush(xmlSaveCtxtPtr ctxt);
extern int xmlSaveSetAttrEscape(xmlSaveCtxtPtr ctxt,
				xmlCharEncodingOutputFunc escape);
extern int xmlSaveSetEscape(xmlSaveCtxtPtr ctxt,
			    xmlCharEncodingOutputFunc escape);
extern xmlSaveCtxtPtr xmlSaveToFd(int fd, const char *encoding,
				  int options);
extern xmlSaveCtxtPtr xmlSaveToFilename(const char *filename,
					const char *encoding, int options);
extern xmlSaveCtxtPtr xmlSaveToIO(xmlOutputWriteCallback iowrite,
				  xmlOutputCloseCallback ioclose,
				  void *ioctx, const char *encoding,
				  int options);
extern long int xmlSaveTree(xmlSaveCtxtPtr ctxt, xmlNodePtr node);

19.2.32. libxml2/libxml/xmlschemas.h


typedef struct _xmlSchemaValidCtxt xmlSchemaValidCtxt;
typedef xmlSchemaValidCtxt *xmlSchemaValidCtxtPtr;
typedef struct _xmlSchemaSAXPlug xmlSchemaSAXPlugStruct;
typedef xmlSchemaSAXPlugStruct *xmlSchemaSAXPlugPtr;
typedef struct _xmlSchemaParserCtxt xmlSchemaParserCtxt;
typedef xmlSchemaParserCtxt *xmlSchemaParserCtxtPtr;
typedef void (*xmlSchemaValidityErrorFunc) (void *, const char *, ...);
typedef void (*xmlSchemaValidityWarningFunc) (void *, const char *, ...);
typedef struct _xmlSchema xmlSchema;
typedef xmlSchema *xmlSchemaPtr;
typedef enum {
    XML_SCHEMA_VAL_VC_I_CREATE = 1 << 0
} xmlSchemaValidOption;
extern void xmlSchemaDump(FILE * output, xmlSchemaPtr schema);
extern void xmlSchemaFree(xmlSchemaPtr schema);
extern void xmlSchemaFreeParserCtxt(xmlSchemaParserCtxtPtr ctxt);
extern void xmlSchemaFreeValidCtxt(xmlSchemaValidCtxtPtr ctxt);
extern int xmlSchemaGetParserErrors(xmlSchemaParserCtxtPtr ctxt,
				    xmlSchemaValidityErrorFunc * err,
				    xmlSchemaValidityWarningFunc * warn,
				    void **ctx);
extern int xmlSchemaGetValidErrors(xmlSchemaValidCtxtPtr ctxt,
				   xmlSchemaValidityErrorFunc * err,
				   xmlSchemaValidityWarningFunc * warn,
				   void **ctx);
extern int xmlSchemaIsValid(xmlSchemaValidCtxtPtr ctxt);
extern xmlSchemaParserCtxtPtr xmlSchemaNewDocParserCtxt(xmlDocPtr doc);
extern xmlSchemaParserCtxtPtr xmlSchemaNewMemParserCtxt(const char *buffer,
							int size);
extern xmlSchemaParserCtxtPtr xmlSchemaNewParserCtxt(const char *URL);
extern xmlSchemaValidCtxtPtr xmlSchemaNewValidCtxt(xmlSchemaPtr schema);
extern xmlSchemaPtr xmlSchemaParse(xmlSchemaParserCtxtPtr ctxt);
extern xmlSchemaSAXPlugPtr xmlSchemaSAXPlug(xmlSchemaValidCtxtPtr ctxt,
					    xmlSAXHandlerPtr * sax,
					    void **user_data);
extern int xmlSchemaSAXUnplug(xmlSchemaSAXPlugPtr plug);
extern void xmlSchemaSetParserErrors(xmlSchemaParserCtxtPtr ctxt,
				     xmlSchemaValidityErrorFunc err,
				     xmlSchemaValidityWarningFunc warn,
				     void *ctx);
extern void xmlSchemaSetValidErrors(xmlSchemaValidCtxtPtr ctxt,
				    xmlSchemaValidityErrorFunc err,
				    xmlSchemaValidityWarningFunc warn,
				    void *ctx);
extern int xmlSchemaSetValidOptions(xmlSchemaValidCtxtPtr ctxt,
				    int options);
extern void xmlSchemaSetValidStructuredErrors(xmlSchemaValidCtxtPtr ctxt,
					      xmlStructuredErrorFunc
					      serror, void *ctx);
extern int xmlSchemaValidCtxtGetOptions(xmlSchemaValidCtxtPtr ctxt);
extern int xmlSchemaValidateDoc(xmlSchemaValidCtxtPtr ctxt,
				xmlDocPtr instance);
extern int xmlSchemaValidateFile(xmlSchemaValidCtxtPtr ctxt,
				 const char *filename, int options);
extern int xmlSchemaValidateOneElement(xmlSchemaValidCtxtPtr ctxt,
				       xmlNodePtr elem);
extern int xmlSchemaValidateStream(xmlSchemaValidCtxtPtr ctxt,
				   xmlParserInputBufferPtr input,
				   xmlCharEncoding enc,
				   xmlSAXHandlerPtr sax, void *user_data);

19.2.33. libxml2/libxml/xmlschemastypes.h


typedef struct _xmlSchemaType xmlSchemaType;
typedef xmlSchemaType *xmlSchemaTypePtr;
typedef struct _xmlSchemaVal xmlSchemaVal;
typedef xmlSchemaVal *xmlSchemaValPtr;
typedef enum {
    XML_SCHEMAS_UNKNOWN = 0,
    XML_SCHEMAS_STRING = 1,
    XML_SCHEMAS_NORMSTRING = 2,
    XML_SCHEMAS_DECIMAL = 3,
    XML_SCHEMAS_TIME = 4,
    XML_SCHEMAS_GDAY = 5,
    XML_SCHEMAS_GMONTH = 6,
    XML_SCHEMAS_GMONTHDAY = 7,
    XML_SCHEMAS_GYEAR = 8,
    XML_SCHEMAS_GYEARMONTH = 9,
    XML_SCHEMAS_DATE = 10,
    XML_SCHEMAS_DATETIME = 11,
    XML_SCHEMAS_DURATION = 12,
    XML_SCHEMAS_FLOAT = 13,
    XML_SCHEMAS_DOUBLE = 14,
    XML_SCHEMAS_BOOLEAN = 15,
    XML_SCHEMAS_TOKEN = 16,
    XML_SCHEMAS_LANGUAGE = 17,
    XML_SCHEMAS_NMTOKEN = 18,
    XML_SCHEMAS_NMTOKENS = 19,
    XML_SCHEMAS_NAME = 20,
    XML_SCHEMAS_QNAME = 21,
    XML_SCHEMAS_NCNAME = 22,
    XML_SCHEMAS_ID = 23,
    XML_SCHEMAS_IDREF = 24,
    XML_SCHEMAS_IDREFS = 25,
    XML_SCHEMAS_ENTITY = 26,
    XML_SCHEMAS_ENTITIES = 27,
    XML_SCHEMAS_NOTATION = 28,
    XML_SCHEMAS_ANYURI = 29,
    XML_SCHEMAS_INTEGER = 30,
    XML_SCHEMAS_NPINTEGER = 31,
    XML_SCHEMAS_NINTEGER = 32,
    XML_SCHEMAS_NNINTEGER = 33,
    XML_SCHEMAS_PINTEGER = 34,
    XML_SCHEMAS_INT = 35,
    XML_SCHEMAS_UINT = 36,
    XML_SCHEMAS_LONG = 37,
    XML_SCHEMAS_ULONG = 38,
    XML_SCHEMAS_SHORT = 39,
    XML_SCHEMAS_USHORT = 40,
    XML_SCHEMAS_BYTE = 41,
    XML_SCHEMAS_UBYTE = 42,
    XML_SCHEMAS_HEXBINARY = 43,
    XML_SCHEMAS_BASE64BINARY = 44,
    XML_SCHEMAS_ANYTYPE = 45,
    XML_SCHEMAS_ANYSIMPLETYPE = 46
} xmlSchemaValType;
extern void xmlSchemaCleanupTypes(void);
extern xmlChar *xmlSchemaCollapseString(const xmlChar * value);
extern int xmlSchemaCompareValues(xmlSchemaValPtr x, xmlSchemaValPtr y);
extern void xmlSchemaFreeValue(xmlSchemaValPtr val);
extern xmlSchemaTypePtr xmlSchemaGetBuiltInType(xmlSchemaValType type);
extern int xmlSchemaGetCanonValue(xmlSchemaValPtr val,
				  const xmlChar * *retValue);
extern xmlSchemaValType xmlSchemaGetValType(xmlSchemaValPtr val);
extern void xmlSchemaInitTypes(void);
extern int xmlSchemaValPredefTypeNode(xmlSchemaTypePtr type,
				      const xmlChar * value,
				      xmlSchemaValPtr * val,
				      xmlNodePtr node);

19.2.34. libxml2/libxml/xmlstring.h


#define BAD_CAST	(xmlChar *)

typedef unsigned char xmlChar;
extern xmlChar *xmlCharStrdup(const char *cur);
extern xmlChar *xmlCharStrndup(const char *cur, int len);
extern int xmlCheckUTF8(const unsigned char *utf);
extern int xmlGetUTF8Char(const unsigned char *utf, int *len);
extern int xmlStrEqual(const xmlChar * str1, const xmlChar * str2);
extern int xmlStrPrintf(xmlChar * buf, int len, const xmlChar * msg, ...);
extern int xmlStrQEqual(const xmlChar * pref, const xmlChar * name,
			const xmlChar * str);
extern int xmlStrVPrintf(xmlChar * buf, int len, const xmlChar * msg,
			 va_list ap);
extern int xmlStrcasecmp(const xmlChar * str1, const xmlChar * str2);
extern const xmlChar *xmlStrcasestr(const xmlChar * str, xmlChar * val);
extern xmlChar *xmlStrcat(xmlChar * cur, const xmlChar * add);
extern const xmlChar *xmlStrchr(const xmlChar * str, xmlChar val);
extern int xmlStrcmp(const xmlChar * str1, const xmlChar * str2);
extern xmlChar *xmlStrdup(const xmlChar * cur);
extern int xmlStrlen(const xmlChar * str);
extern int xmlStrncasecmp(const xmlChar * str1, const xmlChar * str2,
			  int len);
extern xmlChar *xmlStrncat(xmlChar * cur, const xmlChar * add, int len);
extern xmlChar *xmlStrncatNew(const xmlChar * str1, const xmlChar * str2,
			      int len);
extern int xmlStrncmp(const xmlChar * str1, const xmlChar * str2, int len);
extern xmlChar *xmlStrndup(const xmlChar * cur, int len);
extern const xmlChar *xmlStrstr(const xmlChar * str, const xmlChar * val);
extern xmlChar *xmlStrsub(const xmlChar * str, int start, int len);
extern int xmlUTF8Charcmp(const xmlChar * utf1, const xmlChar * utf2);
extern int xmlUTF8Size(const xmlChar * utf);
extern int xmlUTF8Strlen(const xmlChar * utf);
extern int xmlUTF8Strloc(const xmlChar * utf, const xmlChar * utfchar);
extern xmlChar *xmlUTF8Strndup(const xmlChar * utf, int len);
extern const xmlChar *xmlUTF8Strpos(const xmlChar * utf, int pos);
extern int xmlUTF8Strsize(const xmlChar * utf, int len);
extern xmlChar *xmlUTF8Strsub(const xmlChar * utf, int start, int len);

19.2.35. libxml2/libxml/xmlversion.h


#define LIBXML_AUTOMATA_ENABLED
#define LIBXML_C14N_ENABLED
#define LIBXML_CATALOG_ENABLED
#define LIBXML_DEBUG_ENABLED
#define LIBXML_DOCB_ENABLED
#define LIBXML_EXPR_ENABLED
#define LIBXML_FTP_ENABLED
#define LIBXML_HTML_ENABLED
#define LIBXML_HTTP_ENABLED
#define LIBXML_ICONV_ENABLED
#define LIBXML_ISO8859X_ENABLED
#define LIBXML_LEGACY_ENABLED
#define LIBXML_MODULES_ENABLED
#define LIBXML_OUTPUT_ENABLED
#define LIBXML_PATTERN_ENABLED
#define LIBXML_PUSH_ENABLED
#define LIBXML_READER_ENABLED
#define LIBXML_REGEXP_ENABLED
#define LIBXML_SAX1_ENABLED
#define LIBXML_SCHEMAS_ENABLED
#define LIBXML_SCHEMATRON_ENABLED
#define LIBXML_THREAD_ENABLED
#define LIBXML_TREE_ENABLED
#define LIBXML_UNICODE_ENABLED
#define LIBXML_VALID_ENABLED
#define LIBXML_VERSION_EXTRA	""
#define LIBXML_WRITER_ENABLED
#define LIBXML_XINCLUDE_ENABLED
#define LIBXML_XPATH_ENABLED
#define LIBXML_XPTR_ENABLED
#define WITHOUT_TRIO
#define LIBXML_MODULE_EXTENSION	".so"
#define LIBXML_DOTTED_VERSION	"2.6.22"
#define LIBXML_VERSION	20622
#define LIBXML_VERSION_STRING	"20622"
#define LIBXML_TEST_VERSION	xmlCheckVersion(20622);
#define ATTRIBUTE_UNUSED	__attribute__((unused))

extern void xmlCheckVersion(int version);

19.2.36. libxml2/libxml/xmlwriter.h


#define xmlTextWriterWriteDocType	xmlTextWriterWriteDTD
#define xmlTextWriterWriteProcessingInstruction	xmlTextWriterWritePI

typedef struct _xmlTextWriter xmlTextWriter;
typedef xmlTextWriter *xmlTextWriterPtr;
extern void xmlFreeTextWriter(xmlTextWriterPtr writer);
extern xmlTextWriterPtr xmlNewTextWriter(xmlOutputBufferPtr out);
extern xmlTextWriterPtr xmlNewTextWriterDoc(xmlDocPtr * doc,
					    int compression);
extern xmlTextWriterPtr xmlNewTextWriterFilename(const char *uri,
						 int compression);
extern xmlTextWriterPtr xmlNewTextWriterMemory(xmlBufferPtr buf,
					       int compression);
extern xmlTextWriterPtr xmlNewTextWriterPushParser(xmlParserCtxtPtr ctxt,
						   int compression);
extern xmlTextWriterPtr xmlNewTextWriterTree(xmlDocPtr doc,
					     xmlNodePtr node,
					     int compression);
extern int xmlTextWriterEndAttribute(xmlTextWriterPtr writer);
extern int xmlTextWriterEndCDATA(xmlTextWriterPtr writer);
extern int xmlTextWriterEndComment(xmlTextWriterPtr writer);
extern int xmlTextWriterEndDTD(xmlTextWriterPtr writer);
extern int xmlTextWriterEndDTDAttlist(xmlTextWriterPtr writer);
extern int xmlTextWriterEndDTDElement(xmlTextWriterPtr writer);
extern int xmlTextWriterEndDTDEntity(xmlTextWriterPtr writer);
extern int xmlTextWriterEndDocument(xmlTextWriterPtr writer);
extern int xmlTextWriterEndElement(xmlTextWriterPtr writer);
extern int xmlTextWriterEndPI(xmlTextWriterPtr writer);
extern int xmlTextWriterFlush(xmlTextWriterPtr writer);
extern int xmlTextWriterFullEndElement(xmlTextWriterPtr writer);
extern int xmlTextWriterSetIndent(xmlTextWriterPtr writer, int indent);
extern int xmlTextWriterSetIndentString(xmlTextWriterPtr writer,
					const xmlChar * str);
extern int xmlTextWriterStartAttribute(xmlTextWriterPtr writer,
				       const xmlChar * name);
extern int xmlTextWriterStartAttributeNS(xmlTextWriterPtr writer,
					 const xmlChar * prefix,
					 const xmlChar * name,
					 const xmlChar * namespaceURI);
extern int xmlTextWriterStartCDATA(xmlTextWriterPtr writer);
extern int xmlTextWriterStartComment(xmlTextWriterPtr writer);
extern int xmlTextWriterStartDTD(xmlTextWriterPtr writer,
				 const xmlChar * name,
				 const xmlChar * pubid,
				 const xmlChar * sysid);
extern int xmlTextWriterStartDTDAttlist(xmlTextWriterPtr writer,
					const xmlChar * name);
extern int xmlTextWriterStartDTDElement(xmlTextWriterPtr writer,
					const xmlChar * name);
extern int xmlTextWriterStartDTDEntity(xmlTextWriterPtr writer, int pe,
				       const xmlChar * name);
extern int xmlTextWriterStartDocument(xmlTextWriterPtr writer,
				      const char *version,
				      const char *encoding,
				      const char *standalone);
extern int xmlTextWriterStartElement(xmlTextWriterPtr writer,
				     const xmlChar * name);
extern int xmlTextWriterStartElementNS(xmlTextWriterPtr writer,
				       const xmlChar * prefix,
				       const xmlChar * name,
				       const xmlChar * namespaceURI);
extern int xmlTextWriterStartPI(xmlTextWriterPtr writer,
				const xmlChar * target);
extern int xmlTextWriterWriteAttribute(xmlTextWriterPtr writer,
				       const xmlChar * name,
				       const xmlChar * content);
extern int xmlTextWriterWriteAttributeNS(xmlTextWriterPtr writer,
					 const xmlChar * prefix,
					 const xmlChar * name,
					 const xmlChar * namespaceURI,
					 const xmlChar * content);
extern int xmlTextWriterWriteBase64(xmlTextWriterPtr writer,
				    const char *data, int start, int len);
extern int xmlTextWriterWriteBinHex(xmlTextWriterPtr writer,
				    const char *data, int start, int len);
extern int xmlTextWriterWriteCDATA(xmlTextWriterPtr writer,
				   const xmlChar * content);
extern int xmlTextWriterWriteComment(xmlTextWriterPtr writer,
				     const xmlChar * content);
extern int xmlTextWriterWriteDTD(xmlTextWriterPtr writer,
				 const xmlChar * name,
				 const xmlChar * pubid,
				 const xmlChar * sysid,
				 const xmlChar * subset);
extern int xmlTextWriterWriteDTDAttlist(xmlTextWriterPtr writer,
					const xmlChar * name,
					const xmlChar * content);
extern int xmlTextWriterWriteDTDElement(xmlTextWriterPtr writer,
					const xmlChar * name,
					const xmlChar * content);
extern int xmlTextWriterWriteDTDEntity(xmlTextWriterPtr writer, int pe,
				       const xmlChar * name,
				       const xmlChar * pubid,
				       const xmlChar * sysid,
				       const xmlChar * ndataid,
				       const xmlChar * content);
extern int xmlTextWriterWriteDTDExternalEntity(xmlTextWriterPtr writer,
					       int pe,
					       const xmlChar * name,
					       const xmlChar * pubid,
					       const xmlChar * sysid,
					       const xmlChar * ndataid);
extern int xmlTextWriterWriteDTDExternalEntityContents(xmlTextWriterPtr
						       writer,
						       const xmlChar *
						       pubid,
						       const xmlChar *
						       sysid,
						       const xmlChar *
						       ndataid);
extern int xmlTextWriterWriteDTDInternalEntity(xmlTextWriterPtr writer,
					       int pe,
					       const xmlChar * name,
					       const xmlChar * content);
extern int xmlTextWriterWriteDTDNotation(xmlTextWriterPtr writer,
					 const xmlChar * name,
					 const xmlChar * pubid,
					 const xmlChar * sysid);
extern int xmlTextWriterWriteElement(xmlTextWriterPtr writer,
				     const xmlChar * name,
				     const xmlChar * content);
extern int xmlTextWriterWriteElementNS(xmlTextWriterPtr writer,
				       const xmlChar * prefix,
				       const xmlChar * name,
				       const xmlChar * namespaceURI,
				       const xmlChar * content);
extern int xmlTextWriterWriteFormatAttribute(xmlTextWriterPtr writer,
					     const xmlChar * name,
					     const char *format, ...);
extern int xmlTextWriterWriteFormatAttributeNS(xmlTextWriterPtr writer,
					       const xmlChar * prefix,
					       const xmlChar * name,
					       const xmlChar *
					       namespaceURI,
					       const char *format, ...);
extern int xmlTextWriterWriteFormatCDATA(xmlTextWriterPtr writer,
					 const char *format, ...);
extern int xmlTextWriterWriteFormatComment(xmlTextWriterPtr writer,
					   const char *format, ...);
extern int xmlTextWriterWriteFormatDTD(xmlTextWriterPtr writer,
				       const xmlChar * name,
				       const xmlChar * pubid,
				       const xmlChar * sysid,
				       const char *format, ...);
extern int xmlTextWriterWriteFormatDTDAttlist(xmlTextWriterPtr writer,
					      const xmlChar * name,
					      const char *format, ...);
extern int xmlTextWriterWriteFormatDTDElement(xmlTextWriterPtr writer,
					      const xmlChar * name,
					      const char *format, ...);
extern int xmlTextWriterWriteFormatDTDInternalEntity(xmlTextWriterPtr
						     writer, int pe,
						     const xmlChar * name,
						     const char *format,
						     ...);
extern int xmlTextWriterWriteFormatElement(xmlTextWriterPtr writer,
					   const xmlChar * name,
					   const char *format, ...);
extern int xmlTextWriterWriteFormatElementNS(xmlTextWriterPtr writer,
					     const xmlChar * prefix,
					     const xmlChar * name,
					     const xmlChar * namespaceURI,
					     const char *format, ...);
extern int xmlTextWriterWriteFormatPI(xmlTextWriterPtr writer,
				      const xmlChar * target,
				      const char *format, ...);
extern int xmlTextWriterWriteFormatRaw(xmlTextWriterPtr writer,
				       const char *format, ...);
extern int xmlTextWriterWriteFormatString(xmlTextWriterPtr writer,
					  const char *format, ...);
extern int xmlTextWriterWritePI(xmlTextWriterPtr writer,
				const xmlChar * target,
				const xmlChar * content);
extern int xmlTextWriterWriteRaw(xmlTextWriterPtr writer,
				 const xmlChar * content);
extern int xmlTextWriterWriteRawLen(xmlTextWriterPtr writer,
				    const xmlChar * content, int len);
extern int xmlTextWriterWriteString(xmlTextWriterPtr writer,
				    const xmlChar * content);
extern int xmlTextWriterWriteVFormatAttribute(xmlTextWriterPtr writer,
					      const xmlChar * name,
					      const char *format,
					      va_list argptr);
extern int xmlTextWriterWriteVFormatAttributeNS(xmlTextWriterPtr writer,
						const xmlChar * prefix,
						const xmlChar * name,
						const xmlChar *
						namespaceURI,
						const char *format,
						va_list argptr);
extern int xmlTextWriterWriteVFormatCDATA(xmlTextWriterPtr writer,
					  const char *format,
					  va_list argptr);
extern int xmlTextWriterWriteVFormatComment(xmlTextWriterPtr writer,
					    const char *format,
					    va_list argptr);
extern int xmlTextWriterWriteVFormatDTD(xmlTextWriterPtr writer,
					const xmlChar * name,
					const xmlChar * pubid,
					const xmlChar * sysid,
					const char *format,
					va_list argptr);
extern int xmlTextWriterWriteVFormatDTDAttlist(xmlTextWriterPtr writer,
					       const xmlChar * name,
					       const char *format,
					       va_list argptr);
extern int xmlTextWriterWriteVFormatDTDElement(xmlTextWriterPtr writer,
					       const xmlChar * name,
					       const char *format,
					       va_list argptr);
extern int xmlTextWriterWriteVFormatDTDInternalEntity(xmlTextWriterPtr
						      writer, int pe,
						      const xmlChar * name,
						      const char *format,
						      va_list argptr);
extern int xmlTextWriterWriteVFormatElement(xmlTextWriterPtr writer,
					    const xmlChar * name,
					    const char *format,
					    va_list argptr);
extern int xmlTextWriterWriteVFormatElementNS(xmlTextWriterPtr writer,
					      const xmlChar * prefix,
					      const xmlChar * name,
					      const xmlChar * namespaceURI,
					      const char *format,
					      va_list argptr);
extern int xmlTextWriterWriteVFormatPI(xmlTextWriterPtr writer,
				       const xmlChar * target,
				       const char *format, va_list argptr);
extern int xmlTextWriterWriteVFormatRaw(xmlTextWriterPtr writer,
					const char *format,
					va_list argptr);
extern int xmlTextWriterWriteVFormatString(xmlTextWriterPtr writer,
					   const char *format,
					   va_list argptr);

19.2.37. libxml2/libxml/xpath.h


#define xmlXPathNodeSetItem(ns,index)	 \
	((((ns) != NULL) && ((index) >= 0) && ((index) < (ns)->nodeNr)) ? \
	(ns)->nodeTab[(index)] : NULL)
#define xmlXPathNodeSetIsEmpty(ns)	 \
	(((ns) == NULL) || ((ns)->nodeNr == 0) || ((ns)->nodeTab == NULL))
#define xmlXPathNodeSetGetLength(ns)	((ns) ? (ns)->nodeNr : 0)
#define XML_XPATH_CHECKNS	(1<<0)
#define XML_XPATH_NOVAR	(1<<1)

typedef struct _xmlXPathCompExpr xmlXPathCompExpr;
typedef xmlXPathCompExpr *xmlXPathCompExprPtr;
typedef enum {
    XPATH_UNDEFINED = 0,
    XPATH_NODESET = 1,
    XPATH_BOOLEAN = 2,
    XPATH_NUMBER = 3,
    XPATH_STRING = 4,
    XPATH_POINT = 5,
    XPATH_RANGE = 6,
    XPATH_LOCATIONSET = 7,
    XPATH_USERS = 8,
    XPATH_XSLT_TREE = 9
} xmlXPathObjectType;
typedef struct _xmlNodeSet {
    int nodeNr;
    int nodeMax;
    xmlNodePtr *nodeTab;
} xmlNodeSet;
typedef xmlNodeSet *xmlNodeSetPtr;
typedef struct _xmlXPathObject {
    xmlXPathObjectType type;
    xmlNodeSetPtr nodesetval;
    int boolval;
    double floatval;
    xmlChar *stringval;
    void *user;
    int index;
    void *user2;
    int index2;
} xmlXPathObject;
typedef xmlXPathObject *xmlXPathObjectPtr;
typedef int (*xmlXPathConvertFunc) (xmlXPathObjectPtr, int);
typedef struct _xmlXPathType {
    const xmlChar *name;
    xmlXPathConvertFunc func;
} xmlXPathType;
typedef xmlXPathType *xmlXPathTypePtr;
typedef struct _xmlXPathContext {
    xmlDocPtr doc;
    xmlNodePtr node;
    int nb_variables_unused;
    int max_variables_unused;
    xmlHashTablePtr varHash;
    int nb_types;
    int max_types;
    xmlXPathTypePtr types;
    int nb_funcs_unused;
    int max_funcs_unused;
    xmlHashTablePtr funcHash;
    int nb_axis;
    int max_axis;
    xmlXPathAxisPtr axis;
    xmlNsPtr *namespaces;
    int nsNr;
    void *user;
    int contextSize;
    int proximityPosition;
    int xptr;
    xmlNodePtr here;
    xmlNodePtr origin;
    xmlHashTablePtr nsHash;
    xmlXPathVariableLookupFunc varLookupFunc;
    void *varLookupData;
    void *extra;
    const xmlChar *function;
    const xmlChar *functionURI;
    xmlXPathFuncLookupFunc funcLookupFunc;
    void *funcLookupData;
    xmlNsPtr *tmpNsList;
    int tmpNsNr;
    void *userData;
    xmlStructuredErrorFunc error;
    xmlError lastError;
    xmlNodePtr debugNode;
    xmlDictPtr dict;
    int flags;
} xmlXPathContext;
typedef xmlXPathContext *xmlXPathContextPtr;
typedef struct _xmlXPathParserContext {
    const xmlChar *cur;
    const xmlChar *base;
    int error;
    xmlXPathContextPtr context;
    xmlXPathObjectPtr value;
    int valueNr;
    int valueMax;
    xmlXPathObjectPtr *valueTab;
    xmlXPathCompExprPtr comp;
    int xptr;
    xmlNodePtr ancestor;
} xmlXPathParserContext;
typedef xmlXPathParserContext *xmlXPathParserContextPtr;
typedef xmlXPathObjectPtr(*xmlXPathAxisFunc) (xmlXPathParserContextPtr,
					      xmlXPathObjectPtr);
typedef struct _xmlXPathAxis {
    const xmlChar *name;
    xmlXPathAxisFunc func;
} xmlXPathAxis;
typedef xmlXPathAxis *xmlXPathAxisPtr;
typedef xmlXPathObjectPtr(*xmlXPathVariableLookupFunc) (void *,
							const xmlChar *,
							const xmlChar *);
typedef void (*xmlXPathFunction) (xmlXPathParserContextPtr, int);
typedef xmlXPathFunction(*xmlXPathFuncLookupFunc) (void *, const xmlChar *,
						   const xmlChar *);
typedef enum {
    XPATH_EXPRESSION_OK = 0,
    XPATH_NUMBER_ERROR,
    XPATH_UNFINISHED_LITERAL_ERROR,
    XPATH_START_LITERAL_ERROR,
    XPATH_VARIABLE_REF_ERROR,
    XPATH_UNDEF_VARIABLE_ERROR,
    XPATH_INVALID_PREDICATE_ERROR,
    XPATH_EXPR_ERROR,
    XPATH_UNCLOSED_ERROR,
    XPATH_UNKNOWN_FUNC_ERROR,
    XPATH_INVALID_OPERAND,
    XPATH_INVALID_TYPE,
    XPATH_INVALID_ARITY,
    XPATH_INVALID_CTXT_SIZE,
    XPATH_INVALID_CTXT_POSITION,
    XPATH_MEMORY_ERROR,
    XPTR_SYNTAX_ERROR,
    XPTR_RESOURCE_ERROR,
    XPTR_SUB_RESOURCE_ERROR,
    XPATH_UNDEF_PREFIX_ERROR,
    XPATH_ENCODING_ERROR,
    XPATH_INVALID_CHAR_ERROR,
    XPATH_INVALID_CTXT
} xmlXPathError;
typedef void (*xmlXPathEvalFunc) (xmlXPathParserContextPtr, int);
typedef struct _xmlXPathFunct {
    const xmlChar *name;
    xmlXPathEvalFunc func;
} xmlXPathFunct;
typedef struct _xmlXPathVariable {
    const xmlChar *name;
    xmlXPathObjectPtr value;
} xmlXPathVariable;
typedef xmlXPathVariable *xmlXPathVariablePtr;
typedef xmlXPathFunct *xmlXPathFuncPtr;
extern double xmlXPathCastBooleanToNumber(int val);
extern xmlChar *xmlXPathCastBooleanToString(int val);
extern int xmlXPathCastNodeSetToBoolean(xmlNodeSetPtr ns);
extern double xmlXPathCastNodeSetToNumber(xmlNodeSetPtr ns);
extern xmlChar *xmlXPathCastNodeSetToString(xmlNodeSetPtr ns);
extern double xmlXPathCastNodeToNumber(xmlNodePtr node);
extern xmlChar *xmlXPathCastNodeToString(xmlNodePtr node);
extern int xmlXPathCastNumberToBoolean(double val);
extern xmlChar *xmlXPathCastNumberToString(double val);
extern int xmlXPathCastStringToBoolean(const xmlChar * val);
extern double xmlXPathCastStringToNumber(const xmlChar * val);
extern int xmlXPathCastToBoolean(xmlXPathObjectPtr val);
extern double xmlXPathCastToNumber(xmlXPathObjectPtr val);
extern xmlChar *xmlXPathCastToString(xmlXPathObjectPtr val);
extern int xmlXPathCmpNodes(xmlNodePtr node1, xmlNodePtr node2);
extern xmlXPathCompExprPtr xmlXPathCompile(const xmlChar * str);
extern xmlXPathObjectPtr xmlXPathCompiledEval(xmlXPathCompExprPtr comp,
					      xmlXPathContextPtr ctx);
extern xmlXPathObjectPtr xmlXPathConvertBoolean(xmlXPathObjectPtr val);
extern xmlXPathObjectPtr xmlXPathConvertNumber(xmlXPathObjectPtr val);
extern xmlXPathObjectPtr xmlXPathConvertString(xmlXPathObjectPtr val);
extern xmlXPathCompExprPtr xmlXPathCtxtCompile(xmlXPathContextPtr ctxt,
					       const xmlChar * str);
extern xmlXPathObjectPtr xmlXPathEval(const xmlChar * str,
				      xmlXPathContextPtr ctx);
extern xmlXPathObjectPtr xmlXPathEvalExpression(const xmlChar * str,
						xmlXPathContextPtr ctxt);
extern int xmlXPathEvalPredicate(xmlXPathContextPtr ctxt,
				 xmlXPathObjectPtr res);
extern void xmlXPathFreeCompExpr(xmlXPathCompExprPtr comp);
extern void xmlXPathFreeContext(xmlXPathContextPtr ctxt);
extern void xmlXPathFreeNodeSet(xmlNodeSetPtr obj);
extern void xmlXPathFreeNodeSetList(xmlXPathObjectPtr obj);
extern void xmlXPathFreeObject(xmlXPathObjectPtr obj);
extern void xmlXPathInit(void);
extern int xmlXPathIsInf(double val);
extern int xmlXPathIsNaN(double val);
extern double xmlXPathNAN;
extern double xmlXPathNINF;
extern xmlXPathContextPtr xmlXPathNewContext(xmlDocPtr doc);
extern xmlNodeSetPtr xmlXPathNodeSetCreate(xmlNodePtr val);
extern xmlXPathObjectPtr xmlXPathObjectCopy(xmlXPathObjectPtr val);
extern long int xmlXPathOrderDocElems(xmlDocPtr doc);
extern double xmlXPathPINF;

19.2.38. libxml2/libxml/xpathInternals.h


#define xmlXPathStackIsNodeSet(ctxt)	 \
	(((ctxt)->value != NULL) && (((ctxt)->value->type == XPATH_NODESET) \
	|| ((ctxt)->value->type == XPATH_XSLT_TREE)))
#define xmlXPathStackIsExternal(ctxt)	 \
	((ctxt->value != NULL) && (ctxt->value->type == XPATH_USERS))
#define CAST_TO_BOOLEAN	 \
	if ((ctxt->value != NULL) && (ctxt->value->type != XPATH_BOOLEAN)) \
	xmlXPathBooleanFunction(ctxt, 1);
#define CAST_TO_NUMBER	 \
	if ((ctxt->value != NULL) && (ctxt->value->type != XPATH_NUMBER)) \
	xmlXPathNumberFunction(ctxt, 1);
#define CAST_TO_STRING	 \
	if ((ctxt->value != NULL) && (ctxt->value->type != XPATH_STRING)) \
	xmlXPathStringFunction(ctxt, 1);
#define CHECK_TYPE(typeval)	 \
	if ((ctxt->value == NULL) || (ctxt->value->type != typeval)) \
	XP_ERROR(XPATH_INVALID_TYPE)
#define CHECK_TYPE0(typeval)	 \
	if ((ctxt->value == NULL) || (ctxt->value->type != typeval)) \
	XP_ERROR0(XPATH_INVALID_TYPE)
#define CHECK_ARITY(x)	 \
	if (ctxt == NULL) return; if (nargs != (x)) \
	XP_ERROR(XPATH_INVALID_ARITY);
#define xmlXPathReturnBoolean(ctxt,val)	 \
	valuePush((ctxt), xmlXPathNewBoolean(val))
#define xmlXPathReturnEmptyString(ctxt)	 \
	valuePush((ctxt), xmlXPathNewCString(""))
#define xmlXPathReturnNumber(ctxt,val)	 \
	valuePush((ctxt), xmlXPathNewFloat(val))
#define xmlXPathReturnEmptyNodeSet(ctxt)	 \
	valuePush((ctxt), xmlXPathNewNodeSet(NULL))
#define xmlXPathReturnExternal(ctxt,val)	 \
	valuePush((ctxt), xmlXPathWrapExternal(val))
#define xmlXPathReturnNodeSet(ctxt,ns)	 \
	valuePush((ctxt), xmlXPathWrapNodeSet(ns))
#define xmlXPathReturnString(ctxt,str)	 \
	valuePush((ctxt), xmlXPathWrapString(str))
#define xmlXPathSetArityError(ctxt)	 \
	xmlXPathSetError((ctxt), XPATH_INVALID_ARITY)
#define xmlXPathSetTypeError(ctxt)	 \
	xmlXPathSetError((ctxt), XPATH_INVALID_TYPE)
#define xmlXPathEmptyNodeSet(ns)	 \
	{ while ((ns)->nodeNr > 0) (ns)->nodeTab[(ns)->nodeNr--] = NULL; }
#define xmlXPathSetError(ctxt,err)	 \
	{ xmlXPatherror((ctxt), __FILE__, __LINE__, (err)); if ((ctxt) != \
	NULL) (ctxt)->error = (err); }
#define xmlXPathGetDocument(ctxt)	((ctxt)->context->doc)
#define xmlXPathGetContextNode(ctxt)	((ctxt)->context->node)
#define xmlXPathCheckError(ctxt)	((ctxt)->error != XPATH_EXPRESSION_OK)
#define xmlXPathGetError(ctxt)	((ctxt)->error)
#define CHECK_ERROR	if (ctxt->error != XPATH_EXPRESSION_OK) return
#define CHECK_ERROR0	if (ctxt->error != XPATH_EXPRESSION_OK) return(0)
#define xmlXPathReturnFalse(ctxt)	xmlXPathReturnBoolean((ctxt), 0)
#define xmlXPathReturnTrue(ctxt)	xmlXPathReturnBoolean((ctxt), 1)
#define XP_ERROR0(X)	{ xmlXPathErr(ctxt, X); return(0); }
#define XP_ERROR(X)	{ xmlXPathErr(ctxt, X); return; }

extern xmlXPathObjectPtr valuePop(xmlXPathParserContextPtr ctxt);
extern int valuePush(xmlXPathParserContextPtr ctxt,
		     xmlXPathObjectPtr value);
extern void xmlXPathAddValues(xmlXPathParserContextPtr ctxt);
extern void xmlXPathBooleanFunction(xmlXPathParserContextPtr ctxt,
				    int nargs);
extern void xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt,
				    int nargs);
extern int xmlXPathCompareValues(xmlXPathParserContextPtr ctxt, int inf,
				 int strict);
extern void xmlXPathConcatFunction(xmlXPathParserContextPtr ctxt,
				   int nargs);
extern void xmlXPathContainsFunction(xmlXPathParserContextPtr ctxt,
				     int nargs);
extern void xmlXPathCountFunction(xmlXPathParserContextPtr ctxt,
				  int nargs);
extern void xmlXPathDebugDumpCompExpr(FILE * output,
				      xmlXPathCompExprPtr comp, int depth);
extern void xmlXPathDebugDumpObject(FILE * output, xmlXPathObjectPtr cur,
				    int depth);
extern xmlNodeSetPtr xmlXPathDifference(xmlNodeSetPtr nodes1,
					xmlNodeSetPtr nodes2);
extern xmlNodeSetPtr xmlXPathDistinct(xmlNodeSetPtr nodes);
extern xmlNodeSetPtr xmlXPathDistinctSorted(xmlNodeSetPtr nodes);
extern void xmlXPathDivValues(xmlXPathParserContextPtr ctxt);
extern int xmlXPathEqualValues(xmlXPathParserContextPtr ctxt);
extern void xmlXPathErr(xmlXPathParserContextPtr ctxt, int error);
extern void xmlXPathEvalExpr(xmlXPathParserContextPtr ctxt);
extern int xmlXPathEvaluatePredicateResult(xmlXPathParserContextPtr ctxt,
					   xmlXPathObjectPtr res);
extern void xmlXPathFalseFunction(xmlXPathParserContextPtr ctxt,
				  int nargs);
extern void xmlXPathFloorFunction(xmlXPathParserContextPtr ctxt,
				  int nargs);
extern void xmlXPathFreeParserContext(xmlXPathParserContextPtr ctxt);
extern xmlXPathFunction xmlXPathFunctionLookup(xmlXPathContextPtr ctxt,
					       const xmlChar * name);
extern xmlXPathFunction xmlXPathFunctionLookupNS(xmlXPathContextPtr ctxt,
						 const xmlChar * name,
						 const xmlChar * ns_uri);
extern int xmlXPathHasSameNodes(xmlNodeSetPtr nodes1,
				xmlNodeSetPtr nodes2);
extern void xmlXPathIdFunction(xmlXPathParserContextPtr ctxt, int nargs);
extern xmlNodeSetPtr xmlXPathIntersection(xmlNodeSetPtr nodes1,
					  xmlNodeSetPtr nodes2);
extern int xmlXPathIsNodeType(const xmlChar * name);
extern void xmlXPathLangFunction(xmlXPathParserContextPtr ctxt, int nargs);
extern void xmlXPathLastFunction(xmlXPathParserContextPtr ctxt, int nargs);
extern xmlNodeSetPtr xmlXPathLeading(xmlNodeSetPtr nodes1,
				     xmlNodeSetPtr nodes2);
extern xmlNodeSetPtr xmlXPathLeadingSorted(xmlNodeSetPtr nodes1,
					   xmlNodeSetPtr nodes2);
extern void xmlXPathLocalNameFunction(xmlXPathParserContextPtr ctxt,
				      int nargs);
extern void xmlXPathModValues(xmlXPathParserContextPtr ctxt);
extern void xmlXPathMultValues(xmlXPathParserContextPtr ctxt);
extern void xmlXPathNamespaceURIFunction(xmlXPathParserContextPtr ctxt,
					 int nargs);
extern xmlXPathObjectPtr xmlXPathNewBoolean(int val);
extern xmlXPathObjectPtr xmlXPathNewCString(const char *val);
extern xmlXPathObjectPtr xmlXPathNewFloat(double val);
extern xmlXPathObjectPtr xmlXPathNewNodeSet(xmlNodePtr val);
extern xmlXPathObjectPtr xmlXPathNewNodeSetList(xmlNodeSetPtr val);
extern xmlXPathParserContextPtr xmlXPathNewParserContext(const xmlChar *
							 str,
							 xmlXPathContextPtr
							 ctxt);
extern xmlXPathObjectPtr xmlXPathNewString(const xmlChar * val);
extern xmlXPathObjectPtr xmlXPathNewValueTree(xmlNodePtr val);
extern xmlNodePtr xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt,
				       xmlNodePtr cur);
extern xmlNodePtr xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt,
					     xmlNodePtr cur);
extern xmlNodePtr xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt,
					xmlNodePtr cur);
extern xmlNodePtr xmlXPathNextChild(xmlXPathParserContextPtr ctxt,
				    xmlNodePtr cur);
extern xmlNodePtr xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt,
					 xmlNodePtr cur);
extern xmlNodePtr xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr
					       ctxt, xmlNodePtr cur);
extern xmlNodePtr xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt,
					xmlNodePtr cur);
extern xmlNodePtr xmlXPathNextFollowingSibling(xmlXPathParserContextPtr
					       ctxt, xmlNodePtr cur);
extern xmlNodePtr xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt,
					xmlNodePtr cur);
extern xmlNodePtr xmlXPathNextParent(xmlXPathParserContextPtr ctxt,
				     xmlNodePtr cur);
extern xmlNodePtr xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt,
					xmlNodePtr cur);
extern xmlNodePtr xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr
					       ctxt, xmlNodePtr cur);
extern xmlNodePtr xmlXPathNextSelf(xmlXPathParserContextPtr ctxt,
				   xmlNodePtr cur);
extern xmlNodeSetPtr xmlXPathNodeLeading(xmlNodeSetPtr nodes,
					 xmlNodePtr node);
extern xmlNodeSetPtr xmlXPathNodeLeadingSorted(xmlNodeSetPtr nodes,
					       xmlNodePtr node);
extern void xmlXPathNodeSetAdd(xmlNodeSetPtr cur, xmlNodePtr val);
extern void xmlXPathNodeSetAddNs(xmlNodeSetPtr cur, xmlNodePtr node,
				 xmlNsPtr ns);
extern void xmlXPathNodeSetAddUnique(xmlNodeSetPtr cur, xmlNodePtr val);
extern int xmlXPathNodeSetContains(xmlNodeSetPtr cur, xmlNodePtr val);
extern void xmlXPathNodeSetDel(xmlNodeSetPtr cur, xmlNodePtr val);
extern void xmlXPathNodeSetFreeNs(xmlNsPtr ns);
extern xmlNodeSetPtr xmlXPathNodeSetMerge(xmlNodeSetPtr val1,
					  xmlNodeSetPtr val2);
extern void xmlXPathNodeSetRemove(xmlNodeSetPtr cur, int val);
extern void xmlXPathNodeSetSort(xmlNodeSetPtr set);
extern xmlNodeSetPtr xmlXPathNodeTrailing(xmlNodeSetPtr nodes,
					  xmlNodePtr node);
extern xmlNodeSetPtr xmlXPathNodeTrailingSorted(xmlNodeSetPtr nodes,
						xmlNodePtr node);
extern void xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt,
				      int nargs);
extern int xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt);
extern void xmlXPathNotFunction(xmlXPathParserContextPtr ctxt, int nargs);
extern const xmlChar *xmlXPathNsLookup(xmlXPathContextPtr ctxt,
				       const xmlChar * prefix);
extern void xmlXPathNumberFunction(xmlXPathParserContextPtr ctxt,
				   int nargs);
extern xmlChar *xmlXPathParseNCName(xmlXPathParserContextPtr ctxt);
extern xmlChar *xmlXPathParseName(xmlXPathParserContextPtr ctxt);
extern int xmlXPathPopBoolean(xmlXPathParserContextPtr ctxt);
extern void *xmlXPathPopExternal(xmlXPathParserContextPtr ctxt);
extern xmlNodeSetPtr xmlXPathPopNodeSet(xmlXPathParserContextPtr ctxt);
extern double xmlXPathPopNumber(xmlXPathParserContextPtr ctxt);
extern xmlChar *xmlXPathPopString(xmlXPathParserContextPtr ctxt);
extern void xmlXPathPositionFunction(xmlXPathParserContextPtr ctxt,
				     int nargs);
extern void xmlXPathRegisterAllFunctions(xmlXPathContextPtr ctxt);
extern int xmlXPathRegisterFunc(xmlXPathContextPtr ctxt,
				const xmlChar * name, xmlXPathFunction f);
extern void xmlXPathRegisterFuncLookup(xmlXPathContextPtr ctxt,
				       xmlXPathFuncLookupFunc f,
				       void *funcCtxt);
extern int xmlXPathRegisterFuncNS(xmlXPathContextPtr ctxt,
				  const xmlChar * name,
				  const xmlChar * ns_uri,
				  xmlXPathFunction f);
extern int xmlXPathRegisterNs(xmlXPathContextPtr ctxt,
			      const xmlChar * prefix,
			      const xmlChar * ns_uri);
extern int xmlXPathRegisterVariable(xmlXPathContextPtr ctxt,
				    const xmlChar * name,
				    xmlXPathObjectPtr value);
extern void xmlXPathRegisterVariableLookup(xmlXPathContextPtr ctxt,
					   xmlXPathVariableLookupFunc f,
					   void *data);
extern int xmlXPathRegisterVariableNS(xmlXPathContextPtr ctxt,
				      const xmlChar * name,
				      const xmlChar * ns_uri,
				      xmlXPathObjectPtr value);
extern void xmlXPathRegisteredFuncsCleanup(xmlXPathContextPtr ctxt);
extern void xmlXPathRegisteredNsCleanup(xmlXPathContextPtr ctxt);
extern void xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt);
extern void xmlXPathRoot(xmlXPathParserContextPtr ctxt);
extern void xmlXPathRoundFunction(xmlXPathParserContextPtr ctxt,
				  int nargs);
extern void xmlXPathStartsWithFunction(xmlXPathParserContextPtr ctxt,
				       int nargs);
extern double xmlXPathStringEvalNumber(const xmlChar * str);
extern void xmlXPathStringFunction(xmlXPathParserContextPtr ctxt,
				   int nargs);
extern void xmlXPathStringLengthFunction(xmlXPathParserContextPtr ctxt,
					 int nargs);
extern void xmlXPathSubValues(xmlXPathParserContextPtr ctxt);
extern void xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt,
					   int nargs);
extern void xmlXPathSubstringBeforeFunction(xmlXPathParserContextPtr ctxt,
					    int nargs);
extern void xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt,
				      int nargs);
extern void xmlXPathSumFunction(xmlXPathParserContextPtr ctxt, int nargs);
extern xmlNodeSetPtr xmlXPathTrailing(xmlNodeSetPtr nodes1,
				      xmlNodeSetPtr nodes2);
extern xmlNodeSetPtr xmlXPathTrailingSorted(xmlNodeSetPtr nodes1,
					    xmlNodeSetPtr nodes2);
extern void xmlXPathTranslateFunction(xmlXPathParserContextPtr ctxt,
				      int nargs);
extern void xmlXPathTrueFunction(xmlXPathParserContextPtr ctxt, int nargs);
extern void xmlXPathValueFlipSign(xmlXPathParserContextPtr ctxt);
extern xmlXPathObjectPtr xmlXPathVariableLookup(xmlXPathContextPtr ctxt,
						const xmlChar * name);
extern xmlXPathObjectPtr xmlXPathVariableLookupNS(xmlXPathContextPtr ctxt,
						  const xmlChar * name,
						  const xmlChar * ns_uri);
extern xmlXPathObjectPtr xmlXPathWrapCString(char *val);
extern xmlXPathObjectPtr xmlXPathWrapExternal(void *val);
extern xmlXPathObjectPtr xmlXPathWrapNodeSet(xmlNodeSetPtr val);
extern xmlXPathObjectPtr xmlXPathWrapString(xmlChar * val);
extern void xmlXPatherror(xmlXPathParserContextPtr ctxt, const char *file,
			  int line, int no);

19.2.39. libxml2/libxml/xpointer.h


typedef struct _xmlLocationSet {
    int locNr;
    int locMax;
    xmlXPathObjectPtr *locTab;
} xmlLocationSet;
typedef xmlLocationSet *xmlLocationSetPtr;
extern xmlNodePtr xmlXPtrBuildNodeList(xmlXPathObjectPtr obj);
extern xmlXPathObjectPtr xmlXPtrEval(const xmlChar * str,
				     xmlXPathContextPtr ctx);
extern void xmlXPtrEvalRangePredicate(xmlXPathParserContextPtr ctxt);
extern void xmlXPtrFreeLocationSet(xmlLocationSetPtr obj);
extern void xmlXPtrLocationSetAdd(xmlLocationSetPtr cur,
				  xmlXPathObjectPtr val);
extern xmlLocationSetPtr xmlXPtrLocationSetCreate(xmlXPathObjectPtr val);
extern void xmlXPtrLocationSetDel(xmlLocationSetPtr cur,
				  xmlXPathObjectPtr val);
extern xmlLocationSetPtr xmlXPtrLocationSetMerge(xmlLocationSetPtr val1,
						 xmlLocationSetPtr val2);
extern void xmlXPtrLocationSetRemove(xmlLocationSetPtr cur, int val);
extern xmlXPathObjectPtr xmlXPtrNewCollapsedRange(xmlNodePtr start);
extern xmlXPathContextPtr xmlXPtrNewContext(xmlDocPtr doc, xmlNodePtr here,
					    xmlNodePtr origin);
extern xmlXPathObjectPtr xmlXPtrNewLocationSetNodeSet(xmlNodeSetPtr set);
extern xmlXPathObjectPtr xmlXPtrNewLocationSetNodes(xmlNodePtr start,
						    xmlNodePtr end);
extern xmlXPathObjectPtr xmlXPtrNewRange(xmlNodePtr start, int startindex,
					 xmlNodePtr end, int endindex);
extern xmlXPathObjectPtr xmlXPtrNewRangeNodeObject(xmlNodePtr start,
						   xmlXPathObjectPtr end);
extern xmlXPathObjectPtr xmlXPtrNewRangeNodePoint(xmlNodePtr start,
						  xmlXPathObjectPtr end);
extern xmlXPathObjectPtr xmlXPtrNewRangeNodes(xmlNodePtr start,
					      xmlNodePtr end);
extern xmlXPathObjectPtr xmlXPtrNewRangePointNode(xmlXPathObjectPtr start,
						  xmlNodePtr end);
extern xmlXPathObjectPtr xmlXPtrNewRangePoints(xmlXPathObjectPtr start,
					       xmlXPathObjectPtr end);
extern void xmlXPtrRangeToFunction(xmlXPathParserContextPtr ctxt,
				   int nargs);
extern xmlXPathObjectPtr xmlXPtrWrapLocationSet(xmlLocationSetPtr val);