/home/crealab/.cagefs/tmp/php0ZR3xN
/**
* Summary: interfaces to the Catalog handling system
* Description: the catalog module implements the support for
* XML Catalogs and SGML catalogs
*
* SGML Open Technical Resolution TR9401:1997.
* http://www.jclark.com/sp/catalog.htm
*
* XML Catalogs Working Draft 06 August 2001
* http://www.oasis-open.org/committees/entity/spec-2001-08-06.html
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_CATALOG_H__
#define __XML_CATALOG_H__
#include <stdio.h>
#include <libxml/xmlversion.h>
#include <libxml/xmlstring.h>
#include <libxml/tree.h>
#ifdef LIBXML_CATALOG_ENABLED
#ifdef __cplusplus
extern "C" {
#endif
/**
* XML_CATALOGS_NAMESPACE:
*
* The namespace for the XML Catalogs elements.
*/
#define XML_CATALOGS_NAMESPACE \
(const xmlChar *) "urn:oasis:names:tc:entity:xmlns:xml:catalog"
/**
* XML_CATALOG_PI:
*
* The specific XML Catalog Processing Instruction name.
*/
#define XML_CATALOG_PI \
(const xmlChar *) "oasis-xml-catalog"
/*
* The API is voluntarily limited to general cataloging.
*/
typedef enum {
XML_CATA_PREFER_NONE = 0,
XML_CATA_PREFER_PUBLIC = 1,
XML_CATA_PREFER_SYSTEM
} xmlCatalogPrefer;
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;
/*
* Operations on a given catalog.
*/
XMLPUBFUN xmlCatalogPtr XMLCALL
xmlNewCatalog (int sgml);
XMLPUBFUN xmlCatalogPtr XMLCALL
xmlLoadACatalog (const char *filename);
XMLPUBFUN xmlCatalogPtr XMLCALL
xmlLoadSGMLSuperCatalog (const char *filename);
XMLPUBFUN int XMLCALL
xmlConvertSGMLCatalog (xmlCatalogPtr catal);
XMLPUBFUN int XMLCALL
xmlACatalogAdd (xmlCatalogPtr catal,
const xmlChar *type,
const xmlChar *orig,
const xmlChar *replace);
XMLPUBFUN int XMLCALL
xmlACatalogRemove (xmlCatalogPtr catal,
const xmlChar *value);
XMLPUBFUN xmlChar * XMLCALL
xmlACatalogResolve (xmlCatalogPtr catal,
const xmlChar *pubID,
const xmlChar *sysID);
XMLPUBFUN xmlChar * XMLCALL
xmlACatalogResolveSystem(xmlCatalogPtr catal,
const xmlChar *sysID);
XMLPUBFUN xmlChar * XMLCALL
xmlACatalogResolvePublic(xmlCatalogPtr catal,
const xmlChar *pubID);
XMLPUBFUN xmlChar * XMLCALL
xmlACatalogResolveURI (xmlCatalogPtr catal,
const xmlChar *URI);
#ifdef LIBXML_OUTPUT_ENABLED
XMLPUBFUN void XMLCALL
xmlACatalogDump (xmlCatalogPtr catal,
FILE *out);
#endif /* LIBXML_OUTPUT_ENABLED */
XMLPUBFUN void XMLCALL
xmlFreeCatalog (xmlCatalogPtr catal);
XMLPUBFUN int XMLCALL
xmlCatalogIsEmpty (xmlCatalogPtr catal);
/*
* Global operations.
*/
XMLPUBFUN void XMLCALL
xmlInitializeCatalog (void);
XMLPUBFUN int XMLCALL
xmlLoadCatalog (const char *filename);
XMLPUBFUN void XMLCALL
xmlLoadCatalogs (const char *paths);
XMLPUBFUN void XMLCALL
xmlCatalogCleanup (void);
#ifdef LIBXML_OUTPUT_ENABLED
XMLPUBFUN void XMLCALL
xmlCatalogDump (FILE *out);
#endif /* LIBXML_OUTPUT_ENABLED */
XMLPUBFUN xmlChar * XMLCALL
xmlCatalogResolve (const xmlChar *pubID,
const xmlChar *sysID);
XMLPUBFUN xmlChar * XMLCALL
xmlCatalogResolveSystem (const xmlChar *sysID);
XMLPUBFUN xmlChar * XMLCALL
xmlCatalogResolvePublic (const xmlChar *pubID);
XMLPUBFUN xmlChar * XMLCALL
xmlCatalogResolveURI (const xmlChar *URI);
XMLPUBFUN int XMLCALL
xmlCatalogAdd (const xmlChar *type,
const xmlChar *orig,
const xmlChar *replace);
XMLPUBFUN int XMLCALL
xmlCatalogRemove (const xmlChar *value);
XMLPUBFUN xmlDocPtr XMLCALL
xmlParseCatalogFile (const char *filename);
XMLPUBFUN int XMLCALL
xmlCatalogConvert (void);
/*
* Strictly minimal interfaces for per-document catalogs used
* by the parser.
*/
XMLPUBFUN void XMLCALL
xmlCatalogFreeLocal (void *catalogs);
XMLPUBFUN void * XMLCALL
xmlCatalogAddLocal (void *catalogs,
const xmlChar *URL);
XMLPUBFUN xmlChar * XMLCALL
xmlCatalogLocalResolve (void *catalogs,
const xmlChar *pubID,
const xmlChar *sysID);
XMLPUBFUN xmlChar * XMLCALL
xmlCatalogLocalResolveURI(void *catalogs,
const xmlChar *URI);
/*
* Preference settings.
*/
XMLPUBFUN int XMLCALL
xmlCatalogSetDebug (int level);
XMLPUBFUN xmlCatalogPrefer XMLCALL
xmlCatalogSetDefaultPrefer(xmlCatalogPrefer prefer);
XMLPUBFUN void XMLCALL
xmlCatalogSetDefaults (xmlCatalogAllow allow);
XMLPUBFUN xmlCatalogAllow XMLCALL
xmlCatalogGetDefaults (void);
/* DEPRECATED interfaces */
XMLPUBFUN const xmlChar * XMLCALL
xmlCatalogGetSystem (const xmlChar *sysID);
XMLPUBFUN const xmlChar * XMLCALL
xmlCatalogGetPublic (const xmlChar *pubID);
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_CATALOG_ENABLED */
#endif /* __XML_CATALOG_H__ */
/*
* Summary: interface for the I/O interfaces used by the parser
* Description: interface for the I/O interfaces used by the parser
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_IO_H__
#define __XML_IO_H__
#include <stdio.h>
#include <libxml/xmlversion.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* Those are the functions and datatypes for the parser input
* I/O structures.
*/
/**
* xmlInputMatchCallback:
* @filename: the filename or URI
*
* Callback used in the I/O Input API to detect if the current handler
* can provide input functionality for this resource.
*
* Returns 1 if yes and 0 if another Input module should be used
*/
typedef int (XMLCALL *xmlInputMatchCallback) (char const *filename);
/**
* xmlInputOpenCallback:
* @filename: the filename or URI
*
* Callback used in the I/O Input API to open the resource
*
* Returns an Input context or NULL in case or error
*/
typedef void * (XMLCALL *xmlInputOpenCallback) (char const *filename);
/**
* xmlInputReadCallback:
* @context: an Input context
* @buffer: the buffer to store data read
* @len: the length of the buffer in bytes
*
* Callback used in the I/O Input API to read the resource
*
* Returns the number of bytes read or -1 in case of error
*/
typedef int (XMLCALL *xmlInputReadCallback) (void * context, char * buffer, int len);
/**
* xmlInputCloseCallback:
* @context: an Input context
*
* Callback used in the I/O Input API to close the resource
*
* Returns 0 or -1 in case of error
*/
typedef int (XMLCALL *xmlInputCloseCallback) (void * context);
#ifdef LIBXML_OUTPUT_ENABLED
/*
* Those are the functions and datatypes for the library output
* I/O structures.
*/
/**
* xmlOutputMatchCallback:
* @filename: the filename or URI
*
* Callback used in the I/O Output API to detect if the current handler
* can provide output functionality for this resource.
*
* Returns 1 if yes and 0 if another Output module should be used
*/
typedef int (XMLCALL *xmlOutputMatchCallback) (char const *filename);
/**
* xmlOutputOpenCallback:
* @filename: the filename or URI
*
* Callback used in the I/O Output API to open the resource
*
* Returns an Output context or NULL in case or error
*/
typedef void * (XMLCALL *xmlOutputOpenCallback) (char const *filename);
/**
* xmlOutputWriteCallback:
* @context: an Output context
* @buffer: the buffer of data to write
* @len: the length of the buffer in bytes
*
* Callback used in the I/O Output API to write to the resource
*
* Returns the number of bytes written or -1 in case of error
*/
typedef int (XMLCALL *xmlOutputWriteCallback) (void * context, const char * buffer,
int len);
/**
* xmlOutputCloseCallback:
* @context: an Output context
*
* Callback used in the I/O Output API to close the resource
*
* Returns 0 or -1 in case of error
*/
typedef int (XMLCALL *xmlOutputCloseCallback) (void * context);
#endif /* LIBXML_OUTPUT_ENABLED */
#ifdef __cplusplus
}
#endif
#include <libxml/globals.h>
#include <libxml/tree.h>
#include <libxml/parser.h>
#include <libxml/encoding.h>
#ifdef __cplusplus
extern "C" {
#endif
struct _xmlParserInputBuffer {
void* context;
xmlInputReadCallback readcallback;
xmlInputCloseCallback closecallback;
xmlCharEncodingHandlerPtr encoder; /* I18N conversions to UTF-8 */
xmlBufPtr buffer; /* Local buffer encoded in UTF-8 */
xmlBufPtr raw; /* if encoder != NULL buffer for raw input */
int compressed; /* -1=unknown, 0=not compressed, 1=compressed */
int error;
unsigned long rawconsumed;/* amount consumed from raw */
};
#ifdef LIBXML_OUTPUT_ENABLED
struct _xmlOutputBuffer {
void* context;
xmlOutputWriteCallback writecallback;
xmlOutputCloseCallback closecallback;
xmlCharEncodingHandlerPtr encoder; /* I18N conversions to UTF-8 */
xmlBufPtr buffer; /* Local buffer encoded in UTF-8 or ISOLatin */
xmlBufPtr conv; /* if encoder != NULL buffer for output */
int written; /* total number of byte written */
int error;
};
#endif /* LIBXML_OUTPUT_ENABLED */
/*
* Interfaces for input
*/
XMLPUBFUN void XMLCALL
xmlCleanupInputCallbacks (void);
XMLPUBFUN int XMLCALL
xmlPopInputCallbacks (void);
XMLPUBFUN void XMLCALL
xmlRegisterDefaultInputCallbacks (void);
XMLPUBFUN xmlParserInputBufferPtr XMLCALL
xmlAllocParserInputBuffer (xmlCharEncoding enc);
XMLPUBFUN xmlParserInputBufferPtr XMLCALL
xmlParserInputBufferCreateFilename (const char *URI,
xmlCharEncoding enc);
XMLPUBFUN xmlParserInputBufferPtr XMLCALL
xmlParserInputBufferCreateFile (FILE *file,
xmlCharEncoding enc);
XMLPUBFUN xmlParserInputBufferPtr XMLCALL
xmlParserInputBufferCreateFd (int fd,
xmlCharEncoding enc);
XMLPUBFUN xmlParserInputBufferPtr XMLCALL
xmlParserInputBufferCreateMem (const char *mem, int size,
xmlCharEncoding enc);
XMLPUBFUN xmlParserInputBufferPtr XMLCALL
xmlParserInputBufferCreateStatic (const char *mem, int size,
xmlCharEncoding enc);
XMLPUBFUN xmlParserInputBufferPtr XMLCALL
xmlParserInputBufferCreateIO (xmlInputReadCallback ioread,
xmlInputCloseCallback ioclose,
void *ioctx,
xmlCharEncoding enc);
XMLPUBFUN int XMLCALL
xmlParserInputBufferRead (xmlParserInputBufferPtr in,
int len);
XMLPUBFUN int XMLCALL
xmlParserInputBufferGrow (xmlParserInputBufferPtr in,
int len);
XMLPUBFUN int XMLCALL
xmlParserInputBufferPush (xmlParserInputBufferPtr in,
int len,
const char *buf);
XMLPUBFUN void XMLCALL
xmlFreeParserInputBuffer (xmlParserInputBufferPtr in);
XMLPUBFUN char * XMLCALL
xmlParserGetDirectory (const char *filename);
XMLPUBFUN int XMLCALL
xmlRegisterInputCallbacks (xmlInputMatchCallback matchFunc,
xmlInputOpenCallback openFunc,
xmlInputReadCallback readFunc,
xmlInputCloseCallback closeFunc);
xmlParserInputBufferPtr
__xmlParserInputBufferCreateFilename(const char *URI,
xmlCharEncoding enc);
#ifdef LIBXML_OUTPUT_ENABLED
/*
* Interfaces for output
*/
XMLPUBFUN void XMLCALL
xmlCleanupOutputCallbacks (void);
XMLPUBFUN int XMLCALL
xmlPopOutputCallbacks (void);
XMLPUBFUN void XMLCALL
xmlRegisterDefaultOutputCallbacks(void);
XMLPUBFUN xmlOutputBufferPtr XMLCALL
xmlAllocOutputBuffer (xmlCharEncodingHandlerPtr encoder);
XMLPUBFUN xmlOutputBufferPtr XMLCALL
xmlOutputBufferCreateFilename (const char *URI,
xmlCharEncodingHandlerPtr encoder,
int compression);
XMLPUBFUN xmlOutputBufferPtr XMLCALL
xmlOutputBufferCreateFile (FILE *file,
xmlCharEncodingHandlerPtr encoder);
XMLPUBFUN xmlOutputBufferPtr XMLCALL
xmlOutputBufferCreateBuffer (xmlBufferPtr buffer,
xmlCharEncodingHandlerPtr encoder);
XMLPUBFUN xmlOutputBufferPtr XMLCALL
xmlOutputBufferCreateFd (int fd,
xmlCharEncodingHandlerPtr encoder);
XMLPUBFUN xmlOutputBufferPtr XMLCALL
xmlOutputBufferCreateIO (xmlOutputWriteCallback iowrite,
xmlOutputCloseCallback ioclose,
void *ioctx,
xmlCharEncodingHandlerPtr encoder);
/* Couple of APIs to get the output without digging into the buffers */
XMLPUBFUN const xmlChar * XMLCALL
xmlOutputBufferGetContent (xmlOutputBufferPtr out);
XMLPUBFUN size_t XMLCALL
xmlOutputBufferGetSize (xmlOutputBufferPtr out);
XMLPUBFUN int XMLCALL
xmlOutputBufferWrite (xmlOutputBufferPtr out,
int len,
const char *buf);
XMLPUBFUN int XMLCALL
xmlOutputBufferWriteString (xmlOutputBufferPtr out,
const char *str);
XMLPUBFUN int XMLCALL
xmlOutputBufferWriteEscape (xmlOutputBufferPtr out,
const xmlChar *str,
xmlCharEncodingOutputFunc escaping);
XMLPUBFUN int XMLCALL
xmlOutputBufferFlush (xmlOutputBufferPtr out);
XMLPUBFUN int XMLCALL
xmlOutputBufferClose (xmlOutputBufferPtr out);
XMLPUBFUN int XMLCALL
xmlRegisterOutputCallbacks (xmlOutputMatchCallback matchFunc,
xmlOutputOpenCallback openFunc,
xmlOutputWriteCallback writeFunc,
xmlOutputCloseCallback closeFunc);
xmlOutputBufferPtr
__xmlOutputBufferCreateFilename(const char *URI,
xmlCharEncodingHandlerPtr encoder,
int compression);
#ifdef LIBXML_HTTP_ENABLED
/* This function only exists if HTTP support built into the library */
XMLPUBFUN void XMLCALL
xmlRegisterHTTPPostCallbacks (void );
#endif /* LIBXML_HTTP_ENABLED */
#endif /* LIBXML_OUTPUT_ENABLED */
XMLPUBFUN xmlParserInputPtr XMLCALL
xmlCheckHTTPInput (xmlParserCtxtPtr ctxt,
xmlParserInputPtr ret);
/*
* A predefined entity loader disabling network accesses
*/
XMLPUBFUN xmlParserInputPtr XMLCALL
xmlNoNetExternalEntityLoader (const char *URL,
const char *ID,
xmlParserCtxtPtr ctxt);
/*
* xmlNormalizeWindowsPath is obsolete, don't use it.
* Check xmlCanonicPath in uri.h for a better alternative.
*/
XMLPUBFUN xmlChar * XMLCALL
xmlNormalizeWindowsPath (const xmlChar *path);
XMLPUBFUN int XMLCALL
xmlCheckFilename (const char *path);
/**
* Default 'file://' protocol callbacks
*/
XMLPUBFUN int XMLCALL
xmlFileMatch (const char *filename);
XMLPUBFUN void * XMLCALL
xmlFileOpen (const char *filename);
XMLPUBFUN int XMLCALL
xmlFileRead (void * context,
char * buffer,
int len);
XMLPUBFUN int XMLCALL
xmlFileClose (void * context);
/**
* Default 'http://' protocol callbacks
*/
#ifdef LIBXML_HTTP_ENABLED
XMLPUBFUN int XMLCALL
xmlIOHTTPMatch (const char *filename);
XMLPUBFUN void * XMLCALL
xmlIOHTTPOpen (const char *filename);
#ifdef LIBXML_OUTPUT_ENABLED
XMLPUBFUN void * XMLCALL
xmlIOHTTPOpenW (const char * post_uri,
int compression );
#endif /* LIBXML_OUTPUT_ENABLED */
XMLPUBFUN int XMLCALL
xmlIOHTTPRead (void * context,
char * buffer,
int len);
XMLPUBFUN int XMLCALL
xmlIOHTTPClose (void * context);
#endif /* LIBXML_HTTP_ENABLED */
/**
* Default 'ftp://' protocol callbacks
*/
#ifdef LIBXML_FTP_ENABLED
XMLPUBFUN int XMLCALL
xmlIOFTPMatch (const char *filename);
XMLPUBFUN void * XMLCALL
xmlIOFTPOpen (const char *filename);
XMLPUBFUN int XMLCALL
xmlIOFTPRead (void * context,
char * buffer,
int len);
XMLPUBFUN int XMLCALL
xmlIOFTPClose (void * context);
#endif /* LIBXML_FTP_ENABLED */
#ifdef __cplusplus
}
#endif
#endif /* __XML_IO_H__ */
/*
* Summary: pattern expression handling
* Description: allows to compile and test pattern expressions for nodes
* either in a tree or based on a parser state.
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_PATTERN_H__
#define __XML_PATTERN_H__
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#include <libxml/dict.h>
#ifdef LIBXML_PATTERN_ENABLED
#ifdef __cplusplus
extern "C" {
#endif
/**
* xmlPattern:
*
* A compiled (XPath based) pattern to select nodes
*/
typedef struct _xmlPattern xmlPattern;
typedef xmlPattern *xmlPatternPtr;
/**
* xmlPatternFlags:
*
* This is the set of options affecting the behaviour of pattern
* matching with this module
*
*/
typedef enum {
XML_PATTERN_DEFAULT = 0, /* simple pattern match */
XML_PATTERN_XPATH = 1<<0, /* standard XPath pattern */
XML_PATTERN_XSSEL = 1<<1, /* XPath subset for schema selector */
XML_PATTERN_XSFIELD = 1<<2 /* XPath subset for schema field */
} xmlPatternFlags;
XMLPUBFUN void XMLCALL
xmlFreePattern (xmlPatternPtr comp);
XMLPUBFUN void XMLCALL
xmlFreePatternList (xmlPatternPtr comp);
XMLPUBFUN xmlPatternPtr XMLCALL
xmlPatterncompile (const xmlChar *pattern,
xmlDict *dict,
int flags,
const xmlChar **namespaces);
XMLPUBFUN int XMLCALL
xmlPatternMatch (xmlPatternPtr comp,
xmlNodePtr node);
/* streaming interfaces */
typedef struct _xmlStreamCtxt xmlStreamCtxt;
typedef xmlStreamCtxt *xmlStreamCtxtPtr;
XMLPUBFUN int XMLCALL
xmlPatternStreamable (xmlPatternPtr comp);
XMLPUBFUN int XMLCALL
xmlPatternMaxDepth (xmlPatternPtr comp);
XMLPUBFUN int XMLCALL
xmlPatternMinDepth (xmlPatternPtr comp);
XMLPUBFUN int XMLCALL
xmlPatternFromRoot (xmlPatternPtr comp);
XMLPUBFUN xmlStreamCtxtPtr XMLCALL
xmlPatternGetStreamCtxt (xmlPatternPtr comp);
XMLPUBFUN void XMLCALL
xmlFreeStreamCtxt (xmlStreamCtxtPtr stream);
XMLPUBFUN int XMLCALL
xmlStreamPushNode (xmlStreamCtxtPtr stream,
const xmlChar *name,
const xmlChar *ns,
int nodeType);
XMLPUBFUN int XMLCALL
xmlStreamPush (xmlStreamCtxtPtr stream,
const xmlChar *name,
const xmlChar *ns);
XMLPUBFUN int XMLCALL
xmlStreamPushAttr (xmlStreamCtxtPtr stream,
const xmlChar *name,
const xmlChar *ns);
XMLPUBFUN int XMLCALL
xmlStreamPop (xmlStreamCtxtPtr stream);
XMLPUBFUN int XMLCALL
xmlStreamWantsAnyNode (xmlStreamCtxtPtr stream);
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_PATTERN_ENABLED */
#endif /* __XML_PATTERN_H__ */
/*
* Summary: incomplete XML Schemas structure implementation
* Description: interface to the XML Schemas handling and schema validity
* checking, it is incomplete right now.
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_SCHEMA_H__
#define __XML_SCHEMA_H__
#include <libxml/xmlversion.h>
#ifdef LIBXML_SCHEMAS_ENABLED
#include <libxml/tree.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* This error codes are obsolete; not used any more.
*/
typedef enum {
XML_SCHEMAS_ERR_OK = 0,
XML_SCHEMAS_ERR_NOROOT = 1,
XML_SCHEMAS_ERR_UNDECLAREDELEM,
XML_SCHEMAS_ERR_NOTTOPLEVEL,
XML_SCHEMAS_ERR_MISSING,
XML_SCHEMAS_ERR_WRONGELEM,
XML_SCHEMAS_ERR_NOTYPE,
XML_SCHEMAS_ERR_NOROLLBACK,
XML_SCHEMAS_ERR_ISABSTRACT,
XML_SCHEMAS_ERR_NOTEMPTY,
XML_SCHEMAS_ERR_ELEMCONT,
XML_SCHEMAS_ERR_HAVEDEFAULT,
XML_SCHEMAS_ERR_NOTNILLABLE,
XML_SCHEMAS_ERR_EXTRACONTENT,
XML_SCHEMAS_ERR_INVALIDATTR,
XML_SCHEMAS_ERR_INVALIDELEM,
XML_SCHEMAS_ERR_NOTDETERMINIST,
XML_SCHEMAS_ERR_CONSTRUCT,
XML_SCHEMAS_ERR_INTERNAL,
XML_SCHEMAS_ERR_NOTSIMPLE,
XML_SCHEMAS_ERR_ATTRUNKNOWN,
XML_SCHEMAS_ERR_ATTRINVALID,
XML_SCHEMAS_ERR_VALUE,
XML_SCHEMAS_ERR_FACET,
XML_SCHEMAS_ERR_,
XML_SCHEMAS_ERR_XXX
} xmlSchemaValidError;
/*
* ATTENTION: Change xmlSchemaSetValidOptions's check
* for invalid values, if adding to the validation
* options below.
*/
/**
* xmlSchemaValidOption:
*
* This is the set of XML Schema validation options.
*/
typedef enum {
XML_SCHEMA_VAL_VC_I_CREATE = 1<<0
/* Default/fixed: create an attribute node
* or an element's text node on the instance.
*/
} xmlSchemaValidOption;
/*
XML_SCHEMA_VAL_XSI_ASSEMBLE = 1<<1,
* assemble schemata using
* xsi:schemaLocation and
* xsi:noNamespaceSchemaLocation
*/
/**
* The schemas related types are kept internal
*/
typedef struct _xmlSchema xmlSchema;
typedef xmlSchema *xmlSchemaPtr;
/**
* xmlSchemaValidityErrorFunc:
* @ctx: the validation context
* @msg: the message
* @...: extra arguments
*
* Signature of an error callback from an XSD validation
*/
typedef void (XMLCDECL *xmlSchemaValidityErrorFunc)
(void *ctx, const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
/**
* xmlSchemaValidityWarningFunc:
* @ctx: the validation context
* @msg: the message
* @...: extra arguments
*
* Signature of a warning callback from an XSD validation
*/
typedef void (XMLCDECL *xmlSchemaValidityWarningFunc)
(void *ctx, const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
/**
* A schemas validation context
*/
typedef struct _xmlSchemaParserCtxt xmlSchemaParserCtxt;
typedef xmlSchemaParserCtxt *xmlSchemaParserCtxtPtr;
typedef struct _xmlSchemaValidCtxt xmlSchemaValidCtxt;
typedef xmlSchemaValidCtxt *xmlSchemaValidCtxtPtr;
/**
* xmlSchemaValidityLocatorFunc:
* @ctx: user provided context
* @file: returned file information
* @line: returned line information
*
* A schemas validation locator, a callback called by the validator.
* This is used when file or node information are not available
* to find out what file and line number are affected
*
* Returns: 0 in case of success and -1 in case of error
*/
typedef int (XMLCDECL *xmlSchemaValidityLocatorFunc) (void *ctx,
const char **file, unsigned long *line);
/*
* Interfaces for parsing.
*/
XMLPUBFUN xmlSchemaParserCtxtPtr XMLCALL
xmlSchemaNewParserCtxt (const char *URL);
XMLPUBFUN xmlSchemaParserCtxtPtr XMLCALL
xmlSchemaNewMemParserCtxt (const char *buffer,
int size);
XMLPUBFUN xmlSchemaParserCtxtPtr XMLCALL
xmlSchemaNewDocParserCtxt (xmlDocPtr doc);
XMLPUBFUN void XMLCALL
xmlSchemaFreeParserCtxt (xmlSchemaParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlSchemaSetParserErrors (xmlSchemaParserCtxtPtr ctxt,
xmlSchemaValidityErrorFunc err,
xmlSchemaValidityWarningFunc warn,
void *ctx);
XMLPUBFUN void XMLCALL
xmlSchemaSetParserStructuredErrors(xmlSchemaParserCtxtPtr ctxt,
xmlStructuredErrorFunc serror,
void *ctx);
XMLPUBFUN int XMLCALL
xmlSchemaGetParserErrors(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaValidityErrorFunc * err,
xmlSchemaValidityWarningFunc * warn,
void **ctx);
XMLPUBFUN int XMLCALL
xmlSchemaIsValid (xmlSchemaValidCtxtPtr ctxt);
XMLPUBFUN xmlSchemaPtr XMLCALL
xmlSchemaParse (xmlSchemaParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlSchemaFree (xmlSchemaPtr schema);
#ifdef LIBXML_OUTPUT_ENABLED
XMLPUBFUN void XMLCALL
xmlSchemaDump (FILE *output,
xmlSchemaPtr schema);
#endif /* LIBXML_OUTPUT_ENABLED */
/*
* Interfaces for validating
*/
XMLPUBFUN void XMLCALL
xmlSchemaSetValidErrors (xmlSchemaValidCtxtPtr ctxt,
xmlSchemaValidityErrorFunc err,
xmlSchemaValidityWarningFunc warn,
void *ctx);
XMLPUBFUN void XMLCALL
xmlSchemaSetValidStructuredErrors(xmlSchemaValidCtxtPtr ctxt,
xmlStructuredErrorFunc serror,
void *ctx);
XMLPUBFUN int XMLCALL
xmlSchemaGetValidErrors (xmlSchemaValidCtxtPtr ctxt,
xmlSchemaValidityErrorFunc *err,
xmlSchemaValidityWarningFunc *warn,
void **ctx);
XMLPUBFUN int XMLCALL
xmlSchemaSetValidOptions (xmlSchemaValidCtxtPtr ctxt,
int options);
XMLPUBFUN void XMLCALL
xmlSchemaValidateSetFilename(xmlSchemaValidCtxtPtr vctxt,
const char *filename);
XMLPUBFUN int XMLCALL
xmlSchemaValidCtxtGetOptions(xmlSchemaValidCtxtPtr ctxt);
XMLPUBFUN xmlSchemaValidCtxtPtr XMLCALL
xmlSchemaNewValidCtxt (xmlSchemaPtr schema);
XMLPUBFUN void XMLCALL
xmlSchemaFreeValidCtxt (xmlSchemaValidCtxtPtr ctxt);
XMLPUBFUN int XMLCALL
xmlSchemaValidateDoc (xmlSchemaValidCtxtPtr ctxt,
xmlDocPtr instance);
XMLPUBFUN int XMLCALL
xmlSchemaValidateOneElement (xmlSchemaValidCtxtPtr ctxt,
xmlNodePtr elem);
XMLPUBFUN int XMLCALL
xmlSchemaValidateStream (xmlSchemaValidCtxtPtr ctxt,
xmlParserInputBufferPtr input,
xmlCharEncoding enc,
xmlSAXHandlerPtr sax,
void *user_data);
XMLPUBFUN int XMLCALL
xmlSchemaValidateFile (xmlSchemaValidCtxtPtr ctxt,
const char * filename,
int options);
XMLPUBFUN xmlParserCtxtPtr XMLCALL
xmlSchemaValidCtxtGetParserCtxt(xmlSchemaValidCtxtPtr ctxt);
/*
* Interface to insert Schemas SAX validation in a SAX stream
*/
typedef struct _xmlSchemaSAXPlug xmlSchemaSAXPlugStruct;
typedef xmlSchemaSAXPlugStruct *xmlSchemaSAXPlugPtr;
XMLPUBFUN xmlSchemaSAXPlugPtr XMLCALL
xmlSchemaSAXPlug (xmlSchemaValidCtxtPtr ctxt,
xmlSAXHandlerPtr *sax,
void **user_data);
XMLPUBFUN int XMLCALL
xmlSchemaSAXUnplug (xmlSchemaSAXPlugPtr plug);
XMLPUBFUN void XMLCALL
xmlSchemaValidateSetLocator (xmlSchemaValidCtxtPtr vctxt,
xmlSchemaValidityLocatorFunc f,
void *ctxt);
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_SCHEMAS_ENABLED */
#endif /* __XML_SCHEMA_H__ */
/*
* Summary: API to build regexp automata
* Description: the API to build regexp automata
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_AUTOMATA_H__
#define __XML_AUTOMATA_H__
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#ifdef LIBXML_REGEXP_ENABLED
#ifdef LIBXML_AUTOMATA_ENABLED
#include <libxml/xmlregexp.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* xmlAutomataPtr:
*
* A libxml automata description, It can be compiled into a regexp
*/
typedef struct _xmlAutomata xmlAutomata;
typedef xmlAutomata *xmlAutomataPtr;
/**
* xmlAutomataStatePtr:
*
* A state int the automata description,
*/
typedef struct _xmlAutomataState xmlAutomataState;
typedef xmlAutomataState *xmlAutomataStatePtr;
/*
* Building API
*/
XMLPUBFUN xmlAutomataPtr XMLCALL
xmlNewAutomata (void);
XMLPUBFUN void XMLCALL
xmlFreeAutomata (xmlAutomataPtr am);
XMLPUBFUN xmlAutomataStatePtr XMLCALL
xmlAutomataGetInitState (xmlAutomataPtr am);
XMLPUBFUN int XMLCALL
xmlAutomataSetFinalState (xmlAutomataPtr am,
xmlAutomataStatePtr state);
XMLPUBFUN xmlAutomataStatePtr XMLCALL
xmlAutomataNewState (xmlAutomataPtr am);
XMLPUBFUN xmlAutomataStatePtr XMLCALL
xmlAutomataNewTransition (xmlAutomataPtr am,
xmlAutomataStatePtr from,
xmlAutomataStatePtr to,
const xmlChar *token,
void *data);
XMLPUBFUN xmlAutomataStatePtr XMLCALL
xmlAutomataNewTransition2 (xmlAutomataPtr am,
xmlAutomataStatePtr from,
xmlAutomataStatePtr to,
const xmlChar *token,
const xmlChar *token2,
void *data);
XMLPUBFUN xmlAutomataStatePtr XMLCALL
xmlAutomataNewNegTrans (xmlAutomataPtr am,
xmlAutomataStatePtr from,
xmlAutomataStatePtr to,
const xmlChar *token,
const xmlChar *token2,
void *data);
XMLPUBFUN xmlAutomataStatePtr XMLCALL
xmlAutomataNewCountTrans (xmlAutomataPtr am,
xmlAutomataStatePtr from,
xmlAutomataStatePtr to,
const xmlChar *token,
int min,
int max,
void *data);
XMLPUBFUN xmlAutomataStatePtr XMLCALL
xmlAutomataNewCountTrans2 (xmlAutomataPtr am,
xmlAutomataStatePtr from,
xmlAutomataStatePtr to,
const xmlChar *token,
const xmlChar *token2,
int min,
int max,
void *data);
XMLPUBFUN xmlAutomataStatePtr XMLCALL
xmlAutomataNewOnceTrans (xmlAutomataPtr am,
xmlAutomataStatePtr from,
xmlAutomataStatePtr to,
const xmlChar *token,
int min,
int max,
void *data);
XMLPUBFUN xmlAutomataStatePtr XMLCALL
xmlAutomataNewOnceTrans2 (xmlAutomataPtr am,
xmlAutomataStatePtr from,
xmlAutomataStatePtr to,
const xmlChar *token,
const xmlChar *token2,
int min,
int max,
void *data);
XMLPUBFUN xmlAutomataStatePtr XMLCALL
xmlAutomataNewAllTrans (xmlAutomataPtr am,
xmlAutomataStatePtr from,
xmlAutomataStatePtr to,
int lax);
XMLPUBFUN xmlAutomataStatePtr XMLCALL
xmlAutomataNewEpsilon (xmlAutomataPtr am,
xmlAutomataStatePtr from,
xmlAutomataStatePtr to);
XMLPUBFUN xmlAutomataStatePtr XMLCALL
xmlAutomataNewCountedTrans (xmlAutomataPtr am,
xmlAutomataStatePtr from,
xmlAutomataStatePtr to,
int counter);
XMLPUBFUN xmlAutomataStatePtr XMLCALL
xmlAutomataNewCounterTrans (xmlAutomataPtr am,
xmlAutomataStatePtr from,
xmlAutomataStatePtr to,
int counter);
XMLPUBFUN int XMLCALL
xmlAutomataNewCounter (xmlAutomataPtr am,
int min,
int max);
XMLPUBFUN xmlRegexpPtr XMLCALL
xmlAutomataCompile (xmlAutomataPtr am);
XMLPUBFUN int XMLCALL
xmlAutomataIsDeterminist (xmlAutomataPtr am);
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_AUTOMATA_ENABLED */
#endif /* LIBXML_REGEXP_ENABLED */
#endif /* __XML_AUTOMATA_H__ */
/*
* Summary: specific APIs to process HTML tree, especially serialization
* Description: this module implements a few function needed to process
* tree in an HTML specific way.
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __HTML_TREE_H__
#define __HTML_TREE_H__
#include <stdio.h>
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#include <libxml/HTMLparser.h>
#ifdef LIBXML_HTML_ENABLED
#ifdef __cplusplus
extern "C" {
#endif
/**
* HTML_TEXT_NODE:
*
* Macro. A text node in a HTML document is really implemented
* the same way as a text node in an XML document.
*/
#define HTML_TEXT_NODE XML_TEXT_NODE
/**
* HTML_ENTITY_REF_NODE:
*
* Macro. An entity reference in a HTML document is really implemented
* the same way as an entity reference in an XML document.
*/
#define HTML_ENTITY_REF_NODE XML_ENTITY_REF_NODE
/**
* HTML_COMMENT_NODE:
*
* Macro. A comment in a HTML document is really implemented
* the same way as a comment in an XML document.
*/
#define HTML_COMMENT_NODE XML_COMMENT_NODE
/**
* HTML_PRESERVE_NODE:
*
* Macro. A preserved node in a HTML document is really implemented
* the same way as a CDATA section in an XML document.
*/
#define HTML_PRESERVE_NODE XML_CDATA_SECTION_NODE
/**
* HTML_PI_NODE:
*
* Macro. A processing instruction in a HTML document is really implemented
* the same way as a processing instruction in an XML document.
*/
#define HTML_PI_NODE XML_PI_NODE
XMLPUBFUN htmlDocPtr XMLCALL
htmlNewDoc (const xmlChar *URI,
const xmlChar *ExternalID);
XMLPUBFUN htmlDocPtr XMLCALL
htmlNewDocNoDtD (const xmlChar *URI,
const xmlChar *ExternalID);
XMLPUBFUN const xmlChar * XMLCALL
htmlGetMetaEncoding (htmlDocPtr doc);
XMLPUBFUN int XMLCALL
htmlSetMetaEncoding (htmlDocPtr doc,
const xmlChar *encoding);
#ifdef LIBXML_OUTPUT_ENABLED
XMLPUBFUN void XMLCALL
htmlDocDumpMemory (xmlDocPtr cur,
xmlChar **mem,
int *size);
XMLPUBFUN void XMLCALL
htmlDocDumpMemoryFormat (xmlDocPtr cur,
xmlChar **mem,
int *size,
int format);
XMLPUBFUN int XMLCALL
htmlDocDump (FILE *f,
xmlDocPtr cur);
XMLPUBFUN int XMLCALL
htmlSaveFile (const char *filename,
xmlDocPtr cur);
XMLPUBFUN int XMLCALL
htmlNodeDump (xmlBufferPtr buf,
xmlDocPtr doc,
xmlNodePtr cur);
XMLPUBFUN void XMLCALL
htmlNodeDumpFile (FILE *out,
xmlDocPtr doc,
xmlNodePtr cur);
XMLPUBFUN int XMLCALL
htmlNodeDumpFileFormat (FILE *out,
xmlDocPtr doc,
xmlNodePtr cur,
const char *encoding,
int format);
XMLPUBFUN int XMLCALL
htmlSaveFileEnc (const char *filename,
xmlDocPtr cur,
const char *encoding);
XMLPUBFUN int XMLCALL
htmlSaveFileFormat (const char *filename,
xmlDocPtr cur,
const char *encoding,
int format);
XMLPUBFUN void XMLCALL
htmlNodeDumpFormatOutput(xmlOutputBufferPtr buf,
xmlDocPtr doc,
xmlNodePtr cur,
const char *encoding,
int format);
XMLPUBFUN void XMLCALL
htmlDocContentDumpOutput(xmlOutputBufferPtr buf,
xmlDocPtr cur,
const char *encoding);
XMLPUBFUN void XMLCALL
htmlDocContentDumpFormatOutput(xmlOutputBufferPtr buf,
xmlDocPtr cur,
const char *encoding,
int format);
XMLPUBFUN void XMLCALL
htmlNodeDumpOutput (xmlOutputBufferPtr buf,
xmlDocPtr doc,
xmlNodePtr cur,
const char *encoding);
#endif /* LIBXML_OUTPUT_ENABLED */
XMLPUBFUN int XMLCALL
htmlIsBooleanAttr (const xmlChar *name);
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_HTML_ENABLED */
#endif /* __HTML_TREE_H__ */
/*
* Summary: SAX2 parser interface used to build the DOM tree
* Description: those are the default SAX2 interfaces used by
* the library when building DOM tree.
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_SAX2_H__
#define __XML_SAX2_H__
#include <stdio.h>
#include <stdlib.h>
#include <libxml/xmlversion.h>
#include <libxml/parser.h>
#ifdef __cplusplus
extern "C" {
#endif
XMLPUBFUN const xmlChar * XMLCALL
xmlSAX2GetPublicId (void *ctx);
XMLPUBFUN const xmlChar * XMLCALL
xmlSAX2GetSystemId (void *ctx);
XMLPUBFUN void XMLCALL
xmlSAX2SetDocumentLocator (void *ctx,
xmlSAXLocatorPtr loc);
XMLPUBFUN int XMLCALL
xmlSAX2GetLineNumber (void *ctx);
XMLPUBFUN int XMLCALL
xmlSAX2GetColumnNumber (void *ctx);
XMLPUBFUN int XMLCALL
xmlSAX2IsStandalone (void *ctx);
XMLPUBFUN int XMLCALL
xmlSAX2HasInternalSubset (void *ctx);
XMLPUBFUN int XMLCALL
xmlSAX2HasExternalSubset (void *ctx);
XMLPUBFUN void XMLCALL
xmlSAX2InternalSubset (void *ctx,
const xmlChar *name,
const xmlChar *ExternalID,
const xmlChar *SystemID);
XMLPUBFUN void XMLCALL
xmlSAX2ExternalSubset (void *ctx,
const xmlChar *name,
const xmlChar *ExternalID,
const xmlChar *SystemID);
XMLPUBFUN xmlEntityPtr XMLCALL
xmlSAX2GetEntity (void *ctx,
const xmlChar *name);
XMLPUBFUN xmlEntityPtr XMLCALL
xmlSAX2GetParameterEntity (void *ctx,
const xmlChar *name);
XMLPUBFUN xmlParserInputPtr XMLCALL
xmlSAX2ResolveEntity (void *ctx,
const xmlChar *publicId,
const xmlChar *systemId);
XMLPUBFUN void XMLCALL
xmlSAX2EntityDecl (void *ctx,
const xmlChar *name,
int type,
const xmlChar *publicId,
const xmlChar *systemId,
xmlChar *content);
XMLPUBFUN void XMLCALL
xmlSAX2AttributeDecl (void *ctx,
const xmlChar *elem,
const xmlChar *fullname,
int type,
int def,
const xmlChar *defaultValue,
xmlEnumerationPtr tree);
XMLPUBFUN void XMLCALL
xmlSAX2ElementDecl (void *ctx,
const xmlChar *name,
int type,
xmlElementContentPtr content);
XMLPUBFUN void XMLCALL
xmlSAX2NotationDecl (void *ctx,
const xmlChar *name,
const xmlChar *publicId,
const xmlChar *systemId);
XMLPUBFUN void XMLCALL
xmlSAX2UnparsedEntityDecl (void *ctx,
const xmlChar *name,
const xmlChar *publicId,
const xmlChar *systemId,
const xmlChar *notationName);
XMLPUBFUN void XMLCALL
xmlSAX2StartDocument (void *ctx);
XMLPUBFUN void XMLCALL
xmlSAX2EndDocument (void *ctx);
#if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || \
defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_LEGACY_ENABLED)
XMLPUBFUN void XMLCALL
xmlSAX2StartElement (void *ctx,
const xmlChar *fullname,
const xmlChar **atts);
XMLPUBFUN void XMLCALL
xmlSAX2EndElement (void *ctx,
const xmlChar *name);
#endif /* LIBXML_SAX1_ENABLED or LIBXML_HTML_ENABLED or LIBXML_LEGACY_ENABLED */
XMLPUBFUN void XMLCALL
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);
XMLPUBFUN void XMLCALL
xmlSAX2EndElementNs (void *ctx,
const xmlChar *localname,
const xmlChar *prefix,
const xmlChar *URI);
XMLPUBFUN void XMLCALL
xmlSAX2Reference (void *ctx,
const xmlChar *name);
XMLPUBFUN void XMLCALL
xmlSAX2Characters (void *ctx,
const xmlChar *ch,
int len);
XMLPUBFUN void XMLCALL
xmlSAX2IgnorableWhitespace (void *ctx,
const xmlChar *ch,
int len);
XMLPUBFUN void XMLCALL
xmlSAX2ProcessingInstruction (void *ctx,
const xmlChar *target,
const xmlChar *data);
XMLPUBFUN void XMLCALL
xmlSAX2Comment (void *ctx,
const xmlChar *value);
XMLPUBFUN void XMLCALL
xmlSAX2CDataBlock (void *ctx,
const xmlChar *value,
int len);
#ifdef LIBXML_SAX1_ENABLED
XMLPUBFUN int XMLCALL
xmlSAXDefaultVersion (int version);
#endif /* LIBXML_SAX1_ENABLED */
XMLPUBFUN int XMLCALL
xmlSAXVersion (xmlSAXHandler *hdlr,
int version);
XMLPUBFUN void XMLCALL
xmlSAX2InitDefaultSAXHandler (xmlSAXHandler *hdlr,
int warning);
#ifdef LIBXML_HTML_ENABLED
XMLPUBFUN void XMLCALL
xmlSAX2InitHtmlDefaultSAXHandler(xmlSAXHandler *hdlr);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
htmlDefaultSAXHandlerInit (void);
#endif
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlDefaultSAXHandlerInit (void);
#ifdef __cplusplus
}
#endif
#endif /* __XML_SAX2_H__ */
/*
* Summary: lists interfaces
* Description: this module implement the list support used in
* various place in the library.
*
* Copy: See Copyright for the status of this software.
*
* Author: Gary Pennington <Gary.Pennington@uk.sun.com>
*/
#ifndef __XML_LINK_INCLUDE__
#define __XML_LINK_INCLUDE__
#include <libxml/xmlversion.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct _xmlLink xmlLink;
typedef xmlLink *xmlLinkPtr;
typedef struct _xmlList xmlList;
typedef xmlList *xmlListPtr;
/**
* xmlListDeallocator:
* @lk: the data to deallocate
*
* Callback function used to free data from a list.
*/
typedef void (*xmlListDeallocator) (xmlLinkPtr lk);
/**
* xmlListDataCompare:
* @data0: the first data
* @data1: the second data
*
* Callback function used to compare 2 data.
*
* Returns 0 is equality, -1 or 1 otherwise depending on the ordering.
*/
typedef int (*xmlListDataCompare) (const void *data0, const void *data1);
/**
* xmlListWalker:
* @data: the data found in the list
* @user: extra user provided data to the walker
*
* Callback function used when walking a list with xmlListWalk().
*
* Returns 0 to stop walking the list, 1 otherwise.
*/
typedef int (*xmlListWalker) (const void *data, void *user);
/* Creation/Deletion */
XMLPUBFUN xmlListPtr XMLCALL
xmlListCreate (xmlListDeallocator deallocator,
xmlListDataCompare compare);
XMLPUBFUN void XMLCALL
xmlListDelete (xmlListPtr l);
/* Basic Operators */
XMLPUBFUN void * XMLCALL
xmlListSearch (xmlListPtr l,
void *data);
XMLPUBFUN void * XMLCALL
xmlListReverseSearch (xmlListPtr l,
void *data);
XMLPUBFUN int XMLCALL
xmlListInsert (xmlListPtr l,
void *data) ;
XMLPUBFUN int XMLCALL
xmlListAppend (xmlListPtr l,
void *data) ;
XMLPUBFUN int XMLCALL
xmlListRemoveFirst (xmlListPtr l,
void *data);
XMLPUBFUN int XMLCALL
xmlListRemoveLast (xmlListPtr l,
void *data);
XMLPUBFUN int XMLCALL
xmlListRemoveAll (xmlListPtr l,
void *data);
XMLPUBFUN void XMLCALL
xmlListClear (xmlListPtr l);
XMLPUBFUN int XMLCALL
xmlListEmpty (xmlListPtr l);
XMLPUBFUN xmlLinkPtr XMLCALL
xmlListFront (xmlListPtr l);
XMLPUBFUN xmlLinkPtr XMLCALL
xmlListEnd (xmlListPtr l);
XMLPUBFUN int XMLCALL
xmlListSize (xmlListPtr l);
XMLPUBFUN void XMLCALL
xmlListPopFront (xmlListPtr l);
XMLPUBFUN void XMLCALL
xmlListPopBack (xmlListPtr l);
XMLPUBFUN int XMLCALL
xmlListPushFront (xmlListPtr l,
void *data);
XMLPUBFUN int XMLCALL
xmlListPushBack (xmlListPtr l,
void *data);
/* Advanced Operators */
XMLPUBFUN void XMLCALL
xmlListReverse (xmlListPtr l);
XMLPUBFUN void XMLCALL
xmlListSort (xmlListPtr l);
XMLPUBFUN void XMLCALL
xmlListWalk (xmlListPtr l,
xmlListWalker walker,
void *user);
XMLPUBFUN void XMLCALL
xmlListReverseWalk (xmlListPtr l,
xmlListWalker walker,
void *user);
XMLPUBFUN void XMLCALL
xmlListMerge (xmlListPtr l1,
xmlListPtr l2);
XMLPUBFUN xmlListPtr XMLCALL
xmlListDup (const xmlListPtr old);
XMLPUBFUN int XMLCALL
xmlListCopy (xmlListPtr cur,
const xmlListPtr old);
/* Link operators */
XMLPUBFUN void * XMLCALL
xmlLinkGetData (xmlLinkPtr lk);
/* xmlListUnique() */
/* xmlListSwap */
#ifdef __cplusplus
}
#endif
#endif /* __XML_LINK_INCLUDE__ */
/*
* Summary: interface for the XML entities handling
* Description: this module provides some of the entity API needed
* for the parser and applications.
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_ENTITIES_H__
#define __XML_ENTITIES_H__
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* The different valid entity types.
*/
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;
/*
* An unit of storage for an entity, contains the string, the value
* and the linkind data needed for the linking in the hash table.
*/
struct _xmlEntity {
void *_private; /* application data */
xmlElementType type; /* XML_ENTITY_DECL, must be second ! */
const xmlChar *name; /* Entity name */
struct _xmlNode *children; /* First child link */
struct _xmlNode *last; /* Last child link */
struct _xmlDtd *parent; /* -> DTD */
struct _xmlNode *next; /* next sibling link */
struct _xmlNode *prev; /* previous sibling link */
struct _xmlDoc *doc; /* the containing document */
xmlChar *orig; /* content without ref substitution */
xmlChar *content; /* content or ndata if unparsed */
int length; /* the content length */
xmlEntityType etype; /* The entity type */
const xmlChar *ExternalID; /* External identifier for PUBLIC */
const xmlChar *SystemID; /* URI for a SYSTEM or PUBLIC Entity */
struct _xmlEntity *nexte; /* unused */
const xmlChar *URI; /* the full URI as computed */
int owner; /* does the entity own the childrens */
int checked; /* was the entity content checked */
/* this is also used to count entities
* references done from that entity
* and if it contains '<' */
};
/*
* All entities are stored in an hash table.
* There is 2 separate hash tables for global and parameter entities.
*/
typedef struct _xmlHashTable xmlEntitiesTable;
typedef xmlEntitiesTable *xmlEntitiesTablePtr;
/*
* External functions:
*/
#ifdef LIBXML_LEGACY_ENABLED
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlInitializePredefinedEntities (void);
#endif /* LIBXML_LEGACY_ENABLED */
XMLPUBFUN xmlEntityPtr XMLCALL
xmlNewEntity (xmlDocPtr doc,
const xmlChar *name,
int type,
const xmlChar *ExternalID,
const xmlChar *SystemID,
const xmlChar *content);
XMLPUBFUN xmlEntityPtr XMLCALL
xmlAddDocEntity (xmlDocPtr doc,
const xmlChar *name,
int type,
const xmlChar *ExternalID,
const xmlChar *SystemID,
const xmlChar *content);
XMLPUBFUN xmlEntityPtr XMLCALL
xmlAddDtdEntity (xmlDocPtr doc,
const xmlChar *name,
int type,
const xmlChar *ExternalID,
const xmlChar *SystemID,
const xmlChar *content);
XMLPUBFUN xmlEntityPtr XMLCALL
xmlGetPredefinedEntity (const xmlChar *name);
XMLPUBFUN xmlEntityPtr XMLCALL
xmlGetDocEntity (const xmlDoc *doc,
const xmlChar *name);
XMLPUBFUN xmlEntityPtr XMLCALL
xmlGetDtdEntity (xmlDocPtr doc,
const xmlChar *name);
XMLPUBFUN xmlEntityPtr XMLCALL
xmlGetParameterEntity (xmlDocPtr doc,
const xmlChar *name);
#ifdef LIBXML_LEGACY_ENABLED
XML_DEPRECATED
XMLPUBFUN const xmlChar * XMLCALL
xmlEncodeEntities (xmlDocPtr doc,
const xmlChar *input);
#endif /* LIBXML_LEGACY_ENABLED */
XMLPUBFUN xmlChar * XMLCALL
xmlEncodeEntitiesReentrant(xmlDocPtr doc,
const xmlChar *input);
XMLPUBFUN xmlChar * XMLCALL
xmlEncodeSpecialChars (const xmlDoc *doc,
const xmlChar *input);
XMLPUBFUN xmlEntitiesTablePtr XMLCALL
xmlCreateEntitiesTable (void);
#ifdef LIBXML_TREE_ENABLED
XMLPUBFUN xmlEntitiesTablePtr XMLCALL
xmlCopyEntitiesTable (xmlEntitiesTablePtr table);
#endif /* LIBXML_TREE_ENABLED */
XMLPUBFUN void XMLCALL
xmlFreeEntitiesTable (xmlEntitiesTablePtr table);
#ifdef LIBXML_OUTPUT_ENABLED
XMLPUBFUN void XMLCALL
xmlDumpEntitiesTable (xmlBufferPtr buf,
xmlEntitiesTablePtr table);
XMLPUBFUN void XMLCALL
xmlDumpEntityDecl (xmlBufferPtr buf,
xmlEntityPtr ent);
#endif /* LIBXML_OUTPUT_ENABLED */
#ifdef LIBXML_LEGACY_ENABLED
XMLPUBFUN void XMLCALL
xmlCleanupPredefinedEntities(void);
#endif /* LIBXML_LEGACY_ENABLED */
#ifdef __cplusplus
}
#endif
# endif /* __XML_ENTITIES_H__ */
/*
* Summary: The DTD validation
* Description: API for the DTD handling and the validity checking
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_VALID_H__
#define __XML_VALID_H__
#include <libxml/xmlversion.h>
#include <libxml/xmlerror.h>
#include <libxml/tree.h>
#include <libxml/list.h>
#include <libxml/xmlautomata.h>
#include <libxml/xmlregexp.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* Validation state added for non-determinist content model.
*/
typedef struct _xmlValidState xmlValidState;
typedef xmlValidState *xmlValidStatePtr;
/**
* xmlValidityErrorFunc:
* @ctx: usually an xmlValidCtxtPtr to a validity error context,
* but comes from ctxt->userData (which normally contains such
* a pointer); ctxt->userData can be changed by the user.
* @msg: the string to format *printf like vararg
* @...: remaining arguments to the format
*
* Callback called when a validity error is found. This is a message
* oriented function similar to an *printf function.
*/
typedef void (XMLCDECL *xmlValidityErrorFunc) (void *ctx,
const char *msg,
...) LIBXML_ATTR_FORMAT(2,3);
/**
* xmlValidityWarningFunc:
* @ctx: usually an xmlValidCtxtPtr to a validity error context,
* but comes from ctxt->userData (which normally contains such
* a pointer); ctxt->userData can be changed by the user.
* @msg: the string to format *printf like vararg
* @...: remaining arguments to the format
*
* Callback called when a validity warning is found. This is a message
* oriented function similar to an *printf function.
*/
typedef void (XMLCDECL *xmlValidityWarningFunc) (void *ctx,
const char *msg,
...) LIBXML_ATTR_FORMAT(2,3);
#ifdef IN_LIBXML
/**
* XML_VCTXT_DTD_VALIDATED:
*
* Set after xmlValidateDtdFinal was called.
*/
#define XML_VCTXT_DTD_VALIDATED (1u << 0)
/**
* XML_VCTXT_USE_PCTXT:
*
* Set if the validation context is part of a parser context.
*/
#define XML_VCTXT_USE_PCTXT (1u << 1)
#endif
/*
* xmlValidCtxt:
* An xmlValidCtxt is used for error reporting when validating.
*/
typedef struct _xmlValidCtxt xmlValidCtxt;
typedef xmlValidCtxt *xmlValidCtxtPtr;
struct _xmlValidCtxt {
void *userData; /* user specific data block */
xmlValidityErrorFunc error; /* the callback in case of errors */
xmlValidityWarningFunc warning; /* the callback in case of warning */
/* Node analysis stack used when validating within entities */
xmlNodePtr node; /* Current parsed Node */
int nodeNr; /* Depth of the parsing stack */
int nodeMax; /* Max depth of the parsing stack */
xmlNodePtr *nodeTab; /* array of nodes */
unsigned int flags; /* internal flags */
xmlDocPtr doc; /* the document */
int valid; /* temporary validity check result */
/* state state used for non-determinist content validation */
xmlValidState *vstate; /* current state */
int vstateNr; /* Depth of the validation stack */
int vstateMax; /* Max depth of the validation stack */
xmlValidState *vstateTab; /* array of validation states */
#ifdef LIBXML_REGEXP_ENABLED
xmlAutomataPtr am; /* the automata */
xmlAutomataStatePtr state; /* used to build the automata */
#else
void *am;
void *state;
#endif
};
/*
* ALL notation declarations are stored in a table.
* There is one table per DTD.
*/
typedef struct _xmlHashTable xmlNotationTable;
typedef xmlNotationTable *xmlNotationTablePtr;
/*
* ALL element declarations are stored in a table.
* There is one table per DTD.
*/
typedef struct _xmlHashTable xmlElementTable;
typedef xmlElementTable *xmlElementTablePtr;
/*
* ALL attribute declarations are stored in a table.
* There is one table per DTD.
*/
typedef struct _xmlHashTable xmlAttributeTable;
typedef xmlAttributeTable *xmlAttributeTablePtr;
/*
* ALL IDs attributes are stored in a table.
* There is one table per document.
*/
typedef struct _xmlHashTable xmlIDTable;
typedef xmlIDTable *xmlIDTablePtr;
/*
* ALL Refs attributes are stored in a table.
* There is one table per document.
*/
typedef struct _xmlHashTable xmlRefTable;
typedef xmlRefTable *xmlRefTablePtr;
/* Notation */
XMLPUBFUN xmlNotationPtr XMLCALL
xmlAddNotationDecl (xmlValidCtxtPtr ctxt,
xmlDtdPtr dtd,
const xmlChar *name,
const xmlChar *PublicID,
const xmlChar *SystemID);
#ifdef LIBXML_TREE_ENABLED
XMLPUBFUN xmlNotationTablePtr XMLCALL
xmlCopyNotationTable (xmlNotationTablePtr table);
#endif /* LIBXML_TREE_ENABLED */
XMLPUBFUN void XMLCALL
xmlFreeNotationTable (xmlNotationTablePtr table);
#ifdef LIBXML_OUTPUT_ENABLED
XMLPUBFUN void XMLCALL
xmlDumpNotationDecl (xmlBufferPtr buf,
xmlNotationPtr nota);
XMLPUBFUN void XMLCALL
xmlDumpNotationTable (xmlBufferPtr buf,
xmlNotationTablePtr table);
#endif /* LIBXML_OUTPUT_ENABLED */
/* Element Content */
/* the non Doc version are being deprecated */
XMLPUBFUN xmlElementContentPtr XMLCALL
xmlNewElementContent (const xmlChar *name,
xmlElementContentType type);
XMLPUBFUN xmlElementContentPtr XMLCALL
xmlCopyElementContent (xmlElementContentPtr content);
XMLPUBFUN void XMLCALL
xmlFreeElementContent (xmlElementContentPtr cur);
/* the new versions with doc argument */
XMLPUBFUN xmlElementContentPtr XMLCALL
xmlNewDocElementContent (xmlDocPtr doc,
const xmlChar *name,
xmlElementContentType type);
XMLPUBFUN xmlElementContentPtr XMLCALL
xmlCopyDocElementContent(xmlDocPtr doc,
xmlElementContentPtr content);
XMLPUBFUN void XMLCALL
xmlFreeDocElementContent(xmlDocPtr doc,
xmlElementContentPtr cur);
XMLPUBFUN void XMLCALL
xmlSnprintfElementContent(char *buf,
int size,
xmlElementContentPtr content,
int englob);
#ifdef LIBXML_OUTPUT_ENABLED
/* DEPRECATED */
XMLPUBFUN void XMLCALL
xmlSprintfElementContent(char *buf,
xmlElementContentPtr content,
int englob);
#endif /* LIBXML_OUTPUT_ENABLED */
/* DEPRECATED */
/* Element */
XMLPUBFUN xmlElementPtr XMLCALL
xmlAddElementDecl (xmlValidCtxtPtr ctxt,
xmlDtdPtr dtd,
const xmlChar *name,
xmlElementTypeVal type,
xmlElementContentPtr content);
#ifdef LIBXML_TREE_ENABLED
XMLPUBFUN xmlElementTablePtr XMLCALL
xmlCopyElementTable (xmlElementTablePtr table);
#endif /* LIBXML_TREE_ENABLED */
XMLPUBFUN void XMLCALL
xmlFreeElementTable (xmlElementTablePtr table);
#ifdef LIBXML_OUTPUT_ENABLED
XMLPUBFUN void XMLCALL
xmlDumpElementTable (xmlBufferPtr buf,
xmlElementTablePtr table);
XMLPUBFUN void XMLCALL
xmlDumpElementDecl (xmlBufferPtr buf,
xmlElementPtr elem);
#endif /* LIBXML_OUTPUT_ENABLED */
/* Enumeration */
XMLPUBFUN xmlEnumerationPtr XMLCALL
xmlCreateEnumeration (const xmlChar *name);
XMLPUBFUN void XMLCALL
xmlFreeEnumeration (xmlEnumerationPtr cur);
#ifdef LIBXML_TREE_ENABLED
XMLPUBFUN xmlEnumerationPtr XMLCALL
xmlCopyEnumeration (xmlEnumerationPtr cur);
#endif /* LIBXML_TREE_ENABLED */
/* Attribute */
XMLPUBFUN xmlAttributePtr XMLCALL
xmlAddAttributeDecl (xmlValidCtxtPtr ctxt,
xmlDtdPtr dtd,
const xmlChar *elem,
const xmlChar *name,
const xmlChar *ns,
xmlAttributeType type,
xmlAttributeDefault def,
const xmlChar *defaultValue,
xmlEnumerationPtr tree);
#ifdef LIBXML_TREE_ENABLED
XMLPUBFUN xmlAttributeTablePtr XMLCALL
xmlCopyAttributeTable (xmlAttributeTablePtr table);
#endif /* LIBXML_TREE_ENABLED */
XMLPUBFUN void XMLCALL
xmlFreeAttributeTable (xmlAttributeTablePtr table);
#ifdef LIBXML_OUTPUT_ENABLED
XMLPUBFUN void XMLCALL
xmlDumpAttributeTable (xmlBufferPtr buf,
xmlAttributeTablePtr table);
XMLPUBFUN void XMLCALL
xmlDumpAttributeDecl (xmlBufferPtr buf,
xmlAttributePtr attr);
#endif /* LIBXML_OUTPUT_ENABLED */
/* IDs */
XMLPUBFUN xmlIDPtr XMLCALL
xmlAddID (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
const xmlChar *value,
xmlAttrPtr attr);
XMLPUBFUN void XMLCALL
xmlFreeIDTable (xmlIDTablePtr table);
XMLPUBFUN xmlAttrPtr XMLCALL
xmlGetID (xmlDocPtr doc,
const xmlChar *ID);
XMLPUBFUN int XMLCALL
xmlIsID (xmlDocPtr doc,
xmlNodePtr elem,
xmlAttrPtr attr);
XMLPUBFUN int XMLCALL
xmlRemoveID (xmlDocPtr doc,
xmlAttrPtr attr);
/* IDREFs */
XML_DEPRECATED
XMLPUBFUN xmlRefPtr XMLCALL
xmlAddRef (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
const xmlChar *value,
xmlAttrPtr attr);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlFreeRefTable (xmlRefTablePtr table);
XML_DEPRECATED
XMLPUBFUN int XMLCALL
xmlIsRef (xmlDocPtr doc,
xmlNodePtr elem,
xmlAttrPtr attr);
XML_DEPRECATED
XMLPUBFUN int XMLCALL
xmlRemoveRef (xmlDocPtr doc,
xmlAttrPtr attr);
XML_DEPRECATED
XMLPUBFUN xmlListPtr XMLCALL
xmlGetRefs (xmlDocPtr doc,
const xmlChar *ID);
/**
* The public function calls related to validity checking.
*/
#ifdef LIBXML_VALID_ENABLED
/* Allocate/Release Validation Contexts */
XMLPUBFUN xmlValidCtxtPtr XMLCALL
xmlNewValidCtxt(void);
XMLPUBFUN void XMLCALL
xmlFreeValidCtxt(xmlValidCtxtPtr);
XMLPUBFUN int XMLCALL
xmlValidateRoot (xmlValidCtxtPtr ctxt,
xmlDocPtr doc);
XMLPUBFUN int XMLCALL
xmlValidateElementDecl (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlElementPtr elem);
XMLPUBFUN xmlChar * XMLCALL
xmlValidNormalizeAttributeValue(xmlDocPtr doc,
xmlNodePtr elem,
const xmlChar *name,
const xmlChar *value);
XMLPUBFUN xmlChar * XMLCALL
xmlValidCtxtNormalizeAttributeValue(xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlNodePtr elem,
const xmlChar *name,
const xmlChar *value);
XMLPUBFUN int XMLCALL
xmlValidateAttributeDecl(xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlAttributePtr attr);
XMLPUBFUN int XMLCALL
xmlValidateAttributeValue(xmlAttributeType type,
const xmlChar *value);
XMLPUBFUN int XMLCALL
xmlValidateNotationDecl (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlNotationPtr nota);
XMLPUBFUN int XMLCALL
xmlValidateDtd (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlDtdPtr dtd);
XMLPUBFUN int XMLCALL
xmlValidateDtdFinal (xmlValidCtxtPtr ctxt,
xmlDocPtr doc);
XMLPUBFUN int XMLCALL
xmlValidateDocument (xmlValidCtxtPtr ctxt,
xmlDocPtr doc);
XMLPUBFUN int XMLCALL
xmlValidateElement (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlNodePtr elem);
XMLPUBFUN int XMLCALL
xmlValidateOneElement (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlNodePtr elem);
XMLPUBFUN int XMLCALL
xmlValidateOneAttribute (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlNodePtr elem,
xmlAttrPtr attr,
const xmlChar *value);
XMLPUBFUN int XMLCALL
xmlValidateOneNamespace (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlNodePtr elem,
const xmlChar *prefix,
xmlNsPtr ns,
const xmlChar *value);
XMLPUBFUN int XMLCALL
xmlValidateDocumentFinal(xmlValidCtxtPtr ctxt,
xmlDocPtr doc);
#endif /* LIBXML_VALID_ENABLED */
#if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
XMLPUBFUN int XMLCALL
xmlValidateNotationUse (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
const xmlChar *notationName);
#endif /* LIBXML_VALID_ENABLED or LIBXML_SCHEMAS_ENABLED */
XMLPUBFUN int XMLCALL
xmlIsMixedElement (xmlDocPtr doc,
const xmlChar *name);
XMLPUBFUN xmlAttributePtr XMLCALL
xmlGetDtdAttrDesc (xmlDtdPtr dtd,
const xmlChar *elem,
const xmlChar *name);
XMLPUBFUN xmlAttributePtr XMLCALL
xmlGetDtdQAttrDesc (xmlDtdPtr dtd,
const xmlChar *elem,
const xmlChar *name,
const xmlChar *prefix);
XMLPUBFUN xmlNotationPtr XMLCALL
xmlGetDtdNotationDesc (xmlDtdPtr dtd,
const xmlChar *name);
XMLPUBFUN xmlElementPtr XMLCALL
xmlGetDtdQElementDesc (xmlDtdPtr dtd,
const xmlChar *name,
const xmlChar *prefix);
XMLPUBFUN xmlElementPtr XMLCALL
xmlGetDtdElementDesc (xmlDtdPtr dtd,
const xmlChar *name);
#ifdef LIBXML_VALID_ENABLED
XMLPUBFUN int XMLCALL
xmlValidGetPotentialChildren(xmlElementContent *ctree,
const xmlChar **names,
int *len,
int max);
XMLPUBFUN int XMLCALL
xmlValidGetValidElements(xmlNode *prev,
xmlNode *next,
const xmlChar **names,
int max);
XMLPUBFUN int XMLCALL
xmlValidateNameValue (const xmlChar *value);
XMLPUBFUN int XMLCALL
xmlValidateNamesValue (const xmlChar *value);
XMLPUBFUN int XMLCALL
xmlValidateNmtokenValue (const xmlChar *value);
XMLPUBFUN int XMLCALL
xmlValidateNmtokensValue(const xmlChar *value);
#ifdef LIBXML_REGEXP_ENABLED
/*
* Validation based on the regexp support
*/
XMLPUBFUN int XMLCALL
xmlValidBuildContentModel(xmlValidCtxtPtr ctxt,
xmlElementPtr elem);
XMLPUBFUN int XMLCALL
xmlValidatePushElement (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlNodePtr elem,
const xmlChar *qname);
XMLPUBFUN int XMLCALL
xmlValidatePushCData (xmlValidCtxtPtr ctxt,
const xmlChar *data,
int len);
XMLPUBFUN int XMLCALL
xmlValidatePopElement (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlNodePtr elem,
const xmlChar *qname);
#endif /* LIBXML_REGEXP_ENABLED */
#endif /* LIBXML_VALID_ENABLED */
#ifdef __cplusplus
}
#endif
#endif /* __XML_VALID_H__ */
/*
* Summary: macros for marking symbols as exportable/importable.
* Description: macros for marking symbols as exportable/importable.
*
* Copy: See Copyright for the status of this software.
*/
#ifndef __XML_EXPORTS_H__
#define __XML_EXPORTS_H__
#if defined(_WIN32) || defined(__CYGWIN__)
/** DOC_DISABLE */
#ifdef LIBXML_STATIC
#define XMLPUBLIC
#elif defined(IN_LIBXML)
#define XMLPUBLIC __declspec(dllexport)
#else
#define XMLPUBLIC __declspec(dllimport)
#endif
#if defined(LIBXML_FASTCALL)
#define XMLCALL __fastcall
#else
#define XMLCALL __cdecl
#endif
#define XMLCDECL __cdecl
/** DOC_ENABLE */
#else /* not Windows */
/**
* XMLPUBLIC:
*
* Macro which declares a public symbol
*/
#define XMLPUBLIC
/**
* XMLCALL:
*
* Macro which declares the calling convention for exported functions
*/
#define XMLCALL
/**
* XMLCDECL:
*
* Macro which declares the calling convention for exported functions that
* use '...'.
*/
#define XMLCDECL
#endif /* platform switch */
/*
* XMLPUBFUN:
*
* Macro which declares an exportable function
*/
#define XMLPUBFUN XMLPUBLIC
/**
* XMLPUBVAR:
*
* Macro which declares an exportable variable
*/
#define XMLPUBVAR XMLPUBLIC extern
/* Compatibility */
#if !defined(LIBXML_DLL_IMPORT)
#define LIBXML_DLL_IMPORT XMLPUBVAR
#endif
#endif /* __XML_EXPORTS_H__ */
/*
* Summary: the core parser module
* Description: Interfaces, constants and types related to the XML parser
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_PARSER_H__
#define __XML_PARSER_H__
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#include <libxml/dict.h>
#include <libxml/hash.h>
#include <libxml/valid.h>
#include <libxml/entities.h>
#include <libxml/xmlerror.h>
#include <libxml/xmlstring.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* XML_DEFAULT_VERSION:
*
* The default version of XML used: 1.0
*/
#define XML_DEFAULT_VERSION "1.0"
/**
* xmlParserInput:
*
* An xmlParserInput is an input flow for the XML processor.
* Each entity parsed is associated an xmlParserInput (except the
* few predefined ones). This is the case both for internal entities
* - in which case the flow is already completely in memory - or
* external entities - in which case we use the buf structure for
* progressive reading and I18N conversions to the internal UTF-8 format.
*/
/**
* xmlParserInputDeallocate:
* @str: the string to deallocate
*
* Callback for freeing some parser input allocations.
*/
typedef void (* xmlParserInputDeallocate)(xmlChar *str);
struct _xmlParserInput {
/* Input buffer */
xmlParserInputBufferPtr buf; /* UTF-8 encoded buffer */
const char *filename; /* The file analyzed, if any */
const char *directory; /* the directory/base of the file */
const xmlChar *base; /* Base of the array to parse */
const xmlChar *cur; /* Current char being parsed */
const xmlChar *end; /* end of the array to parse */
int length; /* length if known */
int line; /* Current line */
int col; /* Current column */
/*
* NOTE: consumed is only tested for equality in the parser code,
* so even if there is an overflow this should not give troubles
* for parsing very large instances.
*/
unsigned long consumed; /* How many xmlChars already consumed */
xmlParserInputDeallocate free; /* function to deallocate the base */
const xmlChar *encoding; /* the encoding string for entity */
const xmlChar *version; /* the version string for entity */
int standalone; /* Was that entity marked standalone */
int id; /* an unique identifier for the entity */
};
/**
* xmlParserNodeInfo:
*
* The parser can be asked to collect Node information, i.e. at what
* place in the file they were detected.
* NOTE: This is off by default and not very well tested.
*/
typedef struct _xmlParserNodeInfo xmlParserNodeInfo;
typedef xmlParserNodeInfo *xmlParserNodeInfoPtr;
struct _xmlParserNodeInfo {
const struct _xmlNode* node;
/* Position & line # that text that created the node begins & ends on */
unsigned long begin_pos;
unsigned long begin_line;
unsigned long end_pos;
unsigned long end_line;
};
typedef struct _xmlParserNodeInfoSeq xmlParserNodeInfoSeq;
typedef xmlParserNodeInfoSeq *xmlParserNodeInfoSeqPtr;
struct _xmlParserNodeInfoSeq {
unsigned long maximum;
unsigned long length;
xmlParserNodeInfo* buffer;
};
/**
* xmlParserInputState:
*
* The parser is now working also as a state based parser.
* The recursive one use the state info for entities processing.
*/
typedef enum {
XML_PARSER_EOF = -1, /* nothing is to be parsed */
XML_PARSER_START = 0, /* nothing has been parsed */
XML_PARSER_MISC, /* Misc* before int subset */
XML_PARSER_PI, /* Within a processing instruction */
XML_PARSER_DTD, /* within some DTD content */
XML_PARSER_PROLOG, /* Misc* after internal subset */
XML_PARSER_COMMENT, /* within a comment */
XML_PARSER_START_TAG, /* within a start tag */
XML_PARSER_CONTENT, /* within the content */
XML_PARSER_CDATA_SECTION, /* within a CDATA section */
XML_PARSER_END_TAG, /* within a closing tag */
XML_PARSER_ENTITY_DECL, /* within an entity declaration */
XML_PARSER_ENTITY_VALUE, /* within an entity value in a decl */
XML_PARSER_ATTRIBUTE_VALUE, /* within an attribute value */
XML_PARSER_SYSTEM_LITERAL, /* within a SYSTEM value */
XML_PARSER_EPILOG, /* the Misc* after the last end tag */
XML_PARSER_IGNORE, /* within an IGNORED section */
XML_PARSER_PUBLIC_LITERAL /* within a PUBLIC value */
} xmlParserInputState;
/**
* XML_DETECT_IDS:
*
* Bit in the loadsubset context field to tell to do ID/REFs lookups.
* Use it to initialize xmlLoadExtDtdDefaultValue.
*/
#define XML_DETECT_IDS 2
/**
* XML_COMPLETE_ATTRS:
*
* Bit in the loadsubset context field to tell to do complete the
* elements attributes lists with the ones defaulted from the DTDs.
* Use it to initialize xmlLoadExtDtdDefaultValue.
*/
#define XML_COMPLETE_ATTRS 4
/**
* XML_SKIP_IDS:
*
* Bit in the loadsubset context field to tell to not do ID/REFs registration.
* Used to initialize xmlLoadExtDtdDefaultValue in some special cases.
*/
#define XML_SKIP_IDS 8
/**
* xmlParserMode:
*
* A parser can operate in various modes
*/
typedef enum {
XML_PARSE_UNKNOWN = 0,
XML_PARSE_DOM = 1,
XML_PARSE_SAX = 2,
XML_PARSE_PUSH_DOM = 3,
XML_PARSE_PUSH_SAX = 4,
XML_PARSE_READER = 5
} xmlParserMode;
typedef struct _xmlStartTag xmlStartTag;
/**
* xmlParserCtxt:
*
* The parser context.
* NOTE This doesn't completely define the parser state, the (current ?)
* design of the parser uses recursive function calls since this allow
* and easy mapping from the production rules of the specification
* to the actual code. The drawback is that the actual function call
* also reflect the parser state. However most of the parsing routines
* takes as the only argument the parser context pointer, so migrating
* to a state based parser for progressive parsing shouldn't be too hard.
*/
struct _xmlParserCtxt {
struct _xmlSAXHandler *sax; /* The SAX handler */
void *userData; /* For SAX interface only, used by DOM build */
xmlDocPtr myDoc; /* the document being built */
int wellFormed; /* is the document well formed */
int replaceEntities; /* shall we replace entities ? */
const xmlChar *version; /* the XML version string */
const xmlChar *encoding; /* the declared encoding, if any */
int standalone; /* standalone document */
int html; /* an HTML(1) document
* 3 is HTML after <head>
* 10 is HTML after <body>
*/
/* Input stream stack */
xmlParserInputPtr input; /* Current input stream */
int inputNr; /* Number of current input streams */
int inputMax; /* Max number of input streams */
xmlParserInputPtr *inputTab; /* stack of inputs */
/* Node analysis stack only used for DOM building */
xmlNodePtr node; /* Current parsed Node */
int nodeNr; /* Depth of the parsing stack */
int nodeMax; /* Max depth of the parsing stack */
xmlNodePtr *nodeTab; /* array of nodes */
int record_info; /* Whether node info should be kept */
xmlParserNodeInfoSeq node_seq; /* info about each node parsed */
int errNo; /* error code */
int hasExternalSubset; /* reference and external subset */
int hasPErefs; /* the internal subset has PE refs */
int external; /* are we parsing an external entity */
int valid; /* is the document valid */
int validate; /* shall we try to validate ? */
xmlValidCtxt vctxt; /* The validity context */
xmlParserInputState instate; /* current type of input */
int token; /* next char look-ahead */
char *directory; /* the data directory */
/* Node name stack */
const xmlChar *name; /* Current parsed Node */
int nameNr; /* Depth of the parsing stack */
int nameMax; /* Max depth of the parsing stack */
const xmlChar * *nameTab; /* array of nodes */
long nbChars; /* unused */
long checkIndex; /* used by progressive parsing lookup */
int keepBlanks; /* ugly but ... */
int disableSAX; /* SAX callbacks are disabled */
int inSubset; /* Parsing is in int 1/ext 2 subset */
const xmlChar * intSubName; /* name of subset */
xmlChar * extSubURI; /* URI of external subset */
xmlChar * extSubSystem; /* SYSTEM ID of external subset */
/* xml:space values */
int * space; /* Should the parser preserve spaces */
int spaceNr; /* Depth of the parsing stack */
int spaceMax; /* Max depth of the parsing stack */
int * spaceTab; /* array of space infos */
int depth; /* to prevent entity substitution loops */
xmlParserInputPtr entity; /* used to check entities boundaries */
int charset; /* encoding of the in-memory content
actually an xmlCharEncoding */
int nodelen; /* Those two fields are there to */
int nodemem; /* Speed up large node parsing */
int pedantic; /* signal pedantic warnings */
void *_private; /* For user data, libxml won't touch it */
int loadsubset; /* should the external subset be loaded */
int linenumbers; /* set line number in element content */
void *catalogs; /* document's own catalog */
int recovery; /* run in recovery mode */
int progressive; /* is this a progressive parsing */
xmlDictPtr dict; /* dictionary for the parser */
const xmlChar * *atts; /* array for the attributes callbacks */
int maxatts; /* the size of the array */
int docdict; /* use strings from dict to build tree */
/*
* pre-interned strings
*/
const xmlChar *str_xml;
const xmlChar *str_xmlns;
const xmlChar *str_xml_ns;
/*
* Everything below is used only by the new SAX mode
*/
int sax2; /* operating in the new SAX mode */
int nsNr; /* the number of inherited namespaces */
int nsMax; /* the size of the arrays */
const xmlChar * *nsTab; /* the array of prefix/namespace name */
int *attallocs; /* which attribute were allocated */
xmlStartTag *pushTab; /* array of data for push */
xmlHashTablePtr attsDefault; /* defaulted attributes if any */
xmlHashTablePtr attsSpecial; /* non-CDATA attributes if any */
int nsWellFormed; /* is the document XML Namespace okay */
int options; /* Extra options */
/*
* Those fields are needed only for streaming parsing so far
*/
int dictNames; /* Use dictionary names for the tree */
int freeElemsNr; /* number of freed element nodes */
xmlNodePtr freeElems; /* List of freed element nodes */
int freeAttrsNr; /* number of freed attributes nodes */
xmlAttrPtr freeAttrs; /* List of freed attributes nodes */
/*
* the complete error information for the last error.
*/
xmlError lastError;
xmlParserMode parseMode; /* the parser mode */
unsigned long nbentities; /* number of entities references */
unsigned long sizeentities; /* size of parsed entities */
/* for use by HTML non-recursive parser */
xmlParserNodeInfo *nodeInfo; /* Current NodeInfo */
int nodeInfoNr; /* Depth of the parsing stack */
int nodeInfoMax; /* Max depth of the parsing stack */
xmlParserNodeInfo *nodeInfoTab; /* array of nodeInfos */
int input_id; /* we need to label inputs */
unsigned long sizeentcopy; /* volume of entity copy */
};
/**
* xmlSAXLocator:
*
* A SAX Locator.
*/
struct _xmlSAXLocator {
const xmlChar *(*getPublicId)(void *ctx);
const xmlChar *(*getSystemId)(void *ctx);
int (*getLineNumber)(void *ctx);
int (*getColumnNumber)(void *ctx);
};
/**
* xmlSAXHandler:
*
* A SAX handler is bunch of callbacks called by the parser when processing
* of the input generate data or structure information.
*/
/**
* resolveEntitySAXFunc:
* @ctx: the user data (XML parser context)
* @publicId: The public ID of the entity
* @systemId: The system ID of the entity
*
* Callback:
* The entity loader, to control the loading of external entities,
* the application can either:
* - override this resolveEntity() callback in the SAX block
* - or better use the xmlSetExternalEntityLoader() function to
* set up it's own entity resolution routine
*
* Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
*/
typedef xmlParserInputPtr (*resolveEntitySAXFunc) (void *ctx,
const xmlChar *publicId,
const xmlChar *systemId);
/**
* internalSubsetSAXFunc:
* @ctx: the user data (XML parser context)
* @name: the root element name
* @ExternalID: the external ID
* @SystemID: the SYSTEM ID (e.g. filename or URL)
*
* Callback on internal subset declaration.
*/
typedef void (*internalSubsetSAXFunc) (void *ctx,
const xmlChar *name,
const xmlChar *ExternalID,
const xmlChar *SystemID);
/**
* externalSubsetSAXFunc:
* @ctx: the user data (XML parser context)
* @name: the root element name
* @ExternalID: the external ID
* @SystemID: the SYSTEM ID (e.g. filename or URL)
*
* Callback on external subset declaration.
*/
typedef void (*externalSubsetSAXFunc) (void *ctx,
const xmlChar *name,
const xmlChar *ExternalID,
const xmlChar *SystemID);
/**
* getEntitySAXFunc:
* @ctx: the user data (XML parser context)
* @name: The entity name
*
* Get an entity by name.
*
* Returns the xmlEntityPtr if found.
*/
typedef xmlEntityPtr (*getEntitySAXFunc) (void *ctx,
const xmlChar *name);
/**
* getParameterEntitySAXFunc:
* @ctx: the user data (XML parser context)
* @name: The entity name
*
* Get a parameter entity by name.
*
* Returns the xmlEntityPtr if found.
*/
typedef xmlEntityPtr (*getParameterEntitySAXFunc) (void *ctx,
const xmlChar *name);
/**
* entityDeclSAXFunc:
* @ctx: the user data (XML parser context)
* @name: the entity name
* @type: the entity type
* @publicId: The public ID of the entity
* @systemId: The system ID of the entity
* @content: the entity value (without processing).
*
* An entity definition has been parsed.
*/
typedef void (*entityDeclSAXFunc) (void *ctx,
const xmlChar *name,
int type,
const xmlChar *publicId,
const xmlChar *systemId,
xmlChar *content);
/**
* notationDeclSAXFunc:
* @ctx: the user data (XML parser context)
* @name: The name of the notation
* @publicId: The public ID of the entity
* @systemId: The system ID of the entity
*
* What to do when a notation declaration has been parsed.
*/
typedef void (*notationDeclSAXFunc)(void *ctx,
const xmlChar *name,
const xmlChar *publicId,
const xmlChar *systemId);
/**
* attributeDeclSAXFunc:
* @ctx: the user data (XML parser context)
* @elem: the name of the element
* @fullname: the attribute name
* @type: the attribute type
* @def: the type of default value
* @defaultValue: the attribute default value
* @tree: the tree of enumerated value set
*
* An attribute definition has been parsed.
*/
typedef void (*attributeDeclSAXFunc)(void *ctx,
const xmlChar *elem,
const xmlChar *fullname,
int type,
int def,
const xmlChar *defaultValue,
xmlEnumerationPtr tree);
/**
* elementDeclSAXFunc:
* @ctx: the user data (XML parser context)
* @name: the element name
* @type: the element type
* @content: the element value tree
*
* An element definition has been parsed.
*/
typedef void (*elementDeclSAXFunc)(void *ctx,
const xmlChar *name,
int type,
xmlElementContentPtr content);
/**
* unparsedEntityDeclSAXFunc:
* @ctx: the user data (XML parser context)
* @name: The name of the entity
* @publicId: The public ID of the entity
* @systemId: The system ID of the entity
* @notationName: the name of the notation
*
* What to do when an unparsed entity declaration is parsed.
*/
typedef void (*unparsedEntityDeclSAXFunc)(void *ctx,
const xmlChar *name,
const xmlChar *publicId,
const xmlChar *systemId,
const xmlChar *notationName);
/**
* setDocumentLocatorSAXFunc:
* @ctx: the user data (XML parser context)
* @loc: A SAX Locator
*
* Receive the document locator at startup, actually xmlDefaultSAXLocator.
* Everything is available on the context, so this is useless in our case.
*/
typedef void (*setDocumentLocatorSAXFunc) (void *ctx,
xmlSAXLocatorPtr loc);
/**
* startDocumentSAXFunc:
* @ctx: the user data (XML parser context)
*
* Called when the document start being processed.
*/
typedef void (*startDocumentSAXFunc) (void *ctx);
/**
* endDocumentSAXFunc:
* @ctx: the user data (XML parser context)
*
* Called when the document end has been detected.
*/
typedef void (*endDocumentSAXFunc) (void *ctx);
/**
* startElementSAXFunc:
* @ctx: the user data (XML parser context)
* @name: The element name, including namespace prefix
* @atts: An array of name/value attributes pairs, NULL terminated
*
* Called when an opening tag has been processed.
*/
typedef void (*startElementSAXFunc) (void *ctx,
const xmlChar *name,
const xmlChar **atts);
/**
* endElementSAXFunc:
* @ctx: the user data (XML parser context)
* @name: The element name
*
* Called when the end of an element has been detected.
*/
typedef void (*endElementSAXFunc) (void *ctx,
const xmlChar *name);
/**
* attributeSAXFunc:
* @ctx: the user data (XML parser context)
* @name: The attribute name, including namespace prefix
* @value: The attribute value
*
* Handle an attribute that has been read by the parser.
* The default handling is to convert the attribute into an
* DOM subtree and past it in a new xmlAttr element added to
* the element.
*/
typedef void (*attributeSAXFunc) (void *ctx,
const xmlChar *name,
const xmlChar *value);
/**
* referenceSAXFunc:
* @ctx: the user data (XML parser context)
* @name: The entity name
*
* Called when an entity reference is detected.
*/
typedef void (*referenceSAXFunc) (void *ctx,
const xmlChar *name);
/**
* charactersSAXFunc:
* @ctx: the user data (XML parser context)
* @ch: a xmlChar string
* @len: the number of xmlChar
*
* Receiving some chars from the parser.
*/
typedef void (*charactersSAXFunc) (void *ctx,
const xmlChar *ch,
int len);
/**
* ignorableWhitespaceSAXFunc:
* @ctx: the user data (XML parser context)
* @ch: a xmlChar string
* @len: the number of xmlChar
*
* Receiving some ignorable whitespaces from the parser.
* UNUSED: by default the DOM building will use characters.
*/
typedef void (*ignorableWhitespaceSAXFunc) (void *ctx,
const xmlChar *ch,
int len);
/**
* processingInstructionSAXFunc:
* @ctx: the user data (XML parser context)
* @target: the target name
* @data: the PI data's
*
* A processing instruction has been parsed.
*/
typedef void (*processingInstructionSAXFunc) (void *ctx,
const xmlChar *target,
const xmlChar *data);
/**
* commentSAXFunc:
* @ctx: the user data (XML parser context)
* @value: the comment content
*
* A comment has been parsed.
*/
typedef void (*commentSAXFunc) (void *ctx,
const xmlChar *value);
/**
* cdataBlockSAXFunc:
* @ctx: the user data (XML parser context)
* @value: The pcdata content
* @len: the block length
*
* Called when a pcdata block has been parsed.
*/
typedef void (*cdataBlockSAXFunc) (
void *ctx,
const xmlChar *value,
int len);
/**
* warningSAXFunc:
* @ctx: an XML parser context
* @msg: the message to display/transmit
* @...: extra parameters for the message display
*
* Display and format a warning messages, callback.
*/
typedef void (XMLCDECL *warningSAXFunc) (void *ctx,
const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
/**
* errorSAXFunc:
* @ctx: an XML parser context
* @msg: the message to display/transmit
* @...: extra parameters for the message display
*
* Display and format an error messages, callback.
*/
typedef void (XMLCDECL *errorSAXFunc) (void *ctx,
const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
/**
* fatalErrorSAXFunc:
* @ctx: an XML parser context
* @msg: the message to display/transmit
* @...: extra parameters for the message display
*
* Display and format fatal error messages, callback.
* Note: so far fatalError() SAX callbacks are not used, error()
* get all the callbacks for errors.
*/
typedef void (XMLCDECL *fatalErrorSAXFunc) (void *ctx,
const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
/**
* isStandaloneSAXFunc:
* @ctx: the user data (XML parser context)
*
* Is this document tagged standalone?
*
* Returns 1 if true
*/
typedef int (*isStandaloneSAXFunc) (void *ctx);
/**
* hasInternalSubsetSAXFunc:
* @ctx: the user data (XML parser context)
*
* Does this document has an internal subset.
*
* Returns 1 if true
*/
typedef int (*hasInternalSubsetSAXFunc) (void *ctx);
/**
* hasExternalSubsetSAXFunc:
* @ctx: the user data (XML parser context)
*
* Does this document has an external subset?
*
* Returns 1 if true
*/
typedef int (*hasExternalSubsetSAXFunc) (void *ctx);
/************************************************************************
* *
* The SAX version 2 API extensions *
* *
************************************************************************/
/**
* XML_SAX2_MAGIC:
*
* Special constant found in SAX2 blocks initialized fields
*/
#define XML_SAX2_MAGIC 0xDEEDBEAF
/**
* startElementNsSAX2Func:
* @ctx: the user data (XML parser context)
* @localname: the local name of the element
* @prefix: the element namespace prefix if available
* @URI: the element namespace name if available
* @nb_namespaces: number of namespace definitions on that node
* @namespaces: pointer to the array of prefix/URI pairs namespace definitions
* @nb_attributes: the number of attributes on that node
* @nb_defaulted: the number of defaulted attributes. The defaulted
* ones are at the end of the array
* @attributes: pointer to the array of (localname/prefix/URI/value/end)
* attribute values.
*
* SAX2 callback when an element start has been detected by the parser.
* It provides the namespace information for the element, as well as
* the new namespace declarations on the element.
*/
typedef void (*startElementNsSAX2Func) (void *ctx,
const xmlChar *localname,
const xmlChar *prefix,
const xmlChar *URI,
int nb_namespaces,
const xmlChar **namespaces,
int nb_attributes,
int nb_defaulted,
const xmlChar **attributes);
/**
* endElementNsSAX2Func:
* @ctx: the user data (XML parser context)
* @localname: the local name of the element
* @prefix: the element namespace prefix if available
* @URI: the element namespace name if available
*
* SAX2 callback when an element end has been detected by the parser.
* It provides the namespace information for the element.
*/
typedef void (*endElementNsSAX2Func) (void *ctx,
const xmlChar *localname,
const xmlChar *prefix,
const xmlChar *URI);
struct _xmlSAXHandler {
internalSubsetSAXFunc internalSubset;
isStandaloneSAXFunc isStandalone;
hasInternalSubsetSAXFunc hasInternalSubset;
hasExternalSubsetSAXFunc hasExternalSubset;
resolveEntitySAXFunc resolveEntity;
getEntitySAXFunc getEntity;
entityDeclSAXFunc entityDecl;
notationDeclSAXFunc notationDecl;
attributeDeclSAXFunc attributeDecl;
elementDeclSAXFunc elementDecl;
unparsedEntityDeclSAXFunc unparsedEntityDecl;
setDocumentLocatorSAXFunc setDocumentLocator;
startDocumentSAXFunc startDocument;
endDocumentSAXFunc endDocument;
startElementSAXFunc startElement;
endElementSAXFunc endElement;
referenceSAXFunc reference;
charactersSAXFunc characters;
ignorableWhitespaceSAXFunc ignorableWhitespace;
processingInstructionSAXFunc processingInstruction;
commentSAXFunc comment;
warningSAXFunc warning;
errorSAXFunc error;
fatalErrorSAXFunc fatalError; /* unused error() get all the errors */
getParameterEntitySAXFunc getParameterEntity;
cdataBlockSAXFunc cdataBlock;
externalSubsetSAXFunc externalSubset;
unsigned int initialized;
/* The following fields are extensions available only on version 2 */
void *_private;
startElementNsSAX2Func startElementNs;
endElementNsSAX2Func endElementNs;
xmlStructuredErrorFunc serror;
};
/*
* SAX Version 1
*/
typedef struct _xmlSAXHandlerV1 xmlSAXHandlerV1;
typedef xmlSAXHandlerV1 *xmlSAXHandlerV1Ptr;
struct _xmlSAXHandlerV1 {
internalSubsetSAXFunc internalSubset;
isStandaloneSAXFunc isStandalone;
hasInternalSubsetSAXFunc hasInternalSubset;
hasExternalSubsetSAXFunc hasExternalSubset;
resolveEntitySAXFunc resolveEntity;
getEntitySAXFunc getEntity;
entityDeclSAXFunc entityDecl;
notationDeclSAXFunc notationDecl;
attributeDeclSAXFunc attributeDecl;
elementDeclSAXFunc elementDecl;
unparsedEntityDeclSAXFunc unparsedEntityDecl;
setDocumentLocatorSAXFunc setDocumentLocator;
startDocumentSAXFunc startDocument;
endDocumentSAXFunc endDocument;
startElementSAXFunc startElement;
endElementSAXFunc endElement;
referenceSAXFunc reference;
charactersSAXFunc characters;
ignorableWhitespaceSAXFunc ignorableWhitespace;
processingInstructionSAXFunc processingInstruction;
commentSAXFunc comment;
warningSAXFunc warning;
errorSAXFunc error;
fatalErrorSAXFunc fatalError; /* unused error() get all the errors */
getParameterEntitySAXFunc getParameterEntity;
cdataBlockSAXFunc cdataBlock;
externalSubsetSAXFunc externalSubset;
unsigned int initialized;
};
/**
* xmlExternalEntityLoader:
* @URL: The System ID of the resource requested
* @ID: The Public ID of the resource requested
* @context: the XML parser context
*
* External entity loaders types.
*
* Returns the entity input parser.
*/
typedef xmlParserInputPtr (*xmlExternalEntityLoader) (const char *URL,
const char *ID,
xmlParserCtxtPtr context);
#ifdef __cplusplus
}
#endif
#include <libxml/encoding.h>
#include <libxml/xmlIO.h>
#include <libxml/globals.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* Init/Cleanup
*/
XMLPUBFUN void XMLCALL
xmlInitParser (void);
XMLPUBFUN void XMLCALL
xmlCleanupParser (void);
/*
* Input functions
*/
XMLPUBFUN int XMLCALL
xmlParserInputRead (xmlParserInputPtr in,
int len);
XMLPUBFUN int XMLCALL
xmlParserInputGrow (xmlParserInputPtr in,
int len);
/*
* Basic parsing Interfaces
*/
#ifdef LIBXML_SAX1_ENABLED
XMLPUBFUN xmlDocPtr XMLCALL
xmlParseDoc (const xmlChar *cur);
XMLPUBFUN xmlDocPtr XMLCALL
xmlParseFile (const char *filename);
XMLPUBFUN xmlDocPtr XMLCALL
xmlParseMemory (const char *buffer,
int size);
#endif /* LIBXML_SAX1_ENABLED */
XMLPUBFUN int XMLCALL
xmlSubstituteEntitiesDefault(int val);
XMLPUBFUN int XMLCALL
xmlKeepBlanksDefault (int val);
XMLPUBFUN void XMLCALL
xmlStopParser (xmlParserCtxtPtr ctxt);
XMLPUBFUN int XMLCALL
xmlPedanticParserDefault(int val);
XMLPUBFUN int XMLCALL
xmlLineNumbersDefault (int val);
#ifdef LIBXML_SAX1_ENABLED
/*
* Recovery mode
*/
XMLPUBFUN xmlDocPtr XMLCALL
xmlRecoverDoc (const xmlChar *cur);
XMLPUBFUN xmlDocPtr XMLCALL
xmlRecoverMemory (const char *buffer,
int size);
XMLPUBFUN xmlDocPtr XMLCALL
xmlRecoverFile (const char *filename);
#endif /* LIBXML_SAX1_ENABLED */
/*
* Less common routines and SAX interfaces
*/
XMLPUBFUN int XMLCALL
xmlParseDocument (xmlParserCtxtPtr ctxt);
XMLPUBFUN int XMLCALL
xmlParseExtParsedEnt (xmlParserCtxtPtr ctxt);
#ifdef LIBXML_SAX1_ENABLED
XMLPUBFUN int XMLCALL
xmlSAXUserParseFile (xmlSAXHandlerPtr sax,
void *user_data,
const char *filename);
XMLPUBFUN int XMLCALL
xmlSAXUserParseMemory (xmlSAXHandlerPtr sax,
void *user_data,
const char *buffer,
int size);
XMLPUBFUN xmlDocPtr XMLCALL
xmlSAXParseDoc (xmlSAXHandlerPtr sax,
const xmlChar *cur,
int recovery);
XMLPUBFUN xmlDocPtr XMLCALL
xmlSAXParseMemory (xmlSAXHandlerPtr sax,
const char *buffer,
int size,
int recovery);
XMLPUBFUN xmlDocPtr XMLCALL
xmlSAXParseMemoryWithData (xmlSAXHandlerPtr sax,
const char *buffer,
int size,
int recovery,
void *data);
XMLPUBFUN xmlDocPtr XMLCALL
xmlSAXParseFile (xmlSAXHandlerPtr sax,
const char *filename,
int recovery);
XMLPUBFUN xmlDocPtr XMLCALL
xmlSAXParseFileWithData (xmlSAXHandlerPtr sax,
const char *filename,
int recovery,
void *data);
XMLPUBFUN xmlDocPtr XMLCALL
xmlSAXParseEntity (xmlSAXHandlerPtr sax,
const char *filename);
XMLPUBFUN xmlDocPtr XMLCALL
xmlParseEntity (const char *filename);
#endif /* LIBXML_SAX1_ENABLED */
#ifdef LIBXML_VALID_ENABLED
XMLPUBFUN xmlDtdPtr XMLCALL
xmlSAXParseDTD (xmlSAXHandlerPtr sax,
const xmlChar *ExternalID,
const xmlChar *SystemID);
XMLPUBFUN xmlDtdPtr XMLCALL
xmlParseDTD (const xmlChar *ExternalID,
const xmlChar *SystemID);
XMLPUBFUN xmlDtdPtr XMLCALL
xmlIOParseDTD (xmlSAXHandlerPtr sax,
xmlParserInputBufferPtr input,
xmlCharEncoding enc);
#endif /* LIBXML_VALID_ENABLE */
#ifdef LIBXML_SAX1_ENABLED
XMLPUBFUN int XMLCALL
xmlParseBalancedChunkMemory(xmlDocPtr doc,
xmlSAXHandlerPtr sax,
void *user_data,
int depth,
const xmlChar *string,
xmlNodePtr *lst);
#endif /* LIBXML_SAX1_ENABLED */
XMLPUBFUN xmlParserErrors XMLCALL
xmlParseInNodeContext (xmlNodePtr node,
const char *data,
int datalen,
int options,
xmlNodePtr *lst);
#ifdef LIBXML_SAX1_ENABLED
XMLPUBFUN int XMLCALL
xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc,
xmlSAXHandlerPtr sax,
void *user_data,
int depth,
const xmlChar *string,
xmlNodePtr *lst,
int recover);
XMLPUBFUN int XMLCALL
xmlParseExternalEntity (xmlDocPtr doc,
xmlSAXHandlerPtr sax,
void *user_data,
int depth,
const xmlChar *URL,
const xmlChar *ID,
xmlNodePtr *lst);
#endif /* LIBXML_SAX1_ENABLED */
XMLPUBFUN int XMLCALL
xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx,
const xmlChar *URL,
const xmlChar *ID,
xmlNodePtr *lst);
/*
* Parser contexts handling.
*/
XMLPUBFUN xmlParserCtxtPtr XMLCALL
xmlNewParserCtxt (void);
XMLPUBFUN int XMLCALL
xmlInitParserCtxt (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlClearParserCtxt (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlFreeParserCtxt (xmlParserCtxtPtr ctxt);
#ifdef LIBXML_SAX1_ENABLED
XMLPUBFUN void XMLCALL
xmlSetupParserForBuffer (xmlParserCtxtPtr ctxt,
const xmlChar* buffer,
const char *filename);
#endif /* LIBXML_SAX1_ENABLED */
XMLPUBFUN xmlParserCtxtPtr XMLCALL
xmlCreateDocParserCtxt (const xmlChar *cur);
#ifdef LIBXML_LEGACY_ENABLED
/*
* Reading/setting optional parsing features.
*/
XML_DEPRECATED
XMLPUBFUN int XMLCALL
xmlGetFeaturesList (int *len,
const char **result);
XML_DEPRECATED
XMLPUBFUN int XMLCALL
xmlGetFeature (xmlParserCtxtPtr ctxt,
const char *name,
void *result);
XML_DEPRECATED
XMLPUBFUN int XMLCALL
xmlSetFeature (xmlParserCtxtPtr ctxt,
const char *name,
void *value);
#endif /* LIBXML_LEGACY_ENABLED */
#ifdef LIBXML_PUSH_ENABLED
/*
* Interfaces for the Push mode.
*/
XMLPUBFUN xmlParserCtxtPtr XMLCALL
xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax,
void *user_data,
const char *chunk,
int size,
const char *filename);
XMLPUBFUN int XMLCALL
xmlParseChunk (xmlParserCtxtPtr ctxt,
const char *chunk,
int size,
int terminate);
#endif /* LIBXML_PUSH_ENABLED */
/*
* Special I/O mode.
*/
XMLPUBFUN xmlParserCtxtPtr XMLCALL
xmlCreateIOParserCtxt (xmlSAXHandlerPtr sax,
void *user_data,
xmlInputReadCallback ioread,
xmlInputCloseCallback ioclose,
void *ioctx,
xmlCharEncoding enc);
XMLPUBFUN xmlParserInputPtr XMLCALL
xmlNewIOInputStream (xmlParserCtxtPtr ctxt,
xmlParserInputBufferPtr input,
xmlCharEncoding enc);
/*
* Node infos.
*/
XMLPUBFUN const xmlParserNodeInfo* XMLCALL
xmlParserFindNodeInfo (const xmlParserCtxtPtr ctxt,
const xmlNodePtr node);
XMLPUBFUN void XMLCALL
xmlInitNodeInfoSeq (xmlParserNodeInfoSeqPtr seq);
XMLPUBFUN void XMLCALL
xmlClearNodeInfoSeq (xmlParserNodeInfoSeqPtr seq);
XMLPUBFUN unsigned long XMLCALL
xmlParserFindNodeInfoIndex(const xmlParserNodeInfoSeqPtr seq,
const xmlNodePtr node);
XMLPUBFUN void XMLCALL
xmlParserAddNodeInfo (xmlParserCtxtPtr ctxt,
const xmlParserNodeInfoPtr info);
/*
* External entities handling actually implemented in xmlIO.
*/
XMLPUBFUN void XMLCALL
xmlSetExternalEntityLoader(xmlExternalEntityLoader f);
XMLPUBFUN xmlExternalEntityLoader XMLCALL
xmlGetExternalEntityLoader(void);
XMLPUBFUN xmlParserInputPtr XMLCALL
xmlLoadExternalEntity (const char *URL,
const char *ID,
xmlParserCtxtPtr ctxt);
/*
* Index lookup, actually implemented in the encoding module
*/
XMLPUBFUN long XMLCALL
xmlByteConsumed (xmlParserCtxtPtr ctxt);
/*
* New set of simpler/more flexible APIs
*/
/**
* xmlParserOption:
*
* This is the set of XML parser options that can be passed down
* to the xmlReadDoc() and similar calls.
*/
typedef enum {
XML_PARSE_RECOVER = 1<<0, /* recover on errors */
XML_PARSE_NOENT = 1<<1, /* substitute entities */
XML_PARSE_DTDLOAD = 1<<2, /* load the external subset */
XML_PARSE_DTDATTR = 1<<3, /* default DTD attributes */
XML_PARSE_DTDVALID = 1<<4, /* validate with the DTD */
XML_PARSE_NOERROR = 1<<5, /* suppress error reports */
XML_PARSE_NOWARNING = 1<<6, /* suppress warning reports */
XML_PARSE_PEDANTIC = 1<<7, /* pedantic error reporting */
XML_PARSE_NOBLANKS = 1<<8, /* remove blank nodes */
XML_PARSE_SAX1 = 1<<9, /* use the SAX1 interface internally */
XML_PARSE_XINCLUDE = 1<<10,/* Implement XInclude substitution */
XML_PARSE_NONET = 1<<11,/* Forbid network access */
XML_PARSE_NODICT = 1<<12,/* Do not reuse the context dictionary */
XML_PARSE_NSCLEAN = 1<<13,/* remove redundant namespaces declarations */
XML_PARSE_NOCDATA = 1<<14,/* merge CDATA as text nodes */
XML_PARSE_NOXINCNODE= 1<<15,/* do not generate XINCLUDE START/END nodes */
XML_PARSE_COMPACT = 1<<16,/* compact small text nodes; no modification of
the tree allowed afterwards (will possibly
crash if you try to modify the tree) */
XML_PARSE_OLD10 = 1<<17,/* parse using XML-1.0 before update 5 */
XML_PARSE_NOBASEFIX = 1<<18,/* do not fixup XINCLUDE xml:base uris */
XML_PARSE_HUGE = 1<<19,/* relax any hardcoded limit from the parser */
XML_PARSE_OLDSAX = 1<<20,/* parse using SAX2 interface before 2.7.0 */
XML_PARSE_IGNORE_ENC= 1<<21,/* ignore internal document encoding hint */
XML_PARSE_BIG_LINES = 1<<22 /* Store big lines numbers in text PSVI field */
} xmlParserOption;
XMLPUBFUN void XMLCALL
xmlCtxtReset (xmlParserCtxtPtr ctxt);
XMLPUBFUN int XMLCALL
xmlCtxtResetPush (xmlParserCtxtPtr ctxt,
const char *chunk,
int size,
const char *filename,
const char *encoding);
XMLPUBFUN int XMLCALL
xmlCtxtUseOptions (xmlParserCtxtPtr ctxt,
int options);
XMLPUBFUN xmlDocPtr XMLCALL
xmlReadDoc (const xmlChar *cur,
const char *URL,
const char *encoding,
int options);
XMLPUBFUN xmlDocPtr XMLCALL
xmlReadFile (const char *URL,
const char *encoding,
int options);
XMLPUBFUN xmlDocPtr XMLCALL
xmlReadMemory (const char *buffer,
int size,
const char *URL,
const char *encoding,
int options);
XMLPUBFUN xmlDocPtr XMLCALL
xmlReadFd (int fd,
const char *URL,
const char *encoding,
int options);
XMLPUBFUN xmlDocPtr XMLCALL
xmlReadIO (xmlInputReadCallback ioread,
xmlInputCloseCallback ioclose,
void *ioctx,
const char *URL,
const char *encoding,
int options);
XMLPUBFUN xmlDocPtr XMLCALL
xmlCtxtReadDoc (xmlParserCtxtPtr ctxt,
const xmlChar *cur,
const char *URL,
const char *encoding,
int options);
XMLPUBFUN xmlDocPtr XMLCALL
xmlCtxtReadFile (xmlParserCtxtPtr ctxt,
const char *filename,
const char *encoding,
int options);
XMLPUBFUN xmlDocPtr XMLCALL
xmlCtxtReadMemory (xmlParserCtxtPtr ctxt,
const char *buffer,
int size,
const char *URL,
const char *encoding,
int options);
XMLPUBFUN xmlDocPtr XMLCALL
xmlCtxtReadFd (xmlParserCtxtPtr ctxt,
int fd,
const char *URL,
const char *encoding,
int options);
XMLPUBFUN xmlDocPtr XMLCALL
xmlCtxtReadIO (xmlParserCtxtPtr ctxt,
xmlInputReadCallback ioread,
xmlInputCloseCallback ioclose,
void *ioctx,
const char *URL,
const char *encoding,
int options);
/*
* Library wide options
*/
/**
* xmlFeature:
*
* Used to examine the existence of features that can be enabled
* or disabled at compile-time.
* They used to be called XML_FEATURE_xxx but this clashed with Expat
*/
typedef enum {
XML_WITH_THREAD = 1,
XML_WITH_TREE = 2,
XML_WITH_OUTPUT = 3,
XML_WITH_PUSH = 4,
XML_WITH_READER = 5,
XML_WITH_PATTERN = 6,
XML_WITH_WRITER = 7,
XML_WITH_SAX1 = 8,
XML_WITH_FTP = 9,
XML_WITH_HTTP = 10,
XML_WITH_VALID = 11,
XML_WITH_HTML = 12,
XML_WITH_LEGACY = 13,
XML_WITH_C14N = 14,
XML_WITH_CATALOG = 15,
XML_WITH_XPATH = 16,
XML_WITH_XPTR = 17,
XML_WITH_XINCLUDE = 18,
XML_WITH_ICONV = 19,
XML_WITH_ISO8859X = 20,
XML_WITH_UNICODE = 21,
XML_WITH_REGEXP = 22,
XML_WITH_AUTOMATA = 23,
XML_WITH_EXPR = 24,
XML_WITH_SCHEMAS = 25,
XML_WITH_SCHEMATRON = 26,
XML_WITH_MODULES = 27,
XML_WITH_DEBUG = 28,
XML_WITH_DEBUG_MEM = 29,
XML_WITH_DEBUG_RUN = 30,
XML_WITH_ZLIB = 31,
XML_WITH_ICU = 32,
XML_WITH_LZMA = 33,
XML_WITH_NONE = 99999 /* just to be sure of allocation size */
} xmlFeature;
XMLPUBFUN int XMLCALL
xmlHasFeature (xmlFeature feature);
#ifdef __cplusplus
}
#endif
#endif /* __XML_PARSER_H__ */
/*
* Summary: Old SAX version 1 handler, deprecated
* Description: DEPRECATED set of SAX version 1 interfaces used to
* build the DOM tree.
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_SAX_H__
#define __XML_SAX_H__
#include <stdio.h>
#include <stdlib.h>
#include <libxml/xmlversion.h>
#include <libxml/parser.h>
#ifdef LIBXML_LEGACY_ENABLED
#ifdef __cplusplus
extern "C" {
#endif
XML_DEPRECATED
XMLPUBFUN const xmlChar * XMLCALL
getPublicId (void *ctx);
XML_DEPRECATED
XMLPUBFUN const xmlChar * XMLCALL
getSystemId (void *ctx);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
setDocumentLocator (void *ctx,
xmlSAXLocatorPtr loc);
XML_DEPRECATED
XMLPUBFUN int XMLCALL
getLineNumber (void *ctx);
XML_DEPRECATED
XMLPUBFUN int XMLCALL
getColumnNumber (void *ctx);
XML_DEPRECATED
XMLPUBFUN int XMLCALL
isStandalone (void *ctx);
XML_DEPRECATED
XMLPUBFUN int XMLCALL
hasInternalSubset (void *ctx);
XML_DEPRECATED
XMLPUBFUN int XMLCALL
hasExternalSubset (void *ctx);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
internalSubset (void *ctx,
const xmlChar *name,
const xmlChar *ExternalID,
const xmlChar *SystemID);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
externalSubset (void *ctx,
const xmlChar *name,
const xmlChar *ExternalID,
const xmlChar *SystemID);
XML_DEPRECATED
XMLPUBFUN xmlEntityPtr XMLCALL
getEntity (void *ctx,
const xmlChar *name);
XML_DEPRECATED
XMLPUBFUN xmlEntityPtr XMLCALL
getParameterEntity (void *ctx,
const xmlChar *name);
XML_DEPRECATED
XMLPUBFUN xmlParserInputPtr XMLCALL
resolveEntity (void *ctx,
const xmlChar *publicId,
const xmlChar *systemId);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
entityDecl (void *ctx,
const xmlChar *name,
int type,
const xmlChar *publicId,
const xmlChar *systemId,
xmlChar *content);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
attributeDecl (void *ctx,
const xmlChar *elem,
const xmlChar *fullname,
int type,
int def,
const xmlChar *defaultValue,
xmlEnumerationPtr tree);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
elementDecl (void *ctx,
const xmlChar *name,
int type,
xmlElementContentPtr content);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
notationDecl (void *ctx,
const xmlChar *name,
const xmlChar *publicId,
const xmlChar *systemId);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
unparsedEntityDecl (void *ctx,
const xmlChar *name,
const xmlChar *publicId,
const xmlChar *systemId,
const xmlChar *notationName);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
startDocument (void *ctx);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
endDocument (void *ctx);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
attribute (void *ctx,
const xmlChar *fullname,
const xmlChar *value);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
startElement (void *ctx,
const xmlChar *fullname,
const xmlChar **atts);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
endElement (void *ctx,
const xmlChar *name);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
reference (void *ctx,
const xmlChar *name);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
characters (void *ctx,
const xmlChar *ch,
int len);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
ignorableWhitespace (void *ctx,
const xmlChar *ch,
int len);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
processingInstruction (void *ctx,
const xmlChar *target,
const xmlChar *data);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
globalNamespace (void *ctx,
const xmlChar *href,
const xmlChar *prefix);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
setNamespace (void *ctx,
const xmlChar *name);
XML_DEPRECATED
XMLPUBFUN xmlNsPtr XMLCALL
getNamespace (void *ctx);
XML_DEPRECATED
XMLPUBFUN int XMLCALL
checkNamespace (void *ctx,
xmlChar *nameSpace);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
namespaceDecl (void *ctx,
const xmlChar *href,
const xmlChar *prefix);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
comment (void *ctx,
const xmlChar *value);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
cdataBlock (void *ctx,
const xmlChar *value,
int len);
#ifdef LIBXML_SAX1_ENABLED
XML_DEPRECATED
XMLPUBFUN void XMLCALL
initxmlDefaultSAXHandler (xmlSAXHandlerV1 *hdlr,
int warning);
#ifdef LIBXML_HTML_ENABLED
XML_DEPRECATED
XMLPUBFUN void XMLCALL
inithtmlDefaultSAXHandler (xmlSAXHandlerV1 *hdlr);
#endif
#endif /* LIBXML_SAX1_ENABLED */
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_LEGACY_ENABLED */
#endif /* __XML_SAX_H__ */
/*
* Summary: error handling
* Description: the API used to report errors
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#include <libxml/parser.h>
#ifndef __XML_ERROR_H__
#define __XML_ERROR_H__
#ifdef __cplusplus
extern "C" {
#endif
/**
* xmlErrorLevel:
*
* Indicates the level of an error
*/
typedef enum {
XML_ERR_NONE = 0,
XML_ERR_WARNING = 1, /* A simple warning */
XML_ERR_ERROR = 2, /* A recoverable error */
XML_ERR_FATAL = 3 /* A fatal error */
} xmlErrorLevel;
/**
* xmlErrorDomain:
*
* Indicates where an error may have come from
*/
typedef enum {
XML_FROM_NONE = 0,
XML_FROM_PARSER, /* The XML parser */
XML_FROM_TREE, /* The tree module */
XML_FROM_NAMESPACE, /* The XML Namespace module */
XML_FROM_DTD, /* The XML DTD validation with parser context*/
XML_FROM_HTML, /* The HTML parser */
XML_FROM_MEMORY, /* The memory allocator */
XML_FROM_OUTPUT, /* The serialization code */
XML_FROM_IO, /* The Input/Output stack */
XML_FROM_FTP, /* The FTP module */
XML_FROM_HTTP, /* The HTTP module */
XML_FROM_XINCLUDE, /* The XInclude processing */
XML_FROM_XPATH, /* The XPath module */
XML_FROM_XPOINTER, /* The XPointer module */
XML_FROM_REGEXP, /* The regular expressions module */
XML_FROM_DATATYPE, /* The W3C XML Schemas Datatype module */
XML_FROM_SCHEMASP, /* The W3C XML Schemas parser module */
XML_FROM_SCHEMASV, /* The W3C XML Schemas validation module */
XML_FROM_RELAXNGP, /* The Relax-NG parser module */
XML_FROM_RELAXNGV, /* The Relax-NG validator module */
XML_FROM_CATALOG, /* The Catalog module */
XML_FROM_C14N, /* The Canonicalization module */
XML_FROM_XSLT, /* The XSLT engine from libxslt */
XML_FROM_VALID, /* The XML DTD validation with valid context */
XML_FROM_CHECK, /* The error checking module */
XML_FROM_WRITER, /* The xmlwriter module */
XML_FROM_MODULE, /* The dynamically loaded module module*/
XML_FROM_I18N, /* The module handling character conversion */
XML_FROM_SCHEMATRONV,/* The Schematron validator module */
XML_FROM_BUFFER, /* The buffers module */
XML_FROM_URI /* The URI module */
} xmlErrorDomain;
/**
* xmlError:
*
* An XML Error instance.
*/
typedef struct _xmlError xmlError;
typedef xmlError *xmlErrorPtr;
struct _xmlError {
int domain; /* What part of the library raised this error */
int code; /* The error code, e.g. an xmlParserError */
char *message;/* human-readable informative error message */
xmlErrorLevel level;/* how consequent is the error */
char *file; /* the filename */
int line; /* the line number if available */
char *str1; /* extra string information */
char *str2; /* extra string information */
char *str3; /* extra string information */
int int1; /* extra number information */
int int2; /* error column # or 0 if N/A (todo: rename field when we would brk ABI) */
void *ctxt; /* the parser context if available */
void *node; /* the node in the tree */
};
/**
* xmlParserError:
*
* This is an error that the XML (or HTML) parser can generate
*/
typedef enum {
XML_ERR_OK = 0,
XML_ERR_INTERNAL_ERROR, /* 1 */
XML_ERR_NO_MEMORY, /* 2 */
XML_ERR_DOCUMENT_START, /* 3 */
XML_ERR_DOCUMENT_EMPTY, /* 4 */
XML_ERR_DOCUMENT_END, /* 5 */
XML_ERR_INVALID_HEX_CHARREF, /* 6 */
XML_ERR_INVALID_DEC_CHARREF, /* 7 */
XML_ERR_INVALID_CHARREF, /* 8 */
XML_ERR_INVALID_CHAR, /* 9 */
XML_ERR_CHARREF_AT_EOF, /* 10 */
XML_ERR_CHARREF_IN_PROLOG, /* 11 */
XML_ERR_CHARREF_IN_EPILOG, /* 12 */
XML_ERR_CHARREF_IN_DTD, /* 13 */
XML_ERR_ENTITYREF_AT_EOF, /* 14 */
XML_ERR_ENTITYREF_IN_PROLOG, /* 15 */
XML_ERR_ENTITYREF_IN_EPILOG, /* 16 */
XML_ERR_ENTITYREF_IN_DTD, /* 17 */
XML_ERR_PEREF_AT_EOF, /* 18 */
XML_ERR_PEREF_IN_PROLOG, /* 19 */
XML_ERR_PEREF_IN_EPILOG, /* 20 */
XML_ERR_PEREF_IN_INT_SUBSET, /* 21 */
XML_ERR_ENTITYREF_NO_NAME, /* 22 */
XML_ERR_ENTITYREF_SEMICOL_MISSING, /* 23 */
XML_ERR_PEREF_NO_NAME, /* 24 */
XML_ERR_PEREF_SEMICOL_MISSING, /* 25 */
XML_ERR_UNDECLARED_ENTITY, /* 26 */
XML_WAR_UNDECLARED_ENTITY, /* 27 */
XML_ERR_UNPARSED_ENTITY, /* 28 */
XML_ERR_ENTITY_IS_EXTERNAL, /* 29 */
XML_ERR_ENTITY_IS_PARAMETER, /* 30 */
XML_ERR_UNKNOWN_ENCODING, /* 31 */
XML_ERR_UNSUPPORTED_ENCODING, /* 32 */
XML_ERR_STRING_NOT_STARTED, /* 33 */
XML_ERR_STRING_NOT_CLOSED, /* 34 */
XML_ERR_NS_DECL_ERROR, /* 35 */
XML_ERR_ENTITY_NOT_STARTED, /* 36 */
XML_ERR_ENTITY_NOT_FINISHED, /* 37 */
XML_ERR_LT_IN_ATTRIBUTE, /* 38 */
XML_ERR_ATTRIBUTE_NOT_STARTED, /* 39 */
XML_ERR_ATTRIBUTE_NOT_FINISHED, /* 40 */
XML_ERR_ATTRIBUTE_WITHOUT_VALUE, /* 41 */
XML_ERR_ATTRIBUTE_REDEFINED, /* 42 */
XML_ERR_LITERAL_NOT_STARTED, /* 43 */
XML_ERR_LITERAL_NOT_FINISHED, /* 44 */
XML_ERR_COMMENT_NOT_FINISHED, /* 45 */
XML_ERR_PI_NOT_STARTED, /* 46 */
XML_ERR_PI_NOT_FINISHED, /* 47 */
XML_ERR_NOTATION_NOT_STARTED, /* 48 */
XML_ERR_NOTATION_NOT_FINISHED, /* 49 */
XML_ERR_ATTLIST_NOT_STARTED, /* 50 */
XML_ERR_ATTLIST_NOT_FINISHED, /* 51 */
XML_ERR_MIXED_NOT_STARTED, /* 52 */
XML_ERR_MIXED_NOT_FINISHED, /* 53 */
XML_ERR_ELEMCONTENT_NOT_STARTED, /* 54 */
XML_ERR_ELEMCONTENT_NOT_FINISHED, /* 55 */
XML_ERR_XMLDECL_NOT_STARTED, /* 56 */
XML_ERR_XMLDECL_NOT_FINISHED, /* 57 */
XML_ERR_CONDSEC_NOT_STARTED, /* 58 */
XML_ERR_CONDSEC_NOT_FINISHED, /* 59 */
XML_ERR_EXT_SUBSET_NOT_FINISHED, /* 60 */
XML_ERR_DOCTYPE_NOT_FINISHED, /* 61 */
XML_ERR_MISPLACED_CDATA_END, /* 62 */
XML_ERR_CDATA_NOT_FINISHED, /* 63 */
XML_ERR_RESERVED_XML_NAME, /* 64 */
XML_ERR_SPACE_REQUIRED, /* 65 */
XML_ERR_SEPARATOR_REQUIRED, /* 66 */
XML_ERR_NMTOKEN_REQUIRED, /* 67 */
XML_ERR_NAME_REQUIRED, /* 68 */
XML_ERR_PCDATA_REQUIRED, /* 69 */
XML_ERR_URI_REQUIRED, /* 70 */
XML_ERR_PUBID_REQUIRED, /* 71 */
XML_ERR_LT_REQUIRED, /* 72 */
XML_ERR_GT_REQUIRED, /* 73 */
XML_ERR_LTSLASH_REQUIRED, /* 74 */
XML_ERR_EQUAL_REQUIRED, /* 75 */
XML_ERR_TAG_NAME_MISMATCH, /* 76 */
XML_ERR_TAG_NOT_FINISHED, /* 77 */
XML_ERR_STANDALONE_VALUE, /* 78 */
XML_ERR_ENCODING_NAME, /* 79 */
XML_ERR_HYPHEN_IN_COMMENT, /* 80 */
XML_ERR_INVALID_ENCODING, /* 81 */
XML_ERR_EXT_ENTITY_STANDALONE, /* 82 */
XML_ERR_CONDSEC_INVALID, /* 83 */
XML_ERR_VALUE_REQUIRED, /* 84 */
XML_ERR_NOT_WELL_BALANCED, /* 85 */
XML_ERR_EXTRA_CONTENT, /* 86 */
XML_ERR_ENTITY_CHAR_ERROR, /* 87 */
XML_ERR_ENTITY_PE_INTERNAL, /* 88 */
XML_ERR_ENTITY_LOOP, /* 89 */
XML_ERR_ENTITY_BOUNDARY, /* 90 */
XML_ERR_INVALID_URI, /* 91 */
XML_ERR_URI_FRAGMENT, /* 92 */
XML_WAR_CATALOG_PI, /* 93 */
XML_ERR_NO_DTD, /* 94 */
XML_ERR_CONDSEC_INVALID_KEYWORD, /* 95 */
XML_ERR_VERSION_MISSING, /* 96 */
XML_WAR_UNKNOWN_VERSION, /* 97 */
XML_WAR_LANG_VALUE, /* 98 */
XML_WAR_NS_URI, /* 99 */
XML_WAR_NS_URI_RELATIVE, /* 100 */
XML_ERR_MISSING_ENCODING, /* 101 */
XML_WAR_SPACE_VALUE, /* 102 */
XML_ERR_NOT_STANDALONE, /* 103 */
XML_ERR_ENTITY_PROCESSING, /* 104 */
XML_ERR_NOTATION_PROCESSING, /* 105 */
XML_WAR_NS_COLUMN, /* 106 */
XML_WAR_ENTITY_REDEFINED, /* 107 */
XML_ERR_UNKNOWN_VERSION, /* 108 */
XML_ERR_VERSION_MISMATCH, /* 109 */
XML_ERR_NAME_TOO_LONG, /* 110 */
XML_ERR_USER_STOP, /* 111 */
XML_ERR_COMMENT_ABRUPTLY_ENDED, /* 112 */
XML_NS_ERR_XML_NAMESPACE = 200,
XML_NS_ERR_UNDEFINED_NAMESPACE, /* 201 */
XML_NS_ERR_QNAME, /* 202 */
XML_NS_ERR_ATTRIBUTE_REDEFINED, /* 203 */
XML_NS_ERR_EMPTY, /* 204 */
XML_NS_ERR_COLON, /* 205 */
XML_DTD_ATTRIBUTE_DEFAULT = 500,
XML_DTD_ATTRIBUTE_REDEFINED, /* 501 */
XML_DTD_ATTRIBUTE_VALUE, /* 502 */
XML_DTD_CONTENT_ERROR, /* 503 */
XML_DTD_CONTENT_MODEL, /* 504 */
XML_DTD_CONTENT_NOT_DETERMINIST, /* 505 */
XML_DTD_DIFFERENT_PREFIX, /* 506 */
XML_DTD_ELEM_DEFAULT_NAMESPACE, /* 507 */
XML_DTD_ELEM_NAMESPACE, /* 508 */
XML_DTD_ELEM_REDEFINED, /* 509 */
XML_DTD_EMPTY_NOTATION, /* 510 */
XML_DTD_ENTITY_TYPE, /* 511 */
XML_DTD_ID_FIXED, /* 512 */
XML_DTD_ID_REDEFINED, /* 513 */
XML_DTD_ID_SUBSET, /* 514 */
XML_DTD_INVALID_CHILD, /* 515 */
XML_DTD_INVALID_DEFAULT, /* 516 */
XML_DTD_LOAD_ERROR, /* 517 */
XML_DTD_MISSING_ATTRIBUTE, /* 518 */
XML_DTD_MIXED_CORRUPT, /* 519 */
XML_DTD_MULTIPLE_ID, /* 520 */
XML_DTD_NO_DOC, /* 521 */
XML_DTD_NO_DTD, /* 522 */
XML_DTD_NO_ELEM_NAME, /* 523 */
XML_DTD_NO_PREFIX, /* 524 */
XML_DTD_NO_ROOT, /* 525 */
XML_DTD_NOTATION_REDEFINED, /* 526 */
XML_DTD_NOTATION_VALUE, /* 527 */
XML_DTD_NOT_EMPTY, /* 528 */
XML_DTD_NOT_PCDATA, /* 529 */
XML_DTD_NOT_STANDALONE, /* 530 */
XML_DTD_ROOT_NAME, /* 531 */
XML_DTD_STANDALONE_WHITE_SPACE, /* 532 */
XML_DTD_UNKNOWN_ATTRIBUTE, /* 533 */
XML_DTD_UNKNOWN_ELEM, /* 534 */
XML_DTD_UNKNOWN_ENTITY, /* 535 */
XML_DTD_UNKNOWN_ID, /* 536 */
XML_DTD_UNKNOWN_NOTATION, /* 537 */
XML_DTD_STANDALONE_DEFAULTED, /* 538 */
XML_DTD_XMLID_VALUE, /* 539 */
XML_DTD_XMLID_TYPE, /* 540 */
XML_DTD_DUP_TOKEN, /* 541 */
XML_HTML_STRUCURE_ERROR = 800,
XML_HTML_UNKNOWN_TAG, /* 801 */
XML_HTML_INCORRECTLY_OPENED_COMMENT, /* 802 */
XML_RNGP_ANYNAME_ATTR_ANCESTOR = 1000,
XML_RNGP_ATTR_CONFLICT, /* 1001 */
XML_RNGP_ATTRIBUTE_CHILDREN, /* 1002 */
XML_RNGP_ATTRIBUTE_CONTENT, /* 1003 */
XML_RNGP_ATTRIBUTE_EMPTY, /* 1004 */
XML_RNGP_ATTRIBUTE_NOOP, /* 1005 */
XML_RNGP_CHOICE_CONTENT, /* 1006 */
XML_RNGP_CHOICE_EMPTY, /* 1007 */
XML_RNGP_CREATE_FAILURE, /* 1008 */
XML_RNGP_DATA_CONTENT, /* 1009 */
XML_RNGP_DEF_CHOICE_AND_INTERLEAVE, /* 1010 */
XML_RNGP_DEFINE_CREATE_FAILED, /* 1011 */
XML_RNGP_DEFINE_EMPTY, /* 1012 */
XML_RNGP_DEFINE_MISSING, /* 1013 */
XML_RNGP_DEFINE_NAME_MISSING, /* 1014 */
XML_RNGP_ELEM_CONTENT_EMPTY, /* 1015 */
XML_RNGP_ELEM_CONTENT_ERROR, /* 1016 */
XML_RNGP_ELEMENT_EMPTY, /* 1017 */
XML_RNGP_ELEMENT_CONTENT, /* 1018 */
XML_RNGP_ELEMENT_NAME, /* 1019 */
XML_RNGP_ELEMENT_NO_CONTENT, /* 1020 */
XML_RNGP_ELEM_TEXT_CONFLICT, /* 1021 */
XML_RNGP_EMPTY, /* 1022 */
XML_RNGP_EMPTY_CONSTRUCT, /* 1023 */
XML_RNGP_EMPTY_CONTENT, /* 1024 */
XML_RNGP_EMPTY_NOT_EMPTY, /* 1025 */
XML_RNGP_ERROR_TYPE_LIB, /* 1026 */
XML_RNGP_EXCEPT_EMPTY, /* 1027 */
XML_RNGP_EXCEPT_MISSING, /* 1028 */
XML_RNGP_EXCEPT_MULTIPLE, /* 1029 */
XML_RNGP_EXCEPT_NO_CONTENT, /* 1030 */
XML_RNGP_EXTERNALREF_EMTPY, /* 1031 */
XML_RNGP_EXTERNAL_REF_FAILURE, /* 1032 */
XML_RNGP_EXTERNALREF_RECURSE, /* 1033 */
XML_RNGP_FORBIDDEN_ATTRIBUTE, /* 1034 */
XML_RNGP_FOREIGN_ELEMENT, /* 1035 */
XML_RNGP_GRAMMAR_CONTENT, /* 1036 */
XML_RNGP_GRAMMAR_EMPTY, /* 1037 */
XML_RNGP_GRAMMAR_MISSING, /* 1038 */
XML_RNGP_GRAMMAR_NO_START, /* 1039 */
XML_RNGP_GROUP_ATTR_CONFLICT, /* 1040 */
XML_RNGP_HREF_ERROR, /* 1041 */
XML_RNGP_INCLUDE_EMPTY, /* 1042 */
XML_RNGP_INCLUDE_FAILURE, /* 1043 */
XML_RNGP_INCLUDE_RECURSE, /* 1044 */
XML_RNGP_INTERLEAVE_ADD, /* 1045 */
XML_RNGP_INTERLEAVE_CREATE_FAILED, /* 1046 */
XML_RNGP_INTERLEAVE_EMPTY, /* 1047 */
XML_RNGP_INTERLEAVE_NO_CONTENT, /* 1048 */
XML_RNGP_INVALID_DEFINE_NAME, /* 1049 */
XML_RNGP_INVALID_URI, /* 1050 */
XML_RNGP_INVALID_VALUE, /* 1051 */
XML_RNGP_MISSING_HREF, /* 1052 */
XML_RNGP_NAME_MISSING, /* 1053 */
XML_RNGP_NEED_COMBINE, /* 1054 */
XML_RNGP_NOTALLOWED_NOT_EMPTY, /* 1055 */
XML_RNGP_NSNAME_ATTR_ANCESTOR, /* 1056 */
XML_RNGP_NSNAME_NO_NS, /* 1057 */
XML_RNGP_PARAM_FORBIDDEN, /* 1058 */
XML_RNGP_PARAM_NAME_MISSING, /* 1059 */
XML_RNGP_PARENTREF_CREATE_FAILED, /* 1060 */
XML_RNGP_PARENTREF_NAME_INVALID, /* 1061 */
XML_RNGP_PARENTREF_NO_NAME, /* 1062 */
XML_RNGP_PARENTREF_NO_PARENT, /* 1063 */
XML_RNGP_PARENTREF_NOT_EMPTY, /* 1064 */
XML_RNGP_PARSE_ERROR, /* 1065 */
XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME, /* 1066 */
XML_RNGP_PAT_ATTR_ATTR, /* 1067 */
XML_RNGP_PAT_ATTR_ELEM, /* 1068 */
XML_RNGP_PAT_DATA_EXCEPT_ATTR, /* 1069 */
XML_RNGP_PAT_DATA_EXCEPT_ELEM, /* 1070 */
XML_RNGP_PAT_DATA_EXCEPT_EMPTY, /* 1071 */
XML_RNGP_PAT_DATA_EXCEPT_GROUP, /* 1072 */
XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE, /* 1073 */
XML_RNGP_PAT_DATA_EXCEPT_LIST, /* 1074 */
XML_RNGP_PAT_DATA_EXCEPT_ONEMORE, /* 1075 */
XML_RNGP_PAT_DATA_EXCEPT_REF, /* 1076 */
XML_RNGP_PAT_DATA_EXCEPT_TEXT, /* 1077 */
XML_RNGP_PAT_LIST_ATTR, /* 1078 */
XML_RNGP_PAT_LIST_ELEM, /* 1079 */
XML_RNGP_PAT_LIST_INTERLEAVE, /* 1080 */
XML_RNGP_PAT_LIST_LIST, /* 1081 */
XML_RNGP_PAT_LIST_REF, /* 1082 */
XML_RNGP_PAT_LIST_TEXT, /* 1083 */
XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME, /* 1084 */
XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME, /* 1085 */
XML_RNGP_PAT_ONEMORE_GROUP_ATTR, /* 1086 */
XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR, /* 1087 */
XML_RNGP_PAT_START_ATTR, /* 1088 */
XML_RNGP_PAT_START_DATA, /* 1089 */
XML_RNGP_PAT_START_EMPTY, /* 1090 */
XML_RNGP_PAT_START_GROUP, /* 1091 */
XML_RNGP_PAT_START_INTERLEAVE, /* 1092 */
XML_RNGP_PAT_START_LIST, /* 1093 */
XML_RNGP_PAT_START_ONEMORE, /* 1094 */
XML_RNGP_PAT_START_TEXT, /* 1095 */
XML_RNGP_PAT_START_VALUE, /* 1096 */
XML_RNGP_PREFIX_UNDEFINED, /* 1097 */
XML_RNGP_REF_CREATE_FAILED, /* 1098 */
XML_RNGP_REF_CYCLE, /* 1099 */
XML_RNGP_REF_NAME_INVALID, /* 1100 */
XML_RNGP_REF_NO_DEF, /* 1101 */
XML_RNGP_REF_NO_NAME, /* 1102 */
XML_RNGP_REF_NOT_EMPTY, /* 1103 */
XML_RNGP_START_CHOICE_AND_INTERLEAVE, /* 1104 */
XML_RNGP_START_CONTENT, /* 1105 */
XML_RNGP_START_EMPTY, /* 1106 */
XML_RNGP_START_MISSING, /* 1107 */
XML_RNGP_TEXT_EXPECTED, /* 1108 */
XML_RNGP_TEXT_HAS_CHILD, /* 1109 */
XML_RNGP_TYPE_MISSING, /* 1110 */
XML_RNGP_TYPE_NOT_FOUND, /* 1111 */
XML_RNGP_TYPE_VALUE, /* 1112 */
XML_RNGP_UNKNOWN_ATTRIBUTE, /* 1113 */
XML_RNGP_UNKNOWN_COMBINE, /* 1114 */
XML_RNGP_UNKNOWN_CONSTRUCT, /* 1115 */
XML_RNGP_UNKNOWN_TYPE_LIB, /* 1116 */
XML_RNGP_URI_FRAGMENT, /* 1117 */
XML_RNGP_URI_NOT_ABSOLUTE, /* 1118 */
XML_RNGP_VALUE_EMPTY, /* 1119 */
XML_RNGP_VALUE_NO_CONTENT, /* 1120 */
XML_RNGP_XMLNS_NAME, /* 1121 */
XML_RNGP_XML_NS, /* 1122 */
XML_XPATH_EXPRESSION_OK = 1200,
XML_XPATH_NUMBER_ERROR, /* 1201 */
XML_XPATH_UNFINISHED_LITERAL_ERROR, /* 1202 */
XML_XPATH_START_LITERAL_ERROR, /* 1203 */
XML_XPATH_VARIABLE_REF_ERROR, /* 1204 */
XML_XPATH_UNDEF_VARIABLE_ERROR, /* 1205 */
XML_XPATH_INVALID_PREDICATE_ERROR, /* 1206 */
XML_XPATH_EXPR_ERROR, /* 1207 */
XML_XPATH_UNCLOSED_ERROR, /* 1208 */
XML_XPATH_UNKNOWN_FUNC_ERROR, /* 1209 */
XML_XPATH_INVALID_OPERAND, /* 1210 */
XML_XPATH_INVALID_TYPE, /* 1211 */
XML_XPATH_INVALID_ARITY, /* 1212 */
XML_XPATH_INVALID_CTXT_SIZE, /* 1213 */
XML_XPATH_INVALID_CTXT_POSITION, /* 1214 */
XML_XPATH_MEMORY_ERROR, /* 1215 */
XML_XPTR_SYNTAX_ERROR, /* 1216 */
XML_XPTR_RESOURCE_ERROR, /* 1217 */
XML_XPTR_SUB_RESOURCE_ERROR, /* 1218 */
XML_XPATH_UNDEF_PREFIX_ERROR, /* 1219 */
XML_XPATH_ENCODING_ERROR, /* 1220 */
XML_XPATH_INVALID_CHAR_ERROR, /* 1221 */
XML_TREE_INVALID_HEX = 1300,
XML_TREE_INVALID_DEC, /* 1301 */
XML_TREE_UNTERMINATED_ENTITY, /* 1302 */
XML_TREE_NOT_UTF8, /* 1303 */
XML_SAVE_NOT_UTF8 = 1400,
XML_SAVE_CHAR_INVALID, /* 1401 */
XML_SAVE_NO_DOCTYPE, /* 1402 */
XML_SAVE_UNKNOWN_ENCODING, /* 1403 */
XML_REGEXP_COMPILE_ERROR = 1450,
XML_IO_UNKNOWN = 1500,
XML_IO_EACCES, /* 1501 */
XML_IO_EAGAIN, /* 1502 */
XML_IO_EBADF, /* 1503 */
XML_IO_EBADMSG, /* 1504 */
XML_IO_EBUSY, /* 1505 */
XML_IO_ECANCELED, /* 1506 */
XML_IO_ECHILD, /* 1507 */
XML_IO_EDEADLK, /* 1508 */
XML_IO_EDOM, /* 1509 */
XML_IO_EEXIST, /* 1510 */
XML_IO_EFAULT, /* 1511 */
XML_IO_EFBIG, /* 1512 */
XML_IO_EINPROGRESS, /* 1513 */
XML_IO_EINTR, /* 1514 */
XML_IO_EINVAL, /* 1515 */
XML_IO_EIO, /* 1516 */
XML_IO_EISDIR, /* 1517 */
XML_IO_EMFILE, /* 1518 */
XML_IO_EMLINK, /* 1519 */
XML_IO_EMSGSIZE, /* 1520 */
XML_IO_ENAMETOOLONG, /* 1521 */
XML_IO_ENFILE, /* 1522 */
XML_IO_ENODEV, /* 1523 */
XML_IO_ENOENT, /* 1524 */
XML_IO_ENOEXEC, /* 1525 */
XML_IO_ENOLCK, /* 1526 */
XML_IO_ENOMEM, /* 1527 */
XML_IO_ENOSPC, /* 1528 */
XML_IO_ENOSYS, /* 1529 */
XML_IO_ENOTDIR, /* 1530 */
XML_IO_ENOTEMPTY, /* 1531 */
XML_IO_ENOTSUP, /* 1532 */
XML_IO_ENOTTY, /* 1533 */
XML_IO_ENXIO, /* 1534 */
XML_IO_EPERM, /* 1535 */
XML_IO_EPIPE, /* 1536 */
XML_IO_ERANGE, /* 1537 */
XML_IO_EROFS, /* 1538 */
XML_IO_ESPIPE, /* 1539 */
XML_IO_ESRCH, /* 1540 */
XML_IO_ETIMEDOUT, /* 1541 */
XML_IO_EXDEV, /* 1542 */
XML_IO_NETWORK_ATTEMPT, /* 1543 */
XML_IO_ENCODER, /* 1544 */
XML_IO_FLUSH, /* 1545 */
XML_IO_WRITE, /* 1546 */
XML_IO_NO_INPUT, /* 1547 */
XML_IO_BUFFER_FULL, /* 1548 */
XML_IO_LOAD_ERROR, /* 1549 */
XML_IO_ENOTSOCK, /* 1550 */
XML_IO_EISCONN, /* 1551 */
XML_IO_ECONNREFUSED, /* 1552 */
XML_IO_ENETUNREACH, /* 1553 */
XML_IO_EADDRINUSE, /* 1554 */
XML_IO_EALREADY, /* 1555 */
XML_IO_EAFNOSUPPORT, /* 1556 */
XML_XINCLUDE_RECURSION=1600,
XML_XINCLUDE_PARSE_VALUE, /* 1601 */
XML_XINCLUDE_ENTITY_DEF_MISMATCH, /* 1602 */
XML_XINCLUDE_NO_HREF, /* 1603 */
XML_XINCLUDE_NO_FALLBACK, /* 1604 */
XML_XINCLUDE_HREF_URI, /* 1605 */
XML_XINCLUDE_TEXT_FRAGMENT, /* 1606 */
XML_XINCLUDE_TEXT_DOCUMENT, /* 1607 */
XML_XINCLUDE_INVALID_CHAR, /* 1608 */
XML_XINCLUDE_BUILD_FAILED, /* 1609 */
XML_XINCLUDE_UNKNOWN_ENCODING, /* 1610 */
XML_XINCLUDE_MULTIPLE_ROOT, /* 1611 */
XML_XINCLUDE_XPTR_FAILED, /* 1612 */
XML_XINCLUDE_XPTR_RESULT, /* 1613 */
XML_XINCLUDE_INCLUDE_IN_INCLUDE, /* 1614 */
XML_XINCLUDE_FALLBACKS_IN_INCLUDE, /* 1615 */
XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE, /* 1616 */
XML_XINCLUDE_DEPRECATED_NS, /* 1617 */
XML_XINCLUDE_FRAGMENT_ID, /* 1618 */
XML_CATALOG_MISSING_ATTR = 1650,
XML_CATALOG_ENTRY_BROKEN, /* 1651 */
XML_CATALOG_PREFER_VALUE, /* 1652 */
XML_CATALOG_NOT_CATALOG, /* 1653 */
XML_CATALOG_RECURSION, /* 1654 */
XML_SCHEMAP_PREFIX_UNDEFINED = 1700,
XML_SCHEMAP_ATTRFORMDEFAULT_VALUE, /* 1701 */
XML_SCHEMAP_ATTRGRP_NONAME_NOREF, /* 1702 */
XML_SCHEMAP_ATTR_NONAME_NOREF, /* 1703 */
XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF, /* 1704 */
XML_SCHEMAP_ELEMFORMDEFAULT_VALUE, /* 1705 */
XML_SCHEMAP_ELEM_NONAME_NOREF, /* 1706 */
XML_SCHEMAP_EXTENSION_NO_BASE, /* 1707 */
XML_SCHEMAP_FACET_NO_VALUE, /* 1708 */
XML_SCHEMAP_FAILED_BUILD_IMPORT, /* 1709 */
XML_SCHEMAP_GROUP_NONAME_NOREF, /* 1710 */
XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI, /* 1711 */
XML_SCHEMAP_IMPORT_REDEFINE_NSNAME, /* 1712 */
XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI, /* 1713 */
XML_SCHEMAP_INVALID_BOOLEAN, /* 1714 */
XML_SCHEMAP_INVALID_ENUM, /* 1715 */
XML_SCHEMAP_INVALID_FACET, /* 1716 */
XML_SCHEMAP_INVALID_FACET_VALUE, /* 1717 */
XML_SCHEMAP_INVALID_MAXOCCURS, /* 1718 */
XML_SCHEMAP_INVALID_MINOCCURS, /* 1719 */
XML_SCHEMAP_INVALID_REF_AND_SUBTYPE, /* 1720 */
XML_SCHEMAP_INVALID_WHITE_SPACE, /* 1721 */
XML_SCHEMAP_NOATTR_NOREF, /* 1722 */
XML_SCHEMAP_NOTATION_NO_NAME, /* 1723 */
XML_SCHEMAP_NOTYPE_NOREF, /* 1724 */
XML_SCHEMAP_REF_AND_SUBTYPE, /* 1725 */
XML_SCHEMAP_RESTRICTION_NONAME_NOREF, /* 1726 */
XML_SCHEMAP_SIMPLETYPE_NONAME, /* 1727 */
XML_SCHEMAP_TYPE_AND_SUBTYPE, /* 1728 */
XML_SCHEMAP_UNKNOWN_ALL_CHILD, /* 1729 */
XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD, /* 1730 */
XML_SCHEMAP_UNKNOWN_ATTR_CHILD, /* 1731 */
XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD, /* 1732 */
XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP, /* 1733 */
XML_SCHEMAP_UNKNOWN_BASE_TYPE, /* 1734 */
XML_SCHEMAP_UNKNOWN_CHOICE_CHILD, /* 1735 */
XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD, /* 1736 */
XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD, /* 1737 */
XML_SCHEMAP_UNKNOWN_ELEM_CHILD, /* 1738 */
XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD, /* 1739 */
XML_SCHEMAP_UNKNOWN_FACET_CHILD, /* 1740 */
XML_SCHEMAP_UNKNOWN_FACET_TYPE, /* 1741 */
XML_SCHEMAP_UNKNOWN_GROUP_CHILD, /* 1742 */
XML_SCHEMAP_UNKNOWN_IMPORT_CHILD, /* 1743 */
XML_SCHEMAP_UNKNOWN_LIST_CHILD, /* 1744 */
XML_SCHEMAP_UNKNOWN_NOTATION_CHILD, /* 1745 */
XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD, /* 1746 */
XML_SCHEMAP_UNKNOWN_REF, /* 1747 */
XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD, /* 1748 */
XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD, /* 1749 */
XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD, /* 1750 */
XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD, /* 1751 */
XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD, /* 1752 */
XML_SCHEMAP_UNKNOWN_TYPE, /* 1753 */
XML_SCHEMAP_UNKNOWN_UNION_CHILD, /* 1754 */
XML_SCHEMAP_ELEM_DEFAULT_FIXED, /* 1755 */
XML_SCHEMAP_REGEXP_INVALID, /* 1756 */
XML_SCHEMAP_FAILED_LOAD, /* 1757 */
XML_SCHEMAP_NOTHING_TO_PARSE, /* 1758 */
XML_SCHEMAP_NOROOT, /* 1759 */
XML_SCHEMAP_REDEFINED_GROUP, /* 1760 */
XML_SCHEMAP_REDEFINED_TYPE, /* 1761 */
XML_SCHEMAP_REDEFINED_ELEMENT, /* 1762 */
XML_SCHEMAP_REDEFINED_ATTRGROUP, /* 1763 */
XML_SCHEMAP_REDEFINED_ATTR, /* 1764 */
XML_SCHEMAP_REDEFINED_NOTATION, /* 1765 */
XML_SCHEMAP_FAILED_PARSE, /* 1766 */
XML_SCHEMAP_UNKNOWN_PREFIX, /* 1767 */
XML_SCHEMAP_DEF_AND_PREFIX, /* 1768 */
XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD, /* 1769 */
XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI, /* 1770 */
XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI, /* 1771 */
XML_SCHEMAP_NOT_SCHEMA, /* 1772 */
XML_SCHEMAP_UNKNOWN_MEMBER_TYPE, /* 1773 */
XML_SCHEMAP_INVALID_ATTR_USE, /* 1774 */
XML_SCHEMAP_RECURSIVE, /* 1775 */
XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE, /* 1776 */
XML_SCHEMAP_INVALID_ATTR_COMBINATION, /* 1777 */
XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION, /* 1778 */
XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD, /* 1779 */
XML_SCHEMAP_INVALID_ATTR_NAME, /* 1780 */
XML_SCHEMAP_REF_AND_CONTENT, /* 1781 */
XML_SCHEMAP_CT_PROPS_CORRECT_1, /* 1782 */
XML_SCHEMAP_CT_PROPS_CORRECT_2, /* 1783 */
XML_SCHEMAP_CT_PROPS_CORRECT_3, /* 1784 */
XML_SCHEMAP_CT_PROPS_CORRECT_4, /* 1785 */
XML_SCHEMAP_CT_PROPS_CORRECT_5, /* 1786 */
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1, /* 1787 */
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1, /* 1788 */
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2, /* 1789 */
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2, /* 1790 */
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3, /* 1791 */
XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER, /* 1792 */
XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE, /* 1793 */
XML_SCHEMAP_UNION_NOT_EXPRESSIBLE, /* 1794 */
XML_SCHEMAP_SRC_IMPORT_3_1, /* 1795 */
XML_SCHEMAP_SRC_IMPORT_3_2, /* 1796 */
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1, /* 1797 */
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2, /* 1798 */
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3, /* 1799 */
XML_SCHEMAP_COS_CT_EXTENDS_1_3, /* 1800 */
XML_SCHEMAV_NOROOT = 1801,
XML_SCHEMAV_UNDECLAREDELEM, /* 1802 */
XML_SCHEMAV_NOTTOPLEVEL, /* 1803 */
XML_SCHEMAV_MISSING, /* 1804 */
XML_SCHEMAV_WRONGELEM, /* 1805 */
XML_SCHEMAV_NOTYPE, /* 1806 */
XML_SCHEMAV_NOROLLBACK, /* 1807 */
XML_SCHEMAV_ISABSTRACT, /* 1808 */
XML_SCHEMAV_NOTEMPTY, /* 1809 */
XML_SCHEMAV_ELEMCONT, /* 1810 */
XML_SCHEMAV_HAVEDEFAULT, /* 1811 */
XML_SCHEMAV_NOTNILLABLE, /* 1812 */
XML_SCHEMAV_EXTRACONTENT, /* 1813 */
XML_SCHEMAV_INVALIDATTR, /* 1814 */
XML_SCHEMAV_INVALIDELEM, /* 1815 */
XML_SCHEMAV_NOTDETERMINIST, /* 1816 */
XML_SCHEMAV_CONSTRUCT, /* 1817 */
XML_SCHEMAV_INTERNAL, /* 1818 */
XML_SCHEMAV_NOTSIMPLE, /* 1819 */
XML_SCHEMAV_ATTRUNKNOWN, /* 1820 */
XML_SCHEMAV_ATTRINVALID, /* 1821 */
XML_SCHEMAV_VALUE, /* 1822 */
XML_SCHEMAV_FACET, /* 1823 */
XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1, /* 1824 */
XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2, /* 1825 */
XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3, /* 1826 */
XML_SCHEMAV_CVC_TYPE_3_1_1, /* 1827 */
XML_SCHEMAV_CVC_TYPE_3_1_2, /* 1828 */
XML_SCHEMAV_CVC_FACET_VALID, /* 1829 */
XML_SCHEMAV_CVC_LENGTH_VALID, /* 1830 */
XML_SCHEMAV_CVC_MINLENGTH_VALID, /* 1831 */
XML_SCHEMAV_CVC_MAXLENGTH_VALID, /* 1832 */
XML_SCHEMAV_CVC_MININCLUSIVE_VALID, /* 1833 */
XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID, /* 1834 */
XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID, /* 1835 */
XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID, /* 1836 */
XML_SCHEMAV_CVC_TOTALDIGITS_VALID, /* 1837 */
XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID, /* 1838 */
XML_SCHEMAV_CVC_PATTERN_VALID, /* 1839 */
XML_SCHEMAV_CVC_ENUMERATION_VALID, /* 1840 */
XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1, /* 1841 */
XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2, /* 1842 */
XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3, /* 1843 */
XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4, /* 1844 */
XML_SCHEMAV_CVC_ELT_1, /* 1845 */
XML_SCHEMAV_CVC_ELT_2, /* 1846 */
XML_SCHEMAV_CVC_ELT_3_1, /* 1847 */
XML_SCHEMAV_CVC_ELT_3_2_1, /* 1848 */
XML_SCHEMAV_CVC_ELT_3_2_2, /* 1849 */
XML_SCHEMAV_CVC_ELT_4_1, /* 1850 */
XML_SCHEMAV_CVC_ELT_4_2, /* 1851 */
XML_SCHEMAV_CVC_ELT_4_3, /* 1852 */
XML_SCHEMAV_CVC_ELT_5_1_1, /* 1853 */
XML_SCHEMAV_CVC_ELT_5_1_2, /* 1854 */
XML_SCHEMAV_CVC_ELT_5_2_1, /* 1855 */
XML_SCHEMAV_CVC_ELT_5_2_2_1, /* 1856 */
XML_SCHEMAV_CVC_ELT_5_2_2_2_1, /* 1857 */
XML_SCHEMAV_CVC_ELT_5_2_2_2_2, /* 1858 */
XML_SCHEMAV_CVC_ELT_6, /* 1859 */
XML_SCHEMAV_CVC_ELT_7, /* 1860 */
XML_SCHEMAV_CVC_ATTRIBUTE_1, /* 1861 */
XML_SCHEMAV_CVC_ATTRIBUTE_2, /* 1862 */
XML_SCHEMAV_CVC_ATTRIBUTE_3, /* 1863 */
XML_SCHEMAV_CVC_ATTRIBUTE_4, /* 1864 */
XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1, /* 1865 */
XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1, /* 1866 */
XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2, /* 1867 */
XML_SCHEMAV_CVC_COMPLEX_TYPE_4, /* 1868 */
XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1, /* 1869 */
XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2, /* 1870 */
XML_SCHEMAV_ELEMENT_CONTENT, /* 1871 */
XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING, /* 1872 */
XML_SCHEMAV_CVC_COMPLEX_TYPE_1, /* 1873 */
XML_SCHEMAV_CVC_AU, /* 1874 */
XML_SCHEMAV_CVC_TYPE_1, /* 1875 */
XML_SCHEMAV_CVC_TYPE_2, /* 1876 */
XML_SCHEMAV_CVC_IDC, /* 1877 */
XML_SCHEMAV_CVC_WILDCARD, /* 1878 */
XML_SCHEMAV_MISC, /* 1879 */
XML_XPTR_UNKNOWN_SCHEME = 1900,
XML_XPTR_CHILDSEQ_START, /* 1901 */
XML_XPTR_EVAL_FAILED, /* 1902 */
XML_XPTR_EXTRA_OBJECTS, /* 1903 */
XML_C14N_CREATE_CTXT = 1950,
XML_C14N_REQUIRES_UTF8, /* 1951 */
XML_C14N_CREATE_STACK, /* 1952 */
XML_C14N_INVALID_NODE, /* 1953 */
XML_C14N_UNKNOW_NODE, /* 1954 */
XML_C14N_RELATIVE_NAMESPACE, /* 1955 */
XML_FTP_PASV_ANSWER = 2000,
XML_FTP_EPSV_ANSWER, /* 2001 */
XML_FTP_ACCNT, /* 2002 */
XML_FTP_URL_SYNTAX, /* 2003 */
XML_HTTP_URL_SYNTAX = 2020,
XML_HTTP_USE_IP, /* 2021 */
XML_HTTP_UNKNOWN_HOST, /* 2022 */
XML_SCHEMAP_SRC_SIMPLE_TYPE_1 = 3000,
XML_SCHEMAP_SRC_SIMPLE_TYPE_2, /* 3001 */
XML_SCHEMAP_SRC_SIMPLE_TYPE_3, /* 3002 */
XML_SCHEMAP_SRC_SIMPLE_TYPE_4, /* 3003 */
XML_SCHEMAP_SRC_RESOLVE, /* 3004 */
XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE, /* 3005 */
XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE, /* 3006 */
XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES, /* 3007 */
XML_SCHEMAP_ST_PROPS_CORRECT_1, /* 3008 */
XML_SCHEMAP_ST_PROPS_CORRECT_2, /* 3009 */
XML_SCHEMAP_ST_PROPS_CORRECT_3, /* 3010 */
XML_SCHEMAP_COS_ST_RESTRICTS_1_1, /* 3011 */
XML_SCHEMAP_COS_ST_RESTRICTS_1_2, /* 3012 */
XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1, /* 3013 */
XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2, /* 3014 */
XML_SCHEMAP_COS_ST_RESTRICTS_2_1, /* 3015 */
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1, /* 3016 */
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2, /* 3017 */
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1, /* 3018 */
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2, /* 3019 */
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3, /* 3020 */
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4, /* 3021 */
XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5, /* 3022 */
XML_SCHEMAP_COS_ST_RESTRICTS_3_1, /* 3023 */
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1, /* 3024 */
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2, /* 3025 */
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2, /* 3026 */
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1, /* 3027 */
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3, /* 3028 */
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4, /* 3029 */
XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5, /* 3030 */
XML_SCHEMAP_COS_ST_DERIVED_OK_2_1, /* 3031 */
XML_SCHEMAP_COS_ST_DERIVED_OK_2_2, /* 3032 */
XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED, /* 3033 */
XML_SCHEMAP_S4S_ELEM_MISSING, /* 3034 */
XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, /* 3035 */
XML_SCHEMAP_S4S_ATTR_MISSING, /* 3036 */
XML_SCHEMAP_S4S_ATTR_INVALID_VALUE, /* 3037 */
XML_SCHEMAP_SRC_ELEMENT_1, /* 3038 */
XML_SCHEMAP_SRC_ELEMENT_2_1, /* 3039 */
XML_SCHEMAP_SRC_ELEMENT_2_2, /* 3040 */
XML_SCHEMAP_SRC_ELEMENT_3, /* 3041 */
XML_SCHEMAP_P_PROPS_CORRECT_1, /* 3042 */
XML_SCHEMAP_P_PROPS_CORRECT_2_1, /* 3043 */
XML_SCHEMAP_P_PROPS_CORRECT_2_2, /* 3044 */
XML_SCHEMAP_E_PROPS_CORRECT_2, /* 3045 */
XML_SCHEMAP_E_PROPS_CORRECT_3, /* 3046 */
XML_SCHEMAP_E_PROPS_CORRECT_4, /* 3047 */
XML_SCHEMAP_E_PROPS_CORRECT_5, /* 3048 */
XML_SCHEMAP_E_PROPS_CORRECT_6, /* 3049 */
XML_SCHEMAP_SRC_INCLUDE, /* 3050 */
XML_SCHEMAP_SRC_ATTRIBUTE_1, /* 3051 */
XML_SCHEMAP_SRC_ATTRIBUTE_2, /* 3052 */
XML_SCHEMAP_SRC_ATTRIBUTE_3_1, /* 3053 */
XML_SCHEMAP_SRC_ATTRIBUTE_3_2, /* 3054 */
XML_SCHEMAP_SRC_ATTRIBUTE_4, /* 3055 */
XML_SCHEMAP_NO_XMLNS, /* 3056 */
XML_SCHEMAP_NO_XSI, /* 3057 */
XML_SCHEMAP_COS_VALID_DEFAULT_1, /* 3058 */
XML_SCHEMAP_COS_VALID_DEFAULT_2_1, /* 3059 */
XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1, /* 3060 */
XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2, /* 3061 */
XML_SCHEMAP_CVC_SIMPLE_TYPE, /* 3062 */
XML_SCHEMAP_COS_CT_EXTENDS_1_1, /* 3063 */
XML_SCHEMAP_SRC_IMPORT_1_1, /* 3064 */
XML_SCHEMAP_SRC_IMPORT_1_2, /* 3065 */
XML_SCHEMAP_SRC_IMPORT_2, /* 3066 */
XML_SCHEMAP_SRC_IMPORT_2_1, /* 3067 */
XML_SCHEMAP_SRC_IMPORT_2_2, /* 3068 */
XML_SCHEMAP_INTERNAL, /* 3069 non-W3C */
XML_SCHEMAP_NOT_DETERMINISTIC, /* 3070 non-W3C */
XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1, /* 3071 */
XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2, /* 3072 */
XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3, /* 3073 */
XML_SCHEMAP_MG_PROPS_CORRECT_1, /* 3074 */
XML_SCHEMAP_MG_PROPS_CORRECT_2, /* 3075 */
XML_SCHEMAP_SRC_CT_1, /* 3076 */
XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3, /* 3077 */
XML_SCHEMAP_AU_PROPS_CORRECT_2, /* 3078 */
XML_SCHEMAP_A_PROPS_CORRECT_2, /* 3079 */
XML_SCHEMAP_C_PROPS_CORRECT, /* 3080 */
XML_SCHEMAP_SRC_REDEFINE, /* 3081 */
XML_SCHEMAP_SRC_IMPORT, /* 3082 */
XML_SCHEMAP_WARN_SKIP_SCHEMA, /* 3083 */
XML_SCHEMAP_WARN_UNLOCATED_SCHEMA, /* 3084 */
XML_SCHEMAP_WARN_ATTR_REDECL_PROH, /* 3085 */
XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH, /* 3085 */
XML_SCHEMAP_AG_PROPS_CORRECT, /* 3086 */
XML_SCHEMAP_COS_CT_EXTENDS_1_2, /* 3087 */
XML_SCHEMAP_AU_PROPS_CORRECT, /* 3088 */
XML_SCHEMAP_A_PROPS_CORRECT_3, /* 3089 */
XML_SCHEMAP_COS_ALL_LIMITED, /* 3090 */
XML_SCHEMATRONV_ASSERT = 4000, /* 4000 */
XML_SCHEMATRONV_REPORT,
XML_MODULE_OPEN = 4900, /* 4900 */
XML_MODULE_CLOSE, /* 4901 */
XML_CHECK_FOUND_ELEMENT = 5000,
XML_CHECK_FOUND_ATTRIBUTE, /* 5001 */
XML_CHECK_FOUND_TEXT, /* 5002 */
XML_CHECK_FOUND_CDATA, /* 5003 */
XML_CHECK_FOUND_ENTITYREF, /* 5004 */
XML_CHECK_FOUND_ENTITY, /* 5005 */
XML_CHECK_FOUND_PI, /* 5006 */
XML_CHECK_FOUND_COMMENT, /* 5007 */
XML_CHECK_FOUND_DOCTYPE, /* 5008 */
XML_CHECK_FOUND_FRAGMENT, /* 5009 */
XML_CHECK_FOUND_NOTATION, /* 5010 */
XML_CHECK_UNKNOWN_NODE, /* 5011 */
XML_CHECK_ENTITY_TYPE, /* 5012 */
XML_CHECK_NO_PARENT, /* 5013 */
XML_CHECK_NO_DOC, /* 5014 */
XML_CHECK_NO_NAME, /* 5015 */
XML_CHECK_NO_ELEM, /* 5016 */
XML_CHECK_WRONG_DOC, /* 5017 */
XML_CHECK_NO_PREV, /* 5018 */
XML_CHECK_WRONG_PREV, /* 5019 */
XML_CHECK_NO_NEXT, /* 5020 */
XML_CHECK_WRONG_NEXT, /* 5021 */
XML_CHECK_NOT_DTD, /* 5022 */
XML_CHECK_NOT_ATTR, /* 5023 */
XML_CHECK_NOT_ATTR_DECL, /* 5024 */
XML_CHECK_NOT_ELEM_DECL, /* 5025 */
XML_CHECK_NOT_ENTITY_DECL, /* 5026 */
XML_CHECK_NOT_NS_DECL, /* 5027 */
XML_CHECK_NO_HREF, /* 5028 */
XML_CHECK_WRONG_PARENT,/* 5029 */
XML_CHECK_NS_SCOPE, /* 5030 */
XML_CHECK_NS_ANCESTOR, /* 5031 */
XML_CHECK_NOT_UTF8, /* 5032 */
XML_CHECK_NO_DICT, /* 5033 */
XML_CHECK_NOT_NCNAME, /* 5034 */
XML_CHECK_OUTSIDE_DICT, /* 5035 */
XML_CHECK_WRONG_NAME, /* 5036 */
XML_CHECK_NAME_NOT_NULL, /* 5037 */
XML_I18N_NO_NAME = 6000,
XML_I18N_NO_HANDLER, /* 6001 */
XML_I18N_EXCESS_HANDLER, /* 6002 */
XML_I18N_CONV_FAILED, /* 6003 */
XML_I18N_NO_OUTPUT, /* 6004 */
XML_BUF_OVERFLOW = 7000
} xmlParserErrors;
/**
* xmlGenericErrorFunc:
* @ctx: a parsing context
* @msg: the message
* @...: the extra arguments of the varargs to format the message
*
* Signature of the function to use when there is an error and
* no parsing or validity context available .
*/
typedef void (XMLCDECL *xmlGenericErrorFunc) (void *ctx,
const char *msg,
...) LIBXML_ATTR_FORMAT(2,3);
/**
* xmlStructuredErrorFunc:
* @userData: user provided data for the error callback
* @error: the error being raised.
*
* Signature of the function to use when there is an error and
* the module handles the new error reporting mechanism.
*/
typedef void (XMLCALL *xmlStructuredErrorFunc) (void *userData, xmlErrorPtr error);
/*
* Use the following function to reset the two global variables
* xmlGenericError and xmlGenericErrorContext.
*/
XMLPUBFUN void XMLCALL
xmlSetGenericErrorFunc (void *ctx,
xmlGenericErrorFunc handler);
XMLPUBFUN void XMLCALL
initGenericErrorDefaultFunc (xmlGenericErrorFunc *handler);
XMLPUBFUN void XMLCALL
xmlSetStructuredErrorFunc (void *ctx,
xmlStructuredErrorFunc handler);
/*
* Default message routines used by SAX and Valid context for error
* and warning reporting.
*/
XMLPUBFUN void XMLCDECL
xmlParserError (void *ctx,
const char *msg,
...) LIBXML_ATTR_FORMAT(2,3);
XMLPUBFUN void XMLCDECL
xmlParserWarning (void *ctx,
const char *msg,
...) LIBXML_ATTR_FORMAT(2,3);
XMLPUBFUN void XMLCDECL
xmlParserValidityError (void *ctx,
const char *msg,
...) LIBXML_ATTR_FORMAT(2,3);
XMLPUBFUN void XMLCDECL
xmlParserValidityWarning (void *ctx,
const char *msg,
...) LIBXML_ATTR_FORMAT(2,3);
XMLPUBFUN void XMLCALL
xmlParserPrintFileInfo (xmlParserInputPtr input);
XMLPUBFUN void XMLCALL
xmlParserPrintFileContext (xmlParserInputPtr input);
/*
* Extended error information routines
*/
XMLPUBFUN xmlErrorPtr XMLCALL
xmlGetLastError (void);
XMLPUBFUN void XMLCALL
xmlResetLastError (void);
XMLPUBFUN xmlErrorPtr XMLCALL
xmlCtxtGetLastError (void *ctx);
XMLPUBFUN void XMLCALL
xmlCtxtResetLastError (void *ctx);
XMLPUBFUN void XMLCALL
xmlResetError (xmlErrorPtr err);
XMLPUBFUN int XMLCALL
xmlCopyError (xmlErrorPtr from,
xmlErrorPtr to);
#ifdef IN_LIBXML
/*
* Internal callback reporting routine
*/
XMLPUBFUN void XMLCALL
__xmlRaiseError (xmlStructuredErrorFunc schannel,
xmlGenericErrorFunc channel,
void *data,
void *ctx,
void *node,
int domain,
int code,
xmlErrorLevel level,
const char *file,
int line,
const char *str1,
const char *str2,
const char *str3,
int int1,
int col,
const char *msg,
...) LIBXML_ATTR_FORMAT(16,17);
XMLPUBFUN void XMLCALL
__xmlSimpleError (int domain,
int code,
xmlNodePtr node,
const char *msg,
const char *extra) LIBXML_ATTR_FORMAT(4,0);
#endif
#ifdef __cplusplus
}
#endif
#endif /* __XML_ERROR_H__ */
/*
* Summary: API to handle XML Pointers
* Description: API to handle XML Pointers
* Base implementation was made accordingly to
* W3C Candidate Recommendation 7 June 2000
* http://www.w3.org/TR/2000/CR-xptr-20000607
*
* Added support for the element() scheme described in:
* W3C Proposed Recommendation 13 November 2002
* http://www.w3.org/TR/2002/PR-xptr-element-20021113/
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_XPTR_H__
#define __XML_XPTR_H__
#include <libxml/xmlversion.h>
#ifdef LIBXML_XPTR_ENABLED
#include <libxml/tree.h>
#include <libxml/xpath.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifdef LIBXML_XPTR_LOCS_ENABLED
/*
* A Location Set
*/
typedef struct _xmlLocationSet xmlLocationSet;
typedef xmlLocationSet *xmlLocationSetPtr;
struct _xmlLocationSet {
int locNr; /* number of locations in the set */
int locMax; /* size of the array as allocated */
xmlXPathObjectPtr *locTab;/* array of locations */
};
/*
* Handling of location sets.
*/
XML_DEPRECATED
XMLPUBFUN xmlLocationSetPtr XMLCALL
xmlXPtrLocationSetCreate (xmlXPathObjectPtr val);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlXPtrFreeLocationSet (xmlLocationSetPtr obj);
XML_DEPRECATED
XMLPUBFUN xmlLocationSetPtr XMLCALL
xmlXPtrLocationSetMerge (xmlLocationSetPtr val1,
xmlLocationSetPtr val2);
XML_DEPRECATED
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPtrNewRange (xmlNodePtr start,
int startindex,
xmlNodePtr end,
int endindex);
XML_DEPRECATED
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPtrNewRangePoints (xmlXPathObjectPtr start,
xmlXPathObjectPtr end);
XML_DEPRECATED
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPtrNewRangeNodePoint (xmlNodePtr start,
xmlXPathObjectPtr end);
XML_DEPRECATED
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPtrNewRangePointNode (xmlXPathObjectPtr start,
xmlNodePtr end);
XML_DEPRECATED
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPtrNewRangeNodes (xmlNodePtr start,
xmlNodePtr end);
XML_DEPRECATED
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPtrNewLocationSetNodes (xmlNodePtr start,
xmlNodePtr end);
XML_DEPRECATED
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPtrNewLocationSetNodeSet(xmlNodeSetPtr set);
XML_DEPRECATED
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPtrNewRangeNodeObject (xmlNodePtr start,
xmlXPathObjectPtr end);
XML_DEPRECATED
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPtrNewCollapsedRange (xmlNodePtr start);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlXPtrLocationSetAdd (xmlLocationSetPtr cur,
xmlXPathObjectPtr val);
XML_DEPRECATED
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPtrWrapLocationSet (xmlLocationSetPtr val);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlXPtrLocationSetDel (xmlLocationSetPtr cur,
xmlXPathObjectPtr val);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlXPtrLocationSetRemove (xmlLocationSetPtr cur,
int val);
#endif /* LIBXML_XPTR_LOCS_ENABLED */
/*
* Functions.
*/
XMLPUBFUN xmlXPathContextPtr XMLCALL
xmlXPtrNewContext (xmlDocPtr doc,
xmlNodePtr here,
xmlNodePtr origin);
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPtrEval (const xmlChar *str,
xmlXPathContextPtr ctx);
#ifdef LIBXML_XPTR_LOCS_ENABLED
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlXPtrRangeToFunction (xmlXPathParserContextPtr ctxt,
int nargs);
XML_DEPRECATED
XMLPUBFUN xmlNodePtr XMLCALL
xmlXPtrBuildNodeList (xmlXPathObjectPtr obj);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlXPtrEvalRangePredicate (xmlXPathParserContextPtr ctxt);
#endif /* LIBXML_XPTR_LOCS_ENABLED */
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_XPTR_ENABLED */
#endif /* __XML_XPTR_H__ */
/*
* Summary: regular expressions handling
* Description: basic API for libxml regular expressions handling used
* for XML Schemas and validation.
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_REGEXP_H__
#define __XML_REGEXP_H__
#include <libxml/xmlversion.h>
#ifdef LIBXML_REGEXP_ENABLED
#ifdef __cplusplus
extern "C" {
#endif
/**
* xmlRegexpPtr:
*
* A libxml regular expression, they can actually be far more complex
* thank the POSIX regex expressions.
*/
typedef struct _xmlRegexp xmlRegexp;
typedef xmlRegexp *xmlRegexpPtr;
/**
* xmlRegExecCtxtPtr:
*
* A libxml progressive regular expression evaluation context
*/
typedef struct _xmlRegExecCtxt xmlRegExecCtxt;
typedef xmlRegExecCtxt *xmlRegExecCtxtPtr;
#ifdef __cplusplus
}
#endif
#include <libxml/tree.h>
#include <libxml/dict.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* The POSIX like API
*/
XMLPUBFUN xmlRegexpPtr XMLCALL
xmlRegexpCompile (const xmlChar *regexp);
XMLPUBFUN void XMLCALL xmlRegFreeRegexp(xmlRegexpPtr regexp);
XMLPUBFUN int XMLCALL
xmlRegexpExec (xmlRegexpPtr comp,
const xmlChar *value);
XMLPUBFUN void XMLCALL
xmlRegexpPrint (FILE *output,
xmlRegexpPtr regexp);
XMLPUBFUN int XMLCALL
xmlRegexpIsDeterminist(xmlRegexpPtr comp);
/**
* xmlRegExecCallbacks:
* @exec: the regular expression context
* @token: the current token string
* @transdata: transition data
* @inputdata: input data
*
* Callback function when doing a transition in the automata
*/
typedef void (*xmlRegExecCallbacks) (xmlRegExecCtxtPtr exec,
const xmlChar *token,
void *transdata,
void *inputdata);
/*
* The progressive API
*/
XMLPUBFUN xmlRegExecCtxtPtr XMLCALL
xmlRegNewExecCtxt (xmlRegexpPtr comp,
xmlRegExecCallbacks callback,
void *data);
XMLPUBFUN void XMLCALL
xmlRegFreeExecCtxt (xmlRegExecCtxtPtr exec);
XMLPUBFUN int XMLCALL
xmlRegExecPushString(xmlRegExecCtxtPtr exec,
const xmlChar *value,
void *data);
XMLPUBFUN int XMLCALL
xmlRegExecPushString2(xmlRegExecCtxtPtr exec,
const xmlChar *value,
const xmlChar *value2,
void *data);
XMLPUBFUN int XMLCALL
xmlRegExecNextValues(xmlRegExecCtxtPtr exec,
int *nbval,
int *nbneg,
xmlChar **values,
int *terminal);
XMLPUBFUN int XMLCALL
xmlRegExecErrInfo (xmlRegExecCtxtPtr exec,
const xmlChar **string,
int *nbval,
int *nbneg,
xmlChar **values,
int *terminal);
#ifdef LIBXML_EXPR_ENABLED
/*
* Formal regular expression handling
* Its goal is to do some formal work on content models
*/
/* expressions are used within a context */
typedef struct _xmlExpCtxt xmlExpCtxt;
typedef xmlExpCtxt *xmlExpCtxtPtr;
XMLPUBFUN void XMLCALL
xmlExpFreeCtxt (xmlExpCtxtPtr ctxt);
XMLPUBFUN xmlExpCtxtPtr XMLCALL
xmlExpNewCtxt (int maxNodes,
xmlDictPtr dict);
XMLPUBFUN int XMLCALL
xmlExpCtxtNbNodes(xmlExpCtxtPtr ctxt);
XMLPUBFUN int XMLCALL
xmlExpCtxtNbCons(xmlExpCtxtPtr ctxt);
/* Expressions are trees but the tree is opaque */
typedef struct _xmlExpNode xmlExpNode;
typedef xmlExpNode *xmlExpNodePtr;
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;
/*
* 2 core expressions shared by all for the empty language set
* and for the set with just the empty token
*/
XMLPUBVAR xmlExpNodePtr forbiddenExp;
XMLPUBVAR xmlExpNodePtr emptyExp;
/*
* Expressions are reference counted internally
*/
XMLPUBFUN void XMLCALL
xmlExpFree (xmlExpCtxtPtr ctxt,
xmlExpNodePtr expr);
XMLPUBFUN void XMLCALL
xmlExpRef (xmlExpNodePtr expr);
/*
* constructors can be either manual or from a string
*/
XMLPUBFUN xmlExpNodePtr XMLCALL
xmlExpParse (xmlExpCtxtPtr ctxt,
const char *expr);
XMLPUBFUN xmlExpNodePtr XMLCALL
xmlExpNewAtom (xmlExpCtxtPtr ctxt,
const xmlChar *name,
int len);
XMLPUBFUN xmlExpNodePtr XMLCALL
xmlExpNewOr (xmlExpCtxtPtr ctxt,
xmlExpNodePtr left,
xmlExpNodePtr right);
XMLPUBFUN xmlExpNodePtr XMLCALL
xmlExpNewSeq (xmlExpCtxtPtr ctxt,
xmlExpNodePtr left,
xmlExpNodePtr right);
XMLPUBFUN xmlExpNodePtr XMLCALL
xmlExpNewRange (xmlExpCtxtPtr ctxt,
xmlExpNodePtr subset,
int min,
int max);
/*
* The really interesting APIs
*/
XMLPUBFUN int XMLCALL
xmlExpIsNillable(xmlExpNodePtr expr);
XMLPUBFUN int XMLCALL
xmlExpMaxToken (xmlExpNodePtr expr);
XMLPUBFUN int XMLCALL
xmlExpGetLanguage(xmlExpCtxtPtr ctxt,
xmlExpNodePtr expr,
const xmlChar**langList,
int len);
XMLPUBFUN int XMLCALL
xmlExpGetStart (xmlExpCtxtPtr ctxt,
xmlExpNodePtr expr,
const xmlChar**tokList,
int len);
XMLPUBFUN xmlExpNodePtr XMLCALL
xmlExpStringDerive(xmlExpCtxtPtr ctxt,
xmlExpNodePtr expr,
const xmlChar *str,
int len);
XMLPUBFUN xmlExpNodePtr XMLCALL
xmlExpExpDerive (xmlExpCtxtPtr ctxt,
xmlExpNodePtr expr,
xmlExpNodePtr sub);
XMLPUBFUN int XMLCALL
xmlExpSubsume (xmlExpCtxtPtr ctxt,
xmlExpNodePtr expr,
xmlExpNodePtr sub);
XMLPUBFUN void XMLCALL
xmlExpDump (xmlBufferPtr buf,
xmlExpNodePtr expr);
#endif /* LIBXML_EXPR_ENABLED */
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_REGEXP_ENABLED */
#endif /*__XML_REGEXP_H__ */
/*
* Summary: interfaces for tree manipulation
* Description: this module describes the structures found in an tree resulting
* from an XML or HTML parsing, as well as the API provided for
* various processing on that tree
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_TREE_H__
#define __XML_TREE_H__
#include <stdio.h>
#include <limits.h>
#include <libxml/xmlversion.h>
#include <libxml/xmlstring.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* Some of the basic types pointer to structures:
*/
/* xmlIO.h */
typedef struct _xmlParserInputBuffer xmlParserInputBuffer;
typedef xmlParserInputBuffer *xmlParserInputBufferPtr;
typedef struct _xmlOutputBuffer xmlOutputBuffer;
typedef xmlOutputBuffer *xmlOutputBufferPtr;
/* parser.h */
typedef struct _xmlParserInput xmlParserInput;
typedef xmlParserInput *xmlParserInputPtr;
typedef struct _xmlParserCtxt xmlParserCtxt;
typedef xmlParserCtxt *xmlParserCtxtPtr;
typedef struct _xmlSAXLocator xmlSAXLocator;
typedef xmlSAXLocator *xmlSAXLocatorPtr;
typedef struct _xmlSAXHandler xmlSAXHandler;
typedef xmlSAXHandler *xmlSAXHandlerPtr;
/* entities.h */
typedef struct _xmlEntity xmlEntity;
typedef xmlEntity *xmlEntityPtr;
/**
* BASE_BUFFER_SIZE:
*
* default buffer size 4000.
*/
#define BASE_BUFFER_SIZE 4096
/**
* LIBXML_NAMESPACE_DICT:
*
* Defines experimental behaviour:
* 1) xmlNs gets an additional field @context (a xmlDoc)
* 2) when creating a tree, xmlNs->href is stored in the dict of xmlDoc.
*/
/* #define LIBXML_NAMESPACE_DICT */
/**
* xmlBufferAllocationScheme:
*
* A buffer allocation scheme can be defined to either match exactly the
* need or double it's allocated size each time it is found too small.
*/
typedef enum {
XML_BUFFER_ALLOC_DOUBLEIT, /* double each time one need to grow */
XML_BUFFER_ALLOC_EXACT, /* grow only to the minimal size */
XML_BUFFER_ALLOC_IMMUTABLE, /* immutable buffer */
XML_BUFFER_ALLOC_IO, /* special allocation scheme used for I/O */
XML_BUFFER_ALLOC_HYBRID, /* exact up to a threshold, and doubleit thereafter */
XML_BUFFER_ALLOC_BOUNDED /* limit the upper size of the buffer */
} xmlBufferAllocationScheme;
/**
* xmlBuffer:
*
* A buffer structure, this old construct is limited to 2GB and
* is being deprecated, use API with xmlBuf instead
*/
typedef struct _xmlBuffer xmlBuffer;
typedef xmlBuffer *xmlBufferPtr;
struct _xmlBuffer {
xmlChar *content; /* The buffer content UTF8 */
unsigned int use; /* The buffer size used */
unsigned int size; /* The buffer size */
xmlBufferAllocationScheme alloc; /* The realloc method */
xmlChar *contentIO; /* in IO mode we may have a different base */
};
/**
* xmlBuf:
*
* A buffer structure, new one, the actual structure internals are not public
*/
typedef struct _xmlBuf xmlBuf;
/**
* xmlBufPtr:
*
* A pointer to a buffer structure, the actual structure internals are not
* public
*/
typedef xmlBuf *xmlBufPtr;
/*
* A few public routines for xmlBuf. As those are expected to be used
* mostly internally the bulk of the routines are internal in buf.h
*/
XMLPUBFUN xmlChar* XMLCALL xmlBufContent (const xmlBuf* buf);
XMLPUBFUN xmlChar* XMLCALL xmlBufEnd (xmlBufPtr buf);
XMLPUBFUN size_t XMLCALL xmlBufUse (const xmlBufPtr buf);
XMLPUBFUN size_t XMLCALL xmlBufShrink (xmlBufPtr buf, size_t len);
/*
* LIBXML2_NEW_BUFFER:
*
* Macro used to express that the API use the new buffers for
* xmlParserInputBuffer and xmlOutputBuffer. The change was
* introduced in 2.9.0.
*/
#define LIBXML2_NEW_BUFFER
/**
* XML_XML_NAMESPACE:
*
* This is the namespace for the special xml: prefix predefined in the
* XML Namespace specification.
*/
#define XML_XML_NAMESPACE \
(const xmlChar *) "http://www.w3.org/XML/1998/namespace"
/**
* XML_XML_ID:
*
* This is the name for the special xml:id attribute
*/
#define XML_XML_ID (const xmlChar *) "xml:id"
/*
* The different element types carried by an XML tree.
*
* NOTE: This is synchronized with DOM Level1 values
* See http://www.w3.org/TR/REC-DOM-Level-1/
*
* Actually this had diverged a bit, and now XML_DOCUMENT_TYPE_NODE should
* be deprecated to use an XML_DTD_NODE.
*/
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 */ /* removed */
} xmlElementType;
/* For backward compatibility */
#define XML_DOCB_DOCUMENT_NODE 21
/**
* xmlNotation:
*
* A DTD Notation definition.
*/
typedef struct _xmlNotation xmlNotation;
typedef xmlNotation *xmlNotationPtr;
struct _xmlNotation {
const xmlChar *name; /* Notation name */
const xmlChar *PublicID; /* Public identifier, if any */
const xmlChar *SystemID; /* System identifier, if any */
};
/**
* xmlAttributeType:
*
* A DTD Attribute type definition.
*/
typedef enum {
XML_ATTRIBUTE_CDATA = 1,
XML_ATTRIBUTE_ID,
XML_ATTRIBUTE_IDREF ,
XML_ATTRIBUTE_IDREFS,
XML_ATTRIBUTE_ENTITY,
XML_ATTRIBUTE_ENTITIES,
XML_ATTRIBUTE_NMTOKEN,
XML_ATTRIBUTE_NMTOKENS,
XML_ATTRIBUTE_ENUMERATION,
XML_ATTRIBUTE_NOTATION
} xmlAttributeType;
/**
* xmlAttributeDefault:
*
* A DTD Attribute default definition.
*/
typedef enum {
XML_ATTRIBUTE_NONE = 1,
XML_ATTRIBUTE_REQUIRED,
XML_ATTRIBUTE_IMPLIED,
XML_ATTRIBUTE_FIXED
} xmlAttributeDefault;
/**
* xmlEnumeration:
*
* List structure used when there is an enumeration in DTDs.
*/
typedef struct _xmlEnumeration xmlEnumeration;
typedef xmlEnumeration *xmlEnumerationPtr;
struct _xmlEnumeration {
struct _xmlEnumeration *next; /* next one */
const xmlChar *name; /* Enumeration name */
};
/**
* xmlAttribute:
*
* An Attribute declaration in a DTD.
*/
typedef struct _xmlAttribute xmlAttribute;
typedef xmlAttribute *xmlAttributePtr;
struct _xmlAttribute {
void *_private; /* application data */
xmlElementType type; /* XML_ATTRIBUTE_DECL, must be second ! */
const xmlChar *name; /* Attribute name */
struct _xmlNode *children; /* NULL */
struct _xmlNode *last; /* NULL */
struct _xmlDtd *parent; /* -> DTD */
struct _xmlNode *next; /* next sibling link */
struct _xmlNode *prev; /* previous sibling link */
struct _xmlDoc *doc; /* the containing document */
struct _xmlAttribute *nexth; /* next in hash table */
xmlAttributeType atype; /* The attribute type */
xmlAttributeDefault def; /* the default */
const xmlChar *defaultValue; /* or the default value */
xmlEnumerationPtr tree; /* or the enumeration tree if any */
const xmlChar *prefix; /* the namespace prefix if any */
const xmlChar *elem; /* Element holding the attribute */
};
/**
* xmlElementContentType:
*
* Possible definitions of element content types.
*/
typedef enum {
XML_ELEMENT_CONTENT_PCDATA = 1,
XML_ELEMENT_CONTENT_ELEMENT,
XML_ELEMENT_CONTENT_SEQ,
XML_ELEMENT_CONTENT_OR
} xmlElementContentType;
/**
* xmlElementContentOccur:
*
* Possible definitions of element content occurrences.
*/
typedef enum {
XML_ELEMENT_CONTENT_ONCE = 1,
XML_ELEMENT_CONTENT_OPT,
XML_ELEMENT_CONTENT_MULT,
XML_ELEMENT_CONTENT_PLUS
} xmlElementContentOccur;
/**
* xmlElementContent:
*
* An XML Element content as stored after parsing an element definition
* in a DTD.
*/
typedef struct _xmlElementContent xmlElementContent;
typedef xmlElementContent *xmlElementContentPtr;
struct _xmlElementContent {
xmlElementContentType type; /* PCDATA, ELEMENT, SEQ or OR */
xmlElementContentOccur ocur; /* ONCE, OPT, MULT or PLUS */
const xmlChar *name; /* Element name */
struct _xmlElementContent *c1; /* first child */
struct _xmlElementContent *c2; /* second child */
struct _xmlElementContent *parent; /* parent */
const xmlChar *prefix; /* Namespace prefix */
};
/**
* xmlElementTypeVal:
*
* The different possibilities for an element content type.
*/
typedef enum {
XML_ELEMENT_TYPE_UNDEFINED = 0,
XML_ELEMENT_TYPE_EMPTY = 1,
XML_ELEMENT_TYPE_ANY,
XML_ELEMENT_TYPE_MIXED,
XML_ELEMENT_TYPE_ELEMENT
} xmlElementTypeVal;
#ifdef __cplusplus
}
#endif
#include <libxml/xmlregexp.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* xmlElement:
*
* An XML Element declaration from a DTD.
*/
typedef struct _xmlElement xmlElement;
typedef xmlElement *xmlElementPtr;
struct _xmlElement {
void *_private; /* application data */
xmlElementType type; /* XML_ELEMENT_DECL, must be second ! */
const xmlChar *name; /* Element name */
struct _xmlNode *children; /* NULL */
struct _xmlNode *last; /* NULL */
struct _xmlDtd *parent; /* -> DTD */
struct _xmlNode *next; /* next sibling link */
struct _xmlNode *prev; /* previous sibling link */
struct _xmlDoc *doc; /* the containing document */
xmlElementTypeVal etype; /* The type */
xmlElementContentPtr content; /* the allowed element content */
xmlAttributePtr attributes; /* List of the declared attributes */
const xmlChar *prefix; /* the namespace prefix if any */
#ifdef LIBXML_REGEXP_ENABLED
xmlRegexpPtr contModel; /* the validating regexp */
#else
void *contModel;
#endif
};
/**
* XML_LOCAL_NAMESPACE:
*
* A namespace declaration node.
*/
#define XML_LOCAL_NAMESPACE XML_NAMESPACE_DECL
typedef xmlElementType xmlNsType;
/**
* xmlNs:
*
* An XML namespace.
* Note that prefix == NULL is valid, it defines the default namespace
* within the subtree (until overridden).
*
* xmlNsType is unified with xmlElementType.
*/
typedef struct _xmlNs xmlNs;
typedef xmlNs *xmlNsPtr;
struct _xmlNs {
struct _xmlNs *next; /* next Ns link for this node */
xmlNsType type; /* global or local */
const xmlChar *href; /* URL for the namespace */
const xmlChar *prefix; /* prefix for the namespace */
void *_private; /* application data */
struct _xmlDoc *context; /* normally an xmlDoc */
};
/**
* xmlDtd:
*
* An XML DTD, as defined by <!DOCTYPE ... There is actually one for
* the internal subset and for the external subset.
*/
typedef struct _xmlDtd xmlDtd;
typedef xmlDtd *xmlDtdPtr;
struct _xmlDtd {
void *_private; /* application data */
xmlElementType type; /* XML_DTD_NODE, must be second ! */
const xmlChar *name; /* Name of the DTD */
struct _xmlNode *children; /* the value of the property link */
struct _xmlNode *last; /* last child link */
struct _xmlDoc *parent; /* child->parent link */
struct _xmlNode *next; /* next sibling link */
struct _xmlNode *prev; /* previous sibling link */
struct _xmlDoc *doc; /* the containing document */
/* End of common part */
void *notations; /* Hash table for notations if any */
void *elements; /* Hash table for elements if any */
void *attributes; /* Hash table for attributes if any */
void *entities; /* Hash table for entities if any */
const xmlChar *ExternalID; /* External identifier for PUBLIC DTD */
const xmlChar *SystemID; /* URI for a SYSTEM or PUBLIC DTD */
void *pentities; /* Hash table for param entities if any */
};
/**
* xmlAttr:
*
* An attribute on an XML node.
*/
typedef struct _xmlAttr xmlAttr;
typedef xmlAttr *xmlAttrPtr;
struct _xmlAttr {
void *_private; /* application data */
xmlElementType type; /* XML_ATTRIBUTE_NODE, must be second ! */
const xmlChar *name; /* the name of the property */
struct _xmlNode *children; /* the value of the property */
struct _xmlNode *last; /* NULL */
struct _xmlNode *parent; /* child->parent link */
struct _xmlAttr *next; /* next sibling link */
struct _xmlAttr *prev; /* previous sibling link */
struct _xmlDoc *doc; /* the containing document */
xmlNs *ns; /* pointer to the associated namespace */
xmlAttributeType atype; /* the attribute type if validating */
void *psvi; /* for type/PSVI information */
};
/**
* xmlID:
*
* An XML ID instance.
*/
typedef struct _xmlID xmlID;
typedef xmlID *xmlIDPtr;
struct _xmlID {
struct _xmlID *next; /* next ID */
const xmlChar *value; /* The ID name */
xmlAttrPtr attr; /* The attribute holding it */
const xmlChar *name; /* The attribute if attr is not available */
int lineno; /* The line number if attr is not available */
struct _xmlDoc *doc; /* The document holding the ID */
};
/**
* xmlRef:
*
* An XML IDREF instance.
*/
typedef struct _xmlRef xmlRef;
typedef xmlRef *xmlRefPtr;
struct _xmlRef {
struct _xmlRef *next; /* next Ref */
const xmlChar *value; /* The Ref name */
xmlAttrPtr attr; /* The attribute holding it */
const xmlChar *name; /* The attribute if attr is not available */
int lineno; /* The line number if attr is not available */
};
/**
* xmlNode:
*
* A node in an XML tree.
*/
typedef struct _xmlNode xmlNode;
typedef xmlNode *xmlNodePtr;
struct _xmlNode {
void *_private; /* application data */
xmlElementType type; /* type number, must be second ! */
const xmlChar *name; /* the name of the node, or the entity */
struct _xmlNode *children; /* parent->childs link */
struct _xmlNode *last; /* last child link */
struct _xmlNode *parent; /* child->parent link */
struct _xmlNode *next; /* next sibling link */
struct _xmlNode *prev; /* previous sibling link */
struct _xmlDoc *doc; /* the containing document */
/* End of common part */
xmlNs *ns; /* pointer to the associated namespace */
xmlChar *content; /* the content */
struct _xmlAttr *properties;/* properties list */
xmlNs *nsDef; /* namespace definitions on this node */
void *psvi; /* for type/PSVI information */
unsigned short line; /* line number */
unsigned short extra; /* extra data for XPath/XSLT */
};
/**
* XML_GET_CONTENT:
*
* Macro to extract the content pointer of a node.
*/
#define XML_GET_CONTENT(n) \
((n)->type == XML_ELEMENT_NODE ? NULL : (n)->content)
/**
* XML_GET_LINE:
*
* Macro to extract the line number of an element node.
*/
#define XML_GET_LINE(n) \
(xmlGetLineNo(n))
/**
* xmlDocProperty
*
* Set of properties of the document as found by the parser
* Some of them are linked to similarly named xmlParserOption
*/
typedef enum {
XML_DOC_WELLFORMED = 1<<0, /* document is XML well formed */
XML_DOC_NSVALID = 1<<1, /* document is Namespace valid */
XML_DOC_OLD10 = 1<<2, /* parsed with old XML-1.0 parser */
XML_DOC_DTDVALID = 1<<3, /* DTD validation was successful */
XML_DOC_XINCLUDE = 1<<4, /* XInclude substitution was done */
XML_DOC_USERBUILT = 1<<5, /* Document was built using the API
and not by parsing an instance */
XML_DOC_INTERNAL = 1<<6, /* built for internal processing */
XML_DOC_HTML = 1<<7 /* parsed or built HTML document */
} xmlDocProperties;
/**
* xmlDoc:
*
* An XML document.
*/
typedef struct _xmlDoc xmlDoc;
typedef xmlDoc *xmlDocPtr;
struct _xmlDoc {
void *_private; /* application data */
xmlElementType type; /* XML_DOCUMENT_NODE, must be second ! */
char *name; /* name/filename/URI of the document */
struct _xmlNode *children; /* the document tree */
struct _xmlNode *last; /* last child link */
struct _xmlNode *parent; /* child->parent link */
struct _xmlNode *next; /* next sibling link */
struct _xmlNode *prev; /* previous sibling link */
struct _xmlDoc *doc; /* autoreference to itself */
/* End of common part */
int compression;/* level of zlib compression */
int standalone; /* standalone document (no external refs)
1 if standalone="yes"
0 if standalone="no"
-1 if there is no XML declaration
-2 if there is an XML declaration, but no
standalone attribute was specified */
struct _xmlDtd *intSubset; /* the document internal subset */
struct _xmlDtd *extSubset; /* the document external subset */
struct _xmlNs *oldNs; /* Global namespace, the old way */
const xmlChar *version; /* the XML version string */
const xmlChar *encoding; /* external initial encoding, if any */
void *ids; /* Hash table for ID attributes if any */
void *refs; /* Hash table for IDREFs attributes if any */
const xmlChar *URL; /* The URI for that document */
int charset; /* Internal flag for charset handling,
actually an xmlCharEncoding */
struct _xmlDict *dict; /* dict used to allocate names or NULL */
void *psvi; /* for type/PSVI information */
int parseFlags; /* set of xmlParserOption used to parse the
document */
int properties; /* set of xmlDocProperties for this document
set at the end of parsing */
};
typedef struct _xmlDOMWrapCtxt xmlDOMWrapCtxt;
typedef xmlDOMWrapCtxt *xmlDOMWrapCtxtPtr;
/**
* xmlDOMWrapAcquireNsFunction:
* @ctxt: a DOM wrapper context
* @node: the context node (element or attribute)
* @nsName: the requested namespace name
* @nsPrefix: the requested namespace prefix
*
* A function called to acquire namespaces (xmlNs) from the wrapper.
*
* Returns an xmlNsPtr or NULL in case of an error.
*/
typedef xmlNsPtr (*xmlDOMWrapAcquireNsFunction) (xmlDOMWrapCtxtPtr ctxt,
xmlNodePtr node,
const xmlChar *nsName,
const xmlChar *nsPrefix);
/**
* xmlDOMWrapCtxt:
*
* Context for DOM wrapper-operations.
*/
struct _xmlDOMWrapCtxt {
void * _private;
/*
* The type of this context, just in case we need specialized
* contexts in the future.
*/
int type;
/*
* Internal namespace map used for various operations.
*/
void * namespaceMap;
/*
* Use this one to acquire an xmlNsPtr intended for node->ns.
* (Note that this is not intended for elem->nsDef).
*/
xmlDOMWrapAcquireNsFunction getNsForNodeFunc;
};
/**
* xmlChildrenNode:
*
* Macro for compatibility naming layer with libxml1. Maps
* to "children."
*/
#ifndef xmlChildrenNode
#define xmlChildrenNode children
#endif
/**
* xmlRootNode:
*
* Macro for compatibility naming layer with libxml1. Maps
* to "children".
*/
#ifndef xmlRootNode
#define xmlRootNode children
#endif
/*
* Variables.
*/
/*
* Some helper functions
*/
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || \
defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_DEBUG_ENABLED) || \
defined (LIBXML_HTML_ENABLED) || defined(LIBXML_SAX1_ENABLED) || \
defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || \
defined(LIBXML_LEGACY_ENABLED)
XMLPUBFUN int XMLCALL
xmlValidateNCName (const xmlChar *value,
int space);
#endif
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
XMLPUBFUN int XMLCALL
xmlValidateQName (const xmlChar *value,
int space);
XMLPUBFUN int XMLCALL
xmlValidateName (const xmlChar *value,
int space);
XMLPUBFUN int XMLCALL
xmlValidateNMToken (const xmlChar *value,
int space);
#endif
XMLPUBFUN xmlChar * XMLCALL
xmlBuildQName (const xmlChar *ncname,
const xmlChar *prefix,
xmlChar *memory,
int len);
XMLPUBFUN xmlChar * XMLCALL
xmlSplitQName2 (const xmlChar *name,
xmlChar **prefix);
XMLPUBFUN const xmlChar * XMLCALL
xmlSplitQName3 (const xmlChar *name,
int *len);
/*
* Handling Buffers, the old ones see @xmlBuf for the new ones.
*/
XMLPUBFUN void XMLCALL
xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme);
XMLPUBFUN xmlBufferAllocationScheme XMLCALL
xmlGetBufferAllocationScheme(void);
XMLPUBFUN xmlBufferPtr XMLCALL
xmlBufferCreate (void);
XMLPUBFUN xmlBufferPtr XMLCALL
xmlBufferCreateSize (size_t size);
XMLPUBFUN xmlBufferPtr XMLCALL
xmlBufferCreateStatic (void *mem,
size_t size);
XMLPUBFUN int XMLCALL
xmlBufferResize (xmlBufferPtr buf,
unsigned int size);
XMLPUBFUN void XMLCALL
xmlBufferFree (xmlBufferPtr buf);
XMLPUBFUN int XMLCALL
xmlBufferDump (FILE *file,
xmlBufferPtr buf);
XMLPUBFUN int XMLCALL
xmlBufferAdd (xmlBufferPtr buf,
const xmlChar *str,
int len);
XMLPUBFUN int XMLCALL
xmlBufferAddHead (xmlBufferPtr buf,
const xmlChar *str,
int len);
XMLPUBFUN int XMLCALL
xmlBufferCat (xmlBufferPtr buf,
const xmlChar *str);
XMLPUBFUN int XMLCALL
xmlBufferCCat (xmlBufferPtr buf,
const char *str);
XMLPUBFUN int XMLCALL
xmlBufferShrink (xmlBufferPtr buf,
unsigned int len);
XMLPUBFUN int XMLCALL
xmlBufferGrow (xmlBufferPtr buf,
unsigned int len);
XMLPUBFUN void XMLCALL
xmlBufferEmpty (xmlBufferPtr buf);
XMLPUBFUN const xmlChar* XMLCALL
xmlBufferContent (const xmlBuffer *buf);
XMLPUBFUN xmlChar* XMLCALL
xmlBufferDetach (xmlBufferPtr buf);
XMLPUBFUN void XMLCALL
xmlBufferSetAllocationScheme(xmlBufferPtr buf,
xmlBufferAllocationScheme scheme);
XMLPUBFUN int XMLCALL
xmlBufferLength (const xmlBuffer *buf);
/*
* Creating/freeing new structures.
*/
XMLPUBFUN xmlDtdPtr XMLCALL
xmlCreateIntSubset (xmlDocPtr doc,
const xmlChar *name,
const xmlChar *ExternalID,
const xmlChar *SystemID);
XMLPUBFUN xmlDtdPtr XMLCALL
xmlNewDtd (xmlDocPtr doc,
const xmlChar *name,
const xmlChar *ExternalID,
const xmlChar *SystemID);
XMLPUBFUN xmlDtdPtr XMLCALL
xmlGetIntSubset (const xmlDoc *doc);
XMLPUBFUN void XMLCALL
xmlFreeDtd (xmlDtdPtr cur);
#ifdef LIBXML_LEGACY_ENABLED
XML_DEPRECATED
XMLPUBFUN xmlNsPtr XMLCALL
xmlNewGlobalNs (xmlDocPtr doc,
const xmlChar *href,
const xmlChar *prefix);
#endif /* LIBXML_LEGACY_ENABLED */
XMLPUBFUN xmlNsPtr XMLCALL
xmlNewNs (xmlNodePtr node,
const xmlChar *href,
const xmlChar *prefix);
XMLPUBFUN void XMLCALL
xmlFreeNs (xmlNsPtr cur);
XMLPUBFUN void XMLCALL
xmlFreeNsList (xmlNsPtr cur);
XMLPUBFUN xmlDocPtr XMLCALL
xmlNewDoc (const xmlChar *version);
XMLPUBFUN void XMLCALL
xmlFreeDoc (xmlDocPtr cur);
XMLPUBFUN xmlAttrPtr XMLCALL
xmlNewDocProp (xmlDocPtr doc,
const xmlChar *name,
const xmlChar *value);
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \
defined(LIBXML_SCHEMAS_ENABLED)
XMLPUBFUN xmlAttrPtr XMLCALL
xmlNewProp (xmlNodePtr node,
const xmlChar *name,
const xmlChar *value);
#endif
XMLPUBFUN xmlAttrPtr XMLCALL
xmlNewNsProp (xmlNodePtr node,
xmlNsPtr ns,
const xmlChar *name,
const xmlChar *value);
XMLPUBFUN xmlAttrPtr XMLCALL
xmlNewNsPropEatName (xmlNodePtr node,
xmlNsPtr ns,
xmlChar *name,
const xmlChar *value);
XMLPUBFUN void XMLCALL
xmlFreePropList (xmlAttrPtr cur);
XMLPUBFUN void XMLCALL
xmlFreeProp (xmlAttrPtr cur);
XMLPUBFUN xmlAttrPtr XMLCALL
xmlCopyProp (xmlNodePtr target,
xmlAttrPtr cur);
XMLPUBFUN xmlAttrPtr XMLCALL
xmlCopyPropList (xmlNodePtr target,
xmlAttrPtr cur);
#ifdef LIBXML_TREE_ENABLED
XMLPUBFUN xmlDtdPtr XMLCALL
xmlCopyDtd (xmlDtdPtr dtd);
#endif /* LIBXML_TREE_ENABLED */
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
XMLPUBFUN xmlDocPtr XMLCALL
xmlCopyDoc (xmlDocPtr doc,
int recursive);
#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
/*
* Creating new nodes.
*/
XMLPUBFUN xmlNodePtr XMLCALL
xmlNewDocNode (xmlDocPtr doc,
xmlNsPtr ns,
const xmlChar *name,
const xmlChar *content);
XMLPUBFUN xmlNodePtr XMLCALL
xmlNewDocNodeEatName (xmlDocPtr doc,
xmlNsPtr ns,
xmlChar *name,
const xmlChar *content);
XMLPUBFUN xmlNodePtr XMLCALL
xmlNewNode (xmlNsPtr ns,
const xmlChar *name);
XMLPUBFUN xmlNodePtr XMLCALL
xmlNewNodeEatName (xmlNsPtr ns,
xmlChar *name);
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
XMLPUBFUN xmlNodePtr XMLCALL
xmlNewChild (xmlNodePtr parent,
xmlNsPtr ns,
const xmlChar *name,
const xmlChar *content);
#endif
XMLPUBFUN xmlNodePtr XMLCALL
xmlNewDocText (const xmlDoc *doc,
const xmlChar *content);
XMLPUBFUN xmlNodePtr XMLCALL
xmlNewText (const xmlChar *content);
XMLPUBFUN xmlNodePtr XMLCALL
xmlNewDocPI (xmlDocPtr doc,
const xmlChar *name,
const xmlChar *content);
XMLPUBFUN xmlNodePtr XMLCALL
xmlNewPI (const xmlChar *name,
const xmlChar *content);
XMLPUBFUN xmlNodePtr XMLCALL
xmlNewDocTextLen (xmlDocPtr doc,
const xmlChar *content,
int len);
XMLPUBFUN xmlNodePtr XMLCALL
xmlNewTextLen (const xmlChar *content,
int len);
XMLPUBFUN xmlNodePtr XMLCALL
xmlNewDocComment (xmlDocPtr doc,
const xmlChar *content);
XMLPUBFUN xmlNodePtr XMLCALL
xmlNewComment (const xmlChar *content);
XMLPUBFUN xmlNodePtr XMLCALL
xmlNewCDataBlock (xmlDocPtr doc,
const xmlChar *content,
int len);
XMLPUBFUN xmlNodePtr XMLCALL
xmlNewCharRef (xmlDocPtr doc,
const xmlChar *name);
XMLPUBFUN xmlNodePtr XMLCALL
xmlNewReference (const xmlDoc *doc,
const xmlChar *name);
XMLPUBFUN xmlNodePtr XMLCALL
xmlCopyNode (xmlNodePtr node,
int recursive);
XMLPUBFUN xmlNodePtr XMLCALL
xmlDocCopyNode (xmlNodePtr node,
xmlDocPtr doc,
int recursive);
XMLPUBFUN xmlNodePtr XMLCALL
xmlDocCopyNodeList (xmlDocPtr doc,
xmlNodePtr node);
XMLPUBFUN xmlNodePtr XMLCALL
xmlCopyNodeList (xmlNodePtr node);
#ifdef LIBXML_TREE_ENABLED
XMLPUBFUN xmlNodePtr XMLCALL
xmlNewTextChild (xmlNodePtr parent,
xmlNsPtr ns,
const xmlChar *name,
const xmlChar *content);
XMLPUBFUN xmlNodePtr XMLCALL
xmlNewDocRawNode (xmlDocPtr doc,
xmlNsPtr ns,
const xmlChar *name,
const xmlChar *content);
XMLPUBFUN xmlNodePtr XMLCALL
xmlNewDocFragment (xmlDocPtr doc);
#endif /* LIBXML_TREE_ENABLED */
/*
* Navigating.
*/
XMLPUBFUN long XMLCALL
xmlGetLineNo (const xmlNode *node);
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
XMLPUBFUN xmlChar * XMLCALL
xmlGetNodePath (const xmlNode *node);
#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) */
XMLPUBFUN xmlNodePtr XMLCALL
xmlDocGetRootElement (const xmlDoc *doc);
XMLPUBFUN xmlNodePtr XMLCALL
xmlGetLastChild (const xmlNode *parent);
XMLPUBFUN int XMLCALL
xmlNodeIsText (const xmlNode *node);
XMLPUBFUN int XMLCALL
xmlIsBlankNode (const xmlNode *node);
/*
* Changing the structure.
*/
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
XMLPUBFUN xmlNodePtr XMLCALL
xmlDocSetRootElement (xmlDocPtr doc,
xmlNodePtr root);
#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */
#ifdef LIBXML_TREE_ENABLED
XMLPUBFUN void XMLCALL
xmlNodeSetName (xmlNodePtr cur,
const xmlChar *name);
#endif /* LIBXML_TREE_ENABLED */
XMLPUBFUN xmlNodePtr XMLCALL
xmlAddChild (xmlNodePtr parent,
xmlNodePtr cur);
XMLPUBFUN xmlNodePtr XMLCALL
xmlAddChildList (xmlNodePtr parent,
xmlNodePtr cur);
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
XMLPUBFUN xmlNodePtr XMLCALL
xmlReplaceNode (xmlNodePtr old,
xmlNodePtr cur);
#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \
defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
XMLPUBFUN xmlNodePtr XMLCALL
xmlAddPrevSibling (xmlNodePtr cur,
xmlNodePtr elem);
#endif /* LIBXML_TREE_ENABLED || LIBXML_HTML_ENABLED || LIBXML_SCHEMAS_ENABLED */
XMLPUBFUN xmlNodePtr XMLCALL
xmlAddSibling (xmlNodePtr cur,
xmlNodePtr elem);
XMLPUBFUN xmlNodePtr XMLCALL
xmlAddNextSibling (xmlNodePtr cur,
xmlNodePtr elem);
XMLPUBFUN void XMLCALL
xmlUnlinkNode (xmlNodePtr cur);
XMLPUBFUN xmlNodePtr XMLCALL
xmlTextMerge (xmlNodePtr first,
xmlNodePtr second);
XMLPUBFUN int XMLCALL
xmlTextConcat (xmlNodePtr node,
const xmlChar *content,
int len);
XMLPUBFUN void XMLCALL
xmlFreeNodeList (xmlNodePtr cur);
XMLPUBFUN void XMLCALL
xmlFreeNode (xmlNodePtr cur);
XMLPUBFUN void XMLCALL
xmlSetTreeDoc (xmlNodePtr tree,
xmlDocPtr doc);
XMLPUBFUN void XMLCALL
xmlSetListDoc (xmlNodePtr list,
xmlDocPtr doc);
/*
* Namespaces.
*/
XMLPUBFUN xmlNsPtr XMLCALL
xmlSearchNs (xmlDocPtr doc,
xmlNodePtr node,
const xmlChar *nameSpace);
XMLPUBFUN xmlNsPtr XMLCALL
xmlSearchNsByHref (xmlDocPtr doc,
xmlNodePtr node,
const xmlChar *href);
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || \
defined(LIBXML_SCHEMAS_ENABLED)
XMLPUBFUN xmlNsPtr * XMLCALL
xmlGetNsList (const xmlDoc *doc,
const xmlNode *node);
#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) */
XMLPUBFUN void XMLCALL
xmlSetNs (xmlNodePtr node,
xmlNsPtr ns);
XMLPUBFUN xmlNsPtr XMLCALL
xmlCopyNamespace (xmlNsPtr cur);
XMLPUBFUN xmlNsPtr XMLCALL
xmlCopyNamespaceList (xmlNsPtr cur);
/*
* Changing the content.
*/
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || \
defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
XMLPUBFUN xmlAttrPtr XMLCALL
xmlSetProp (xmlNodePtr node,
const xmlChar *name,
const xmlChar *value);
XMLPUBFUN xmlAttrPtr XMLCALL
xmlSetNsProp (xmlNodePtr node,
xmlNsPtr ns,
const xmlChar *name,
const xmlChar *value);
#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || \
defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) */
XMLPUBFUN xmlChar * XMLCALL
xmlGetNoNsProp (const xmlNode *node,
const xmlChar *name);
XMLPUBFUN xmlChar * XMLCALL
xmlGetProp (const xmlNode *node,
const xmlChar *name);
XMLPUBFUN xmlAttrPtr XMLCALL
xmlHasProp (const xmlNode *node,
const xmlChar *name);
XMLPUBFUN xmlAttrPtr XMLCALL
xmlHasNsProp (const xmlNode *node,
const xmlChar *name,
const xmlChar *nameSpace);
XMLPUBFUN xmlChar * XMLCALL
xmlGetNsProp (const xmlNode *node,
const xmlChar *name,
const xmlChar *nameSpace);
XMLPUBFUN xmlNodePtr XMLCALL
xmlStringGetNodeList (const xmlDoc *doc,
const xmlChar *value);
XMLPUBFUN xmlNodePtr XMLCALL
xmlStringLenGetNodeList (const xmlDoc *doc,
const xmlChar *value,
int len);
XMLPUBFUN xmlChar * XMLCALL
xmlNodeListGetString (xmlDocPtr doc,
const xmlNode *list,
int inLine);
#ifdef LIBXML_TREE_ENABLED
XMLPUBFUN xmlChar * XMLCALL
xmlNodeListGetRawString (const xmlDoc *doc,
const xmlNode *list,
int inLine);
#endif /* LIBXML_TREE_ENABLED */
XMLPUBFUN void XMLCALL
xmlNodeSetContent (xmlNodePtr cur,
const xmlChar *content);
#ifdef LIBXML_TREE_ENABLED
XMLPUBFUN void XMLCALL
xmlNodeSetContentLen (xmlNodePtr cur,
const xmlChar *content,
int len);
#endif /* LIBXML_TREE_ENABLED */
XMLPUBFUN void XMLCALL
xmlNodeAddContent (xmlNodePtr cur,
const xmlChar *content);
XMLPUBFUN void XMLCALL
xmlNodeAddContentLen (xmlNodePtr cur,
const xmlChar *content,
int len);
XMLPUBFUN xmlChar * XMLCALL
xmlNodeGetContent (const xmlNode *cur);
XMLPUBFUN int XMLCALL
xmlNodeBufGetContent (xmlBufferPtr buffer,
const xmlNode *cur);
XMLPUBFUN int XMLCALL
xmlBufGetNodeContent (xmlBufPtr buf,
const xmlNode *cur);
XMLPUBFUN xmlChar * XMLCALL
xmlNodeGetLang (const xmlNode *cur);
XMLPUBFUN int XMLCALL
xmlNodeGetSpacePreserve (const xmlNode *cur);
#ifdef LIBXML_TREE_ENABLED
XMLPUBFUN void XMLCALL
xmlNodeSetLang (xmlNodePtr cur,
const xmlChar *lang);
XMLPUBFUN void XMLCALL
xmlNodeSetSpacePreserve (xmlNodePtr cur,
int val);
#endif /* LIBXML_TREE_ENABLED */
XMLPUBFUN xmlChar * XMLCALL
xmlNodeGetBase (const xmlDoc *doc,
const xmlNode *cur);
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
XMLPUBFUN void XMLCALL
xmlNodeSetBase (xmlNodePtr cur,
const xmlChar *uri);
#endif
/*
* Removing content.
*/
XMLPUBFUN int XMLCALL
xmlRemoveProp (xmlAttrPtr cur);
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
XMLPUBFUN int XMLCALL
xmlUnsetNsProp (xmlNodePtr node,
xmlNsPtr ns,
const xmlChar *name);
XMLPUBFUN int XMLCALL
xmlUnsetProp (xmlNodePtr node,
const xmlChar *name);
#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
/*
* Internal, don't use.
*/
XMLPUBFUN void XMLCALL
xmlBufferWriteCHAR (xmlBufferPtr buf,
const xmlChar *string);
XMLPUBFUN void XMLCALL
xmlBufferWriteChar (xmlBufferPtr buf,
const char *string);
XMLPUBFUN void XMLCALL
xmlBufferWriteQuotedString(xmlBufferPtr buf,
const xmlChar *string);
#ifdef LIBXML_OUTPUT_ENABLED
XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBufferPtr buf,
xmlDocPtr doc,
xmlAttrPtr attr,
const xmlChar *string);
#endif /* LIBXML_OUTPUT_ENABLED */
#ifdef LIBXML_TREE_ENABLED
/*
* Namespace handling.
*/
XMLPUBFUN int XMLCALL
xmlReconciliateNs (xmlDocPtr doc,
xmlNodePtr tree);
#endif
#ifdef LIBXML_OUTPUT_ENABLED
/*
* Saving.
*/
XMLPUBFUN void XMLCALL
xmlDocDumpFormatMemory (xmlDocPtr cur,
xmlChar **mem,
int *size,
int format);
XMLPUBFUN void XMLCALL
xmlDocDumpMemory (xmlDocPtr cur,
xmlChar **mem,
int *size);
XMLPUBFUN void XMLCALL
xmlDocDumpMemoryEnc (xmlDocPtr out_doc,
xmlChar **doc_txt_ptr,
int * doc_txt_len,
const char *txt_encoding);
XMLPUBFUN void XMLCALL
xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc,
xmlChar **doc_txt_ptr,
int * doc_txt_len,
const char *txt_encoding,
int format);
XMLPUBFUN int XMLCALL
xmlDocFormatDump (FILE *f,
xmlDocPtr cur,
int format);
XMLPUBFUN int XMLCALL
xmlDocDump (FILE *f,
xmlDocPtr cur);
XMLPUBFUN void XMLCALL
xmlElemDump (FILE *f,
xmlDocPtr doc,
xmlNodePtr cur);
XMLPUBFUN int XMLCALL
xmlSaveFile (const char *filename,
xmlDocPtr cur);
XMLPUBFUN int XMLCALL
xmlSaveFormatFile (const char *filename,
xmlDocPtr cur,
int format);
XMLPUBFUN size_t XMLCALL
xmlBufNodeDump (xmlBufPtr buf,
xmlDocPtr doc,
xmlNodePtr cur,
int level,
int format);
XMLPUBFUN int XMLCALL
xmlNodeDump (xmlBufferPtr buf,
xmlDocPtr doc,
xmlNodePtr cur,
int level,
int format);
XMLPUBFUN int XMLCALL
xmlSaveFileTo (xmlOutputBufferPtr buf,
xmlDocPtr cur,
const char *encoding);
XMLPUBFUN int XMLCALL
xmlSaveFormatFileTo (xmlOutputBufferPtr buf,
xmlDocPtr cur,
const char *encoding,
int format);
XMLPUBFUN void XMLCALL
xmlNodeDumpOutput (xmlOutputBufferPtr buf,
xmlDocPtr doc,
xmlNodePtr cur,
int level,
int format,
const char *encoding);
XMLPUBFUN int XMLCALL
xmlSaveFormatFileEnc (const char *filename,
xmlDocPtr cur,
const char *encoding,
int format);
XMLPUBFUN int XMLCALL
xmlSaveFileEnc (const char *filename,
xmlDocPtr cur,
const char *encoding);
#endif /* LIBXML_OUTPUT_ENABLED */
/*
* XHTML
*/
XMLPUBFUN int XMLCALL
xmlIsXHTML (const xmlChar *systemID,
const xmlChar *publicID);
/*
* Compression.
*/
XMLPUBFUN int XMLCALL
xmlGetDocCompressMode (const xmlDoc *doc);
XMLPUBFUN void XMLCALL
xmlSetDocCompressMode (xmlDocPtr doc,
int mode);
XMLPUBFUN int XMLCALL
xmlGetCompressMode (void);
XMLPUBFUN void XMLCALL
xmlSetCompressMode (int mode);
/*
* DOM-wrapper helper functions.
*/
XMLPUBFUN xmlDOMWrapCtxtPtr XMLCALL
xmlDOMWrapNewCtxt (void);
XMLPUBFUN void XMLCALL
xmlDOMWrapFreeCtxt (xmlDOMWrapCtxtPtr ctxt);
XMLPUBFUN int XMLCALL
xmlDOMWrapReconcileNamespaces(xmlDOMWrapCtxtPtr ctxt,
xmlNodePtr elem,
int options);
XMLPUBFUN int XMLCALL
xmlDOMWrapAdoptNode (xmlDOMWrapCtxtPtr ctxt,
xmlDocPtr sourceDoc,
xmlNodePtr node,
xmlDocPtr destDoc,
xmlNodePtr destParent,
int options);
XMLPUBFUN int XMLCALL
xmlDOMWrapRemoveNode (xmlDOMWrapCtxtPtr ctxt,
xmlDocPtr doc,
xmlNodePtr node,
int options);
XMLPUBFUN int XMLCALL
xmlDOMWrapCloneNode (xmlDOMWrapCtxtPtr ctxt,
xmlDocPtr sourceDoc,
xmlNodePtr node,
xmlNodePtr *clonedNode,
xmlDocPtr destDoc,
xmlNodePtr destParent,
int deep,
int options);
#ifdef LIBXML_TREE_ENABLED
/*
* 5 interfaces from DOM ElementTraversal, but different in entities
* traversal.
*/
XMLPUBFUN unsigned long XMLCALL
xmlChildElementCount (xmlNodePtr parent);
XMLPUBFUN xmlNodePtr XMLCALL
xmlNextElementSibling (xmlNodePtr node);
XMLPUBFUN xmlNodePtr XMLCALL
xmlFirstElementChild (xmlNodePtr parent);
XMLPUBFUN xmlNodePtr XMLCALL
xmlLastElementChild (xmlNodePtr parent);
XMLPUBFUN xmlNodePtr XMLCALL
xmlPreviousElementSibling (xmlNodePtr node);
#endif
#ifdef __cplusplus
}
#endif
#ifndef __XML_PARSER_H__
#include <libxml/xmlmemory.h>
#endif
#endif /* __XML_TREE_H__ */
/*
* Summary: interface for the memory allocator
* Description: provides interfaces for the memory allocator,
* including debugging capabilities.
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __DEBUG_MEMORY_ALLOC__
#define __DEBUG_MEMORY_ALLOC__
#include <stdio.h>
#include <libxml/xmlversion.h>
/**
* DEBUG_MEMORY:
*
* DEBUG_MEMORY replaces the allocator with a collect and debug
* shell to the libc allocator.
* DEBUG_MEMORY should only be activated when debugging
* libxml i.e. if libxml has been configured with --with-debug-mem too.
*/
/* #define DEBUG_MEMORY_FREED */
/* #define DEBUG_MEMORY_LOCATION */
#ifdef DEBUG
#ifndef DEBUG_MEMORY
#define DEBUG_MEMORY
#endif
#endif
/**
* DEBUG_MEMORY_LOCATION:
*
* DEBUG_MEMORY_LOCATION should be activated only when debugging
* libxml i.e. if libxml has been configured with --with-debug-mem too.
*/
#ifdef DEBUG_MEMORY_LOCATION
#endif
#ifdef __cplusplus
extern "C" {
#endif
/*
* The XML memory wrapper support 4 basic overloadable functions.
*/
/**
* xmlFreeFunc:
* @mem: an already allocated block of memory
*
* Signature for a free() implementation.
*/
typedef void (XMLCALL *xmlFreeFunc)(void *mem);
/**
* xmlMallocFunc:
* @size: the size requested in bytes
*
* Signature for a malloc() implementation.
*
* Returns a pointer to the newly allocated block or NULL in case of error.
*/
typedef void *(LIBXML_ATTR_ALLOC_SIZE(1) XMLCALL *xmlMallocFunc)(size_t size);
/**
* xmlReallocFunc:
* @mem: an already allocated block of memory
* @size: the new size requested in bytes
*
* Signature for a realloc() implementation.
*
* Returns a pointer to the newly reallocated block or NULL in case of error.
*/
typedef void *(XMLCALL *xmlReallocFunc)(void *mem, size_t size);
/**
* xmlStrdupFunc:
* @str: a zero terminated string
*
* Signature for an strdup() implementation.
*
* Returns the copy of the string or NULL in case of error.
*/
typedef char *(XMLCALL *xmlStrdupFunc)(const char *str);
/*
* The 4 interfaces used for all memory handling within libxml.
LIBXML_DLL_IMPORT xmlFreeFunc xmlFree;
LIBXML_DLL_IMPORT xmlMallocFunc xmlMalloc;
LIBXML_DLL_IMPORT xmlMallocFunc xmlMallocAtomic;
LIBXML_DLL_IMPORT xmlReallocFunc xmlRealloc;
LIBXML_DLL_IMPORT xmlStrdupFunc xmlMemStrdup;
*/
/*
* The way to overload the existing functions.
* The xmlGc function have an extra entry for atomic block
* allocations useful for garbage collected memory allocators
*/
XMLPUBFUN int XMLCALL
xmlMemSetup (xmlFreeFunc freeFunc,
xmlMallocFunc mallocFunc,
xmlReallocFunc reallocFunc,
xmlStrdupFunc strdupFunc);
XMLPUBFUN int XMLCALL
xmlMemGet (xmlFreeFunc *freeFunc,
xmlMallocFunc *mallocFunc,
xmlReallocFunc *reallocFunc,
xmlStrdupFunc *strdupFunc);
XMLPUBFUN int XMLCALL
xmlGcMemSetup (xmlFreeFunc freeFunc,
xmlMallocFunc mallocFunc,
xmlMallocFunc mallocAtomicFunc,
xmlReallocFunc reallocFunc,
xmlStrdupFunc strdupFunc);
XMLPUBFUN int XMLCALL
xmlGcMemGet (xmlFreeFunc *freeFunc,
xmlMallocFunc *mallocFunc,
xmlMallocFunc *mallocAtomicFunc,
xmlReallocFunc *reallocFunc,
xmlStrdupFunc *strdupFunc);
/*
* Initialization of the memory layer.
*/
XML_DEPRECATED
XMLPUBFUN int XMLCALL
xmlInitMemory (void);
/*
* Cleanup of the memory layer.
*/
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlCleanupMemory (void);
/*
* These are specific to the XML debug memory wrapper.
*/
XMLPUBFUN int XMLCALL
xmlMemUsed (void);
XMLPUBFUN int XMLCALL
xmlMemBlocks (void);
XMLPUBFUN void XMLCALL
xmlMemDisplay (FILE *fp);
XMLPUBFUN void XMLCALL
xmlMemDisplayLast(FILE *fp, long nbBytes);
XMLPUBFUN void XMLCALL
xmlMemShow (FILE *fp, int nr);
XMLPUBFUN void XMLCALL
xmlMemoryDump (void);
XMLPUBFUN void * XMLCALL
xmlMemMalloc (size_t size) LIBXML_ATTR_ALLOC_SIZE(1);
XMLPUBFUN void * XMLCALL
xmlMemRealloc (void *ptr,size_t size);
XMLPUBFUN void XMLCALL
xmlMemFree (void *ptr);
XMLPUBFUN char * XMLCALL
xmlMemoryStrdup (const char *str);
XMLPUBFUN void * XMLCALL
xmlMallocLoc (size_t size, const char *file, int line) LIBXML_ATTR_ALLOC_SIZE(1);
XMLPUBFUN void * XMLCALL
xmlReallocLoc (void *ptr, size_t size, const char *file, int line);
XMLPUBFUN void * XMLCALL
xmlMallocAtomicLoc (size_t size, const char *file, int line) LIBXML_ATTR_ALLOC_SIZE(1);
XMLPUBFUN char * XMLCALL
xmlMemStrdupLoc (const char *str, const char *file, int line);
#ifdef DEBUG_MEMORY_LOCATION
/**
* xmlMalloc:
* @size: number of bytes to allocate
*
* Wrapper for the malloc() function used in the XML library.
*
* Returns the pointer to the allocated area or NULL in case of error.
*/
#define xmlMalloc(size) xmlMallocLoc((size), __FILE__, __LINE__)
/**
* xmlMallocAtomic:
* @size: number of bytes to allocate
*
* Wrapper for the malloc() function used in the XML library for allocation
* of block not containing pointers to other areas.
*
* Returns the pointer to the allocated area or NULL in case of error.
*/
#define xmlMallocAtomic(size) xmlMallocAtomicLoc((size), __FILE__, __LINE__)
/**
* xmlRealloc:
* @ptr: pointer to the existing allocated area
* @size: number of bytes to allocate
*
* Wrapper for the realloc() function used in the XML library.
*
* Returns the pointer to the allocated area or NULL in case of error.
*/
#define xmlRealloc(ptr, size) xmlReallocLoc((ptr), (size), __FILE__, __LINE__)
/**
* xmlMemStrdup:
* @str: pointer to the existing string
*
* Wrapper for the strdup() function, xmlStrdup() is usually preferred.
*
* Returns the pointer to the allocated area or NULL in case of error.
*/
#define xmlMemStrdup(str) xmlMemStrdupLoc((str), __FILE__, __LINE__)
#endif /* DEBUG_MEMORY_LOCATION */
#ifdef __cplusplus
}
#endif /* __cplusplus */
#ifndef __XML_GLOBALS_H
#ifndef __XML_THREADS_H__
#include <libxml/threads.h>
#include <libxml/globals.h>
#endif
#endif
#endif /* __DEBUG_MEMORY_ALLOC__ */
/*
* Summary: string dictionary
* Description: dictionary of reusable strings, just used to avoid allocation
* and freeing operations.
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_DICT_H__
#define __XML_DICT_H__
#include <stddef.h>
#include <libxml/xmlversion.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* The dictionary.
*/
typedef struct _xmlDict xmlDict;
typedef xmlDict *xmlDictPtr;
/*
* Initializer
*/
XML_DEPRECATED
XMLPUBFUN int XMLCALL xmlInitializeDict(void);
/*
* Constructor and destructor.
*/
XMLPUBFUN xmlDictPtr XMLCALL
xmlDictCreate (void);
XMLPUBFUN size_t XMLCALL
xmlDictSetLimit (xmlDictPtr dict,
size_t limit);
XMLPUBFUN size_t XMLCALL
xmlDictGetUsage (xmlDictPtr dict);
XMLPUBFUN xmlDictPtr XMLCALL
xmlDictCreateSub(xmlDictPtr sub);
XMLPUBFUN int XMLCALL
xmlDictReference(xmlDictPtr dict);
XMLPUBFUN void XMLCALL
xmlDictFree (xmlDictPtr dict);
/*
* Lookup of entry in the dictionary.
*/
XMLPUBFUN const xmlChar * XMLCALL
xmlDictLookup (xmlDictPtr dict,
const xmlChar *name,
int len);
XMLPUBFUN const xmlChar * XMLCALL
xmlDictExists (xmlDictPtr dict,
const xmlChar *name,
int len);
XMLPUBFUN const xmlChar * XMLCALL
xmlDictQLookup (xmlDictPtr dict,
const xmlChar *prefix,
const xmlChar *name);
XMLPUBFUN int XMLCALL
xmlDictOwns (xmlDictPtr dict,
const xmlChar *str);
XMLPUBFUN int XMLCALL
xmlDictSize (xmlDictPtr dict);
/*
* Cleanup function
*/
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlDictCleanup (void);
#ifdef __cplusplus
}
#endif
#endif /* ! __XML_DICT_H__ */
/*
* Summary: internal interfaces for XML Schemas
* Description: internal interfaces for the XML Schemas handling
* and schema validity checking
* The Schemas development is a Work In Progress.
* Some of those interfaces are not guaranteed to be API or ABI stable !
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_SCHEMA_INTERNALS_H__
#define __XML_SCHEMA_INTERNALS_H__
#include <libxml/xmlversion.h>
#ifdef LIBXML_SCHEMAS_ENABLED
#include <libxml/xmlregexp.h>
#include <libxml/hash.h>
#include <libxml/dict.h>
#ifdef __cplusplus
extern "C" {
#endif
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;
/*
* XML Schemas defines multiple type of types.
*/
typedef enum {
XML_SCHEMA_TYPE_BASIC = 1, /* A built-in datatype */
XML_SCHEMA_TYPE_ANY,
XML_SCHEMA_TYPE_FACET,
XML_SCHEMA_TYPE_SIMPLE,
XML_SCHEMA_TYPE_COMPLEX,
XML_SCHEMA_TYPE_SEQUENCE = 6,
XML_SCHEMA_TYPE_CHOICE,
XML_SCHEMA_TYPE_ALL,
XML_SCHEMA_TYPE_SIMPLE_CONTENT,
XML_SCHEMA_TYPE_COMPLEX_CONTENT,
XML_SCHEMA_TYPE_UR,
XML_SCHEMA_TYPE_RESTRICTION,
XML_SCHEMA_TYPE_EXTENSION,
XML_SCHEMA_TYPE_ELEMENT,
XML_SCHEMA_TYPE_ATTRIBUTE,
XML_SCHEMA_TYPE_ATTRIBUTEGROUP,
XML_SCHEMA_TYPE_GROUP,
XML_SCHEMA_TYPE_NOTATION,
XML_SCHEMA_TYPE_LIST,
XML_SCHEMA_TYPE_UNION,
XML_SCHEMA_TYPE_ANY_ATTRIBUTE,
XML_SCHEMA_TYPE_IDC_UNIQUE,
XML_SCHEMA_TYPE_IDC_KEY,
XML_SCHEMA_TYPE_IDC_KEYREF,
XML_SCHEMA_TYPE_PARTICLE = 25,
XML_SCHEMA_TYPE_ATTRIBUTE_USE,
XML_SCHEMA_FACET_MININCLUSIVE = 1000,
XML_SCHEMA_FACET_MINEXCLUSIVE,
XML_SCHEMA_FACET_MAXINCLUSIVE,
XML_SCHEMA_FACET_MAXEXCLUSIVE,
XML_SCHEMA_FACET_TOTALDIGITS,
XML_SCHEMA_FACET_FRACTIONDIGITS,
XML_SCHEMA_FACET_PATTERN,
XML_SCHEMA_FACET_ENUMERATION,
XML_SCHEMA_FACET_WHITESPACE,
XML_SCHEMA_FACET_LENGTH,
XML_SCHEMA_FACET_MAXLENGTH,
XML_SCHEMA_FACET_MINLENGTH,
XML_SCHEMA_EXTRA_QNAMEREF = 2000,
XML_SCHEMA_EXTRA_ATTR_USE_PROHIB
} xmlSchemaTypeType;
typedef enum {
XML_SCHEMA_CONTENT_UNKNOWN = 0,
XML_SCHEMA_CONTENT_EMPTY = 1,
XML_SCHEMA_CONTENT_ELEMENTS,
XML_SCHEMA_CONTENT_MIXED,
XML_SCHEMA_CONTENT_SIMPLE,
XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS, /* Obsolete */
XML_SCHEMA_CONTENT_BASIC,
XML_SCHEMA_CONTENT_ANY
} xmlSchemaContentType;
typedef struct _xmlSchemaVal xmlSchemaVal;
typedef xmlSchemaVal *xmlSchemaValPtr;
typedef struct _xmlSchemaType xmlSchemaType;
typedef xmlSchemaType *xmlSchemaTypePtr;
typedef struct _xmlSchemaFacet xmlSchemaFacet;
typedef xmlSchemaFacet *xmlSchemaFacetPtr;
/**
* Annotation
*/
typedef struct _xmlSchemaAnnot xmlSchemaAnnot;
typedef xmlSchemaAnnot *xmlSchemaAnnotPtr;
struct _xmlSchemaAnnot {
struct _xmlSchemaAnnot *next;
xmlNodePtr content; /* the annotation */
};
/**
* XML_SCHEMAS_ANYATTR_SKIP:
*
* Skip unknown attribute from validation
* Obsolete, not used anymore.
*/
#define XML_SCHEMAS_ANYATTR_SKIP 1
/**
* XML_SCHEMAS_ANYATTR_LAX:
*
* Ignore validation non definition on attributes
* Obsolete, not used anymore.
*/
#define XML_SCHEMAS_ANYATTR_LAX 2
/**
* XML_SCHEMAS_ANYATTR_STRICT:
*
* Apply strict validation rules on attributes
* Obsolete, not used anymore.
*/
#define XML_SCHEMAS_ANYATTR_STRICT 3
/**
* XML_SCHEMAS_ANY_SKIP:
*
* Skip unknown attribute from validation
*/
#define XML_SCHEMAS_ANY_SKIP 1
/**
* XML_SCHEMAS_ANY_LAX:
*
* Used by wildcards.
* Validate if type found, don't worry if not found
*/
#define XML_SCHEMAS_ANY_LAX 2
/**
* XML_SCHEMAS_ANY_STRICT:
*
* Used by wildcards.
* Apply strict validation rules
*/
#define XML_SCHEMAS_ANY_STRICT 3
/**
* XML_SCHEMAS_ATTR_USE_PROHIBITED:
*
* Used by wildcards.
* The attribute is prohibited.
*/
#define XML_SCHEMAS_ATTR_USE_PROHIBITED 0
/**
* XML_SCHEMAS_ATTR_USE_REQUIRED:
*
* The attribute is required.
*/
#define XML_SCHEMAS_ATTR_USE_REQUIRED 1
/**
* XML_SCHEMAS_ATTR_USE_OPTIONAL:
*
* The attribute is optional.
*/
#define XML_SCHEMAS_ATTR_USE_OPTIONAL 2
/**
* XML_SCHEMAS_ATTR_GLOBAL:
*
* allow elements in no namespace
*/
#define XML_SCHEMAS_ATTR_GLOBAL 1 << 0
/**
* XML_SCHEMAS_ATTR_NSDEFAULT:
*
* allow elements in no namespace
*/
#define XML_SCHEMAS_ATTR_NSDEFAULT 1 << 7
/**
* XML_SCHEMAS_ATTR_INTERNAL_RESOLVED:
*
* this is set when the "type" and "ref" references
* have been resolved.
*/
#define XML_SCHEMAS_ATTR_INTERNAL_RESOLVED 1 << 8
/**
* XML_SCHEMAS_ATTR_FIXED:
*
* the attribute has a fixed value
*/
#define XML_SCHEMAS_ATTR_FIXED 1 << 9
/**
* xmlSchemaAttribute:
* An attribute definition.
*/
typedef struct _xmlSchemaAttribute xmlSchemaAttribute;
typedef xmlSchemaAttribute *xmlSchemaAttributePtr;
struct _xmlSchemaAttribute {
xmlSchemaTypeType type;
struct _xmlSchemaAttribute *next; /* the next attribute (not used?) */
const xmlChar *name; /* the name of the declaration */
const xmlChar *id; /* Deprecated; not used */
const xmlChar *ref; /* Deprecated; not used */
const xmlChar *refNs; /* Deprecated; not used */
const xmlChar *typeName; /* the local name of the type definition */
const xmlChar *typeNs; /* the ns URI of the type definition */
xmlSchemaAnnotPtr annot;
xmlSchemaTypePtr base; /* Deprecated; not used */
int occurs; /* Deprecated; not used */
const xmlChar *defValue; /* The initial value of the value constraint */
xmlSchemaTypePtr subtypes; /* the type definition */
xmlNodePtr node;
const xmlChar *targetNamespace;
int flags;
const xmlChar *refPrefix; /* Deprecated; not used */
xmlSchemaValPtr defVal; /* The compiled value constraint */
xmlSchemaAttributePtr refDecl; /* Deprecated; not used */
};
/**
* xmlSchemaAttributeLink:
* Used to build a list of attribute uses on complexType definitions.
* WARNING: Deprecated; not used.
*/
typedef struct _xmlSchemaAttributeLink xmlSchemaAttributeLink;
typedef xmlSchemaAttributeLink *xmlSchemaAttributeLinkPtr;
struct _xmlSchemaAttributeLink {
struct _xmlSchemaAttributeLink *next;/* the next attribute link ... */
struct _xmlSchemaAttribute *attr;/* the linked attribute */
};
/**
* XML_SCHEMAS_WILDCARD_COMPLETE:
*
* If the wildcard is complete.
*/
#define XML_SCHEMAS_WILDCARD_COMPLETE 1 << 0
/**
* xmlSchemaCharValueLink:
* Used to build a list of namespaces on wildcards.
*/
typedef struct _xmlSchemaWildcardNs xmlSchemaWildcardNs;
typedef xmlSchemaWildcardNs *xmlSchemaWildcardNsPtr;
struct _xmlSchemaWildcardNs {
struct _xmlSchemaWildcardNs *next;/* the next constraint link ... */
const xmlChar *value;/* the value */
};
/**
* xmlSchemaWildcard.
* A wildcard.
*/
typedef struct _xmlSchemaWildcard xmlSchemaWildcard;
typedef xmlSchemaWildcard *xmlSchemaWildcardPtr;
struct _xmlSchemaWildcard {
xmlSchemaTypeType type; /* The kind of type */
const xmlChar *id; /* Deprecated; not used */
xmlSchemaAnnotPtr annot;
xmlNodePtr node;
int minOccurs; /* Deprecated; not used */
int maxOccurs; /* Deprecated; not used */
int processContents;
int any; /* Indicates if the ns constraint is of ##any */
xmlSchemaWildcardNsPtr nsSet; /* The list of allowed namespaces */
xmlSchemaWildcardNsPtr negNsSet; /* The negated namespace */
int flags;
};
/**
* XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED:
*
* The attribute wildcard has been built.
*/
#define XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED 1 << 0
/**
* XML_SCHEMAS_ATTRGROUP_GLOBAL:
*
* The attribute group has been defined.
*/
#define XML_SCHEMAS_ATTRGROUP_GLOBAL 1 << 1
/**
* XML_SCHEMAS_ATTRGROUP_MARKED:
*
* Marks the attr group as marked; used for circular checks.
*/
#define XML_SCHEMAS_ATTRGROUP_MARKED 1 << 2
/**
* XML_SCHEMAS_ATTRGROUP_REDEFINED:
*
* The attr group was redefined.
*/
#define XML_SCHEMAS_ATTRGROUP_REDEFINED 1 << 3
/**
* XML_SCHEMAS_ATTRGROUP_HAS_REFS:
*
* Whether this attr. group contains attr. group references.
*/
#define XML_SCHEMAS_ATTRGROUP_HAS_REFS 1 << 4
/**
* An attribute group definition.
*
* xmlSchemaAttribute and xmlSchemaAttributeGroup start of structures
* must be kept similar
*/
typedef struct _xmlSchemaAttributeGroup xmlSchemaAttributeGroup;
typedef xmlSchemaAttributeGroup *xmlSchemaAttributeGroupPtr;
struct _xmlSchemaAttributeGroup {
xmlSchemaTypeType type; /* The kind of type */
struct _xmlSchemaAttribute *next;/* the next attribute if in a group ... */
const xmlChar *name;
const xmlChar *id;
const xmlChar *ref; /* Deprecated; not used */
const xmlChar *refNs; /* Deprecated; not used */
xmlSchemaAnnotPtr annot;
xmlSchemaAttributePtr attributes; /* Deprecated; not used */
xmlNodePtr node;
int flags;
xmlSchemaWildcardPtr attributeWildcard;
const xmlChar *refPrefix; /* Deprecated; not used */
xmlSchemaAttributeGroupPtr refItem; /* Deprecated; not used */
const xmlChar *targetNamespace;
void *attrUses;
};
/**
* xmlSchemaTypeLink:
* Used to build a list of types (e.g. member types of
* simpleType with variety "union").
*/
typedef struct _xmlSchemaTypeLink xmlSchemaTypeLink;
typedef xmlSchemaTypeLink *xmlSchemaTypeLinkPtr;
struct _xmlSchemaTypeLink {
struct _xmlSchemaTypeLink *next;/* the next type link ... */
xmlSchemaTypePtr type;/* the linked type */
};
/**
* xmlSchemaFacetLink:
* Used to build a list of facets.
*/
typedef struct _xmlSchemaFacetLink xmlSchemaFacetLink;
typedef xmlSchemaFacetLink *xmlSchemaFacetLinkPtr;
struct _xmlSchemaFacetLink {
struct _xmlSchemaFacetLink *next;/* the next facet link ... */
xmlSchemaFacetPtr facet;/* the linked facet */
};
/**
* XML_SCHEMAS_TYPE_MIXED:
*
* the element content type is mixed
*/
#define XML_SCHEMAS_TYPE_MIXED 1 << 0
/**
* XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION:
*
* the simple or complex type has a derivation method of "extension".
*/
#define XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION 1 << 1
/**
* XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION:
*
* the simple or complex type has a derivation method of "restriction".
*/
#define XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION 1 << 2
/**
* XML_SCHEMAS_TYPE_GLOBAL:
*
* the type is global
*/
#define XML_SCHEMAS_TYPE_GLOBAL 1 << 3
/**
* XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD:
*
* the complexType owns an attribute wildcard, i.e.
* it can be freed by the complexType
*/
#define XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD 1 << 4 /* Obsolete. */
/**
* XML_SCHEMAS_TYPE_VARIETY_ABSENT:
*
* the simpleType has a variety of "absent".
* TODO: Actually not necessary :-/, since if
* none of the variety flags occur then it's
* automatically absent.
*/
#define XML_SCHEMAS_TYPE_VARIETY_ABSENT 1 << 5
/**
* XML_SCHEMAS_TYPE_VARIETY_LIST:
*
* the simpleType has a variety of "list".
*/
#define XML_SCHEMAS_TYPE_VARIETY_LIST 1 << 6
/**
* XML_SCHEMAS_TYPE_VARIETY_UNION:
*
* the simpleType has a variety of "union".
*/
#define XML_SCHEMAS_TYPE_VARIETY_UNION 1 << 7
/**
* XML_SCHEMAS_TYPE_VARIETY_ATOMIC:
*
* the simpleType has a variety of "union".
*/
#define XML_SCHEMAS_TYPE_VARIETY_ATOMIC 1 << 8
/**
* XML_SCHEMAS_TYPE_FINAL_EXTENSION:
*
* the complexType has a final of "extension".
*/
#define XML_SCHEMAS_TYPE_FINAL_EXTENSION 1 << 9
/**
* XML_SCHEMAS_TYPE_FINAL_RESTRICTION:
*
* the simpleType/complexType has a final of "restriction".
*/
#define XML_SCHEMAS_TYPE_FINAL_RESTRICTION 1 << 10
/**
* XML_SCHEMAS_TYPE_FINAL_LIST:
*
* the simpleType has a final of "list".
*/
#define XML_SCHEMAS_TYPE_FINAL_LIST 1 << 11
/**
* XML_SCHEMAS_TYPE_FINAL_UNION:
*
* the simpleType has a final of "union".
*/
#define XML_SCHEMAS_TYPE_FINAL_UNION 1 << 12
/**
* XML_SCHEMAS_TYPE_FINAL_DEFAULT:
*
* the simpleType has a final of "default".
*/
#define XML_SCHEMAS_TYPE_FINAL_DEFAULT 1 << 13
/**
* XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE:
*
* Marks the item as a builtin primitive.
*/
#define XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE 1 << 14
/**
* XML_SCHEMAS_TYPE_MARKED:
*
* Marks the item as marked; used for circular checks.
*/
#define XML_SCHEMAS_TYPE_MARKED 1 << 16
/**
* XML_SCHEMAS_TYPE_BLOCK_DEFAULT:
*
* the complexType did not specify 'block' so use the default of the
* <schema> item.
*/
#define XML_SCHEMAS_TYPE_BLOCK_DEFAULT 1 << 17
/**
* XML_SCHEMAS_TYPE_BLOCK_EXTENSION:
*
* the complexType has a 'block' of "extension".
*/
#define XML_SCHEMAS_TYPE_BLOCK_EXTENSION 1 << 18
/**
* XML_SCHEMAS_TYPE_BLOCK_RESTRICTION:
*
* the complexType has a 'block' of "restriction".
*/
#define XML_SCHEMAS_TYPE_BLOCK_RESTRICTION 1 << 19
/**
* XML_SCHEMAS_TYPE_ABSTRACT:
*
* the simple/complexType is abstract.
*/
#define XML_SCHEMAS_TYPE_ABSTRACT 1 << 20
/**
* XML_SCHEMAS_TYPE_FACETSNEEDVALUE:
*
* indicates if the facets need a computed value
*/
#define XML_SCHEMAS_TYPE_FACETSNEEDVALUE 1 << 21
/**
* XML_SCHEMAS_TYPE_INTERNAL_RESOLVED:
*
* indicates that the type was typefixed
*/
#define XML_SCHEMAS_TYPE_INTERNAL_RESOLVED 1 << 22
/**
* XML_SCHEMAS_TYPE_INTERNAL_INVALID:
*
* indicates that the type is invalid
*/
#define XML_SCHEMAS_TYPE_INTERNAL_INVALID 1 << 23
/**
* XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE:
*
* a whitespace-facet value of "preserve"
*/
#define XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE 1 << 24
/**
* XML_SCHEMAS_TYPE_WHITESPACE_REPLACE:
*
* a whitespace-facet value of "replace"
*/
#define XML_SCHEMAS_TYPE_WHITESPACE_REPLACE 1 << 25
/**
* XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE:
*
* a whitespace-facet value of "collapse"
*/
#define XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE 1 << 26
/**
* XML_SCHEMAS_TYPE_HAS_FACETS:
*
* has facets
*/
#define XML_SCHEMAS_TYPE_HAS_FACETS 1 << 27
/**
* XML_SCHEMAS_TYPE_NORMVALUENEEDED:
*
* indicates if the facets (pattern) need a normalized value
*/
#define XML_SCHEMAS_TYPE_NORMVALUENEEDED 1 << 28
/**
* XML_SCHEMAS_TYPE_FIXUP_1:
*
* First stage of fixup was done.
*/
#define XML_SCHEMAS_TYPE_FIXUP_1 1 << 29
/**
* XML_SCHEMAS_TYPE_REDEFINED:
*
* The type was redefined.
*/
#define XML_SCHEMAS_TYPE_REDEFINED 1 << 30
/**
* XML_SCHEMAS_TYPE_REDEFINING:
*
* The type redefines an other type.
*/
/* #define XML_SCHEMAS_TYPE_REDEFINING 1 << 31 */
/**
* _xmlSchemaType:
*
* Schemas type definition.
*/
struct _xmlSchemaType {
xmlSchemaTypeType type; /* The kind of type */
struct _xmlSchemaType *next; /* the next type if in a sequence ... */
const xmlChar *name;
const xmlChar *id ; /* Deprecated; not used */
const xmlChar *ref; /* Deprecated; not used */
const xmlChar *refNs; /* Deprecated; not used */
xmlSchemaAnnotPtr annot;
xmlSchemaTypePtr subtypes;
xmlSchemaAttributePtr attributes; /* Deprecated; not used */
xmlNodePtr node;
int minOccurs; /* Deprecated; not used */
int maxOccurs; /* Deprecated; not used */
int flags;
xmlSchemaContentType contentType;
const xmlChar *base; /* Base type's local name */
const xmlChar *baseNs; /* Base type's target namespace */
xmlSchemaTypePtr baseType; /* The base type component */
xmlSchemaFacetPtr facets; /* Local facets */
struct _xmlSchemaType *redef; /* Deprecated; not used */
int recurse; /* Obsolete */
xmlSchemaAttributeLinkPtr *attributeUses; /* Deprecated; not used */
xmlSchemaWildcardPtr attributeWildcard;
int builtInType; /* Type of built-in types. */
xmlSchemaTypeLinkPtr memberTypes; /* member-types if a union type. */
xmlSchemaFacetLinkPtr facetSet; /* All facets (incl. inherited) */
const xmlChar *refPrefix; /* Deprecated; not used */
xmlSchemaTypePtr contentTypeDef; /* Used for the simple content of complex types.
Could we use @subtypes for this? */
xmlRegexpPtr contModel; /* Holds the automaton of the content model */
const xmlChar *targetNamespace;
void *attrUses;
};
/*
* xmlSchemaElement:
* An element definition.
*
* xmlSchemaType, xmlSchemaFacet and xmlSchemaElement start of
* structures must be kept similar
*/
/**
* XML_SCHEMAS_ELEM_NILLABLE:
*
* the element is nillable
*/
#define XML_SCHEMAS_ELEM_NILLABLE 1 << 0
/**
* XML_SCHEMAS_ELEM_GLOBAL:
*
* the element is global
*/
#define XML_SCHEMAS_ELEM_GLOBAL 1 << 1
/**
* XML_SCHEMAS_ELEM_DEFAULT:
*
* the element has a default value
*/
#define XML_SCHEMAS_ELEM_DEFAULT 1 << 2
/**
* XML_SCHEMAS_ELEM_FIXED:
*
* the element has a fixed value
*/
#define XML_SCHEMAS_ELEM_FIXED 1 << 3
/**
* XML_SCHEMAS_ELEM_ABSTRACT:
*
* the element is abstract
*/
#define XML_SCHEMAS_ELEM_ABSTRACT 1 << 4
/**
* XML_SCHEMAS_ELEM_TOPLEVEL:
*
* the element is top level
* obsolete: use XML_SCHEMAS_ELEM_GLOBAL instead
*/
#define XML_SCHEMAS_ELEM_TOPLEVEL 1 << 5
/**
* XML_SCHEMAS_ELEM_REF:
*
* the element is a reference to a type
*/
#define XML_SCHEMAS_ELEM_REF 1 << 6
/**
* XML_SCHEMAS_ELEM_NSDEFAULT:
*
* allow elements in no namespace
* Obsolete, not used anymore.
*/
#define XML_SCHEMAS_ELEM_NSDEFAULT 1 << 7
/**
* XML_SCHEMAS_ELEM_INTERNAL_RESOLVED:
*
* this is set when "type", "ref", "substitutionGroup"
* references have been resolved.
*/
#define XML_SCHEMAS_ELEM_INTERNAL_RESOLVED 1 << 8
/**
* XML_SCHEMAS_ELEM_CIRCULAR:
*
* a helper flag for the search of circular references.
*/
#define XML_SCHEMAS_ELEM_CIRCULAR 1 << 9
/**
* XML_SCHEMAS_ELEM_BLOCK_ABSENT:
*
* the "block" attribute is absent
*/
#define XML_SCHEMAS_ELEM_BLOCK_ABSENT 1 << 10
/**
* XML_SCHEMAS_ELEM_BLOCK_EXTENSION:
*
* disallowed substitutions are absent
*/
#define XML_SCHEMAS_ELEM_BLOCK_EXTENSION 1 << 11
/**
* XML_SCHEMAS_ELEM_BLOCK_RESTRICTION:
*
* disallowed substitutions: "restriction"
*/
#define XML_SCHEMAS_ELEM_BLOCK_RESTRICTION 1 << 12
/**
* XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION:
*
* disallowed substitutions: "substitution"
*/
#define XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION 1 << 13
/**
* XML_SCHEMAS_ELEM_FINAL_ABSENT:
*
* substitution group exclusions are absent
*/
#define XML_SCHEMAS_ELEM_FINAL_ABSENT 1 << 14
/**
* XML_SCHEMAS_ELEM_FINAL_EXTENSION:
*
* substitution group exclusions: "extension"
*/
#define XML_SCHEMAS_ELEM_FINAL_EXTENSION 1 << 15
/**
* XML_SCHEMAS_ELEM_FINAL_RESTRICTION:
*
* substitution group exclusions: "restriction"
*/
#define XML_SCHEMAS_ELEM_FINAL_RESTRICTION 1 << 16
/**
* XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD:
*
* the declaration is a substitution group head
*/
#define XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD 1 << 17
/**
* XML_SCHEMAS_ELEM_INTERNAL_CHECKED:
*
* this is set when the elem decl has been checked against
* all constraints
*/
#define XML_SCHEMAS_ELEM_INTERNAL_CHECKED 1 << 18
typedef struct _xmlSchemaElement xmlSchemaElement;
typedef xmlSchemaElement *xmlSchemaElementPtr;
struct _xmlSchemaElement {
xmlSchemaTypeType type; /* The kind of type */
struct _xmlSchemaType *next; /* Not used? */
const xmlChar *name;
const xmlChar *id; /* Deprecated; not used */
const xmlChar *ref; /* Deprecated; not used */
const xmlChar *refNs; /* Deprecated; not used */
xmlSchemaAnnotPtr annot;
xmlSchemaTypePtr subtypes; /* the type definition */
xmlSchemaAttributePtr attributes;
xmlNodePtr node;
int minOccurs; /* Deprecated; not used */
int maxOccurs; /* Deprecated; not used */
int flags;
const xmlChar *targetNamespace;
const xmlChar *namedType;
const xmlChar *namedTypeNs;
const xmlChar *substGroup;
const xmlChar *substGroupNs;
const xmlChar *scope;
const xmlChar *value; /* The original value of the value constraint. */
struct _xmlSchemaElement *refDecl; /* This will now be used for the
substitution group affiliation */
xmlRegexpPtr contModel; /* Obsolete for WXS, maybe used for RelaxNG */
xmlSchemaContentType contentType;
const xmlChar *refPrefix; /* Deprecated; not used */
xmlSchemaValPtr defVal; /* The compiled value constraint. */
void *idcs; /* The identity-constraint defs */
};
/*
* XML_SCHEMAS_FACET_UNKNOWN:
*
* unknown facet handling
*/
#define XML_SCHEMAS_FACET_UNKNOWN 0
/*
* XML_SCHEMAS_FACET_PRESERVE:
*
* preserve the type of the facet
*/
#define XML_SCHEMAS_FACET_PRESERVE 1
/*
* XML_SCHEMAS_FACET_REPLACE:
*
* replace the type of the facet
*/
#define XML_SCHEMAS_FACET_REPLACE 2
/*
* XML_SCHEMAS_FACET_COLLAPSE:
*
* collapse the types of the facet
*/
#define XML_SCHEMAS_FACET_COLLAPSE 3
/**
* A facet definition.
*/
struct _xmlSchemaFacet {
xmlSchemaTypeType type; /* The kind of type */
struct _xmlSchemaFacet *next;/* the next type if in a sequence ... */
const xmlChar *value; /* The original value */
const xmlChar *id; /* Obsolete */
xmlSchemaAnnotPtr annot;
xmlNodePtr node;
int fixed; /* XML_SCHEMAS_FACET_PRESERVE, etc. */
int whitespace;
xmlSchemaValPtr val; /* The compiled value */
xmlRegexpPtr regexp; /* The regex for patterns */
};
/**
* A notation definition.
*/
typedef struct _xmlSchemaNotation xmlSchemaNotation;
typedef xmlSchemaNotation *xmlSchemaNotationPtr;
struct _xmlSchemaNotation {
xmlSchemaTypeType type; /* The kind of type */
const xmlChar *name;
xmlSchemaAnnotPtr annot;
const xmlChar *identifier;
const xmlChar *targetNamespace;
};
/*
* TODO: Actually all those flags used for the schema should sit
* on the schema parser context, since they are used only
* during parsing an XML schema document, and not available
* on the component level as per spec.
*/
/**
* XML_SCHEMAS_QUALIF_ELEM:
*
* Reflects elementFormDefault == qualified in
* an XML schema document.
*/
#define XML_SCHEMAS_QUALIF_ELEM 1 << 0
/**
* XML_SCHEMAS_QUALIF_ATTR:
*
* Reflects attributeFormDefault == qualified in
* an XML schema document.
*/
#define XML_SCHEMAS_QUALIF_ATTR 1 << 1
/**
* XML_SCHEMAS_FINAL_DEFAULT_EXTENSION:
*
* the schema has "extension" in the set of finalDefault.
*/
#define XML_SCHEMAS_FINAL_DEFAULT_EXTENSION 1 << 2
/**
* XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION:
*
* the schema has "restriction" in the set of finalDefault.
*/
#define XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION 1 << 3
/**
* XML_SCHEMAS_FINAL_DEFAULT_LIST:
*
* the schema has "list" in the set of finalDefault.
*/
#define XML_SCHEMAS_FINAL_DEFAULT_LIST 1 << 4
/**
* XML_SCHEMAS_FINAL_DEFAULT_UNION:
*
* the schema has "union" in the set of finalDefault.
*/
#define XML_SCHEMAS_FINAL_DEFAULT_UNION 1 << 5
/**
* XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION:
*
* the schema has "extension" in the set of blockDefault.
*/
#define XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION 1 << 6
/**
* XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION:
*
* the schema has "restriction" in the set of blockDefault.
*/
#define XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION 1 << 7
/**
* XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION:
*
* the schema has "substitution" in the set of blockDefault.
*/
#define XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION 1 << 8
/**
* XML_SCHEMAS_INCLUDING_CONVERT_NS:
*
* the schema is currently including an other schema with
* no target namespace.
*/
#define XML_SCHEMAS_INCLUDING_CONVERT_NS 1 << 9
/**
* _xmlSchema:
*
* A Schemas definition
*/
struct _xmlSchema {
const xmlChar *name; /* schema name */
const xmlChar *targetNamespace; /* the target namespace */
const xmlChar *version;
const xmlChar *id; /* Obsolete */
xmlDocPtr doc;
xmlSchemaAnnotPtr annot;
int flags;
xmlHashTablePtr typeDecl;
xmlHashTablePtr attrDecl;
xmlHashTablePtr attrgrpDecl;
xmlHashTablePtr elemDecl;
xmlHashTablePtr notaDecl;
xmlHashTablePtr schemasImports;
void *_private; /* unused by the library for users or bindings */
xmlHashTablePtr groupDecl;
xmlDictPtr dict;
void *includes; /* the includes, this is opaque for now */
int preserve; /* whether to free the document */
int counter; /* used to give anonymous components unique names */
xmlHashTablePtr idcDef; /* All identity-constraint defs. */
void *volatiles; /* Obsolete */
};
XMLPUBFUN void XMLCALL xmlSchemaFreeType (xmlSchemaTypePtr type);
XMLPUBFUN void XMLCALL xmlSchemaFreeWildcard(xmlSchemaWildcardPtr wildcard);
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_SCHEMAS_ENABLED */
#endif /* __XML_SCHEMA_INTERNALS_H__ */
/*
* Summary: text writing API for XML
* Description: text writing API for XML
*
* Copy: See Copyright for the status of this software.
*
* Author: Alfred Mickautsch <alfred@mickautsch.de>
*/
#ifndef __XML_XMLWRITER_H__
#define __XML_XMLWRITER_H__
#include <libxml/xmlversion.h>
#ifdef LIBXML_WRITER_ENABLED
#include <stdarg.h>
#include <libxml/xmlIO.h>
#include <libxml/list.h>
#include <libxml/xmlstring.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct _xmlTextWriter xmlTextWriter;
typedef xmlTextWriter *xmlTextWriterPtr;
/*
* Constructors & Destructor
*/
XMLPUBFUN xmlTextWriterPtr XMLCALL
xmlNewTextWriter(xmlOutputBufferPtr out);
XMLPUBFUN xmlTextWriterPtr XMLCALL
xmlNewTextWriterFilename(const char *uri, int compression);
XMLPUBFUN xmlTextWriterPtr XMLCALL
xmlNewTextWriterMemory(xmlBufferPtr buf, int compression);
XMLPUBFUN xmlTextWriterPtr XMLCALL
xmlNewTextWriterPushParser(xmlParserCtxtPtr ctxt, int compression);
XMLPUBFUN xmlTextWriterPtr XMLCALL
xmlNewTextWriterDoc(xmlDocPtr * doc, int compression);
XMLPUBFUN xmlTextWriterPtr XMLCALL
xmlNewTextWriterTree(xmlDocPtr doc, xmlNodePtr node,
int compression);
XMLPUBFUN void XMLCALL xmlFreeTextWriter(xmlTextWriterPtr writer);
/*
* Functions
*/
/*
* Document
*/
XMLPUBFUN int XMLCALL
xmlTextWriterStartDocument(xmlTextWriterPtr writer,
const char *version,
const char *encoding,
const char *standalone);
XMLPUBFUN int XMLCALL xmlTextWriterEndDocument(xmlTextWriterPtr
writer);
/*
* Comments
*/
XMLPUBFUN int XMLCALL xmlTextWriterStartComment(xmlTextWriterPtr
writer);
XMLPUBFUN int XMLCALL xmlTextWriterEndComment(xmlTextWriterPtr writer);
XMLPUBFUN int XMLCALL
xmlTextWriterWriteFormatComment(xmlTextWriterPtr writer,
const char *format, ...)
LIBXML_ATTR_FORMAT(2,3);
XMLPUBFUN int XMLCALL
xmlTextWriterWriteVFormatComment(xmlTextWriterPtr writer,
const char *format,
va_list argptr)
LIBXML_ATTR_FORMAT(2,0);
XMLPUBFUN int XMLCALL xmlTextWriterWriteComment(xmlTextWriterPtr
writer,
const xmlChar *
content);
/*
* Elements
*/
XMLPUBFUN int XMLCALL
xmlTextWriterStartElement(xmlTextWriterPtr writer,
const xmlChar * name);
XMLPUBFUN int XMLCALL xmlTextWriterStartElementNS(xmlTextWriterPtr
writer,
const xmlChar *
prefix,
const xmlChar * name,
const xmlChar *
namespaceURI);
XMLPUBFUN int XMLCALL xmlTextWriterEndElement(xmlTextWriterPtr writer);
XMLPUBFUN int XMLCALL xmlTextWriterFullEndElement(xmlTextWriterPtr
writer);
/*
* Elements conveniency functions
*/
XMLPUBFUN int XMLCALL
xmlTextWriterWriteFormatElement(xmlTextWriterPtr writer,
const xmlChar * name,
const char *format, ...)
LIBXML_ATTR_FORMAT(3,4);
XMLPUBFUN int XMLCALL
xmlTextWriterWriteVFormatElement(xmlTextWriterPtr writer,
const xmlChar * name,
const char *format,
va_list argptr)
LIBXML_ATTR_FORMAT(3,0);
XMLPUBFUN int XMLCALL xmlTextWriterWriteElement(xmlTextWriterPtr
writer,
const xmlChar * name,
const xmlChar *
content);
XMLPUBFUN int XMLCALL
xmlTextWriterWriteFormatElementNS(xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI,
const char *format, ...)
LIBXML_ATTR_FORMAT(5,6);
XMLPUBFUN int XMLCALL
xmlTextWriterWriteVFormatElementNS(xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI,
const char *format,
va_list argptr)
LIBXML_ATTR_FORMAT(5,0);
XMLPUBFUN int XMLCALL xmlTextWriterWriteElementNS(xmlTextWriterPtr
writer,
const xmlChar *
prefix,
const xmlChar * name,
const xmlChar *
namespaceURI,
const xmlChar *
content);
/*
* Text
*/
XMLPUBFUN int XMLCALL
xmlTextWriterWriteFormatRaw(xmlTextWriterPtr writer,
const char *format, ...)
LIBXML_ATTR_FORMAT(2,3);
XMLPUBFUN int XMLCALL
xmlTextWriterWriteVFormatRaw(xmlTextWriterPtr writer,
const char *format, va_list argptr)
LIBXML_ATTR_FORMAT(2,0);
XMLPUBFUN int XMLCALL
xmlTextWriterWriteRawLen(xmlTextWriterPtr writer,
const xmlChar * content, int len);
XMLPUBFUN int XMLCALL
xmlTextWriterWriteRaw(xmlTextWriterPtr writer,
const xmlChar * content);
XMLPUBFUN int XMLCALL xmlTextWriterWriteFormatString(xmlTextWriterPtr
writer,
const char
*format, ...)
LIBXML_ATTR_FORMAT(2,3);
XMLPUBFUN int XMLCALL xmlTextWriterWriteVFormatString(xmlTextWriterPtr
writer,
const char
*format,
va_list argptr)
LIBXML_ATTR_FORMAT(2,0);
XMLPUBFUN int XMLCALL xmlTextWriterWriteString(xmlTextWriterPtr writer,
const xmlChar *
content);
XMLPUBFUN int XMLCALL xmlTextWriterWriteBase64(xmlTextWriterPtr writer,
const char *data,
int start, int len);
XMLPUBFUN int XMLCALL xmlTextWriterWriteBinHex(xmlTextWriterPtr writer,
const char *data,
int start, int len);
/*
* Attributes
*/
XMLPUBFUN int XMLCALL
xmlTextWriterStartAttribute(xmlTextWriterPtr writer,
const xmlChar * name);
XMLPUBFUN int XMLCALL xmlTextWriterStartAttributeNS(xmlTextWriterPtr
writer,
const xmlChar *
prefix,
const xmlChar *
name,
const xmlChar *
namespaceURI);
XMLPUBFUN int XMLCALL xmlTextWriterEndAttribute(xmlTextWriterPtr
writer);
/*
* Attributes conveniency functions
*/
XMLPUBFUN int XMLCALL
xmlTextWriterWriteFormatAttribute(xmlTextWriterPtr writer,
const xmlChar * name,
const char *format, ...)
LIBXML_ATTR_FORMAT(3,4);
XMLPUBFUN int XMLCALL
xmlTextWriterWriteVFormatAttribute(xmlTextWriterPtr writer,
const xmlChar * name,
const char *format,
va_list argptr)
LIBXML_ATTR_FORMAT(3,0);
XMLPUBFUN int XMLCALL xmlTextWriterWriteAttribute(xmlTextWriterPtr
writer,
const xmlChar * name,
const xmlChar *
content);
XMLPUBFUN int XMLCALL
xmlTextWriterWriteFormatAttributeNS(xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI,
const char *format, ...)
LIBXML_ATTR_FORMAT(5,6);
XMLPUBFUN int XMLCALL
xmlTextWriterWriteVFormatAttributeNS(xmlTextWriterPtr writer,
const xmlChar * prefix,
const xmlChar * name,
const xmlChar * namespaceURI,
const char *format,
va_list argptr)
LIBXML_ATTR_FORMAT(5,0);
XMLPUBFUN int XMLCALL xmlTextWriterWriteAttributeNS(xmlTextWriterPtr
writer,
const xmlChar *
prefix,
const xmlChar *
name,
const xmlChar *
namespaceURI,
const xmlChar *
content);
/*
* PI's
*/
XMLPUBFUN int XMLCALL
xmlTextWriterStartPI(xmlTextWriterPtr writer,
const xmlChar * target);
XMLPUBFUN int XMLCALL xmlTextWriterEndPI(xmlTextWriterPtr writer);
/*
* PI conveniency functions
*/
XMLPUBFUN int XMLCALL
xmlTextWriterWriteFormatPI(xmlTextWriterPtr writer,
const xmlChar * target,
const char *format, ...)
LIBXML_ATTR_FORMAT(3,4);
XMLPUBFUN int XMLCALL
xmlTextWriterWriteVFormatPI(xmlTextWriterPtr writer,
const xmlChar * target,
const char *format, va_list argptr)
LIBXML_ATTR_FORMAT(3,0);
XMLPUBFUN int XMLCALL
xmlTextWriterWritePI(xmlTextWriterPtr writer,
const xmlChar * target,
const xmlChar * content);
/**
* xmlTextWriterWriteProcessingInstruction:
*
* This macro maps to xmlTextWriterWritePI
*/
#define xmlTextWriterWriteProcessingInstruction xmlTextWriterWritePI
/*
* CDATA
*/
XMLPUBFUN int XMLCALL xmlTextWriterStartCDATA(xmlTextWriterPtr writer);
XMLPUBFUN int XMLCALL xmlTextWriterEndCDATA(xmlTextWriterPtr writer);
/*
* CDATA conveniency functions
*/
XMLPUBFUN int XMLCALL
xmlTextWriterWriteFormatCDATA(xmlTextWriterPtr writer,
const char *format, ...)
LIBXML_ATTR_FORMAT(2,3);
XMLPUBFUN int XMLCALL
xmlTextWriterWriteVFormatCDATA(xmlTextWriterPtr writer,
const char *format, va_list argptr)
LIBXML_ATTR_FORMAT(2,0);
XMLPUBFUN int XMLCALL
xmlTextWriterWriteCDATA(xmlTextWriterPtr writer,
const xmlChar * content);
/*
* DTD
*/
XMLPUBFUN int XMLCALL
xmlTextWriterStartDTD(xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid);
XMLPUBFUN int XMLCALL xmlTextWriterEndDTD(xmlTextWriterPtr writer);
/*
* DTD conveniency functions
*/
XMLPUBFUN int XMLCALL
xmlTextWriterWriteFormatDTD(xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid,
const char *format, ...)
LIBXML_ATTR_FORMAT(5,6);
XMLPUBFUN int XMLCALL
xmlTextWriterWriteVFormatDTD(xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid,
const char *format, va_list argptr)
LIBXML_ATTR_FORMAT(5,0);
XMLPUBFUN int XMLCALL
xmlTextWriterWriteDTD(xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid,
const xmlChar * subset);
/**
* xmlTextWriterWriteDocType:
*
* this macro maps to xmlTextWriterWriteDTD
*/
#define xmlTextWriterWriteDocType xmlTextWriterWriteDTD
/*
* DTD element definition
*/
XMLPUBFUN int XMLCALL
xmlTextWriterStartDTDElement(xmlTextWriterPtr writer,
const xmlChar * name);
XMLPUBFUN int XMLCALL xmlTextWriterEndDTDElement(xmlTextWriterPtr
writer);
/*
* DTD element definition conveniency functions
*/
XMLPUBFUN int XMLCALL
xmlTextWriterWriteFormatDTDElement(xmlTextWriterPtr writer,
const xmlChar * name,
const char *format, ...)
LIBXML_ATTR_FORMAT(3,4);
XMLPUBFUN int XMLCALL
xmlTextWriterWriteVFormatDTDElement(xmlTextWriterPtr writer,
const xmlChar * name,
const char *format,
va_list argptr)
LIBXML_ATTR_FORMAT(3,0);
XMLPUBFUN int XMLCALL xmlTextWriterWriteDTDElement(xmlTextWriterPtr
writer,
const xmlChar *
name,
const xmlChar *
content);
/*
* DTD attribute list definition
*/
XMLPUBFUN int XMLCALL
xmlTextWriterStartDTDAttlist(xmlTextWriterPtr writer,
const xmlChar * name);
XMLPUBFUN int XMLCALL xmlTextWriterEndDTDAttlist(xmlTextWriterPtr
writer);
/*
* DTD attribute list definition conveniency functions
*/
XMLPUBFUN int XMLCALL
xmlTextWriterWriteFormatDTDAttlist(xmlTextWriterPtr writer,
const xmlChar * name,
const char *format, ...)
LIBXML_ATTR_FORMAT(3,4);
XMLPUBFUN int XMLCALL
xmlTextWriterWriteVFormatDTDAttlist(xmlTextWriterPtr writer,
const xmlChar * name,
const char *format,
va_list argptr)
LIBXML_ATTR_FORMAT(3,0);
XMLPUBFUN int XMLCALL xmlTextWriterWriteDTDAttlist(xmlTextWriterPtr
writer,
const xmlChar *
name,
const xmlChar *
content);
/*
* DTD entity definition
*/
XMLPUBFUN int XMLCALL
xmlTextWriterStartDTDEntity(xmlTextWriterPtr writer,
int pe, const xmlChar * name);
XMLPUBFUN int XMLCALL xmlTextWriterEndDTDEntity(xmlTextWriterPtr
writer);
/*
* DTD entity definition conveniency functions
*/
XMLPUBFUN int XMLCALL
xmlTextWriterWriteFormatDTDInternalEntity(xmlTextWriterPtr writer,
int pe,
const xmlChar * name,
const char *format, ...)
LIBXML_ATTR_FORMAT(4,5);
XMLPUBFUN int XMLCALL
xmlTextWriterWriteVFormatDTDInternalEntity(xmlTextWriterPtr writer,
int pe,
const xmlChar * name,
const char *format,
va_list argptr)
LIBXML_ATTR_FORMAT(4,0);
XMLPUBFUN int XMLCALL
xmlTextWriterWriteDTDInternalEntity(xmlTextWriterPtr writer,
int pe,
const xmlChar * name,
const xmlChar * content);
XMLPUBFUN int XMLCALL
xmlTextWriterWriteDTDExternalEntity(xmlTextWriterPtr writer,
int pe,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid,
const xmlChar * ndataid);
XMLPUBFUN int XMLCALL
xmlTextWriterWriteDTDExternalEntityContents(xmlTextWriterPtr
writer,
const xmlChar * pubid,
const xmlChar * sysid,
const xmlChar *
ndataid);
XMLPUBFUN int XMLCALL xmlTextWriterWriteDTDEntity(xmlTextWriterPtr
writer, int pe,
const xmlChar * name,
const xmlChar *
pubid,
const xmlChar *
sysid,
const xmlChar *
ndataid,
const xmlChar *
content);
/*
* DTD notation definition
*/
XMLPUBFUN int XMLCALL
xmlTextWriterWriteDTDNotation(xmlTextWriterPtr writer,
const xmlChar * name,
const xmlChar * pubid,
const xmlChar * sysid);
/*
* Indentation
*/
XMLPUBFUN int XMLCALL
xmlTextWriterSetIndent(xmlTextWriterPtr writer, int indent);
XMLPUBFUN int XMLCALL
xmlTextWriterSetIndentString(xmlTextWriterPtr writer,
const xmlChar * str);
XMLPUBFUN int XMLCALL
xmlTextWriterSetQuoteChar(xmlTextWriterPtr writer, xmlChar quotechar);
/*
* misc
*/
XMLPUBFUN int XMLCALL xmlTextWriterFlush(xmlTextWriterPtr writer);
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_WRITER_ENABLED */
#endif /* __XML_XMLWRITER_H__ */
/*
* Summary: minimal FTP implementation
* Description: minimal FTP implementation allowing to fetch resources
* like external subset. This module is DEPRECATED, do not
* use any of its functions.
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __NANO_FTP_H__
#define __NANO_FTP_H__
#include <libxml/xmlversion.h>
#ifdef LIBXML_FTP_ENABLED
/* Needed for portability to Windows 64 bits */
#if defined(_WIN32)
#include <winsock2.h>
#else
/**
* SOCKET:
*
* macro used to provide portability of code to windows sockets
*/
#define SOCKET int
/**
* INVALID_SOCKET:
*
* macro used to provide portability of code to windows sockets
* the value to be used when the socket is not valid
*/
#undef INVALID_SOCKET
#define INVALID_SOCKET (-1)
#endif
#ifdef __cplusplus
extern "C" {
#endif
/**
* ftpListCallback:
* @userData: user provided data for the callback
* @filename: the file name (including "->" when links are shown)
* @attrib: the attribute string
* @owner: the owner string
* @group: the group string
* @size: the file size
* @links: the link count
* @year: the year
* @month: the month
* @day: the day
* @hour: the hour
* @minute: the minute
*
* A callback for the xmlNanoFTPList command.
* Note that only one of year and day:minute are specified.
*/
typedef void (*ftpListCallback) (void *userData,
const char *filename, const char *attrib,
const char *owner, const char *group,
unsigned long size, int links, int year,
const char *month, int day, int hour,
int minute);
/**
* ftpDataCallback:
* @userData: the user provided context
* @data: the data received
* @len: its size in bytes
*
* A callback for the xmlNanoFTPGet command.
*/
typedef void (*ftpDataCallback) (void *userData,
const char *data,
int len);
/*
* Init
*/
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlNanoFTPInit (void);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlNanoFTPCleanup (void);
/*
* Creating/freeing contexts.
*/
XML_DEPRECATED
XMLPUBFUN void * XMLCALL
xmlNanoFTPNewCtxt (const char *URL);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlNanoFTPFreeCtxt (void * ctx);
XML_DEPRECATED
XMLPUBFUN void * XMLCALL
xmlNanoFTPConnectTo (const char *server,
int port);
/*
* Opening/closing session connections.
*/
XML_DEPRECATED
XMLPUBFUN void * XMLCALL
xmlNanoFTPOpen (const char *URL);
XML_DEPRECATED
XMLPUBFUN int XMLCALL
xmlNanoFTPConnect (void *ctx);
XML_DEPRECATED
XMLPUBFUN int XMLCALL
xmlNanoFTPClose (void *ctx);
XML_DEPRECATED
XMLPUBFUN int XMLCALL
xmlNanoFTPQuit (void *ctx);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlNanoFTPScanProxy (const char *URL);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlNanoFTPProxy (const char *host,
int port,
const char *user,
const char *passwd,
int type);
XML_DEPRECATED
XMLPUBFUN int XMLCALL
xmlNanoFTPUpdateURL (void *ctx,
const char *URL);
/*
* Rather internal commands.
*/
XML_DEPRECATED
XMLPUBFUN int XMLCALL
xmlNanoFTPGetResponse (void *ctx);
XML_DEPRECATED
XMLPUBFUN int XMLCALL
xmlNanoFTPCheckResponse (void *ctx);
/*
* CD/DIR/GET handlers.
*/
XML_DEPRECATED
XMLPUBFUN int XMLCALL
xmlNanoFTPCwd (void *ctx,
const char *directory);
XML_DEPRECATED
XMLPUBFUN int XMLCALL
xmlNanoFTPDele (void *ctx,
const char *file);
XML_DEPRECATED
XMLPUBFUN SOCKET XMLCALL
xmlNanoFTPGetConnection (void *ctx);
XML_DEPRECATED
XMLPUBFUN int XMLCALL
xmlNanoFTPCloseConnection(void *ctx);
XML_DEPRECATED
XMLPUBFUN int XMLCALL
xmlNanoFTPList (void *ctx,
ftpListCallback callback,
void *userData,
const char *filename);
XML_DEPRECATED
XMLPUBFUN SOCKET XMLCALL
xmlNanoFTPGetSocket (void *ctx,
const char *filename);
XML_DEPRECATED
XMLPUBFUN int XMLCALL
xmlNanoFTPGet (void *ctx,
ftpDataCallback callback,
void *userData,
const char *filename);
XML_DEPRECATED
XMLPUBFUN int XMLCALL
xmlNanoFTPRead (void *ctx,
void *dest,
int len);
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_FTP_ENABLED */
#endif /* __NANO_FTP_H__ */
/*
* Summary: unfinished XLink detection module
* Description: unfinished XLink detection module
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_XLINK_H__
#define __XML_XLINK_H__
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#ifdef LIBXML_XPTR_ENABLED
#ifdef __cplusplus
extern "C" {
#endif
/**
* Various defines for the various Link properties.
*
* NOTE: the link detection layer will try to resolve QName expansion
* of namespaces. If "foo" is the prefix for "http://foo.com/"
* then the link detection layer will expand role="foo:myrole"
* to "http://foo.com/:myrole".
* NOTE: the link detection layer will expand URI-References found on
* href attributes by using the base mechanism if found.
*/
typedef xmlChar *xlinkHRef;
typedef xmlChar *xlinkRole;
typedef xmlChar *xlinkTitle;
typedef enum {
XLINK_TYPE_NONE = 0,
XLINK_TYPE_SIMPLE,
XLINK_TYPE_EXTENDED,
XLINK_TYPE_EXTENDED_SET
} xlinkType;
typedef enum {
XLINK_SHOW_NONE = 0,
XLINK_SHOW_NEW,
XLINK_SHOW_EMBED,
XLINK_SHOW_REPLACE
} xlinkShow;
typedef enum {
XLINK_ACTUATE_NONE = 0,
XLINK_ACTUATE_AUTO,
XLINK_ACTUATE_ONREQUEST
} xlinkActuate;
/**
* xlinkNodeDetectFunc:
* @ctx: user data pointer
* @node: the node to check
*
* This is the prototype for the link detection routine.
* It calls the default link detection callbacks upon link detection.
*/
typedef void (*xlinkNodeDetectFunc) (void *ctx, xmlNodePtr node);
/*
* The link detection module interact with the upper layers using
* a set of callback registered at parsing time.
*/
/**
* xlinkSimpleLinkFunk:
* @ctx: user data pointer
* @node: the node carrying the link
* @href: the target of the link
* @role: the role string
* @title: the link title
*
* This is the prototype for a simple link detection callback.
*/
typedef void
(*xlinkSimpleLinkFunk) (void *ctx,
xmlNodePtr node,
const xlinkHRef href,
const xlinkRole role,
const xlinkTitle title);
/**
* xlinkExtendedLinkFunk:
* @ctx: user data pointer
* @node: the node carrying the link
* @nbLocators: the number of locators detected on the link
* @hrefs: pointer to the array of locator hrefs
* @roles: pointer to the array of locator roles
* @nbArcs: the number of arcs detected on the link
* @from: pointer to the array of source roles found on the arcs
* @to: pointer to the array of target roles found on the arcs
* @show: array of values for the show attributes found on the arcs
* @actuate: array of values for the actuate attributes found on the arcs
* @nbTitles: the number of titles detected on the link
* @title: array of titles detected on the link
* @langs: array of xml:lang values for the titles
*
* This is the prototype for a extended link detection callback.
*/
typedef void
(*xlinkExtendedLinkFunk)(void *ctx,
xmlNodePtr node,
int nbLocators,
const xlinkHRef *hrefs,
const xlinkRole *roles,
int nbArcs,
const xlinkRole *from,
const xlinkRole *to,
xlinkShow *show,
xlinkActuate *actuate,
int nbTitles,
const xlinkTitle *titles,
const xmlChar **langs);
/**
* xlinkExtendedLinkSetFunk:
* @ctx: user data pointer
* @node: the node carrying the link
* @nbLocators: the number of locators detected on the link
* @hrefs: pointer to the array of locator hrefs
* @roles: pointer to the array of locator roles
* @nbTitles: the number of titles detected on the link
* @title: array of titles detected on the link
* @langs: array of xml:lang values for the titles
*
* This is the prototype for a extended link set detection callback.
*/
typedef void
(*xlinkExtendedLinkSetFunk) (void *ctx,
xmlNodePtr node,
int nbLocators,
const xlinkHRef *hrefs,
const xlinkRole *roles,
int nbTitles,
const xlinkTitle *titles,
const xmlChar **langs);
/**
* This is the structure containing a set of Links detection callbacks.
*
* There is no default xlink callbacks, if one want to get link
* recognition activated, those call backs must be provided before parsing.
*/
typedef struct _xlinkHandler xlinkHandler;
typedef xlinkHandler *xlinkHandlerPtr;
struct _xlinkHandler {
xlinkSimpleLinkFunk simple;
xlinkExtendedLinkFunk extended;
xlinkExtendedLinkSetFunk set;
};
/*
* The default detection routine, can be overridden, they call the default
* detection callbacks.
*/
XMLPUBFUN xlinkNodeDetectFunc XMLCALL
xlinkGetDefaultDetect (void);
XMLPUBFUN void XMLCALL
xlinkSetDefaultDetect (xlinkNodeDetectFunc func);
/*
* Routines to set/get the default handlers.
*/
XMLPUBFUN xlinkHandlerPtr XMLCALL
xlinkGetDefaultHandler (void);
XMLPUBFUN void XMLCALL
xlinkSetDefaultHandler (xlinkHandlerPtr handler);
/*
* Link detection module itself.
*/
XMLPUBFUN xlinkType XMLCALL
xlinkIsLink (xmlDocPtr doc,
xmlNodePtr node);
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_XPTR_ENABLED */
#endif /* __XML_XLINK_H__ */
/*
* Summary: implementation of XML Schema Datatypes
* Description: module providing the XML Schema Datatypes implementation
* both definition and validity checking
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_SCHEMA_TYPES_H__
#define __XML_SCHEMA_TYPES_H__
#include <libxml/xmlversion.h>
#ifdef LIBXML_SCHEMAS_ENABLED
#include <libxml/schemasInternals.h>
#include <libxml/xmlschemas.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef enum {
XML_SCHEMA_WHITESPACE_UNKNOWN = 0,
XML_SCHEMA_WHITESPACE_PRESERVE = 1,
XML_SCHEMA_WHITESPACE_REPLACE = 2,
XML_SCHEMA_WHITESPACE_COLLAPSE = 3
} xmlSchemaWhitespaceValueType;
XMLPUBFUN void XMLCALL
xmlSchemaInitTypes (void);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlSchemaCleanupTypes (void);
XMLPUBFUN xmlSchemaTypePtr XMLCALL
xmlSchemaGetPredefinedType (const xmlChar *name,
const xmlChar *ns);
XMLPUBFUN int XMLCALL
xmlSchemaValidatePredefinedType (xmlSchemaTypePtr type,
const xmlChar *value,
xmlSchemaValPtr *val);
XMLPUBFUN int XMLCALL
xmlSchemaValPredefTypeNode (xmlSchemaTypePtr type,
const xmlChar *value,
xmlSchemaValPtr *val,
xmlNodePtr node);
XMLPUBFUN int XMLCALL
xmlSchemaValidateFacet (xmlSchemaTypePtr base,
xmlSchemaFacetPtr facet,
const xmlChar *value,
xmlSchemaValPtr val);
XMLPUBFUN int XMLCALL
xmlSchemaValidateFacetWhtsp (xmlSchemaFacetPtr facet,
xmlSchemaWhitespaceValueType fws,
xmlSchemaValType valType,
const xmlChar *value,
xmlSchemaValPtr val,
xmlSchemaWhitespaceValueType ws);
XMLPUBFUN void XMLCALL
xmlSchemaFreeValue (xmlSchemaValPtr val);
XMLPUBFUN xmlSchemaFacetPtr XMLCALL
xmlSchemaNewFacet (void);
XMLPUBFUN int XMLCALL
xmlSchemaCheckFacet (xmlSchemaFacetPtr facet,
xmlSchemaTypePtr typeDecl,
xmlSchemaParserCtxtPtr ctxt,
const xmlChar *name);
XMLPUBFUN void XMLCALL
xmlSchemaFreeFacet (xmlSchemaFacetPtr facet);
XMLPUBFUN int XMLCALL
xmlSchemaCompareValues (xmlSchemaValPtr x,
xmlSchemaValPtr y);
XMLPUBFUN xmlSchemaTypePtr XMLCALL
xmlSchemaGetBuiltInListSimpleTypeItemType (xmlSchemaTypePtr type);
XMLPUBFUN int XMLCALL
xmlSchemaValidateListSimpleTypeFacet (xmlSchemaFacetPtr facet,
const xmlChar *value,
unsigned long actualLen,
unsigned long *expectedLen);
XMLPUBFUN xmlSchemaTypePtr XMLCALL
xmlSchemaGetBuiltInType (xmlSchemaValType type);
XMLPUBFUN int XMLCALL
xmlSchemaIsBuiltInTypeFacet (xmlSchemaTypePtr type,
int facetType);
XMLPUBFUN xmlChar * XMLCALL
xmlSchemaCollapseString (const xmlChar *value);
XMLPUBFUN xmlChar * XMLCALL
xmlSchemaWhiteSpaceReplace (const xmlChar *value);
XMLPUBFUN unsigned long XMLCALL
xmlSchemaGetFacetValueAsULong (xmlSchemaFacetPtr facet);
XMLPUBFUN int XMLCALL
xmlSchemaValidateLengthFacet (xmlSchemaTypePtr type,
xmlSchemaFacetPtr facet,
const xmlChar *value,
xmlSchemaValPtr val,
unsigned long *length);
XMLPUBFUN int XMLCALL
xmlSchemaValidateLengthFacetWhtsp(xmlSchemaFacetPtr facet,
xmlSchemaValType valType,
const xmlChar *value,
xmlSchemaValPtr val,
unsigned long *length,
xmlSchemaWhitespaceValueType ws);
XMLPUBFUN int XMLCALL
xmlSchemaValPredefTypeNodeNoNorm(xmlSchemaTypePtr type,
const xmlChar *value,
xmlSchemaValPtr *val,
xmlNodePtr node);
XMLPUBFUN int XMLCALL
xmlSchemaGetCanonValue (xmlSchemaValPtr val,
const xmlChar **retValue);
XMLPUBFUN int XMLCALL
xmlSchemaGetCanonValueWhtsp (xmlSchemaValPtr val,
const xmlChar **retValue,
xmlSchemaWhitespaceValueType ws);
XMLPUBFUN int XMLCALL
xmlSchemaValueAppend (xmlSchemaValPtr prev,
xmlSchemaValPtr cur);
XMLPUBFUN xmlSchemaValPtr XMLCALL
xmlSchemaValueGetNext (xmlSchemaValPtr cur);
XMLPUBFUN const xmlChar * XMLCALL
xmlSchemaValueGetAsString (xmlSchemaValPtr val);
XMLPUBFUN int XMLCALL
xmlSchemaValueGetAsBoolean (xmlSchemaValPtr val);
XMLPUBFUN xmlSchemaValPtr XMLCALL
xmlSchemaNewStringValue (xmlSchemaValType type,
const xmlChar *value);
XMLPUBFUN xmlSchemaValPtr XMLCALL
xmlSchemaNewNOTATIONValue (const xmlChar *name,
const xmlChar *ns);
XMLPUBFUN xmlSchemaValPtr XMLCALL
xmlSchemaNewQNameValue (const xmlChar *namespaceName,
const xmlChar *localName);
XMLPUBFUN int XMLCALL
xmlSchemaCompareValuesWhtsp (xmlSchemaValPtr x,
xmlSchemaWhitespaceValueType xws,
xmlSchemaValPtr y,
xmlSchemaWhitespaceValueType yws);
XMLPUBFUN xmlSchemaValPtr XMLCALL
xmlSchemaCopyValue (xmlSchemaValPtr val);
XMLPUBFUN xmlSchemaValType XMLCALL
xmlSchemaGetValType (xmlSchemaValPtr val);
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_SCHEMAS_ENABLED */
#endif /* __XML_SCHEMA_TYPES_H__ */
/*
* Summary: internal interfaces for XML Path Language implementation
* Description: internal interfaces for XML Path Language implementation
* used to build new modules on top of XPath like XPointer and
* XSLT
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_XPATH_INTERNALS_H__
#define __XML_XPATH_INTERNALS_H__
#include <libxml/xmlversion.h>
#include <libxml/xpath.h>
#ifdef LIBXML_XPATH_ENABLED
#ifdef __cplusplus
extern "C" {
#endif
/************************************************************************
* *
* Helpers *
* *
************************************************************************/
/*
* Many of these macros may later turn into functions. They
* shouldn't be used in #ifdef's preprocessor instructions.
*/
/**
* xmlXPathSetError:
* @ctxt: an XPath parser context
* @err: an xmlXPathError code
*
* Raises an error.
*/
#define xmlXPathSetError(ctxt, err) \
{ xmlXPatherror((ctxt), __FILE__, __LINE__, (err)); \
if ((ctxt) != NULL) (ctxt)->error = (err); }
/**
* xmlXPathSetArityError:
* @ctxt: an XPath parser context
*
* Raises an XPATH_INVALID_ARITY error.
*/
#define xmlXPathSetArityError(ctxt) \
xmlXPathSetError((ctxt), XPATH_INVALID_ARITY)
/**
* xmlXPathSetTypeError:
* @ctxt: an XPath parser context
*
* Raises an XPATH_INVALID_TYPE error.
*/
#define xmlXPathSetTypeError(ctxt) \
xmlXPathSetError((ctxt), XPATH_INVALID_TYPE)
/**
* xmlXPathGetError:
* @ctxt: an XPath parser context
*
* Get the error code of an XPath context.
*
* Returns the context error.
*/
#define xmlXPathGetError(ctxt) ((ctxt)->error)
/**
* xmlXPathCheckError:
* @ctxt: an XPath parser context
*
* Check if an XPath error was raised.
*
* Returns true if an error has been raised, false otherwise.
*/
#define xmlXPathCheckError(ctxt) ((ctxt)->error != XPATH_EXPRESSION_OK)
/**
* xmlXPathGetDocument:
* @ctxt: an XPath parser context
*
* Get the document of an XPath context.
*
* Returns the context document.
*/
#define xmlXPathGetDocument(ctxt) ((ctxt)->context->doc)
/**
* xmlXPathGetContextNode:
* @ctxt: an XPath parser context
*
* Get the context node of an XPath context.
*
* Returns the context node.
*/
#define xmlXPathGetContextNode(ctxt) ((ctxt)->context->node)
XMLPUBFUN int XMLCALL
xmlXPathPopBoolean (xmlXPathParserContextPtr ctxt);
XMLPUBFUN double XMLCALL
xmlXPathPopNumber (xmlXPathParserContextPtr ctxt);
XMLPUBFUN xmlChar * XMLCALL
xmlXPathPopString (xmlXPathParserContextPtr ctxt);
XMLPUBFUN xmlNodeSetPtr XMLCALL
xmlXPathPopNodeSet (xmlXPathParserContextPtr ctxt);
XMLPUBFUN void * XMLCALL
xmlXPathPopExternal (xmlXPathParserContextPtr ctxt);
/**
* xmlXPathReturnBoolean:
* @ctxt: an XPath parser context
* @val: a boolean
*
* Pushes the boolean @val on the context stack.
*/
#define xmlXPathReturnBoolean(ctxt, val) \
valuePush((ctxt), xmlXPathNewBoolean(val))
/**
* xmlXPathReturnTrue:
* @ctxt: an XPath parser context
*
* Pushes true on the context stack.
*/
#define xmlXPathReturnTrue(ctxt) xmlXPathReturnBoolean((ctxt), 1)
/**
* xmlXPathReturnFalse:
* @ctxt: an XPath parser context
*
* Pushes false on the context stack.
*/
#define xmlXPathReturnFalse(ctxt) xmlXPathReturnBoolean((ctxt), 0)
/**
* xmlXPathReturnNumber:
* @ctxt: an XPath parser context
* @val: a double
*
* Pushes the double @val on the context stack.
*/
#define xmlXPathReturnNumber(ctxt, val) \
valuePush((ctxt), xmlXPathNewFloat(val))
/**
* xmlXPathReturnString:
* @ctxt: an XPath parser context
* @str: a string
*
* Pushes the string @str on the context stack.
*/
#define xmlXPathReturnString(ctxt, str) \
valuePush((ctxt), xmlXPathWrapString(str))
/**
* xmlXPathReturnEmptyString:
* @ctxt: an XPath parser context
*
* Pushes an empty string on the stack.
*/
#define xmlXPathReturnEmptyString(ctxt) \
valuePush((ctxt), xmlXPathNewCString(""))
/**
* xmlXPathReturnNodeSet:
* @ctxt: an XPath parser context
* @ns: a node-set
*
* Pushes the node-set @ns on the context stack.
*/
#define xmlXPathReturnNodeSet(ctxt, ns) \
valuePush((ctxt), xmlXPathWrapNodeSet(ns))
/**
* xmlXPathReturnEmptyNodeSet:
* @ctxt: an XPath parser context
*
* Pushes an empty node-set on the context stack.
*/
#define xmlXPathReturnEmptyNodeSet(ctxt) \
valuePush((ctxt), xmlXPathNewNodeSet(NULL))
/**
* xmlXPathReturnExternal:
* @ctxt: an XPath parser context
* @val: user data
*
* Pushes user data on the context stack.
*/
#define xmlXPathReturnExternal(ctxt, val) \
valuePush((ctxt), xmlXPathWrapExternal(val))
/**
* xmlXPathStackIsNodeSet:
* @ctxt: an XPath parser context
*
* Check if the current value on the XPath stack is a node set or
* an XSLT value tree.
*
* Returns true if the current object on the stack is a node-set.
*/
#define xmlXPathStackIsNodeSet(ctxt) \
(((ctxt)->value != NULL) \
&& (((ctxt)->value->type == XPATH_NODESET) \
|| ((ctxt)->value->type == XPATH_XSLT_TREE)))
/**
* xmlXPathStackIsExternal:
* @ctxt: an XPath parser context
*
* Checks if the current value on the XPath stack is an external
* object.
*
* Returns true if the current object on the stack is an external
* object.
*/
#define xmlXPathStackIsExternal(ctxt) \
((ctxt->value != NULL) && (ctxt->value->type == XPATH_USERS))
/**
* xmlXPathEmptyNodeSet:
* @ns: a node-set
*
* Empties a node-set.
*/
#define xmlXPathEmptyNodeSet(ns) \
{ while ((ns)->nodeNr > 0) (ns)->nodeTab[--(ns)->nodeNr] = NULL; }
/**
* CHECK_ERROR:
*
* Macro to return from the function if an XPath error was detected.
*/
#define CHECK_ERROR \
if (ctxt->error != XPATH_EXPRESSION_OK) return
/**
* CHECK_ERROR0:
*
* Macro to return 0 from the function if an XPath error was detected.
*/
#define CHECK_ERROR0 \
if (ctxt->error != XPATH_EXPRESSION_OK) return(0)
/**
* XP_ERROR:
* @X: the error code
*
* Macro to raise an XPath error and return.
*/
#define XP_ERROR(X) \
{ xmlXPathErr(ctxt, X); return; }
/**
* XP_ERROR0:
* @X: the error code
*
* Macro to raise an XPath error and return 0.
*/
#define XP_ERROR0(X) \
{ xmlXPathErr(ctxt, X); return(0); }
/**
* CHECK_TYPE:
* @typeval: the XPath type
*
* Macro to check that the value on top of the XPath stack is of a given
* type.
*/
#define CHECK_TYPE(typeval) \
if ((ctxt->value == NULL) || (ctxt->value->type != typeval)) \
XP_ERROR(XPATH_INVALID_TYPE)
/**
* CHECK_TYPE0:
* @typeval: the XPath type
*
* Macro to check that the value on top of the XPath stack is of a given
* type. Return(0) in case of failure
*/
#define CHECK_TYPE0(typeval) \
if ((ctxt->value == NULL) || (ctxt->value->type != typeval)) \
XP_ERROR0(XPATH_INVALID_TYPE)
/**
* CHECK_ARITY:
* @x: the number of expected args
*
* Macro to check that the number of args passed to an XPath function matches.
*/
#define CHECK_ARITY(x) \
if (ctxt == NULL) return; \
if (nargs != (x)) \
XP_ERROR(XPATH_INVALID_ARITY); \
if (ctxt->valueNr < ctxt->valueFrame + (x)) \
XP_ERROR(XPATH_STACK_ERROR);
/**
* CAST_TO_STRING:
*
* Macro to try to cast the value on the top of the XPath stack to a string.
*/
#define CAST_TO_STRING \
if ((ctxt->value != NULL) && (ctxt->value->type != XPATH_STRING)) \
xmlXPathStringFunction(ctxt, 1);
/**
* CAST_TO_NUMBER:
*
* Macro to try to cast the value on the top of the XPath stack to a number.
*/
#define CAST_TO_NUMBER \
if ((ctxt->value != NULL) && (ctxt->value->type != XPATH_NUMBER)) \
xmlXPathNumberFunction(ctxt, 1);
/**
* CAST_TO_BOOLEAN:
*
* Macro to try to cast the value on the top of the XPath stack to a boolean.
*/
#define CAST_TO_BOOLEAN \
if ((ctxt->value != NULL) && (ctxt->value->type != XPATH_BOOLEAN)) \
xmlXPathBooleanFunction(ctxt, 1);
/*
* Variable Lookup forwarding.
*/
XMLPUBFUN void XMLCALL
xmlXPathRegisterVariableLookup (xmlXPathContextPtr ctxt,
xmlXPathVariableLookupFunc f,
void *data);
/*
* Function Lookup forwarding.
*/
XMLPUBFUN void XMLCALL
xmlXPathRegisterFuncLookup (xmlXPathContextPtr ctxt,
xmlXPathFuncLookupFunc f,
void *funcCtxt);
/*
* Error reporting.
*/
XMLPUBFUN void XMLCALL
xmlXPatherror (xmlXPathParserContextPtr ctxt,
const char *file,
int line,
int no);
XMLPUBFUN void XMLCALL
xmlXPathErr (xmlXPathParserContextPtr ctxt,
int error);
#ifdef LIBXML_DEBUG_ENABLED
XMLPUBFUN void XMLCALL
xmlXPathDebugDumpObject (FILE *output,
xmlXPathObjectPtr cur,
int depth);
XMLPUBFUN void XMLCALL
xmlXPathDebugDumpCompExpr(FILE *output,
xmlXPathCompExprPtr comp,
int depth);
#endif
/**
* NodeSet handling.
*/
XMLPUBFUN int XMLCALL
xmlXPathNodeSetContains (xmlNodeSetPtr cur,
xmlNodePtr val);
XMLPUBFUN xmlNodeSetPtr XMLCALL
xmlXPathDifference (xmlNodeSetPtr nodes1,
xmlNodeSetPtr nodes2);
XMLPUBFUN xmlNodeSetPtr XMLCALL
xmlXPathIntersection (xmlNodeSetPtr nodes1,
xmlNodeSetPtr nodes2);
XMLPUBFUN xmlNodeSetPtr XMLCALL
xmlXPathDistinctSorted (xmlNodeSetPtr nodes);
XMLPUBFUN xmlNodeSetPtr XMLCALL
xmlXPathDistinct (xmlNodeSetPtr nodes);
XMLPUBFUN int XMLCALL
xmlXPathHasSameNodes (xmlNodeSetPtr nodes1,
xmlNodeSetPtr nodes2);
XMLPUBFUN xmlNodeSetPtr XMLCALL
xmlXPathNodeLeadingSorted (xmlNodeSetPtr nodes,
xmlNodePtr node);
XMLPUBFUN xmlNodeSetPtr XMLCALL
xmlXPathLeadingSorted (xmlNodeSetPtr nodes1,
xmlNodeSetPtr nodes2);
XMLPUBFUN xmlNodeSetPtr XMLCALL
xmlXPathNodeLeading (xmlNodeSetPtr nodes,
xmlNodePtr node);
XMLPUBFUN xmlNodeSetPtr XMLCALL
xmlXPathLeading (xmlNodeSetPtr nodes1,
xmlNodeSetPtr nodes2);
XMLPUBFUN xmlNodeSetPtr XMLCALL
xmlXPathNodeTrailingSorted (xmlNodeSetPtr nodes,
xmlNodePtr node);
XMLPUBFUN xmlNodeSetPtr XMLCALL
xmlXPathTrailingSorted (xmlNodeSetPtr nodes1,
xmlNodeSetPtr nodes2);
XMLPUBFUN xmlNodeSetPtr XMLCALL
xmlXPathNodeTrailing (xmlNodeSetPtr nodes,
xmlNodePtr node);
XMLPUBFUN xmlNodeSetPtr XMLCALL
xmlXPathTrailing (xmlNodeSetPtr nodes1,
xmlNodeSetPtr nodes2);
/**
* Extending a context.
*/
XMLPUBFUN int XMLCALL
xmlXPathRegisterNs (xmlXPathContextPtr ctxt,
const xmlChar *prefix,
const xmlChar *ns_uri);
XMLPUBFUN const xmlChar * XMLCALL
xmlXPathNsLookup (xmlXPathContextPtr ctxt,
const xmlChar *prefix);
XMLPUBFUN void XMLCALL
xmlXPathRegisteredNsCleanup (xmlXPathContextPtr ctxt);
XMLPUBFUN int XMLCALL
xmlXPathRegisterFunc (xmlXPathContextPtr ctxt,
const xmlChar *name,
xmlXPathFunction f);
XMLPUBFUN int XMLCALL
xmlXPathRegisterFuncNS (xmlXPathContextPtr ctxt,
const xmlChar *name,
const xmlChar *ns_uri,
xmlXPathFunction f);
XMLPUBFUN int XMLCALL
xmlXPathRegisterVariable (xmlXPathContextPtr ctxt,
const xmlChar *name,
xmlXPathObjectPtr value);
XMLPUBFUN int XMLCALL
xmlXPathRegisterVariableNS (xmlXPathContextPtr ctxt,
const xmlChar *name,
const xmlChar *ns_uri,
xmlXPathObjectPtr value);
XMLPUBFUN xmlXPathFunction XMLCALL
xmlXPathFunctionLookup (xmlXPathContextPtr ctxt,
const xmlChar *name);
XMLPUBFUN xmlXPathFunction XMLCALL
xmlXPathFunctionLookupNS (xmlXPathContextPtr ctxt,
const xmlChar *name,
const xmlChar *ns_uri);
XMLPUBFUN void XMLCALL
xmlXPathRegisteredFuncsCleanup (xmlXPathContextPtr ctxt);
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPathVariableLookup (xmlXPathContextPtr ctxt,
const xmlChar *name);
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPathVariableLookupNS (xmlXPathContextPtr ctxt,
const xmlChar *name,
const xmlChar *ns_uri);
XMLPUBFUN void XMLCALL
xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt);
/**
* Utilities to extend XPath.
*/
XMLPUBFUN xmlXPathParserContextPtr XMLCALL
xmlXPathNewParserContext (const xmlChar *str,
xmlXPathContextPtr ctxt);
XMLPUBFUN void XMLCALL
xmlXPathFreeParserContext (xmlXPathParserContextPtr ctxt);
/* TODO: remap to xmlXPathValuePop and Push. */
XMLPUBFUN xmlXPathObjectPtr XMLCALL
valuePop (xmlXPathParserContextPtr ctxt);
XMLPUBFUN int XMLCALL
valuePush (xmlXPathParserContextPtr ctxt,
xmlXPathObjectPtr value);
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPathNewString (const xmlChar *val);
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPathNewCString (const char *val);
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPathWrapString (xmlChar *val);
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPathWrapCString (char * val);
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPathNewFloat (double val);
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPathNewBoolean (int val);
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPathNewNodeSet (xmlNodePtr val);
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPathNewValueTree (xmlNodePtr val);
XMLPUBFUN int XMLCALL
xmlXPathNodeSetAdd (xmlNodeSetPtr cur,
xmlNodePtr val);
XMLPUBFUN int XMLCALL
xmlXPathNodeSetAddUnique (xmlNodeSetPtr cur,
xmlNodePtr val);
XMLPUBFUN int XMLCALL
xmlXPathNodeSetAddNs (xmlNodeSetPtr cur,
xmlNodePtr node,
xmlNsPtr ns);
XMLPUBFUN void XMLCALL
xmlXPathNodeSetSort (xmlNodeSetPtr set);
XMLPUBFUN void XMLCALL
xmlXPathRoot (xmlXPathParserContextPtr ctxt);
XMLPUBFUN void XMLCALL
xmlXPathEvalExpr (xmlXPathParserContextPtr ctxt);
XMLPUBFUN xmlChar * XMLCALL
xmlXPathParseName (xmlXPathParserContextPtr ctxt);
XMLPUBFUN xmlChar * XMLCALL
xmlXPathParseNCName (xmlXPathParserContextPtr ctxt);
/*
* Existing functions.
*/
XMLPUBFUN double XMLCALL
xmlXPathStringEvalNumber (const xmlChar *str);
XMLPUBFUN int XMLCALL
xmlXPathEvaluatePredicateResult (xmlXPathParserContextPtr ctxt,
xmlXPathObjectPtr res);
XMLPUBFUN void XMLCALL
xmlXPathRegisterAllFunctions (xmlXPathContextPtr ctxt);
XMLPUBFUN xmlNodeSetPtr XMLCALL
xmlXPathNodeSetMerge (xmlNodeSetPtr val1,
xmlNodeSetPtr val2);
XMLPUBFUN void XMLCALL
xmlXPathNodeSetDel (xmlNodeSetPtr cur,
xmlNodePtr val);
XMLPUBFUN void XMLCALL
xmlXPathNodeSetRemove (xmlNodeSetPtr cur,
int val);
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPathNewNodeSetList (xmlNodeSetPtr val);
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPathWrapNodeSet (xmlNodeSetPtr val);
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPathWrapExternal (void *val);
XMLPUBFUN int XMLCALL xmlXPathEqualValues(xmlXPathParserContextPtr ctxt);
XMLPUBFUN int XMLCALL xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt);
XMLPUBFUN int XMLCALL xmlXPathCompareValues(xmlXPathParserContextPtr ctxt, int inf, int strict);
XMLPUBFUN void XMLCALL xmlXPathValueFlipSign(xmlXPathParserContextPtr ctxt);
XMLPUBFUN void XMLCALL xmlXPathAddValues(xmlXPathParserContextPtr ctxt);
XMLPUBFUN void XMLCALL xmlXPathSubValues(xmlXPathParserContextPtr ctxt);
XMLPUBFUN void XMLCALL xmlXPathMultValues(xmlXPathParserContextPtr ctxt);
XMLPUBFUN void XMLCALL xmlXPathDivValues(xmlXPathParserContextPtr ctxt);
XMLPUBFUN void XMLCALL xmlXPathModValues(xmlXPathParserContextPtr ctxt);
XMLPUBFUN int XMLCALL xmlXPathIsNodeType(const xmlChar *name);
/*
* Some of the axis navigation routines.
*/
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextSelf(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextChild(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextParent(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextFollowingSibling(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
/*
* The official core of XPath functions.
*/
XMLPUBFUN void XMLCALL xmlXPathLastFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathPositionFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathCountFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathIdFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathLocalNameFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathNamespaceURIFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathStringLengthFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathConcatFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathContainsFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathStartsWithFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathSubstringBeforeFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathTranslateFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathNotFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathTrueFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathFalseFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathLangFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathNumberFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathSumFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathFloorFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathRoundFunction(xmlXPathParserContextPtr ctxt, int nargs);
XMLPUBFUN void XMLCALL xmlXPathBooleanFunction(xmlXPathParserContextPtr ctxt, int nargs);
/**
* Really internal functions
*/
XMLPUBFUN void XMLCALL xmlXPathNodeSetFreeNs(xmlNsPtr ns);
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_XPATH_ENABLED */
#endif /* ! __XML_XPATH_INTERNALS_H__ */
/*
* Summary: interface for an HTML 4.0 non-verifying parser
* Description: this module implements an HTML 4.0 non-verifying parser
* with API compatible with the XML parser ones. It should
* be able to parse "real world" HTML, even if severely
* broken from a specification point of view.
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __HTML_PARSER_H__
#define __HTML_PARSER_H__
#include <libxml/xmlversion.h>
#include <libxml/parser.h>
#ifdef LIBXML_HTML_ENABLED
#ifdef __cplusplus
extern "C" {
#endif
/*
* Most of the back-end structures from XML and HTML are shared.
*/
typedef xmlParserCtxt htmlParserCtxt;
typedef xmlParserCtxtPtr htmlParserCtxtPtr;
typedef xmlParserNodeInfo htmlParserNodeInfo;
typedef xmlSAXHandler htmlSAXHandler;
typedef xmlSAXHandlerPtr htmlSAXHandlerPtr;
typedef xmlParserInput htmlParserInput;
typedef xmlParserInputPtr htmlParserInputPtr;
typedef xmlDocPtr htmlDocPtr;
typedef xmlNodePtr htmlNodePtr;
/*
* Internal description of an HTML element, representing HTML 4.01
* and XHTML 1.0 (which share the same structure).
*/
typedef struct _htmlElemDesc htmlElemDesc;
typedef htmlElemDesc *htmlElemDescPtr;
struct _htmlElemDesc {
const char *name; /* The tag name */
char startTag; /* Whether the start tag can be implied */
char endTag; /* Whether the end tag can be implied */
char saveEndTag; /* Whether the end tag should be saved */
char empty; /* Is this an empty element ? */
char depr; /* Is this a deprecated element ? */
char dtd; /* 1: only in Loose DTD, 2: only Frameset one */
char isinline; /* is this a block 0 or inline 1 element */
const char *desc; /* the description */
/* NRK Jan.2003
* New fields encapsulating HTML structure
*
* Bugs:
* This is a very limited representation. It fails to tell us when
* an element *requires* subelements (we only have whether they're
* allowed or not), and it doesn't tell us where CDATA and PCDATA
* are allowed. Some element relationships are not fully represented:
* these are flagged with the word MODIFIER
*/
const char** subelts; /* allowed sub-elements of this element */
const char* defaultsubelt; /* subelement for suggested auto-repair
if necessary or NULL */
const char** attrs_opt; /* Optional Attributes */
const char** attrs_depr; /* Additional deprecated attributes */
const char** attrs_req; /* Required attributes */
};
/*
* Internal description of an HTML entity.
*/
typedef struct _htmlEntityDesc htmlEntityDesc;
typedef htmlEntityDesc *htmlEntityDescPtr;
struct _htmlEntityDesc {
unsigned int value; /* the UNICODE value for the character */
const char *name; /* The entity name */
const char *desc; /* the description */
};
/*
* There is only few public functions.
*/
XMLPUBFUN const htmlElemDesc * XMLCALL
htmlTagLookup (const xmlChar *tag);
XMLPUBFUN const htmlEntityDesc * XMLCALL
htmlEntityLookup(const xmlChar *name);
XMLPUBFUN const htmlEntityDesc * XMLCALL
htmlEntityValueLookup(unsigned int value);
XMLPUBFUN int XMLCALL
htmlIsAutoClosed(htmlDocPtr doc,
htmlNodePtr elem);
XMLPUBFUN int XMLCALL
htmlAutoCloseTag(htmlDocPtr doc,
const xmlChar *name,
htmlNodePtr elem);
XMLPUBFUN const htmlEntityDesc * XMLCALL
htmlParseEntityRef(htmlParserCtxtPtr ctxt,
const xmlChar **str);
XMLPUBFUN int XMLCALL
htmlParseCharRef(htmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
htmlParseElement(htmlParserCtxtPtr ctxt);
XMLPUBFUN htmlParserCtxtPtr XMLCALL
htmlNewParserCtxt(void);
XMLPUBFUN htmlParserCtxtPtr XMLCALL
htmlCreateMemoryParserCtxt(const char *buffer,
int size);
XMLPUBFUN int XMLCALL
htmlParseDocument(htmlParserCtxtPtr ctxt);
XMLPUBFUN htmlDocPtr XMLCALL
htmlSAXParseDoc (const xmlChar *cur,
const char *encoding,
htmlSAXHandlerPtr sax,
void *userData);
XMLPUBFUN htmlDocPtr XMLCALL
htmlParseDoc (const xmlChar *cur,
const char *encoding);
XMLPUBFUN htmlDocPtr XMLCALL
htmlSAXParseFile(const char *filename,
const char *encoding,
htmlSAXHandlerPtr sax,
void *userData);
XMLPUBFUN htmlDocPtr XMLCALL
htmlParseFile (const char *filename,
const char *encoding);
XMLPUBFUN int XMLCALL
UTF8ToHtml (unsigned char *out,
int *outlen,
const unsigned char *in,
int *inlen);
XMLPUBFUN int XMLCALL
htmlEncodeEntities(unsigned char *out,
int *outlen,
const unsigned char *in,
int *inlen, int quoteChar);
XMLPUBFUN int XMLCALL
htmlIsScriptAttribute(const xmlChar *name);
XMLPUBFUN int XMLCALL
htmlHandleOmittedElem(int val);
#ifdef LIBXML_PUSH_ENABLED
/**
* Interfaces for the Push mode.
*/
XMLPUBFUN htmlParserCtxtPtr XMLCALL
htmlCreatePushParserCtxt(htmlSAXHandlerPtr sax,
void *user_data,
const char *chunk,
int size,
const char *filename,
xmlCharEncoding enc);
XMLPUBFUN int XMLCALL
htmlParseChunk (htmlParserCtxtPtr ctxt,
const char *chunk,
int size,
int terminate);
#endif /* LIBXML_PUSH_ENABLED */
XMLPUBFUN void XMLCALL
htmlFreeParserCtxt (htmlParserCtxtPtr ctxt);
/*
* New set of simpler/more flexible APIs
*/
/**
* xmlParserOption:
*
* This is the set of XML parser options that can be passed down
* to the xmlReadDoc() and similar calls.
*/
typedef enum {
HTML_PARSE_RECOVER = 1<<0, /* Relaxed parsing */
HTML_PARSE_NODEFDTD = 1<<2, /* do not default a doctype if not found */
HTML_PARSE_NOERROR = 1<<5, /* suppress error reports */
HTML_PARSE_NOWARNING= 1<<6, /* suppress warning reports */
HTML_PARSE_PEDANTIC = 1<<7, /* pedantic error reporting */
HTML_PARSE_NOBLANKS = 1<<8, /* remove blank nodes */
HTML_PARSE_NONET = 1<<11,/* Forbid network access */
HTML_PARSE_NOIMPLIED= 1<<13,/* Do not add implied html/body... elements */
HTML_PARSE_COMPACT = 1<<16,/* compact small text nodes */
HTML_PARSE_IGNORE_ENC=1<<21 /* ignore internal document encoding hint */
} htmlParserOption;
XMLPUBFUN void XMLCALL
htmlCtxtReset (htmlParserCtxtPtr ctxt);
XMLPUBFUN int XMLCALL
htmlCtxtUseOptions (htmlParserCtxtPtr ctxt,
int options);
XMLPUBFUN htmlDocPtr XMLCALL
htmlReadDoc (const xmlChar *cur,
const char *URL,
const char *encoding,
int options);
XMLPUBFUN htmlDocPtr XMLCALL
htmlReadFile (const char *URL,
const char *encoding,
int options);
XMLPUBFUN htmlDocPtr XMLCALL
htmlReadMemory (const char *buffer,
int size,
const char *URL,
const char *encoding,
int options);
XMLPUBFUN htmlDocPtr XMLCALL
htmlReadFd (int fd,
const char *URL,
const char *encoding,
int options);
XMLPUBFUN htmlDocPtr XMLCALL
htmlReadIO (xmlInputReadCallback ioread,
xmlInputCloseCallback ioclose,
void *ioctx,
const char *URL,
const char *encoding,
int options);
XMLPUBFUN htmlDocPtr XMLCALL
htmlCtxtReadDoc (xmlParserCtxtPtr ctxt,
const xmlChar *cur,
const char *URL,
const char *encoding,
int options);
XMLPUBFUN htmlDocPtr XMLCALL
htmlCtxtReadFile (xmlParserCtxtPtr ctxt,
const char *filename,
const char *encoding,
int options);
XMLPUBFUN htmlDocPtr XMLCALL
htmlCtxtReadMemory (xmlParserCtxtPtr ctxt,
const char *buffer,
int size,
const char *URL,
const char *encoding,
int options);
XMLPUBFUN htmlDocPtr XMLCALL
htmlCtxtReadFd (xmlParserCtxtPtr ctxt,
int fd,
const char *URL,
const char *encoding,
int options);
XMLPUBFUN htmlDocPtr XMLCALL
htmlCtxtReadIO (xmlParserCtxtPtr ctxt,
xmlInputReadCallback ioread,
xmlInputCloseCallback ioclose,
void *ioctx,
const char *URL,
const char *encoding,
int options);
/* NRK/Jan2003: further knowledge of HTML structure
*/
typedef enum {
HTML_NA = 0 , /* something we don't check at all */
HTML_INVALID = 0x1 ,
HTML_DEPRECATED = 0x2 ,
HTML_VALID = 0x4 ,
HTML_REQUIRED = 0xc /* VALID bit set so ( & HTML_VALID ) is TRUE */
} htmlStatus ;
/* Using htmlElemDesc rather than name here, to emphasise the fact
that otherwise there's a lookup overhead
*/
XMLPUBFUN htmlStatus XMLCALL htmlAttrAllowed(const htmlElemDesc*, const xmlChar*, int) ;
XMLPUBFUN int XMLCALL htmlElementAllowedHere(const htmlElemDesc*, const xmlChar*) ;
XMLPUBFUN htmlStatus XMLCALL htmlElementStatusHere(const htmlElemDesc*, const htmlElemDesc*) ;
XMLPUBFUN htmlStatus XMLCALL htmlNodeStatus(const htmlNodePtr, int) ;
/**
* htmlDefaultSubelement:
* @elt: HTML element
*
* Returns the default subelement for this element
*/
#define htmlDefaultSubelement(elt) elt->defaultsubelt
/**
* htmlElementAllowedHereDesc:
* @parent: HTML parent element
* @elt: HTML element
*
* Checks whether an HTML element description may be a
* direct child of the specified element.
*
* Returns 1 if allowed; 0 otherwise.
*/
#define htmlElementAllowedHereDesc(parent,elt) \
htmlElementAllowedHere((parent), (elt)->name)
/**
* htmlRequiredAttrs:
* @elt: HTML element
*
* Returns the attributes required for the specified element.
*/
#define htmlRequiredAttrs(elt) (elt)->attrs_req
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_HTML_ENABLED */
#endif /* __HTML_PARSER_H__ */
/*
* Summary: the XML document serializer
* Description: API to save document or subtree of document
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_XMLSAVE_H__
#define __XML_XMLSAVE_H__
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#include <libxml/encoding.h>
#include <libxml/xmlIO.h>
#ifdef LIBXML_OUTPUT_ENABLED
#ifdef __cplusplus
extern "C" {
#endif
/**
* xmlSaveOption:
*
* This is the set of XML save options that can be passed down
* to the xmlSaveToFd() and similar calls.
*/
typedef enum {
XML_SAVE_FORMAT = 1<<0, /* format save output */
XML_SAVE_NO_DECL = 1<<1, /* drop the xml declaration */
XML_SAVE_NO_EMPTY = 1<<2, /* no empty tags */
XML_SAVE_NO_XHTML = 1<<3, /* disable XHTML1 specific rules */
XML_SAVE_XHTML = 1<<4, /* force XHTML1 specific rules */
XML_SAVE_AS_XML = 1<<5, /* force XML serialization on HTML doc */
XML_SAVE_AS_HTML = 1<<6, /* force HTML serialization on XML doc */
XML_SAVE_WSNONSIG = 1<<7 /* format with non-significant whitespace */
} xmlSaveOption;
typedef struct _xmlSaveCtxt xmlSaveCtxt;
typedef xmlSaveCtxt *xmlSaveCtxtPtr;
XMLPUBFUN xmlSaveCtxtPtr XMLCALL
xmlSaveToFd (int fd,
const char *encoding,
int options);
XMLPUBFUN xmlSaveCtxtPtr XMLCALL
xmlSaveToFilename (const char *filename,
const char *encoding,
int options);
XMLPUBFUN xmlSaveCtxtPtr XMLCALL
xmlSaveToBuffer (xmlBufferPtr buffer,
const char *encoding,
int options);
XMLPUBFUN xmlSaveCtxtPtr XMLCALL
xmlSaveToIO (xmlOutputWriteCallback iowrite,
xmlOutputCloseCallback ioclose,
void *ioctx,
const char *encoding,
int options);
XMLPUBFUN long XMLCALL
xmlSaveDoc (xmlSaveCtxtPtr ctxt,
xmlDocPtr doc);
XMLPUBFUN long XMLCALL
xmlSaveTree (xmlSaveCtxtPtr ctxt,
xmlNodePtr node);
XMLPUBFUN int XMLCALL
xmlSaveFlush (xmlSaveCtxtPtr ctxt);
XMLPUBFUN int XMLCALL
xmlSaveClose (xmlSaveCtxtPtr ctxt);
XMLPUBFUN int XMLCALL
xmlSaveSetEscape (xmlSaveCtxtPtr ctxt,
xmlCharEncodingOutputFunc escape);
XMLPUBFUN int XMLCALL
xmlSaveSetAttrEscape (xmlSaveCtxtPtr ctxt,
xmlCharEncodingOutputFunc escape);
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_OUTPUT_ENABLED */
#endif /* __XML_XMLSAVE_H__ */
/**
* Summary: interfaces for thread handling
* Description: set of generic threading related routines
* should work with pthreads, Windows native or TLS threads
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_THREADS_H__
#define __XML_THREADS_H__
#include <libxml/xmlversion.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* xmlMutex are a simple mutual exception locks.
*/
typedef struct _xmlMutex xmlMutex;
typedef xmlMutex *xmlMutexPtr;
/*
* xmlRMutex are reentrant mutual exception locks.
*/
typedef struct _xmlRMutex xmlRMutex;
typedef xmlRMutex *xmlRMutexPtr;
#ifdef __cplusplus
}
#endif
#include <libxml/globals.h>
#ifdef __cplusplus
extern "C" {
#endif
XMLPUBFUN xmlMutexPtr XMLCALL
xmlNewMutex (void);
XMLPUBFUN void XMLCALL
xmlMutexLock (xmlMutexPtr tok);
XMLPUBFUN void XMLCALL
xmlMutexUnlock (xmlMutexPtr tok);
XMLPUBFUN void XMLCALL
xmlFreeMutex (xmlMutexPtr tok);
XMLPUBFUN xmlRMutexPtr XMLCALL
xmlNewRMutex (void);
XMLPUBFUN void XMLCALL
xmlRMutexLock (xmlRMutexPtr tok);
XMLPUBFUN void XMLCALL
xmlRMutexUnlock (xmlRMutexPtr tok);
XMLPUBFUN void XMLCALL
xmlFreeRMutex (xmlRMutexPtr tok);
/*
* Library wide APIs.
*/
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlInitThreads (void);
XMLPUBFUN void XMLCALL
xmlLockLibrary (void);
XMLPUBFUN void XMLCALL
xmlUnlockLibrary(void);
XMLPUBFUN int XMLCALL
xmlGetThreadId (void);
XMLPUBFUN int XMLCALL
xmlIsMainThread (void);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlCleanupThreads(void);
XMLPUBFUN xmlGlobalStatePtr XMLCALL
xmlGetGlobalState(void);
#ifdef HAVE_PTHREAD_H
#elif defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL))
#if defined(LIBXML_STATIC_FOR_DLL)
int XMLCALL
xmlDllMain(void *hinstDLL, unsigned long fdwReason,
void *lpvReserved);
#endif
#endif
#ifdef __cplusplus
}
#endif
#endif /* __XML_THREADS_H__ */
/*
* Summary: minimal HTTP implementation
* Description: minimal HTTP implementation allowing to fetch resources
* like external subset.
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __NANO_HTTP_H__
#define __NANO_HTTP_H__
#include <libxml/xmlversion.h>
#ifdef LIBXML_HTTP_ENABLED
#ifdef __cplusplus
extern "C" {
#endif
XMLPUBFUN void XMLCALL
xmlNanoHTTPInit (void);
XMLPUBFUN void XMLCALL
xmlNanoHTTPCleanup (void);
XMLPUBFUN void XMLCALL
xmlNanoHTTPScanProxy (const char *URL);
XMLPUBFUN int XMLCALL
xmlNanoHTTPFetch (const char *URL,
const char *filename,
char **contentType);
XMLPUBFUN void * XMLCALL
xmlNanoHTTPMethod (const char *URL,
const char *method,
const char *input,
char **contentType,
const char *headers,
int ilen);
XMLPUBFUN void * XMLCALL
xmlNanoHTTPMethodRedir (const char *URL,
const char *method,
const char *input,
char **contentType,
char **redir,
const char *headers,
int ilen);
XMLPUBFUN void * XMLCALL
xmlNanoHTTPOpen (const char *URL,
char **contentType);
XMLPUBFUN void * XMLCALL
xmlNanoHTTPOpenRedir (const char *URL,
char **contentType,
char **redir);
XMLPUBFUN int XMLCALL
xmlNanoHTTPReturnCode (void *ctx);
XMLPUBFUN const char * XMLCALL
xmlNanoHTTPAuthHeader (void *ctx);
XMLPUBFUN const char * XMLCALL
xmlNanoHTTPRedir (void *ctx);
XMLPUBFUN int XMLCALL
xmlNanoHTTPContentLength( void * ctx );
XMLPUBFUN const char * XMLCALL
xmlNanoHTTPEncoding (void *ctx);
XMLPUBFUN const char * XMLCALL
xmlNanoHTTPMimeType (void *ctx);
XMLPUBFUN int XMLCALL
xmlNanoHTTPRead (void *ctx,
void *dest,
int len);
#ifdef LIBXML_OUTPUT_ENABLED
XMLPUBFUN int XMLCALL
xmlNanoHTTPSave (void *ctxt,
const char *filename);
#endif /* LIBXML_OUTPUT_ENABLED */
XMLPUBFUN void XMLCALL
xmlNanoHTTPClose (void *ctx);
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_HTTP_ENABLED */
#endif /* __NANO_HTTP_H__ */
/*
* Summary: set of routines to process strings
* Description: type and interfaces needed for the internal string handling
* of the library, especially UTF8 processing.
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_STRING_H__
#define __XML_STRING_H__
#include <stdarg.h>
#include <libxml/xmlversion.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* xmlChar:
*
* This is a basic byte in an UTF-8 encoded string.
* It's unsigned allowing to pinpoint case where char * are assigned
* to xmlChar * (possibly making serialization back impossible).
*/
typedef unsigned char xmlChar;
/**
* BAD_CAST:
*
* Macro to cast a string to an xmlChar * when one know its safe.
*/
#define BAD_CAST (xmlChar *)
/*
* xmlChar handling
*/
XMLPUBFUN xmlChar * XMLCALL
xmlStrdup (const xmlChar *cur);
XMLPUBFUN xmlChar * XMLCALL
xmlStrndup (const xmlChar *cur,
int len);
XMLPUBFUN xmlChar * XMLCALL
xmlCharStrndup (const char *cur,
int len);
XMLPUBFUN xmlChar * XMLCALL
xmlCharStrdup (const char *cur);
XMLPUBFUN xmlChar * XMLCALL
xmlStrsub (const xmlChar *str,
int start,
int len);
XMLPUBFUN const xmlChar * XMLCALL
xmlStrchr (const xmlChar *str,
xmlChar val);
XMLPUBFUN const xmlChar * XMLCALL
xmlStrstr (const xmlChar *str,
const xmlChar *val);
XMLPUBFUN const xmlChar * XMLCALL
xmlStrcasestr (const xmlChar *str,
const xmlChar *val);
XMLPUBFUN int XMLCALL
xmlStrcmp (const xmlChar *str1,
const xmlChar *str2);
XMLPUBFUN int XMLCALL
xmlStrncmp (const xmlChar *str1,
const xmlChar *str2,
int len);
XMLPUBFUN int XMLCALL
xmlStrcasecmp (const xmlChar *str1,
const xmlChar *str2);
XMLPUBFUN int XMLCALL
xmlStrncasecmp (const xmlChar *str1,
const xmlChar *str2,
int len);
XMLPUBFUN int XMLCALL
xmlStrEqual (const xmlChar *str1,
const xmlChar *str2);
XMLPUBFUN int XMLCALL
xmlStrQEqual (const xmlChar *pref,
const xmlChar *name,
const xmlChar *str);
XMLPUBFUN int XMLCALL
xmlStrlen (const xmlChar *str);
XMLPUBFUN xmlChar * XMLCALL
xmlStrcat (xmlChar *cur,
const xmlChar *add);
XMLPUBFUN xmlChar * XMLCALL
xmlStrncat (xmlChar *cur,
const xmlChar *add,
int len);
XMLPUBFUN xmlChar * XMLCALL
xmlStrncatNew (const xmlChar *str1,
const xmlChar *str2,
int len);
XMLPUBFUN int XMLCALL
xmlStrPrintf (xmlChar *buf,
int len,
const char *msg,
...) LIBXML_ATTR_FORMAT(3,4);
XMLPUBFUN int XMLCALL
xmlStrVPrintf (xmlChar *buf,
int len,
const char *msg,
va_list ap) LIBXML_ATTR_FORMAT(3,0);
XMLPUBFUN int XMLCALL
xmlGetUTF8Char (const unsigned char *utf,
int *len);
XMLPUBFUN int XMLCALL
xmlCheckUTF8 (const unsigned char *utf);
XMLPUBFUN int XMLCALL
xmlUTF8Strsize (const xmlChar *utf,
int len);
XMLPUBFUN xmlChar * XMLCALL
xmlUTF8Strndup (const xmlChar *utf,
int len);
XMLPUBFUN const xmlChar * XMLCALL
xmlUTF8Strpos (const xmlChar *utf,
int pos);
XMLPUBFUN int XMLCALL
xmlUTF8Strloc (const xmlChar *utf,
const xmlChar *utfchar);
XMLPUBFUN xmlChar * XMLCALL
xmlUTF8Strsub (const xmlChar *utf,
int start,
int len);
XMLPUBFUN int XMLCALL
xmlUTF8Strlen (const xmlChar *utf);
XMLPUBFUN int XMLCALL
xmlUTF8Size (const xmlChar *utf);
XMLPUBFUN int XMLCALL
xmlUTF8Charcmp (const xmlChar *utf1,
const xmlChar *utf2);
#ifdef __cplusplus
}
#endif
#endif /* __XML_STRING_H__ */
/*
* Summary: Chained hash tables
* Description: This module implements the hash table support used in
* various places in the library.
*
* Copy: See Copyright for the status of this software.
*
* Author: Bjorn Reese <bjorn.reese@systematic.dk>
*/
#ifndef __XML_HASH_H__
#define __XML_HASH_H__
#ifdef __cplusplus
extern "C" {
#endif
/*
* The hash table.
*/
typedef struct _xmlHashTable xmlHashTable;
typedef xmlHashTable *xmlHashTablePtr;
#ifdef __cplusplus
}
#endif
#include <libxml/xmlversion.h>
#include <libxml/parser.h>
#include <libxml/dict.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* Recent version of gcc produce a warning when a function pointer is assigned
* to an object pointer, or vice versa. The following macro is a dirty hack
* to allow suppression of the warning. If your architecture has function
* pointers which are a different size than a void pointer, there may be some
* serious trouble within the library.
*/
/**
* XML_CAST_FPTR:
* @fptr: pointer to a function
*
* Macro to do a casting from an object pointer to a
* function pointer without encountering a warning from
* gcc
*
* #define XML_CAST_FPTR(fptr) (*(void **)(&fptr))
* This macro violated ISO C aliasing rules (gcc4 on s390 broke)
* so it is disabled now
*/
#define XML_CAST_FPTR(fptr) fptr
/*
* function types:
*/
/**
* xmlHashDeallocator:
* @payload: the data in the hash
* @name: the name associated
*
* Callback to free data from a hash.
*/
typedef void (*xmlHashDeallocator)(void *payload, const xmlChar *name);
/**
* xmlHashCopier:
* @payload: the data in the hash
* @name: the name associated
*
* Callback to copy data from a hash.
*
* Returns a copy of the data or NULL in case of error.
*/
typedef void *(*xmlHashCopier)(void *payload, const xmlChar *name);
/**
* xmlHashScanner:
* @payload: the data in the hash
* @data: extra scanner data
* @name: the name associated
*
* Callback when scanning data in a hash with the simple scanner.
*/
typedef void (*xmlHashScanner)(void *payload, void *data, const xmlChar *name);
/**
* xmlHashScannerFull:
* @payload: the data in the hash
* @data: extra scanner data
* @name: the name associated
* @name2: the second name associated
* @name3: the third name associated
*
* Callback when scanning data in a hash with the full scanner.
*/
typedef void (*xmlHashScannerFull)(void *payload, void *data,
const xmlChar *name, const xmlChar *name2,
const xmlChar *name3);
/*
* Constructor and destructor.
*/
XMLPUBFUN xmlHashTablePtr XMLCALL
xmlHashCreate (int size);
XMLPUBFUN xmlHashTablePtr XMLCALL
xmlHashCreateDict(int size,
xmlDictPtr dict);
XMLPUBFUN void XMLCALL
xmlHashFree (xmlHashTablePtr table,
xmlHashDeallocator f);
XMLPUBFUN void XMLCALL
xmlHashDefaultDeallocator(void *entry,
const xmlChar *name);
/*
* Add a new entry to the hash table.
*/
XMLPUBFUN int XMLCALL
xmlHashAddEntry (xmlHashTablePtr table,
const xmlChar *name,
void *userdata);
XMLPUBFUN int XMLCALL
xmlHashUpdateEntry(xmlHashTablePtr table,
const xmlChar *name,
void *userdata,
xmlHashDeallocator f);
XMLPUBFUN int XMLCALL
xmlHashAddEntry2(xmlHashTablePtr table,
const xmlChar *name,
const xmlChar *name2,
void *userdata);
XMLPUBFUN int XMLCALL
xmlHashUpdateEntry2(xmlHashTablePtr table,
const xmlChar *name,
const xmlChar *name2,
void *userdata,
xmlHashDeallocator f);
XMLPUBFUN int XMLCALL
xmlHashAddEntry3(xmlHashTablePtr table,
const xmlChar *name,
const xmlChar *name2,
const xmlChar *name3,
void *userdata);
XMLPUBFUN int XMLCALL
xmlHashUpdateEntry3(xmlHashTablePtr table,
const xmlChar *name,
const xmlChar *name2,
const xmlChar *name3,
void *userdata,
xmlHashDeallocator f);
/*
* Remove an entry from the hash table.
*/
XMLPUBFUN int XMLCALL
xmlHashRemoveEntry(xmlHashTablePtr table, const xmlChar *name,
xmlHashDeallocator f);
XMLPUBFUN int XMLCALL
xmlHashRemoveEntry2(xmlHashTablePtr table, const xmlChar *name,
const xmlChar *name2, xmlHashDeallocator f);
XMLPUBFUN int XMLCALL
xmlHashRemoveEntry3(xmlHashTablePtr table, const xmlChar *name,
const xmlChar *name2, const xmlChar *name3,
xmlHashDeallocator f);
/*
* Retrieve the userdata.
*/
XMLPUBFUN void * XMLCALL
xmlHashLookup (xmlHashTablePtr table,
const xmlChar *name);
XMLPUBFUN void * XMLCALL
xmlHashLookup2 (xmlHashTablePtr table,
const xmlChar *name,
const xmlChar *name2);
XMLPUBFUN void * XMLCALL
xmlHashLookup3 (xmlHashTablePtr table,
const xmlChar *name,
const xmlChar *name2,
const xmlChar *name3);
XMLPUBFUN void * XMLCALL
xmlHashQLookup (xmlHashTablePtr table,
const xmlChar *name,
const xmlChar *prefix);
XMLPUBFUN void * XMLCALL
xmlHashQLookup2 (xmlHashTablePtr table,
const xmlChar *name,
const xmlChar *prefix,
const xmlChar *name2,
const xmlChar *prefix2);
XMLPUBFUN void * XMLCALL
xmlHashQLookup3 (xmlHashTablePtr table,
const xmlChar *name,
const xmlChar *prefix,
const xmlChar *name2,
const xmlChar *prefix2,
const xmlChar *name3,
const xmlChar *prefix3);
/*
* Helpers.
*/
XMLPUBFUN xmlHashTablePtr XMLCALL
xmlHashCopy (xmlHashTablePtr table,
xmlHashCopier f);
XMLPUBFUN int XMLCALL
xmlHashSize (xmlHashTablePtr table);
XMLPUBFUN void XMLCALL
xmlHashScan (xmlHashTablePtr table,
xmlHashScanner f,
void *data);
XMLPUBFUN void XMLCALL
xmlHashScan3 (xmlHashTablePtr table,
const xmlChar *name,
const xmlChar *name2,
const xmlChar *name3,
xmlHashScanner f,
void *data);
XMLPUBFUN void XMLCALL
xmlHashScanFull (xmlHashTablePtr table,
xmlHashScannerFull f,
void *data);
XMLPUBFUN void XMLCALL
xmlHashScanFull3(xmlHashTablePtr table,
const xmlChar *name,
const xmlChar *name2,
const xmlChar *name3,
xmlHashScannerFull f,
void *data);
#ifdef __cplusplus
}
#endif
#endif /* ! __XML_HASH_H__ */
/*
* Summary: Provide Canonical XML and Exclusive XML Canonicalization
* Description: the c14n modules provides a
*
* "Canonical XML" implementation
* http://www.w3.org/TR/xml-c14n
*
* and an
*
* "Exclusive XML Canonicalization" implementation
* http://www.w3.org/TR/xml-exc-c14n
* Copy: See Copyright for the status of this software.
*
* Author: Aleksey Sanin <aleksey@aleksey.com>
*/
#ifndef __XML_C14N_H__
#define __XML_C14N_H__
#include <libxml/xmlversion.h>
#ifdef LIBXML_C14N_ENABLED
#ifdef LIBXML_OUTPUT_ENABLED
#include <libxml/tree.h>
#include <libxml/xpath.h>
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/*
* XML Canonicalization
* http://www.w3.org/TR/xml-c14n
*
* Exclusive XML Canonicalization
* http://www.w3.org/TR/xml-exc-c14n
*
* Canonical form of an XML document could be created if and only if
* a) default attributes (if any) are added to all nodes
* b) all character and parsed entity references are resolved
* In order to achieve this in libxml2 the document MUST be loaded with
* following global settings:
*
* xmlLoadExtDtdDefaultValue = XML_DETECT_IDS | XML_COMPLETE_ATTRS;
* xmlSubstituteEntitiesDefault(1);
*
* or corresponding parser context setting:
* xmlParserCtxtPtr ctxt;
*
* ...
* ctxt->loadsubset = XML_DETECT_IDS | XML_COMPLETE_ATTRS;
* ctxt->replaceEntities = 1;
* ...
*/
/*
* xmlC14NMode:
*
* Predefined values for C14N modes
*
*/
typedef enum {
XML_C14N_1_0 = 0, /* Original C14N 1.0 spec */
XML_C14N_EXCLUSIVE_1_0 = 1, /* Exclusive C14N 1.0 spec */
XML_C14N_1_1 = 2 /* C14N 1.1 spec */
} xmlC14NMode;
XMLPUBFUN int XMLCALL
xmlC14NDocSaveTo (xmlDocPtr doc,
xmlNodeSetPtr nodes,
int mode, /* a xmlC14NMode */
xmlChar **inclusive_ns_prefixes,
int with_comments,
xmlOutputBufferPtr buf);
XMLPUBFUN int XMLCALL
xmlC14NDocDumpMemory (xmlDocPtr doc,
xmlNodeSetPtr nodes,
int mode, /* a xmlC14NMode */
xmlChar **inclusive_ns_prefixes,
int with_comments,
xmlChar **doc_txt_ptr);
XMLPUBFUN int XMLCALL
xmlC14NDocSave (xmlDocPtr doc,
xmlNodeSetPtr nodes,
int mode, /* a xmlC14NMode */
xmlChar **inclusive_ns_prefixes,
int with_comments,
const char* filename,
int compression);
/**
* This is the core C14N function
*/
/**
* xmlC14NIsVisibleCallback:
* @user_data: user data
* @node: the current node
* @parent: the parent node
*
* Signature for a C14N callback on visible nodes
*
* Returns 1 if the node should be included
*/
typedef int (*xmlC14NIsVisibleCallback) (void* user_data,
xmlNodePtr node,
xmlNodePtr parent);
XMLPUBFUN int XMLCALL
xmlC14NExecute (xmlDocPtr doc,
xmlC14NIsVisibleCallback is_visible_callback,
void* user_data,
int mode, /* a xmlC14NMode */
xmlChar **inclusive_ns_prefixes,
int with_comments,
xmlOutputBufferPtr buf);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* LIBXML_OUTPUT_ENABLED */
#endif /* LIBXML_C14N_ENABLED */
#endif /* __XML_C14N_H__ */
/*
* Summary: Tree debugging APIs
* Description: Interfaces to a set of routines used for debugging the tree
* produced by the XML parser.
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __DEBUG_XML__
#define __DEBUG_XML__
#include <stdio.h>
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#ifdef LIBXML_DEBUG_ENABLED
#include <libxml/xpath.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* The standard Dump routines.
*/
XMLPUBFUN void XMLCALL
xmlDebugDumpString (FILE *output,
const xmlChar *str);
XMLPUBFUN void XMLCALL
xmlDebugDumpAttr (FILE *output,
xmlAttrPtr attr,
int depth);
XMLPUBFUN void XMLCALL
xmlDebugDumpAttrList (FILE *output,
xmlAttrPtr attr,
int depth);
XMLPUBFUN void XMLCALL
xmlDebugDumpOneNode (FILE *output,
xmlNodePtr node,
int depth);
XMLPUBFUN void XMLCALL
xmlDebugDumpNode (FILE *output,
xmlNodePtr node,
int depth);
XMLPUBFUN void XMLCALL
xmlDebugDumpNodeList (FILE *output,
xmlNodePtr node,
int depth);
XMLPUBFUN void XMLCALL
xmlDebugDumpDocumentHead(FILE *output,
xmlDocPtr doc);
XMLPUBFUN void XMLCALL
xmlDebugDumpDocument (FILE *output,
xmlDocPtr doc);
XMLPUBFUN void XMLCALL
xmlDebugDumpDTD (FILE *output,
xmlDtdPtr dtd);
XMLPUBFUN void XMLCALL
xmlDebugDumpEntities (FILE *output,
xmlDocPtr doc);
/****************************************************************
* *
* Checking routines *
* *
****************************************************************/
XMLPUBFUN int XMLCALL
xmlDebugCheckDocument (FILE * output,
xmlDocPtr doc);
/****************************************************************
* *
* XML shell helpers *
* *
****************************************************************/
XMLPUBFUN void XMLCALL
xmlLsOneNode (FILE *output, xmlNodePtr node);
XMLPUBFUN int XMLCALL
xmlLsCountNode (xmlNodePtr node);
XMLPUBFUN const char * XMLCALL
xmlBoolToText (int boolval);
/****************************************************************
* *
* The XML shell related structures and functions *
* *
****************************************************************/
#ifdef LIBXML_XPATH_ENABLED
/**
* xmlShellReadlineFunc:
* @prompt: a string prompt
*
* This is a generic signature for the XML shell input function.
*
* Returns a string which will be freed by the Shell.
*/
typedef char * (* xmlShellReadlineFunc)(char *prompt);
/**
* xmlShellCtxt:
*
* A debugging shell context.
* TODO: add the defined function tables.
*/
typedef struct _xmlShellCtxt xmlShellCtxt;
typedef xmlShellCtxt *xmlShellCtxtPtr;
struct _xmlShellCtxt {
char *filename;
xmlDocPtr doc;
xmlNodePtr node;
xmlXPathContextPtr pctxt;
int loaded;
FILE *output;
xmlShellReadlineFunc input;
};
/**
* xmlShellCmd:
* @ctxt: a shell context
* @arg: a string argument
* @node: a first node
* @node2: a second node
*
* This is a generic signature for the XML shell functions.
*
* Returns an int, negative returns indicating errors.
*/
typedef int (* xmlShellCmd) (xmlShellCtxtPtr ctxt,
char *arg,
xmlNodePtr node,
xmlNodePtr node2);
XMLPUBFUN void XMLCALL
xmlShellPrintXPathError (int errorType,
const char *arg);
XMLPUBFUN void XMLCALL
xmlShellPrintXPathResult(xmlXPathObjectPtr list);
XMLPUBFUN int XMLCALL
xmlShellList (xmlShellCtxtPtr ctxt,
char *arg,
xmlNodePtr node,
xmlNodePtr node2);
XMLPUBFUN int XMLCALL
xmlShellBase (xmlShellCtxtPtr ctxt,
char *arg,
xmlNodePtr node,
xmlNodePtr node2);
XMLPUBFUN int XMLCALL
xmlShellDir (xmlShellCtxtPtr ctxt,
char *arg,
xmlNodePtr node,
xmlNodePtr node2);
XMLPUBFUN int XMLCALL
xmlShellLoad (xmlShellCtxtPtr ctxt,
char *filename,
xmlNodePtr node,
xmlNodePtr node2);
#ifdef LIBXML_OUTPUT_ENABLED
XMLPUBFUN void XMLCALL
xmlShellPrintNode (xmlNodePtr node);
XMLPUBFUN int XMLCALL
xmlShellCat (xmlShellCtxtPtr ctxt,
char *arg,
xmlNodePtr node,
xmlNodePtr node2);
XMLPUBFUN int XMLCALL
xmlShellWrite (xmlShellCtxtPtr ctxt,
char *filename,
xmlNodePtr node,
xmlNodePtr node2);
XMLPUBFUN int XMLCALL
xmlShellSave (xmlShellCtxtPtr ctxt,
char *filename,
xmlNodePtr node,
xmlNodePtr node2);
#endif /* LIBXML_OUTPUT_ENABLED */
#ifdef LIBXML_VALID_ENABLED
XMLPUBFUN int XMLCALL
xmlShellValidate (xmlShellCtxtPtr ctxt,
char *dtd,
xmlNodePtr node,
xmlNodePtr node2);
#endif /* LIBXML_VALID_ENABLED */
XMLPUBFUN int XMLCALL
xmlShellDu (xmlShellCtxtPtr ctxt,
char *arg,
xmlNodePtr tree,
xmlNodePtr node2);
XMLPUBFUN int XMLCALL
xmlShellPwd (xmlShellCtxtPtr ctxt,
char *buffer,
xmlNodePtr node,
xmlNodePtr node2);
/*
* The Shell interface.
*/
XMLPUBFUN void XMLCALL
xmlShell (xmlDocPtr doc,
char *filename,
xmlShellReadlineFunc input,
FILE *output);
#endif /* LIBXML_XPATH_ENABLED */
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_DEBUG_ENABLED */
#endif /* __DEBUG_XML__ */
/*
* Summary: interface for the encoding conversion functions
* Description: interface for the encoding conversion functions needed for
* XML basic encoding and iconv() support.
*
* Related specs are
* rfc2044 (UTF-8 and UTF-16) F. Yergeau Alis Technologies
* [ISO-10646] UTF-8 and UTF-16 in Annexes
* [ISO-8859-1] ISO Latin-1 characters codes.
* [UNICODE] The Unicode Consortium, "The Unicode Standard --
* Worldwide Character Encoding -- Version 1.0", Addison-
* Wesley, Volume 1, 1991, Volume 2, 1992. UTF-8 is
* described in Unicode Technical Report #4.
* [US-ASCII] Coded Character Set--7-bit American Standard Code for
* Information Interchange, ANSI X3.4-1986.
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_CHAR_ENCODING_H__
#define __XML_CHAR_ENCODING_H__
#include <libxml/xmlversion.h>
#ifdef LIBXML_ICONV_ENABLED
#include <iconv.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif
/*
* xmlCharEncoding:
*
* Predefined values for some standard encodings.
* Libxml does not do beforehand translation on UTF8 and ISOLatinX.
* It also supports ASCII, ISO-8859-1, and UTF16 (LE and BE) by default.
*
* Anything else would have to be translated to UTF8 before being
* given to the parser itself. The BOM for UTF16 and the encoding
* declaration are looked at and a converter is looked for at that
* point. If not found the parser stops here as asked by the XML REC. A
* converter can be registered by the user using xmlRegisterCharEncodingHandler
* but the current form doesn't allow stateful transcoding (a serious
* problem agreed !). If iconv has been found it will be used
* automatically and allow stateful transcoding, the simplest is then
* to be sure to enable iconv and to provide iconv libs for the encoding
* support needed.
*
* Note that the generic "UTF-16" is not a predefined value. Instead, only
* the specific UTF-16LE and UTF-16BE are present.
*/
typedef enum {
XML_CHAR_ENCODING_ERROR= -1, /* No char encoding detected */
XML_CHAR_ENCODING_NONE= 0, /* No char encoding detected */
XML_CHAR_ENCODING_UTF8= 1, /* UTF-8 */
XML_CHAR_ENCODING_UTF16LE= 2, /* UTF-16 little endian */
XML_CHAR_ENCODING_UTF16BE= 3, /* UTF-16 big endian */
XML_CHAR_ENCODING_UCS4LE= 4, /* UCS-4 little endian */
XML_CHAR_ENCODING_UCS4BE= 5, /* UCS-4 big endian */
XML_CHAR_ENCODING_EBCDIC= 6, /* EBCDIC uh! */
XML_CHAR_ENCODING_UCS4_2143=7, /* UCS-4 unusual ordering */
XML_CHAR_ENCODING_UCS4_3412=8, /* UCS-4 unusual ordering */
XML_CHAR_ENCODING_UCS2= 9, /* UCS-2 */
XML_CHAR_ENCODING_8859_1= 10,/* ISO-8859-1 ISO Latin 1 */
XML_CHAR_ENCODING_8859_2= 11,/* ISO-8859-2 ISO Latin 2 */
XML_CHAR_ENCODING_8859_3= 12,/* ISO-8859-3 */
XML_CHAR_ENCODING_8859_4= 13,/* ISO-8859-4 */
XML_CHAR_ENCODING_8859_5= 14,/* ISO-8859-5 */
XML_CHAR_ENCODING_8859_6= 15,/* ISO-8859-6 */
XML_CHAR_ENCODING_8859_7= 16,/* ISO-8859-7 */
XML_CHAR_ENCODING_8859_8= 17,/* ISO-8859-8 */
XML_CHAR_ENCODING_8859_9= 18,/* ISO-8859-9 */
XML_CHAR_ENCODING_2022_JP= 19,/* ISO-2022-JP */
XML_CHAR_ENCODING_SHIFT_JIS=20,/* Shift_JIS */
XML_CHAR_ENCODING_EUC_JP= 21,/* EUC-JP */
XML_CHAR_ENCODING_ASCII= 22 /* pure ASCII */
} xmlCharEncoding;
/**
* xmlCharEncodingInputFunc:
* @out: a pointer to an array of bytes to store the UTF-8 result
* @outlen: the length of @out
* @in: a pointer to an array of chars in the original encoding
* @inlen: the length of @in
*
* Take a block of chars in the original encoding and try to convert
* it to an UTF-8 block of chars out.
*
* Returns the number of bytes written, -1 if lack of space, or -2
* if the transcoding failed.
* The value of @inlen after return is the number of octets consumed
* if the return value is positive, else unpredictiable.
* The value of @outlen after return is the number of octets consumed.
*/
typedef int (* xmlCharEncodingInputFunc)(unsigned char *out, int *outlen,
const unsigned char *in, int *inlen);
/**
* xmlCharEncodingOutputFunc:
* @out: a pointer to an array of bytes to store the result
* @outlen: the length of @out
* @in: a pointer to an array of UTF-8 chars
* @inlen: the length of @in
*
* Take a block of UTF-8 chars in and try to convert it to another
* encoding.
* Note: a first call designed to produce heading info is called with
* in = NULL. If stateful this should also initialize the encoder state.
*
* Returns the number of bytes written, -1 if lack of space, or -2
* if the transcoding failed.
* The value of @inlen after return is the number of octets consumed
* if the return value is positive, else unpredictiable.
* The value of @outlen after return is the number of octets produced.
*/
typedef int (* xmlCharEncodingOutputFunc)(unsigned char *out, int *outlen,
const unsigned char *in, int *inlen);
/*
* Block defining the handlers for non UTF-8 encodings.
* If iconv is supported, there are two extra fields.
*/
typedef struct _xmlCharEncodingHandler xmlCharEncodingHandler;
typedef xmlCharEncodingHandler *xmlCharEncodingHandlerPtr;
struct _xmlCharEncodingHandler {
char *name;
xmlCharEncodingInputFunc input;
xmlCharEncodingOutputFunc output;
#ifdef LIBXML_ICONV_ENABLED
iconv_t iconv_in;
iconv_t iconv_out;
#endif /* LIBXML_ICONV_ENABLED */
#ifdef LIBXML_ICU_ENABLED
struct _uconv_t *uconv_in;
struct _uconv_t *uconv_out;
#endif /* LIBXML_ICU_ENABLED */
};
#ifdef __cplusplus
}
#endif
#include <libxml/tree.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* Interfaces for encoding handlers.
*/
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlInitCharEncodingHandlers (void);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlCleanupCharEncodingHandlers (void);
XMLPUBFUN void XMLCALL
xmlRegisterCharEncodingHandler (xmlCharEncodingHandlerPtr handler);
XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL
xmlGetCharEncodingHandler (xmlCharEncoding enc);
XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL
xmlFindCharEncodingHandler (const char *name);
XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL
xmlNewCharEncodingHandler (const char *name,
xmlCharEncodingInputFunc input,
xmlCharEncodingOutputFunc output);
/*
* Interfaces for encoding names and aliases.
*/
XMLPUBFUN int XMLCALL
xmlAddEncodingAlias (const char *name,
const char *alias);
XMLPUBFUN int XMLCALL
xmlDelEncodingAlias (const char *alias);
XMLPUBFUN const char * XMLCALL
xmlGetEncodingAlias (const char *alias);
XMLPUBFUN void XMLCALL
xmlCleanupEncodingAliases (void);
XMLPUBFUN xmlCharEncoding XMLCALL
xmlParseCharEncoding (const char *name);
XMLPUBFUN const char * XMLCALL
xmlGetCharEncodingName (xmlCharEncoding enc);
/*
* Interfaces directly used by the parsers.
*/
XMLPUBFUN xmlCharEncoding XMLCALL
xmlDetectCharEncoding (const unsigned char *in,
int len);
XMLPUBFUN int XMLCALL
xmlCharEncOutFunc (xmlCharEncodingHandler *handler,
xmlBufferPtr out,
xmlBufferPtr in);
XMLPUBFUN int XMLCALL
xmlCharEncInFunc (xmlCharEncodingHandler *handler,
xmlBufferPtr out,
xmlBufferPtr in);
XMLPUBFUN int XMLCALL
xmlCharEncFirstLine (xmlCharEncodingHandler *handler,
xmlBufferPtr out,
xmlBufferPtr in);
XMLPUBFUN int XMLCALL
xmlCharEncCloseFunc (xmlCharEncodingHandler *handler);
/*
* Export a few useful functions
*/
#ifdef LIBXML_OUTPUT_ENABLED
XMLPUBFUN int XMLCALL
UTF8Toisolat1 (unsigned char *out,
int *outlen,
const unsigned char *in,
int *inlen);
#endif /* LIBXML_OUTPUT_ENABLED */
XMLPUBFUN int XMLCALL
isolat1ToUTF8 (unsigned char *out,
int *outlen,
const unsigned char *in,
int *inlen);
#ifdef __cplusplus
}
#endif
#endif /* __XML_CHAR_ENCODING_H__ */
/*
* Summary: implementation of the Relax-NG validation
* Description: implementation of the Relax-NG validation
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_RELAX_NG__
#define __XML_RELAX_NG__
#include <libxml/xmlversion.h>
#include <libxml/hash.h>
#include <libxml/xmlstring.h>
#ifdef LIBXML_SCHEMAS_ENABLED
#ifdef __cplusplus
extern "C" {
#endif
typedef struct _xmlRelaxNG xmlRelaxNG;
typedef xmlRelaxNG *xmlRelaxNGPtr;
/**
* xmlRelaxNGValidityErrorFunc:
* @ctx: the validation context
* @msg: the message
* @...: extra arguments
*
* Signature of an error callback from a Relax-NG validation
*/
typedef void (XMLCDECL *xmlRelaxNGValidityErrorFunc) (void *ctx,
const char *msg,
...) LIBXML_ATTR_FORMAT(2,3);
/**
* xmlRelaxNGValidityWarningFunc:
* @ctx: the validation context
* @msg: the message
* @...: extra arguments
*
* Signature of a warning callback from a Relax-NG validation
*/
typedef void (XMLCDECL *xmlRelaxNGValidityWarningFunc) (void *ctx,
const char *msg,
...) LIBXML_ATTR_FORMAT(2,3);
/**
* A schemas validation context
*/
typedef struct _xmlRelaxNGParserCtxt xmlRelaxNGParserCtxt;
typedef xmlRelaxNGParserCtxt *xmlRelaxNGParserCtxtPtr;
typedef struct _xmlRelaxNGValidCtxt xmlRelaxNGValidCtxt;
typedef xmlRelaxNGValidCtxt *xmlRelaxNGValidCtxtPtr;
/*
* xmlRelaxNGValidErr:
*
* List of possible Relax NG validation errors
*/
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;
/*
* xmlRelaxNGParserFlags:
*
* List of possible Relax NG Parser flags
*/
typedef enum {
XML_RELAXNGP_NONE = 0,
XML_RELAXNGP_FREE_DOC = 1,
XML_RELAXNGP_CRNG = 2
} xmlRelaxNGParserFlag;
XMLPUBFUN int XMLCALL
xmlRelaxNGInitTypes (void);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlRelaxNGCleanupTypes (void);
/*
* Interfaces for parsing.
*/
XMLPUBFUN xmlRelaxNGParserCtxtPtr XMLCALL
xmlRelaxNGNewParserCtxt (const char *URL);
XMLPUBFUN xmlRelaxNGParserCtxtPtr XMLCALL
xmlRelaxNGNewMemParserCtxt (const char *buffer,
int size);
XMLPUBFUN xmlRelaxNGParserCtxtPtr XMLCALL
xmlRelaxNGNewDocParserCtxt (xmlDocPtr doc);
XMLPUBFUN int XMLCALL
xmlRelaxParserSetFlag (xmlRelaxNGParserCtxtPtr ctxt,
int flag);
XMLPUBFUN void XMLCALL
xmlRelaxNGFreeParserCtxt (xmlRelaxNGParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlRelaxNGSetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
xmlRelaxNGValidityErrorFunc err,
xmlRelaxNGValidityWarningFunc warn,
void *ctx);
XMLPUBFUN int XMLCALL
xmlRelaxNGGetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
xmlRelaxNGValidityErrorFunc *err,
xmlRelaxNGValidityWarningFunc *warn,
void **ctx);
XMLPUBFUN void XMLCALL
xmlRelaxNGSetParserStructuredErrors(
xmlRelaxNGParserCtxtPtr ctxt,
xmlStructuredErrorFunc serror,
void *ctx);
XMLPUBFUN xmlRelaxNGPtr XMLCALL
xmlRelaxNGParse (xmlRelaxNGParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlRelaxNGFree (xmlRelaxNGPtr schema);
#ifdef LIBXML_OUTPUT_ENABLED
XMLPUBFUN void XMLCALL
xmlRelaxNGDump (FILE *output,
xmlRelaxNGPtr schema);
XMLPUBFUN void XMLCALL
xmlRelaxNGDumpTree (FILE * output,
xmlRelaxNGPtr schema);
#endif /* LIBXML_OUTPUT_ENABLED */
/*
* Interfaces for validating
*/
XMLPUBFUN void XMLCALL
xmlRelaxNGSetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
xmlRelaxNGValidityErrorFunc err,
xmlRelaxNGValidityWarningFunc warn,
void *ctx);
XMLPUBFUN int XMLCALL
xmlRelaxNGGetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
xmlRelaxNGValidityErrorFunc *err,
xmlRelaxNGValidityWarningFunc *warn,
void **ctx);
XMLPUBFUN void XMLCALL
xmlRelaxNGSetValidStructuredErrors(xmlRelaxNGValidCtxtPtr ctxt,
xmlStructuredErrorFunc serror, void *ctx);
XMLPUBFUN xmlRelaxNGValidCtxtPtr XMLCALL
xmlRelaxNGNewValidCtxt (xmlRelaxNGPtr schema);
XMLPUBFUN void XMLCALL
xmlRelaxNGFreeValidCtxt (xmlRelaxNGValidCtxtPtr ctxt);
XMLPUBFUN int XMLCALL
xmlRelaxNGValidateDoc (xmlRelaxNGValidCtxtPtr ctxt,
xmlDocPtr doc);
/*
* Interfaces for progressive validation when possible
*/
XMLPUBFUN int XMLCALL
xmlRelaxNGValidatePushElement (xmlRelaxNGValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlNodePtr elem);
XMLPUBFUN int XMLCALL
xmlRelaxNGValidatePushCData (xmlRelaxNGValidCtxtPtr ctxt,
const xmlChar *data,
int len);
XMLPUBFUN int XMLCALL
xmlRelaxNGValidatePopElement (xmlRelaxNGValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlNodePtr elem);
XMLPUBFUN int XMLCALL
xmlRelaxNGValidateFullElement (xmlRelaxNGValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlNodePtr elem);
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_SCHEMAS_ENABLED */
#endif /* __XML_RELAX_NG__ */
/*
* Summary: compile-time version information
* Description: compile-time version information for the XML library
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_VERSION_H__
#define __XML_VERSION_H__
#include <libxml/xmlexports.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* use those to be sure nothing nasty will happen if
* your library and includes mismatch
*/
#ifndef LIBXML2_COMPILING_MSCCDEF
XMLPUBFUN void XMLCALL xmlCheckVersion(int version);
#endif /* LIBXML2_COMPILING_MSCCDEF */
/**
* LIBXML_DOTTED_VERSION:
*
* the version string like "1.2.3"
*/
#define LIBXML_DOTTED_VERSION "2.10.2"
/**
* LIBXML_VERSION:
*
* the version number: 1.2.3 value is 10203
*/
#define LIBXML_VERSION 21002
/**
* LIBXML_VERSION_STRING:
*
* the version number string, 1.2.3 value is "10203"
*/
#define LIBXML_VERSION_STRING "21002"
/**
* LIBXML_VERSION_EXTRA:
*
* extra version information, used to show a git commit description
*/
#define LIBXML_VERSION_EXTRA ""
/**
* LIBXML_TEST_VERSION:
*
* Macro to check that the libxml version in use is compatible with
* the version the software has been compiled against
*/
#define LIBXML_TEST_VERSION xmlCheckVersion(21002);
#ifndef VMS
#if 0
/**
* WITH_TRIO:
*
* defined if the trio support need to be configured in
*/
#define WITH_TRIO
#else
/**
* WITHOUT_TRIO:
*
* defined if the trio support should not be configured in
*/
#define WITHOUT_TRIO
#endif
#else /* VMS */
/**
* WITH_TRIO:
*
* defined if the trio support need to be configured in
*/
#define WITH_TRIO 1
#endif /* VMS */
/**
* LIBXML_THREAD_ENABLED:
*
* Whether the thread support is configured in
*/
#if 1
#define LIBXML_THREAD_ENABLED
#endif
/**
* LIBXML_THREAD_ALLOC_ENABLED:
*
* Whether the allocation hooks are per-thread
*/
#if 0
#define LIBXML_THREAD_ALLOC_ENABLED
#endif
/**
* LIBXML_TREE_ENABLED:
*
* Whether the DOM like tree manipulation API support is configured in
*/
#if 1
#define LIBXML_TREE_ENABLED
#endif
/**
* LIBXML_OUTPUT_ENABLED:
*
* Whether the serialization/saving support is configured in
*/
#if 1
#define LIBXML_OUTPUT_ENABLED
#endif
/**
* LIBXML_PUSH_ENABLED:
*
* Whether the push parsing interfaces are configured in
*/
#if 1
#define LIBXML_PUSH_ENABLED
#endif
/**
* LIBXML_READER_ENABLED:
*
* Whether the xmlReader parsing interface is configured in
*/
#if 1
#define LIBXML_READER_ENABLED
#endif
/**
* LIBXML_PATTERN_ENABLED:
*
* Whether the xmlPattern node selection interface is configured in
*/
#if 1
#define LIBXML_PATTERN_ENABLED
#endif
/**
* LIBXML_WRITER_ENABLED:
*
* Whether the xmlWriter saving interface is configured in
*/
#if 1
#define LIBXML_WRITER_ENABLED
#endif
/**
* LIBXML_SAX1_ENABLED:
*
* Whether the older SAX1 interface is configured in
*/
#if 1
#define LIBXML_SAX1_ENABLED
#endif
/**
* LIBXML_FTP_ENABLED:
*
* Whether the FTP support is configured in
*/
#if 1
#define LIBXML_FTP_ENABLED
#endif
/**
* LIBXML_HTTP_ENABLED:
*
* Whether the HTTP support is configured in
*/
#if 1
#define LIBXML_HTTP_ENABLED
#endif
/**
* LIBXML_VALID_ENABLED:
*
* Whether the DTD validation support is configured in
*/
#if 1
#define LIBXML_VALID_ENABLED
#endif
/**
* LIBXML_HTML_ENABLED:
*
* Whether the HTML support is configured in
*/
#if 1
#define LIBXML_HTML_ENABLED
#endif
/**
* LIBXML_LEGACY_ENABLED:
*
* Whether the deprecated APIs are compiled in for compatibility
*/
#if 0
#define LIBXML_LEGACY_ENABLED
#endif
/**
* LIBXML_C14N_ENABLED:
*
* Whether the Canonicalization support is configured in
*/
#if 1
#define LIBXML_C14N_ENABLED
#endif
/**
* LIBXML_CATALOG_ENABLED:
*
* Whether the Catalog support is configured in
*/
#if 1
#define LIBXML_CATALOG_ENABLED
#endif
/**
* LIBXML_XPATH_ENABLED:
*
* Whether XPath is configured in
*/
#if 1
#define LIBXML_XPATH_ENABLED
#endif
/**
* LIBXML_XPTR_ENABLED:
*
* Whether XPointer is configured in
*/
#if 1
#define LIBXML_XPTR_ENABLED
#endif
/**
* LIBXML_XPTR_LOCS_ENABLED:
*
* Whether support for XPointer locations is configured in
*/
#if 0
#define LIBXML_XPTR_LOCS_ENABLED
#endif
/**
* LIBXML_XINCLUDE_ENABLED:
*
* Whether XInclude is configured in
*/
#if 1
#define LIBXML_XINCLUDE_ENABLED
#endif
/**
* LIBXML_ICONV_ENABLED:
*
* Whether iconv support is available
*/
#if 1
#define LIBXML_ICONV_ENABLED
#endif
/**
* LIBXML_ICU_ENABLED:
*
* Whether icu support is available
*/
#if 0
#define LIBXML_ICU_ENABLED
#endif
/**
* LIBXML_ISO8859X_ENABLED:
*
* Whether ISO-8859-* support is made available in case iconv is not
*/
#if 1
#define LIBXML_ISO8859X_ENABLED
#endif
/**
* LIBXML_DEBUG_ENABLED:
*
* Whether Debugging module is configured in
*/
#if 1
#define LIBXML_DEBUG_ENABLED
#endif
/**
* DEBUG_MEMORY_LOCATION:
*
* Whether the memory debugging is configured in
*/
#if 0
#define DEBUG_MEMORY_LOCATION
#endif
/**
* LIBXML_DEBUG_RUNTIME:
*
* Whether the runtime debugging is configured in
*/
#if 0
#define LIBXML_DEBUG_RUNTIME
#endif
/**
* LIBXML_UNICODE_ENABLED:
*
* Whether the Unicode related interfaces are compiled in
*/
#if 1
#define LIBXML_UNICODE_ENABLED
#endif
/**
* LIBXML_REGEXP_ENABLED:
*
* Whether the regular expressions interfaces are compiled in
*/
#if 1
#define LIBXML_REGEXP_ENABLED
#endif
/**
* LIBXML_AUTOMATA_ENABLED:
*
* Whether the automata interfaces are compiled in
*/
#if 1
#define LIBXML_AUTOMATA_ENABLED
#endif
/**
* LIBXML_EXPR_ENABLED:
*
* Whether the formal expressions interfaces are compiled in
*
* This code is unused and disabled unconditionally for now.
*/
#if 0
#define LIBXML_EXPR_ENABLED
#endif
/**
* LIBXML_SCHEMAS_ENABLED:
*
* Whether the Schemas validation interfaces are compiled in
*/
#if 1
#define LIBXML_SCHEMAS_ENABLED
#endif
/**
* LIBXML_SCHEMATRON_ENABLED:
*
* Whether the Schematron validation interfaces are compiled in
*/
#if 1
#define LIBXML_SCHEMATRON_ENABLED
#endif
/**
* LIBXML_MODULES_ENABLED:
*
* Whether the module interfaces are compiled in
*/
#if 1
#define LIBXML_MODULES_ENABLED
/**
* LIBXML_MODULE_EXTENSION:
*
* the string suffix used by dynamic modules (usually shared libraries)
*/
#define LIBXML_MODULE_EXTENSION ".so"
#endif
/**
* LIBXML_ZLIB_ENABLED:
*
* Whether the Zlib support is compiled in
*/
#if 1
#define LIBXML_ZLIB_ENABLED
#endif
/**
* LIBXML_LZMA_ENABLED:
*
* Whether the Lzma support is compiled in
*/
#if 1
#define LIBXML_LZMA_ENABLED
#endif
#ifdef __GNUC__
/**
* ATTRIBUTE_UNUSED:
*
* Macro used to signal to GCC unused function parameters
*/
#ifndef ATTRIBUTE_UNUSED
# if ((__GNUC__ > 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >= 7)))
# define ATTRIBUTE_UNUSED __attribute__((unused))
# else
# define ATTRIBUTE_UNUSED
# endif
#endif
/**
* LIBXML_ATTR_ALLOC_SIZE:
*
* Macro used to indicate to GCC this is an allocator function
*/
#ifndef LIBXML_ATTR_ALLOC_SIZE
# if (!defined(__clang__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3))))
# define LIBXML_ATTR_ALLOC_SIZE(x) __attribute__((alloc_size(x)))
# else
# define LIBXML_ATTR_ALLOC_SIZE(x)
# endif
#else
# define LIBXML_ATTR_ALLOC_SIZE(x)
#endif
/**
* LIBXML_ATTR_FORMAT:
*
* Macro used to indicate to GCC the parameter are printf like
*/
#ifndef LIBXML_ATTR_FORMAT
# if ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)))
# define LIBXML_ATTR_FORMAT(fmt,args) __attribute__((__format__(__printf__,fmt,args)))
# else
# define LIBXML_ATTR_FORMAT(fmt,args)
# endif
#else
# define LIBXML_ATTR_FORMAT(fmt,args)
#endif
#ifndef XML_DEPRECATED
# ifdef IN_LIBXML
# define XML_DEPRECATED
# else
/* Available since at least GCC 3.1 */
# define XML_DEPRECATED __attribute__((deprecated))
# endif
#endif
#else /* ! __GNUC__ */
/**
* ATTRIBUTE_UNUSED:
*
* Macro used to signal to GCC unused function parameters
*/
#define ATTRIBUTE_UNUSED
/**
* LIBXML_ATTR_ALLOC_SIZE:
*
* Macro used to indicate to GCC this is an allocator function
*/
#define LIBXML_ATTR_ALLOC_SIZE(x)
/**
* LIBXML_ATTR_FORMAT:
*
* Macro used to indicate to GCC the parameter are printf like
*/
#define LIBXML_ATTR_FORMAT(fmt,args)
/**
* XML_DEPRECATED:
*
* Macro used to indicate that a function, variable, type or struct member
* is deprecated.
*/
#ifndef XML_DEPRECATED
#define XML_DEPRECATED
#endif
#endif /* __GNUC__ */
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif
/*
* Summary: internals routines and limits exported by the parser.
* Description: this module exports a number of internal parsing routines
* they are not really all intended for applications but
* can prove useful doing low level processing.
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_PARSER_INTERNALS_H__
#define __XML_PARSER_INTERNALS_H__
#include <libxml/xmlversion.h>
#include <libxml/parser.h>
#include <libxml/HTMLparser.h>
#include <libxml/chvalid.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* xmlParserMaxDepth:
*
* arbitrary depth limit for the XML documents that we allow to
* process. This is not a limitation of the parser but a safety
* boundary feature, use XML_PARSE_HUGE option to override it.
*/
XMLPUBVAR unsigned int xmlParserMaxDepth;
/**
* XML_MAX_TEXT_LENGTH:
*
* Maximum size allowed for a single text node when building a tree.
* This is not a limitation of the parser but a safety boundary feature,
* use XML_PARSE_HUGE option to override it.
* Introduced in 2.9.0
*/
#define XML_MAX_TEXT_LENGTH 10000000
/**
* XML_MAX_NAME_LENGTH:
*
* Maximum size allowed for a markup identifier.
* This is not a limitation of the parser but a safety boundary feature,
* use XML_PARSE_HUGE option to override it.
* Note that with the use of parsing dictionaries overriding the limit
* may result in more runtime memory usage in face of "unfriendly' content
* Introduced in 2.9.0
*/
#define XML_MAX_NAME_LENGTH 50000
/**
* XML_MAX_DICTIONARY_LIMIT:
*
* Maximum size allowed by the parser for a dictionary by default
* This is not a limitation of the parser but a safety boundary feature,
* use XML_PARSE_HUGE option to override it.
* Introduced in 2.9.0
*/
#define XML_MAX_DICTIONARY_LIMIT 10000000
/**
* XML_MAX_LOOKUP_LIMIT:
*
* Maximum size allowed by the parser for ahead lookup
* This is an upper boundary enforced by the parser to avoid bad
* behaviour on "unfriendly' content
* Introduced in 2.9.0
*/
#define XML_MAX_LOOKUP_LIMIT 10000000
/**
* XML_MAX_NAMELEN:
*
* Identifiers can be longer, but this will be more costly
* at runtime.
*/
#define XML_MAX_NAMELEN 100
/**
* INPUT_CHUNK:
*
* The parser tries to always have that amount of input ready.
* One of the point is providing context when reporting errors.
*/
#define INPUT_CHUNK 250
/************************************************************************
* *
* UNICODE version of the macros. *
* *
************************************************************************/
/**
* IS_BYTE_CHAR:
* @c: an byte value (int)
*
* Macro to check the following production in the XML spec:
*
* [2] Char ::= #x9 | #xA | #xD | [#x20...]
* any byte character in the accepted range
*/
#define IS_BYTE_CHAR(c) xmlIsChar_ch(c)
/**
* IS_CHAR:
* @c: an UNICODE value (int)
*
* Macro to check the following production in the XML spec:
*
* [2] Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD]
* | [#x10000-#x10FFFF]
* any Unicode character, excluding the surrogate blocks, FFFE, and FFFF.
*/
#define IS_CHAR(c) xmlIsCharQ(c)
/**
* IS_CHAR_CH:
* @c: an xmlChar (usually an unsigned char)
*
* Behaves like IS_CHAR on single-byte value
*/
#define IS_CHAR_CH(c) xmlIsChar_ch(c)
/**
* IS_BLANK:
* @c: an UNICODE value (int)
*
* Macro to check the following production in the XML spec:
*
* [3] S ::= (#x20 | #x9 | #xD | #xA)+
*/
#define IS_BLANK(c) xmlIsBlankQ(c)
/**
* IS_BLANK_CH:
* @c: an xmlChar value (normally unsigned char)
*
* Behaviour same as IS_BLANK
*/
#define IS_BLANK_CH(c) xmlIsBlank_ch(c)
/**
* IS_BASECHAR:
* @c: an UNICODE value (int)
*
* Macro to check the following production in the XML spec:
*
* [85] BaseChar ::= ... long list see REC ...
*/
#define IS_BASECHAR(c) xmlIsBaseCharQ(c)
/**
* IS_DIGIT:
* @c: an UNICODE value (int)
*
* Macro to check the following production in the XML spec:
*
* [88] Digit ::= ... long list see REC ...
*/
#define IS_DIGIT(c) xmlIsDigitQ(c)
/**
* IS_DIGIT_CH:
* @c: an xmlChar value (usually an unsigned char)
*
* Behaves like IS_DIGIT but with a single byte argument
*/
#define IS_DIGIT_CH(c) xmlIsDigit_ch(c)
/**
* IS_COMBINING:
* @c: an UNICODE value (int)
*
* Macro to check the following production in the XML spec:
*
* [87] CombiningChar ::= ... long list see REC ...
*/
#define IS_COMBINING(c) xmlIsCombiningQ(c)
/**
* IS_COMBINING_CH:
* @c: an xmlChar (usually an unsigned char)
*
* Always false (all combining chars > 0xff)
*/
#define IS_COMBINING_CH(c) 0
/**
* IS_EXTENDER:
* @c: an UNICODE value (int)
*
* Macro to check the following production in the XML spec:
*
*
* [89] Extender ::= #x00B7 | #x02D0 | #x02D1 | #x0387 | #x0640 |
* #x0E46 | #x0EC6 | #x3005 | [#x3031-#x3035] |
* [#x309D-#x309E] | [#x30FC-#x30FE]
*/
#define IS_EXTENDER(c) xmlIsExtenderQ(c)
/**
* IS_EXTENDER_CH:
* @c: an xmlChar value (usually an unsigned char)
*
* Behaves like IS_EXTENDER but with a single-byte argument
*/
#define IS_EXTENDER_CH(c) xmlIsExtender_ch(c)
/**
* IS_IDEOGRAPHIC:
* @c: an UNICODE value (int)
*
* Macro to check the following production in the XML spec:
*
*
* [86] Ideographic ::= [#x4E00-#x9FA5] | #x3007 | [#x3021-#x3029]
*/
#define IS_IDEOGRAPHIC(c) xmlIsIdeographicQ(c)
/**
* IS_LETTER:
* @c: an UNICODE value (int)
*
* Macro to check the following production in the XML spec:
*
*
* [84] Letter ::= BaseChar | Ideographic
*/
#define IS_LETTER(c) (IS_BASECHAR(c) || IS_IDEOGRAPHIC(c))
/**
* IS_LETTER_CH:
* @c: an xmlChar value (normally unsigned char)
*
* Macro behaves like IS_LETTER, but only check base chars
*
*/
#define IS_LETTER_CH(c) xmlIsBaseChar_ch(c)
/**
* IS_ASCII_LETTER:
* @c: an xmlChar value
*
* Macro to check [a-zA-Z]
*
*/
#define IS_ASCII_LETTER(c) (((0x41 <= (c)) && ((c) <= 0x5a)) || \
((0x61 <= (c)) && ((c) <= 0x7a)))
/**
* IS_ASCII_DIGIT:
* @c: an xmlChar value
*
* Macro to check [0-9]
*
*/
#define IS_ASCII_DIGIT(c) ((0x30 <= (c)) && ((c) <= 0x39))
/**
* IS_PUBIDCHAR:
* @c: an UNICODE value (int)
*
* Macro to check the following production in the XML spec:
*
*
* [13] PubidChar ::= #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%]
*/
#define IS_PUBIDCHAR(c) xmlIsPubidCharQ(c)
/**
* IS_PUBIDCHAR_CH:
* @c: an xmlChar value (normally unsigned char)
*
* Same as IS_PUBIDCHAR but for single-byte value
*/
#define IS_PUBIDCHAR_CH(c) xmlIsPubidChar_ch(c)
/**
* SKIP_EOL:
* @p: and UTF8 string pointer
*
* Skips the end of line chars.
*/
#define SKIP_EOL(p) \
if (*(p) == 0x13) { p++ ; if (*(p) == 0x10) p++; } \
if (*(p) == 0x10) { p++ ; if (*(p) == 0x13) p++; }
/**
* MOVETO_ENDTAG:
* @p: and UTF8 string pointer
*
* Skips to the next '>' char.
*/
#define MOVETO_ENDTAG(p) \
while ((*p) && (*(p) != '>')) (p)++
/**
* MOVETO_STARTTAG:
* @p: and UTF8 string pointer
*
* Skips to the next '<' char.
*/
#define MOVETO_STARTTAG(p) \
while ((*p) && (*(p) != '<')) (p)++
/**
* Global variables used for predefined strings.
*/
XMLPUBVAR const xmlChar xmlStringText[];
XMLPUBVAR const xmlChar xmlStringTextNoenc[];
XMLPUBVAR const xmlChar xmlStringComment[];
/*
* Function to finish the work of the macros where needed.
*/
XMLPUBFUN int XMLCALL xmlIsLetter (int c);
/**
* Parser context.
*/
XMLPUBFUN xmlParserCtxtPtr XMLCALL
xmlCreateFileParserCtxt (const char *filename);
XMLPUBFUN xmlParserCtxtPtr XMLCALL
xmlCreateURLParserCtxt (const char *filename,
int options);
XMLPUBFUN xmlParserCtxtPtr XMLCALL
xmlCreateMemoryParserCtxt(const char *buffer,
int size);
XMLPUBFUN xmlParserCtxtPtr XMLCALL
xmlCreateEntityParserCtxt(const xmlChar *URL,
const xmlChar *ID,
const xmlChar *base);
XMLPUBFUN int XMLCALL
xmlSwitchEncoding (xmlParserCtxtPtr ctxt,
xmlCharEncoding enc);
XMLPUBFUN int XMLCALL
xmlSwitchToEncoding (xmlParserCtxtPtr ctxt,
xmlCharEncodingHandlerPtr handler);
XML_DEPRECATED
XMLPUBFUN int XMLCALL
xmlSwitchInputEncoding (xmlParserCtxtPtr ctxt,
xmlParserInputPtr input,
xmlCharEncodingHandlerPtr handler);
#ifdef IN_LIBXML
/* internal error reporting */
XMLPUBFUN void XMLCALL
__xmlErrEncoding (xmlParserCtxtPtr ctxt,
xmlParserErrors xmlerr,
const char *msg,
const xmlChar * str1,
const xmlChar * str2) LIBXML_ATTR_FORMAT(3,0);
#endif
/**
* Input Streams.
*/
XMLPUBFUN xmlParserInputPtr XMLCALL
xmlNewStringInputStream (xmlParserCtxtPtr ctxt,
const xmlChar *buffer);
XMLPUBFUN xmlParserInputPtr XMLCALL
xmlNewEntityInputStream (xmlParserCtxtPtr ctxt,
xmlEntityPtr entity);
XMLPUBFUN int XMLCALL
xmlPushInput (xmlParserCtxtPtr ctxt,
xmlParserInputPtr input);
XMLPUBFUN xmlChar XMLCALL
xmlPopInput (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlFreeInputStream (xmlParserInputPtr input);
XMLPUBFUN xmlParserInputPtr XMLCALL
xmlNewInputFromFile (xmlParserCtxtPtr ctxt,
const char *filename);
XMLPUBFUN xmlParserInputPtr XMLCALL
xmlNewInputStream (xmlParserCtxtPtr ctxt);
/**
* Namespaces.
*/
XMLPUBFUN xmlChar * XMLCALL
xmlSplitQName (xmlParserCtxtPtr ctxt,
const xmlChar *name,
xmlChar **prefix);
/**
* Generic production rules.
*/
XMLPUBFUN const xmlChar * XMLCALL
xmlParseName (xmlParserCtxtPtr ctxt);
XMLPUBFUN xmlChar * XMLCALL
xmlParseNmtoken (xmlParserCtxtPtr ctxt);
XMLPUBFUN xmlChar * XMLCALL
xmlParseEntityValue (xmlParserCtxtPtr ctxt,
xmlChar **orig);
XMLPUBFUN xmlChar * XMLCALL
xmlParseAttValue (xmlParserCtxtPtr ctxt);
XMLPUBFUN xmlChar * XMLCALL
xmlParseSystemLiteral (xmlParserCtxtPtr ctxt);
XMLPUBFUN xmlChar * XMLCALL
xmlParsePubidLiteral (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlParseCharData (xmlParserCtxtPtr ctxt,
int cdata);
XMLPUBFUN xmlChar * XMLCALL
xmlParseExternalID (xmlParserCtxtPtr ctxt,
xmlChar **publicID,
int strict);
XMLPUBFUN void XMLCALL
xmlParseComment (xmlParserCtxtPtr ctxt);
XMLPUBFUN const xmlChar * XMLCALL
xmlParsePITarget (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlParsePI (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlParseNotationDecl (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlParseEntityDecl (xmlParserCtxtPtr ctxt);
XMLPUBFUN int XMLCALL
xmlParseDefaultDecl (xmlParserCtxtPtr ctxt,
xmlChar **value);
XMLPUBFUN xmlEnumerationPtr XMLCALL
xmlParseNotationType (xmlParserCtxtPtr ctxt);
XMLPUBFUN xmlEnumerationPtr XMLCALL
xmlParseEnumerationType (xmlParserCtxtPtr ctxt);
XMLPUBFUN int XMLCALL
xmlParseEnumeratedType (xmlParserCtxtPtr ctxt,
xmlEnumerationPtr *tree);
XMLPUBFUN int XMLCALL
xmlParseAttributeType (xmlParserCtxtPtr ctxt,
xmlEnumerationPtr *tree);
XMLPUBFUN void XMLCALL
xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt);
XMLPUBFUN xmlElementContentPtr XMLCALL
xmlParseElementMixedContentDecl
(xmlParserCtxtPtr ctxt,
int inputchk);
XMLPUBFUN xmlElementContentPtr XMLCALL
xmlParseElementChildrenContentDecl
(xmlParserCtxtPtr ctxt,
int inputchk);
XMLPUBFUN int XMLCALL
xmlParseElementContentDecl(xmlParserCtxtPtr ctxt,
const xmlChar *name,
xmlElementContentPtr *result);
XMLPUBFUN int XMLCALL
xmlParseElementDecl (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlParseMarkupDecl (xmlParserCtxtPtr ctxt);
XMLPUBFUN int XMLCALL
xmlParseCharRef (xmlParserCtxtPtr ctxt);
XMLPUBFUN xmlEntityPtr XMLCALL
xmlParseEntityRef (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlParseReference (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlParsePEReference (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlParseDocTypeDecl (xmlParserCtxtPtr ctxt);
#ifdef LIBXML_SAX1_ENABLED
XMLPUBFUN const xmlChar * XMLCALL
xmlParseAttribute (xmlParserCtxtPtr ctxt,
xmlChar **value);
XMLPUBFUN const xmlChar * XMLCALL
xmlParseStartTag (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlParseEndTag (xmlParserCtxtPtr ctxt);
#endif /* LIBXML_SAX1_ENABLED */
XMLPUBFUN void XMLCALL
xmlParseCDSect (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlParseContent (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlParseElement (xmlParserCtxtPtr ctxt);
XMLPUBFUN xmlChar * XMLCALL
xmlParseVersionNum (xmlParserCtxtPtr ctxt);
XMLPUBFUN xmlChar * XMLCALL
xmlParseVersionInfo (xmlParserCtxtPtr ctxt);
XMLPUBFUN xmlChar * XMLCALL
xmlParseEncName (xmlParserCtxtPtr ctxt);
XMLPUBFUN const xmlChar * XMLCALL
xmlParseEncodingDecl (xmlParserCtxtPtr ctxt);
XMLPUBFUN int XMLCALL
xmlParseSDDecl (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlParseXMLDecl (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlParseTextDecl (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlParseMisc (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlParseExternalSubset (xmlParserCtxtPtr ctxt,
const xmlChar *ExternalID,
const xmlChar *SystemID);
/**
* XML_SUBSTITUTE_NONE:
*
* If no entities need to be substituted.
*/
#define XML_SUBSTITUTE_NONE 0
/**
* XML_SUBSTITUTE_REF:
*
* Whether general entities need to be substituted.
*/
#define XML_SUBSTITUTE_REF 1
/**
* XML_SUBSTITUTE_PEREF:
*
* Whether parameter entities need to be substituted.
*/
#define XML_SUBSTITUTE_PEREF 2
/**
* XML_SUBSTITUTE_BOTH:
*
* Both general and parameter entities need to be substituted.
*/
#define XML_SUBSTITUTE_BOTH 3
XMLPUBFUN xmlChar * XMLCALL
xmlStringDecodeEntities (xmlParserCtxtPtr ctxt,
const xmlChar *str,
int what,
xmlChar end,
xmlChar end2,
xmlChar end3);
XMLPUBFUN xmlChar * XMLCALL
xmlStringLenDecodeEntities (xmlParserCtxtPtr ctxt,
const xmlChar *str,
int len,
int what,
xmlChar end,
xmlChar end2,
xmlChar end3);
/*
* Generated by MACROS on top of parser.c c.f. PUSH_AND_POP.
*/
XMLPUBFUN int XMLCALL nodePush (xmlParserCtxtPtr ctxt,
xmlNodePtr value);
XMLPUBFUN xmlNodePtr XMLCALL nodePop (xmlParserCtxtPtr ctxt);
XMLPUBFUN int XMLCALL inputPush (xmlParserCtxtPtr ctxt,
xmlParserInputPtr value);
XMLPUBFUN xmlParserInputPtr XMLCALL inputPop (xmlParserCtxtPtr ctxt);
XMLPUBFUN const xmlChar * XMLCALL namePop (xmlParserCtxtPtr ctxt);
XMLPUBFUN int XMLCALL namePush (xmlParserCtxtPtr ctxt,
const xmlChar *value);
/*
* other commodities shared between parser.c and parserInternals.
*/
XMLPUBFUN int XMLCALL xmlSkipBlankChars (xmlParserCtxtPtr ctxt);
XMLPUBFUN int XMLCALL xmlStringCurrentChar (xmlParserCtxtPtr ctxt,
const xmlChar *cur,
int *len);
XMLPUBFUN void XMLCALL xmlParserHandlePEReference(xmlParserCtxtPtr ctxt);
XMLPUBFUN int XMLCALL xmlCheckLanguageID (const xmlChar *lang);
/*
* Really core function shared with HTML parser.
*/
XMLPUBFUN int XMLCALL xmlCurrentChar (xmlParserCtxtPtr ctxt,
int *len);
XMLPUBFUN int XMLCALL xmlCopyCharMultiByte (xmlChar *out,
int val);
XMLPUBFUN int XMLCALL xmlCopyChar (int len,
xmlChar *out,
int val);
XMLPUBFUN void XMLCALL xmlNextChar (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL xmlParserInputShrink (xmlParserInputPtr in);
#ifdef LIBXML_HTML_ENABLED
/*
* Actually comes from the HTML parser but launched from the init stuff.
*/
XML_DEPRECATED
XMLPUBFUN void XMLCALL htmlInitAutoClose (void);
XMLPUBFUN htmlParserCtxtPtr XMLCALL htmlCreateFileParserCtxt(const char *filename,
const char *encoding);
#endif
/*
* Specific function to keep track of entities references
* and used by the XSLT debugger.
*/
#ifdef LIBXML_LEGACY_ENABLED
/**
* xmlEntityReferenceFunc:
* @ent: the entity
* @firstNode: the fist node in the chunk
* @lastNode: the last nod in the chunk
*
* Callback function used when one needs to be able to track back the
* provenance of a chunk of nodes inherited from an entity replacement.
*/
typedef void (*xmlEntityReferenceFunc) (xmlEntityPtr ent,
xmlNodePtr firstNode,
xmlNodePtr lastNode);
XML_DEPRECATED
XMLPUBFUN void XMLCALL xmlSetEntityReferenceFunc (xmlEntityReferenceFunc func);
XML_DEPRECATED
XMLPUBFUN xmlChar * XMLCALL
xmlParseQuotedString (xmlParserCtxtPtr ctxt);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlParseNamespace (xmlParserCtxtPtr ctxt);
XML_DEPRECATED
XMLPUBFUN xmlChar * XMLCALL
xmlNamespaceParseNSDef (xmlParserCtxtPtr ctxt);
XML_DEPRECATED
XMLPUBFUN xmlChar * XMLCALL
xmlScanName (xmlParserCtxtPtr ctxt);
XML_DEPRECATED
XMLPUBFUN xmlChar * XMLCALL
xmlNamespaceParseNCName (xmlParserCtxtPtr ctxt);
XML_DEPRECATED
XMLPUBFUN void XMLCALL xmlParserHandleReference(xmlParserCtxtPtr ctxt);
XML_DEPRECATED
XMLPUBFUN xmlChar * XMLCALL
xmlNamespaceParseQName (xmlParserCtxtPtr ctxt,
xmlChar **prefix);
/**
* Entities
*/
XML_DEPRECATED
XMLPUBFUN xmlChar * XMLCALL
xmlDecodeEntities (xmlParserCtxtPtr ctxt,
int len,
int what,
xmlChar end,
xmlChar end2,
xmlChar end3);
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlHandleEntity (xmlParserCtxtPtr ctxt,
xmlEntityPtr entity);
#endif /* LIBXML_LEGACY_ENABLED */
#ifdef IN_LIBXML
/*
* internal only
*/
XMLPUBFUN void XMLCALL
xmlErrMemory (xmlParserCtxtPtr ctxt,
const char *extra);
#endif
#ifdef __cplusplus
}
#endif
#endif /* __XML_PARSER_INTERNALS_H__ */
/**
* Summary: library of generic URI related routines
* Description: library of generic URI related routines
* Implements RFC 2396
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_URI_H__
#define __XML_URI_H__
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* xmlURI:
*
* A parsed URI reference. This is a struct containing the various fields
* as described in RFC 2396 but separated for further processing.
*
* Note: query is a deprecated field which is incorrectly unescaped.
* query_raw takes precedence over query if the former is set.
* See: http://mail.gnome.org/archives/xml/2007-April/thread.html#00127
*/
typedef struct _xmlURI xmlURI;
typedef xmlURI *xmlURIPtr;
struct _xmlURI {
char *scheme; /* the URI scheme */
char *opaque; /* opaque part */
char *authority; /* the authority part */
char *server; /* the server part */
char *user; /* the user part */
int port; /* the port number */
char *path; /* the path string */
char *query; /* the query string (deprecated - use with caution) */
char *fragment; /* the fragment identifier */
int cleanup; /* parsing potentially unclean URI */
char *query_raw; /* the query string (as it appears in the URI) */
};
/*
* This function is in tree.h:
* xmlChar * xmlNodeGetBase (xmlDocPtr doc,
* xmlNodePtr cur);
*/
XMLPUBFUN xmlURIPtr XMLCALL
xmlCreateURI (void);
XMLPUBFUN xmlChar * XMLCALL
xmlBuildURI (const xmlChar *URI,
const xmlChar *base);
XMLPUBFUN xmlChar * XMLCALL
xmlBuildRelativeURI (const xmlChar *URI,
const xmlChar *base);
XMLPUBFUN xmlURIPtr XMLCALL
xmlParseURI (const char *str);
XMLPUBFUN xmlURIPtr XMLCALL
xmlParseURIRaw (const char *str,
int raw);
XMLPUBFUN int XMLCALL
xmlParseURIReference (xmlURIPtr uri,
const char *str);
XMLPUBFUN xmlChar * XMLCALL
xmlSaveUri (xmlURIPtr uri);
XMLPUBFUN void XMLCALL
xmlPrintURI (FILE *stream,
xmlURIPtr uri);
XMLPUBFUN xmlChar * XMLCALL
xmlURIEscapeStr (const xmlChar *str,
const xmlChar *list);
XMLPUBFUN char * XMLCALL
xmlURIUnescapeString (const char *str,
int len,
char *target);
XMLPUBFUN int XMLCALL
xmlNormalizeURIPath (char *path);
XMLPUBFUN xmlChar * XMLCALL
xmlURIEscape (const xmlChar *str);
XMLPUBFUN void XMLCALL
xmlFreeURI (xmlURIPtr uri);
XMLPUBFUN xmlChar* XMLCALL
xmlCanonicPath (const xmlChar *path);
XMLPUBFUN xmlChar* XMLCALL
xmlPathToURI (const xmlChar *path);
#ifdef __cplusplus
}
#endif
#endif /* __XML_URI_H__ */
/*
* Summary: XML Schematron implementation
* Description: interface to the XML Schematron validity checking.
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_SCHEMATRON_H__
#define __XML_SCHEMATRON_H__
#include <libxml/xmlversion.h>
#ifdef LIBXML_SCHEMATRON_ENABLED
#include <libxml/tree.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef enum {
XML_SCHEMATRON_OUT_QUIET = 1 << 0, /* quiet no report */
XML_SCHEMATRON_OUT_TEXT = 1 << 1, /* build a textual report */
XML_SCHEMATRON_OUT_XML = 1 << 2, /* output SVRL */
XML_SCHEMATRON_OUT_ERROR = 1 << 3, /* output via xmlStructuredErrorFunc */
XML_SCHEMATRON_OUT_FILE = 1 << 8, /* output to a file descriptor */
XML_SCHEMATRON_OUT_BUFFER = 1 << 9, /* output to a buffer */
XML_SCHEMATRON_OUT_IO = 1 << 10 /* output to I/O mechanism */
} xmlSchematronValidOptions;
/**
* The schemas related types are kept internal
*/
typedef struct _xmlSchematron xmlSchematron;
typedef xmlSchematron *xmlSchematronPtr;
/**
* xmlSchematronValidityErrorFunc:
* @ctx: the validation context
* @msg: the message
* @...: extra arguments
*
* Signature of an error callback from a Schematron validation
*/
typedef void (*xmlSchematronValidityErrorFunc) (void *ctx, const char *msg, ...);
/**
* xmlSchematronValidityWarningFunc:
* @ctx: the validation context
* @msg: the message
* @...: extra arguments
*
* Signature of a warning callback from a Schematron validation
*/
typedef void (*xmlSchematronValidityWarningFunc) (void *ctx, const char *msg, ...);
/**
* A schemas validation context
*/
typedef struct _xmlSchematronParserCtxt xmlSchematronParserCtxt;
typedef xmlSchematronParserCtxt *xmlSchematronParserCtxtPtr;
typedef struct _xmlSchematronValidCtxt xmlSchematronValidCtxt;
typedef xmlSchematronValidCtxt *xmlSchematronValidCtxtPtr;
/*
* Interfaces for parsing.
*/
XMLPUBFUN xmlSchematronParserCtxtPtr XMLCALL
xmlSchematronNewParserCtxt (const char *URL);
XMLPUBFUN xmlSchematronParserCtxtPtr XMLCALL
xmlSchematronNewMemParserCtxt(const char *buffer,
int size);
XMLPUBFUN xmlSchematronParserCtxtPtr XMLCALL
xmlSchematronNewDocParserCtxt(xmlDocPtr doc);
XMLPUBFUN void XMLCALL
xmlSchematronFreeParserCtxt (xmlSchematronParserCtxtPtr ctxt);
/*****
XMLPUBFUN void XMLCALL
xmlSchematronSetParserErrors(xmlSchematronParserCtxtPtr ctxt,
xmlSchematronValidityErrorFunc err,
xmlSchematronValidityWarningFunc warn,
void *ctx);
XMLPUBFUN int XMLCALL
xmlSchematronGetParserErrors(xmlSchematronParserCtxtPtr ctxt,
xmlSchematronValidityErrorFunc * err,
xmlSchematronValidityWarningFunc * warn,
void **ctx);
XMLPUBFUN int XMLCALL
xmlSchematronIsValid (xmlSchematronValidCtxtPtr ctxt);
*****/
XMLPUBFUN xmlSchematronPtr XMLCALL
xmlSchematronParse (xmlSchematronParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlSchematronFree (xmlSchematronPtr schema);
/*
* Interfaces for validating
*/
XMLPUBFUN void XMLCALL
xmlSchematronSetValidStructuredErrors(
xmlSchematronValidCtxtPtr ctxt,
xmlStructuredErrorFunc serror,
void *ctx);
/******
XMLPUBFUN void XMLCALL
xmlSchematronSetValidErrors (xmlSchematronValidCtxtPtr ctxt,
xmlSchematronValidityErrorFunc err,
xmlSchematronValidityWarningFunc warn,
void *ctx);
XMLPUBFUN int XMLCALL
xmlSchematronGetValidErrors (xmlSchematronValidCtxtPtr ctxt,
xmlSchematronValidityErrorFunc *err,
xmlSchematronValidityWarningFunc *warn,
void **ctx);
XMLPUBFUN int XMLCALL
xmlSchematronSetValidOptions(xmlSchematronValidCtxtPtr ctxt,
int options);
XMLPUBFUN int XMLCALL
xmlSchematronValidCtxtGetOptions(xmlSchematronValidCtxtPtr ctxt);
XMLPUBFUN int XMLCALL
xmlSchematronValidateOneElement (xmlSchematronValidCtxtPtr ctxt,
xmlNodePtr elem);
*******/
XMLPUBFUN xmlSchematronValidCtxtPtr XMLCALL
xmlSchematronNewValidCtxt (xmlSchematronPtr schema,
int options);
XMLPUBFUN void XMLCALL
xmlSchematronFreeValidCtxt (xmlSchematronValidCtxtPtr ctxt);
XMLPUBFUN int XMLCALL
xmlSchematronValidateDoc (xmlSchematronValidCtxtPtr ctxt,
xmlDocPtr instance);
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_SCHEMATRON_ENABLED */
#endif /* __XML_SCHEMATRON_H__ */
/*
* Summary: Unicode character range checking
* Description: this module exports interfaces for the character
* range validation APIs
*
* This file is automatically generated from the cvs source
* definition files using the genChRanges.py Python script
*
* Generation date: Mon Mar 27 11:09:48 2006
* Sources: chvalid.def
* Author: William Brack <wbrack@mmm.com.hk>
*/
#ifndef __XML_CHVALID_H__
#define __XML_CHVALID_H__
#include <libxml/xmlversion.h>
#include <libxml/xmlstring.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* Define our typedefs and structures
*
*/
typedef struct _xmlChSRange xmlChSRange;
typedef xmlChSRange *xmlChSRangePtr;
struct _xmlChSRange {
unsigned short low;
unsigned short high;
};
typedef struct _xmlChLRange xmlChLRange;
typedef xmlChLRange *xmlChLRangePtr;
struct _xmlChLRange {
unsigned int low;
unsigned int high;
};
typedef struct _xmlChRangeGroup xmlChRangeGroup;
typedef xmlChRangeGroup *xmlChRangeGroupPtr;
struct _xmlChRangeGroup {
int nbShortRange;
int nbLongRange;
const xmlChSRange *shortRange; /* points to an array of ranges */
const xmlChLRange *longRange;
};
/**
* Range checking routine
*/
XMLPUBFUN int XMLCALL
xmlCharInRange(unsigned int val, const xmlChRangeGroup *group);
/**
* xmlIsBaseChar_ch:
* @c: char to validate
*
* Automatically generated by genChRanges.py
*/
#define xmlIsBaseChar_ch(c) (((0x41 <= (c)) && ((c) <= 0x5a)) || \
((0x61 <= (c)) && ((c) <= 0x7a)) || \
((0xc0 <= (c)) && ((c) <= 0xd6)) || \
((0xd8 <= (c)) && ((c) <= 0xf6)) || \
(0xf8 <= (c)))
/**
* xmlIsBaseCharQ:
* @c: char to validate
*
* Automatically generated by genChRanges.py
*/
#define xmlIsBaseCharQ(c) (((c) < 0x100) ? \
xmlIsBaseChar_ch((c)) : \
xmlCharInRange((c), &xmlIsBaseCharGroup))
XMLPUBVAR const xmlChRangeGroup xmlIsBaseCharGroup;
/**
* xmlIsBlank_ch:
* @c: char to validate
*
* Automatically generated by genChRanges.py
*/
#define xmlIsBlank_ch(c) (((c) == 0x20) || \
((0x9 <= (c)) && ((c) <= 0xa)) || \
((c) == 0xd))
/**
* xmlIsBlankQ:
* @c: char to validate
*
* Automatically generated by genChRanges.py
*/
#define xmlIsBlankQ(c) (((c) < 0x100) ? \
xmlIsBlank_ch((c)) : 0)
/**
* xmlIsChar_ch:
* @c: char to validate
*
* Automatically generated by genChRanges.py
*/
#define xmlIsChar_ch(c) (((0x9 <= (c)) && ((c) <= 0xa)) || \
((c) == 0xd) || \
(0x20 <= (c)))
/**
* xmlIsCharQ:
* @c: char to validate
*
* Automatically generated by genChRanges.py
*/
#define xmlIsCharQ(c) (((c) < 0x100) ? \
xmlIsChar_ch((c)) :\
(((0x100 <= (c)) && ((c) <= 0xd7ff)) || \
((0xe000 <= (c)) && ((c) <= 0xfffd)) || \
((0x10000 <= (c)) && ((c) <= 0x10ffff))))
XMLPUBVAR const xmlChRangeGroup xmlIsCharGroup;
/**
* xmlIsCombiningQ:
* @c: char to validate
*
* Automatically generated by genChRanges.py
*/
#define xmlIsCombiningQ(c) (((c) < 0x100) ? \
0 : \
xmlCharInRange((c), &xmlIsCombiningGroup))
XMLPUBVAR const xmlChRangeGroup xmlIsCombiningGroup;
/**
* xmlIsDigit_ch:
* @c: char to validate
*
* Automatically generated by genChRanges.py
*/
#define xmlIsDigit_ch(c) (((0x30 <= (c)) && ((c) <= 0x39)))
/**
* xmlIsDigitQ:
* @c: char to validate
*
* Automatically generated by genChRanges.py
*/
#define xmlIsDigitQ(c) (((c) < 0x100) ? \
xmlIsDigit_ch((c)) : \
xmlCharInRange((c), &xmlIsDigitGroup))
XMLPUBVAR const xmlChRangeGroup xmlIsDigitGroup;
/**
* xmlIsExtender_ch:
* @c: char to validate
*
* Automatically generated by genChRanges.py
*/
#define xmlIsExtender_ch(c) (((c) == 0xb7))
/**
* xmlIsExtenderQ:
* @c: char to validate
*
* Automatically generated by genChRanges.py
*/
#define xmlIsExtenderQ(c) (((c) < 0x100) ? \
xmlIsExtender_ch((c)) : \
xmlCharInRange((c), &xmlIsExtenderGroup))
XMLPUBVAR const xmlChRangeGroup xmlIsExtenderGroup;
/**
* xmlIsIdeographicQ:
* @c: char to validate
*
* Automatically generated by genChRanges.py
*/
#define xmlIsIdeographicQ(c) (((c) < 0x100) ? \
0 :\
(((0x4e00 <= (c)) && ((c) <= 0x9fa5)) || \
((c) == 0x3007) || \
((0x3021 <= (c)) && ((c) <= 0x3029))))
XMLPUBVAR const xmlChRangeGroup xmlIsIdeographicGroup;
XMLPUBVAR const unsigned char xmlIsPubidChar_tab[256];
/**
* xmlIsPubidChar_ch:
* @c: char to validate
*
* Automatically generated by genChRanges.py
*/
#define xmlIsPubidChar_ch(c) (xmlIsPubidChar_tab[(c)])
/**
* xmlIsPubidCharQ:
* @c: char to validate
*
* Automatically generated by genChRanges.py
*/
#define xmlIsPubidCharQ(c) (((c) < 0x100) ? \
xmlIsPubidChar_ch((c)) : 0)
XMLPUBFUN int XMLCALL
xmlIsBaseChar(unsigned int ch);
XMLPUBFUN int XMLCALL
xmlIsBlank(unsigned int ch);
XMLPUBFUN int XMLCALL
xmlIsChar(unsigned int ch);
XMLPUBFUN int XMLCALL
xmlIsCombining(unsigned int ch);
XMLPUBFUN int XMLCALL
xmlIsDigit(unsigned int ch);
XMLPUBFUN int XMLCALL
xmlIsExtender(unsigned int ch);
XMLPUBFUN int XMLCALL
xmlIsIdeographic(unsigned int ch);
XMLPUBFUN int XMLCALL
xmlIsPubidChar(unsigned int ch);
#ifdef __cplusplus
}
#endif
#endif /* __XML_CHVALID_H__ */
/*
* Summary: implementation of XInclude
* Description: API to handle XInclude processing,
* implements the
* World Wide Web Consortium Last Call Working Draft 10 November 2003
* http://www.w3.org/TR/2003/WD-xinclude-20031110
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_XINCLUDE_H__
#define __XML_XINCLUDE_H__
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#ifdef LIBXML_XINCLUDE_ENABLED
#ifdef __cplusplus
extern "C" {
#endif
/**
* XINCLUDE_NS:
*
* Macro defining the Xinclude namespace: http://www.w3.org/2003/XInclude
*/
#define XINCLUDE_NS (const xmlChar *) "http://www.w3.org/2003/XInclude"
/**
* XINCLUDE_OLD_NS:
*
* Macro defining the draft Xinclude namespace: http://www.w3.org/2001/XInclude
*/
#define XINCLUDE_OLD_NS (const xmlChar *) "http://www.w3.org/2001/XInclude"
/**
* XINCLUDE_NODE:
*
* Macro defining "include"
*/
#define XINCLUDE_NODE (const xmlChar *) "include"
/**
* XINCLUDE_FALLBACK:
*
* Macro defining "fallback"
*/
#define XINCLUDE_FALLBACK (const xmlChar *) "fallback"
/**
* XINCLUDE_HREF:
*
* Macro defining "href"
*/
#define XINCLUDE_HREF (const xmlChar *) "href"
/**
* XINCLUDE_PARSE:
*
* Macro defining "parse"
*/
#define XINCLUDE_PARSE (const xmlChar *) "parse"
/**
* XINCLUDE_PARSE_XML:
*
* Macro defining "xml"
*/
#define XINCLUDE_PARSE_XML (const xmlChar *) "xml"
/**
* XINCLUDE_PARSE_TEXT:
*
* Macro defining "text"
*/
#define XINCLUDE_PARSE_TEXT (const xmlChar *) "text"
/**
* XINCLUDE_PARSE_ENCODING:
*
* Macro defining "encoding"
*/
#define XINCLUDE_PARSE_ENCODING (const xmlChar *) "encoding"
/**
* XINCLUDE_PARSE_XPOINTER:
*
* Macro defining "xpointer"
*/
#define XINCLUDE_PARSE_XPOINTER (const xmlChar *) "xpointer"
typedef struct _xmlXIncludeCtxt xmlXIncludeCtxt;
typedef xmlXIncludeCtxt *xmlXIncludeCtxtPtr;
/*
* standalone processing
*/
XMLPUBFUN int XMLCALL
xmlXIncludeProcess (xmlDocPtr doc);
XMLPUBFUN int XMLCALL
xmlXIncludeProcessFlags (xmlDocPtr doc,
int flags);
XMLPUBFUN int XMLCALL
xmlXIncludeProcessFlagsData(xmlDocPtr doc,
int flags,
void *data);
XMLPUBFUN int XMLCALL
xmlXIncludeProcessTreeFlagsData(xmlNodePtr tree,
int flags,
void *data);
XMLPUBFUN int XMLCALL
xmlXIncludeProcessTree (xmlNodePtr tree);
XMLPUBFUN int XMLCALL
xmlXIncludeProcessTreeFlags(xmlNodePtr tree,
int flags);
/*
* contextual processing
*/
XMLPUBFUN xmlXIncludeCtxtPtr XMLCALL
xmlXIncludeNewContext (xmlDocPtr doc);
XMLPUBFUN int XMLCALL
xmlXIncludeSetFlags (xmlXIncludeCtxtPtr ctxt,
int flags);
XMLPUBFUN void XMLCALL
xmlXIncludeFreeContext (xmlXIncludeCtxtPtr ctxt);
XMLPUBFUN int XMLCALL
xmlXIncludeProcessNode (xmlXIncludeCtxtPtr ctxt,
xmlNodePtr tree);
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_XINCLUDE_ENABLED */
#endif /* __XML_XINCLUDE_H__ */
/*
* Summary: the XMLReader implementation
* Description: API of the XML streaming API based on C# interfaces.
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_XMLREADER_H__
#define __XML_XMLREADER_H__
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#include <libxml/xmlIO.h>
#ifdef LIBXML_SCHEMAS_ENABLED
#include <libxml/relaxng.h>
#include <libxml/xmlschemas.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif
/**
* xmlParserSeverities:
*
* How severe an error callback is when the per-reader error callback API
* is used.
*/
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;
#ifdef LIBXML_READER_ENABLED
/**
* xmlTextReaderMode:
*
* Internal state values for the reader.
*/
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;
/**
* xmlParserProperties:
*
* Some common options to use with xmlTextReaderSetParserProp, but it
* is better to use xmlParserOption and the xmlReaderNewxxx and
* xmlReaderForxxx APIs now.
*/
typedef enum {
XML_PARSER_LOADDTD = 1,
XML_PARSER_DEFAULTATTRS = 2,
XML_PARSER_VALIDATE = 3,
XML_PARSER_SUBST_ENTITIES = 4
} xmlParserProperties;
/**
* xmlReaderTypes:
*
* Predefined constants for the different types of nodes.
*/
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;
/**
* xmlTextReader:
*
* Structure for an xmlReader context.
*/
typedef struct _xmlTextReader xmlTextReader;
/**
* xmlTextReaderPtr:
*
* Pointer to an xmlReader context.
*/
typedef xmlTextReader *xmlTextReaderPtr;
/*
* Constructors & Destructor
*/
XMLPUBFUN xmlTextReaderPtr XMLCALL
xmlNewTextReader (xmlParserInputBufferPtr input,
const char *URI);
XMLPUBFUN xmlTextReaderPtr XMLCALL
xmlNewTextReaderFilename(const char *URI);
XMLPUBFUN void XMLCALL
xmlFreeTextReader (xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL
xmlTextReaderSetup(xmlTextReaderPtr reader,
xmlParserInputBufferPtr input, const char *URL,
const char *encoding, int options);
/*
* Iterators
*/
XMLPUBFUN int XMLCALL
xmlTextReaderRead (xmlTextReaderPtr reader);
#ifdef LIBXML_WRITER_ENABLED
XMLPUBFUN xmlChar * XMLCALL
xmlTextReaderReadInnerXml(xmlTextReaderPtr reader);
XMLPUBFUN xmlChar * XMLCALL
xmlTextReaderReadOuterXml(xmlTextReaderPtr reader);
#endif
XMLPUBFUN xmlChar * XMLCALL
xmlTextReaderReadString (xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL
xmlTextReaderReadAttributeValue(xmlTextReaderPtr reader);
/*
* Attributes of the node
*/
XMLPUBFUN int XMLCALL
xmlTextReaderAttributeCount(xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL
xmlTextReaderDepth (xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL
xmlTextReaderHasAttributes(xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL
xmlTextReaderHasValue(xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL
xmlTextReaderIsDefault (xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL
xmlTextReaderIsEmptyElement(xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL
xmlTextReaderNodeType (xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL
xmlTextReaderQuoteChar (xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL
xmlTextReaderReadState (xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL
xmlTextReaderIsNamespaceDecl(xmlTextReaderPtr reader);
XMLPUBFUN const xmlChar * XMLCALL
xmlTextReaderConstBaseUri (xmlTextReaderPtr reader);
XMLPUBFUN const xmlChar * XMLCALL
xmlTextReaderConstLocalName (xmlTextReaderPtr reader);
XMLPUBFUN const xmlChar * XMLCALL
xmlTextReaderConstName (xmlTextReaderPtr reader);
XMLPUBFUN const xmlChar * XMLCALL
xmlTextReaderConstNamespaceUri(xmlTextReaderPtr reader);
XMLPUBFUN const xmlChar * XMLCALL
xmlTextReaderConstPrefix (xmlTextReaderPtr reader);
XMLPUBFUN const xmlChar * XMLCALL
xmlTextReaderConstXmlLang (xmlTextReaderPtr reader);
XMLPUBFUN const xmlChar * XMLCALL
xmlTextReaderConstString (xmlTextReaderPtr reader,
const xmlChar *str);
XMLPUBFUN const xmlChar * XMLCALL
xmlTextReaderConstValue (xmlTextReaderPtr reader);
/*
* use the Const version of the routine for
* better performance and simpler code
*/
XMLPUBFUN xmlChar * XMLCALL
xmlTextReaderBaseUri (xmlTextReaderPtr reader);
XMLPUBFUN xmlChar * XMLCALL
xmlTextReaderLocalName (xmlTextReaderPtr reader);
XMLPUBFUN xmlChar * XMLCALL
xmlTextReaderName (xmlTextReaderPtr reader);
XMLPUBFUN xmlChar * XMLCALL
xmlTextReaderNamespaceUri(xmlTextReaderPtr reader);
XMLPUBFUN xmlChar * XMLCALL
xmlTextReaderPrefix (xmlTextReaderPtr reader);
XMLPUBFUN xmlChar * XMLCALL
xmlTextReaderXmlLang (xmlTextReaderPtr reader);
XMLPUBFUN xmlChar * XMLCALL
xmlTextReaderValue (xmlTextReaderPtr reader);
/*
* Methods of the XmlTextReader
*/
XMLPUBFUN int XMLCALL
xmlTextReaderClose (xmlTextReaderPtr reader);
XMLPUBFUN xmlChar * XMLCALL
xmlTextReaderGetAttributeNo (xmlTextReaderPtr reader,
int no);
XMLPUBFUN xmlChar * XMLCALL
xmlTextReaderGetAttribute (xmlTextReaderPtr reader,
const xmlChar *name);
XMLPUBFUN xmlChar * XMLCALL
xmlTextReaderGetAttributeNs (xmlTextReaderPtr reader,
const xmlChar *localName,
const xmlChar *namespaceURI);
XMLPUBFUN xmlParserInputBufferPtr XMLCALL
xmlTextReaderGetRemainder (xmlTextReaderPtr reader);
XMLPUBFUN xmlChar * XMLCALL
xmlTextReaderLookupNamespace(xmlTextReaderPtr reader,
const xmlChar *prefix);
XMLPUBFUN int XMLCALL
xmlTextReaderMoveToAttributeNo(xmlTextReaderPtr reader,
int no);
XMLPUBFUN int XMLCALL
xmlTextReaderMoveToAttribute(xmlTextReaderPtr reader,
const xmlChar *name);
XMLPUBFUN int XMLCALL
xmlTextReaderMoveToAttributeNs(xmlTextReaderPtr reader,
const xmlChar *localName,
const xmlChar *namespaceURI);
XMLPUBFUN int XMLCALL
xmlTextReaderMoveToFirstAttribute(xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL
xmlTextReaderMoveToNextAttribute(xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL
xmlTextReaderMoveToElement (xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL
xmlTextReaderNormalization (xmlTextReaderPtr reader);
XMLPUBFUN const xmlChar * XMLCALL
xmlTextReaderConstEncoding (xmlTextReaderPtr reader);
/*
* Extensions
*/
XMLPUBFUN int XMLCALL
xmlTextReaderSetParserProp (xmlTextReaderPtr reader,
int prop,
int value);
XMLPUBFUN int XMLCALL
xmlTextReaderGetParserProp (xmlTextReaderPtr reader,
int prop);
XMLPUBFUN xmlNodePtr XMLCALL
xmlTextReaderCurrentNode (xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL
xmlTextReaderGetParserLineNumber(xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL
xmlTextReaderGetParserColumnNumber(xmlTextReaderPtr reader);
XMLPUBFUN xmlNodePtr XMLCALL
xmlTextReaderPreserve (xmlTextReaderPtr reader);
#ifdef LIBXML_PATTERN_ENABLED
XMLPUBFUN int XMLCALL
xmlTextReaderPreservePattern(xmlTextReaderPtr reader,
const xmlChar *pattern,
const xmlChar **namespaces);
#endif /* LIBXML_PATTERN_ENABLED */
XMLPUBFUN xmlDocPtr XMLCALL
xmlTextReaderCurrentDoc (xmlTextReaderPtr reader);
XMLPUBFUN xmlNodePtr XMLCALL
xmlTextReaderExpand (xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL
xmlTextReaderNext (xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL
xmlTextReaderNextSibling (xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL
xmlTextReaderIsValid (xmlTextReaderPtr reader);
#ifdef LIBXML_SCHEMAS_ENABLED
XMLPUBFUN int XMLCALL
xmlTextReaderRelaxNGValidate(xmlTextReaderPtr reader,
const char *rng);
XMLPUBFUN int XMLCALL
xmlTextReaderRelaxNGValidateCtxt(xmlTextReaderPtr reader,
xmlRelaxNGValidCtxtPtr ctxt,
int options);
XMLPUBFUN int XMLCALL
xmlTextReaderRelaxNGSetSchema(xmlTextReaderPtr reader,
xmlRelaxNGPtr schema);
XMLPUBFUN int XMLCALL
xmlTextReaderSchemaValidate (xmlTextReaderPtr reader,
const char *xsd);
XMLPUBFUN int XMLCALL
xmlTextReaderSchemaValidateCtxt(xmlTextReaderPtr reader,
xmlSchemaValidCtxtPtr ctxt,
int options);
XMLPUBFUN int XMLCALL
xmlTextReaderSetSchema (xmlTextReaderPtr reader,
xmlSchemaPtr schema);
#endif
XMLPUBFUN const xmlChar * XMLCALL
xmlTextReaderConstXmlVersion(xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL
xmlTextReaderStandalone (xmlTextReaderPtr reader);
/*
* Index lookup
*/
XMLPUBFUN long XMLCALL
xmlTextReaderByteConsumed (xmlTextReaderPtr reader);
/*
* New more complete APIs for simpler creation and reuse of readers
*/
XMLPUBFUN xmlTextReaderPtr XMLCALL
xmlReaderWalker (xmlDocPtr doc);
XMLPUBFUN xmlTextReaderPtr XMLCALL
xmlReaderForDoc (const xmlChar * cur,
const char *URL,
const char *encoding,
int options);
XMLPUBFUN xmlTextReaderPtr XMLCALL
xmlReaderForFile (const char *filename,
const char *encoding,
int options);
XMLPUBFUN xmlTextReaderPtr XMLCALL
xmlReaderForMemory (const char *buffer,
int size,
const char *URL,
const char *encoding,
int options);
XMLPUBFUN xmlTextReaderPtr XMLCALL
xmlReaderForFd (int fd,
const char *URL,
const char *encoding,
int options);
XMLPUBFUN xmlTextReaderPtr XMLCALL
xmlReaderForIO (xmlInputReadCallback ioread,
xmlInputCloseCallback ioclose,
void *ioctx,
const char *URL,
const char *encoding,
int options);
XMLPUBFUN int XMLCALL
xmlReaderNewWalker (xmlTextReaderPtr reader,
xmlDocPtr doc);
XMLPUBFUN int XMLCALL
xmlReaderNewDoc (xmlTextReaderPtr reader,
const xmlChar * cur,
const char *URL,
const char *encoding,
int options);
XMLPUBFUN int XMLCALL
xmlReaderNewFile (xmlTextReaderPtr reader,
const char *filename,
const char *encoding,
int options);
XMLPUBFUN int XMLCALL
xmlReaderNewMemory (xmlTextReaderPtr reader,
const char *buffer,
int size,
const char *URL,
const char *encoding,
int options);
XMLPUBFUN int XMLCALL
xmlReaderNewFd (xmlTextReaderPtr reader,
int fd,
const char *URL,
const char *encoding,
int options);
XMLPUBFUN int XMLCALL
xmlReaderNewIO (xmlTextReaderPtr reader,
xmlInputReadCallback ioread,
xmlInputCloseCallback ioclose,
void *ioctx,
const char *URL,
const char *encoding,
int options);
/*
* Error handling extensions
*/
typedef void * xmlTextReaderLocatorPtr;
/**
* xmlTextReaderErrorFunc:
* @arg: the user argument
* @msg: the message
* @severity: the severity of the error
* @locator: a locator indicating where the error occurred
*
* Signature of an error callback from a reader parser
*/
typedef void (XMLCALL *xmlTextReaderErrorFunc)(void *arg,
const char *msg,
xmlParserSeverities severity,
xmlTextReaderLocatorPtr locator);
XMLPUBFUN int XMLCALL
xmlTextReaderLocatorLineNumber(xmlTextReaderLocatorPtr locator);
XMLPUBFUN xmlChar * XMLCALL
xmlTextReaderLocatorBaseURI (xmlTextReaderLocatorPtr locator);
XMLPUBFUN void XMLCALL
xmlTextReaderSetErrorHandler(xmlTextReaderPtr reader,
xmlTextReaderErrorFunc f,
void *arg);
XMLPUBFUN void XMLCALL
xmlTextReaderSetStructuredErrorHandler(xmlTextReaderPtr reader,
xmlStructuredErrorFunc f,
void *arg);
XMLPUBFUN void XMLCALL
xmlTextReaderGetErrorHandler(xmlTextReaderPtr reader,
xmlTextReaderErrorFunc *f,
void **arg);
#endif /* LIBXML_READER_ENABLED */
#ifdef __cplusplus
}
#endif
#endif /* __XML_XMLREADER_H__ */
/*
* Summary: interface for all global variables of the library
* Description: all the global variables and thread handling for
* those variables is handled by this module.
*
* The bottom of this file is automatically generated by build_glob.py
* based on the description file global.data
*
* Copy: See Copyright for the status of this software.
*
* Author: Gary Pennington <Gary.Pennington@uk.sun.com>, Daniel Veillard
*/
#ifndef __XML_GLOBALS_H
#define __XML_GLOBALS_H
#include <libxml/xmlversion.h>
#include <libxml/parser.h>
#include <libxml/xmlerror.h>
#include <libxml/SAX2.h>
#include <libxml/xmlmemory.h>
#ifdef __cplusplus
extern "C" {
#endif
XML_DEPRECATED
XMLPUBFUN void XMLCALL xmlInitGlobals(void);
XML_DEPRECATED
XMLPUBFUN void XMLCALL xmlCleanupGlobals(void);
/**
* xmlParserInputBufferCreateFilenameFunc:
* @URI: the URI to read from
* @enc: the requested source encoding
*
* Signature for the function doing the lookup for a suitable input method
* corresponding to an URI.
*
* Returns the new xmlParserInputBufferPtr in case of success or NULL if no
* method was found.
*/
typedef xmlParserInputBufferPtr (*xmlParserInputBufferCreateFilenameFunc) (const char *URI,
xmlCharEncoding enc);
/**
* xmlOutputBufferCreateFilenameFunc:
* @URI: the URI to write to
* @enc: the requested target encoding
*
* Signature for the function doing the lookup for a suitable output method
* corresponding to an URI.
*
* Returns the new xmlOutputBufferPtr in case of success or NULL if no
* method was found.
*/
typedef xmlOutputBufferPtr (*xmlOutputBufferCreateFilenameFunc) (const char *URI,
xmlCharEncodingHandlerPtr encoder,
int compression);
XMLPUBFUN xmlParserInputBufferCreateFilenameFunc
XMLCALL xmlParserInputBufferCreateFilenameDefault (xmlParserInputBufferCreateFilenameFunc func);
XMLPUBFUN xmlOutputBufferCreateFilenameFunc
XMLCALL xmlOutputBufferCreateFilenameDefault (xmlOutputBufferCreateFilenameFunc func);
/*
* Externally global symbols which need to be protected for backwards
* compatibility support.
*/
#undef htmlDefaultSAXHandler
#undef oldXMLWDcompatibility
#undef xmlBufferAllocScheme
#undef xmlDefaultBufferSize
#undef xmlDefaultSAXHandler
#undef xmlDefaultSAXLocator
#undef xmlDoValidityCheckingDefaultValue
#undef xmlFree
#undef xmlGenericError
#undef xmlStructuredError
#undef xmlGenericErrorContext
#undef xmlStructuredErrorContext
#undef xmlGetWarningsDefaultValue
#undef xmlIndentTreeOutput
#undef xmlTreeIndentString
#undef xmlKeepBlanksDefaultValue
#undef xmlLineNumbersDefaultValue
#undef xmlLoadExtDtdDefaultValue
#undef xmlMalloc
#undef xmlMallocAtomic
#undef xmlMemStrdup
#undef xmlParserDebugEntities
#undef xmlParserVersion
#undef xmlPedanticParserDefaultValue
#undef xmlRealloc
#undef xmlSaveNoEmptyTags
#undef xmlSubstituteEntitiesDefaultValue
#undef xmlRegisterNodeDefaultValue
#undef xmlDeregisterNodeDefaultValue
#undef xmlLastError
#undef xmlParserInputBufferCreateFilenameValue
#undef xmlOutputBufferCreateFilenameValue
/**
* xmlRegisterNodeFunc:
* @node: the current node
*
* Signature for the registration callback of a created node
*/
typedef void (*xmlRegisterNodeFunc) (xmlNodePtr node);
/**
* xmlDeregisterNodeFunc:
* @node: the current node
*
* Signature for the deregistration callback of a discarded node
*/
typedef void (*xmlDeregisterNodeFunc) (xmlNodePtr node);
typedef struct _xmlGlobalState xmlGlobalState;
typedef xmlGlobalState *xmlGlobalStatePtr;
struct _xmlGlobalState
{
const char *xmlParserVersion;
xmlSAXLocator xmlDefaultSAXLocator;
xmlSAXHandlerV1 xmlDefaultSAXHandler;
xmlSAXHandlerV1 docbDefaultSAXHandler; /* unused */
xmlSAXHandlerV1 htmlDefaultSAXHandler;
xmlFreeFunc xmlFree;
xmlMallocFunc xmlMalloc;
xmlStrdupFunc xmlMemStrdup;
xmlReallocFunc xmlRealloc;
xmlGenericErrorFunc xmlGenericError;
xmlStructuredErrorFunc xmlStructuredError;
void *xmlGenericErrorContext;
int oldXMLWDcompatibility;
xmlBufferAllocationScheme xmlBufferAllocScheme;
int xmlDefaultBufferSize;
int xmlSubstituteEntitiesDefaultValue;
int xmlDoValidityCheckingDefaultValue;
int xmlGetWarningsDefaultValue;
int xmlKeepBlanksDefaultValue;
int xmlLineNumbersDefaultValue;
int xmlLoadExtDtdDefaultValue;
int xmlParserDebugEntities;
int xmlPedanticParserDefaultValue;
int xmlSaveNoEmptyTags;
int xmlIndentTreeOutput;
const char *xmlTreeIndentString;
xmlRegisterNodeFunc xmlRegisterNodeDefaultValue;
xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValue;
xmlMallocFunc xmlMallocAtomic;
xmlError xmlLastError;
xmlParserInputBufferCreateFilenameFunc xmlParserInputBufferCreateFilenameValue;
xmlOutputBufferCreateFilenameFunc xmlOutputBufferCreateFilenameValue;
void *xmlStructuredErrorContext;
};
#ifdef __cplusplus
}
#endif
#include <libxml/threads.h>
#ifdef __cplusplus
extern "C" {
#endif
XMLPUBFUN void XMLCALL xmlInitializeGlobalState(xmlGlobalStatePtr gs);
XMLPUBFUN void XMLCALL xmlThrDefSetGenericErrorFunc(void *ctx, xmlGenericErrorFunc handler);
XMLPUBFUN void XMLCALL xmlThrDefSetStructuredErrorFunc(void *ctx, xmlStructuredErrorFunc handler);
XMLPUBFUN xmlRegisterNodeFunc XMLCALL xmlRegisterNodeDefault(xmlRegisterNodeFunc func);
XMLPUBFUN xmlRegisterNodeFunc XMLCALL xmlThrDefRegisterNodeDefault(xmlRegisterNodeFunc func);
XMLPUBFUN xmlDeregisterNodeFunc XMLCALL xmlDeregisterNodeDefault(xmlDeregisterNodeFunc func);
XMLPUBFUN xmlDeregisterNodeFunc XMLCALL xmlThrDefDeregisterNodeDefault(xmlDeregisterNodeFunc func);
XMLPUBFUN xmlOutputBufferCreateFilenameFunc XMLCALL
xmlThrDefOutputBufferCreateFilenameDefault(xmlOutputBufferCreateFilenameFunc func);
XMLPUBFUN xmlParserInputBufferCreateFilenameFunc XMLCALL
xmlThrDefParserInputBufferCreateFilenameDefault(
xmlParserInputBufferCreateFilenameFunc func);
/** DOC_DISABLE */
/*
* In general the memory allocation entry points are not kept
* thread specific but this can be overridden by LIBXML_THREAD_ALLOC_ENABLED
* - xmlMalloc
* - xmlMallocAtomic
* - xmlRealloc
* - xmlMemStrdup
* - xmlFree
*/
#ifdef LIBXML_THREAD_ALLOC_ENABLED
#ifdef LIBXML_THREAD_ENABLED
XMLPUBFUN xmlMallocFunc * XMLCALL __xmlMalloc(void);
#define xmlMalloc \
(*(__xmlMalloc()))
#else
XMLPUBVAR xmlMallocFunc xmlMalloc;
#endif
#ifdef LIBXML_THREAD_ENABLED
XMLPUBFUN xmlMallocFunc * XMLCALL __xmlMallocAtomic(void);
#define xmlMallocAtomic \
(*(__xmlMallocAtomic()))
#else
XMLPUBVAR xmlMallocFunc xmlMallocAtomic;
#endif
#ifdef LIBXML_THREAD_ENABLED
XMLPUBFUN xmlReallocFunc * XMLCALL __xmlRealloc(void);
#define xmlRealloc \
(*(__xmlRealloc()))
#else
XMLPUBVAR xmlReallocFunc xmlRealloc;
#endif
#ifdef LIBXML_THREAD_ENABLED
XMLPUBFUN xmlFreeFunc * XMLCALL __xmlFree(void);
#define xmlFree \
(*(__xmlFree()))
#else
XMLPUBVAR xmlFreeFunc xmlFree;
#endif
#ifdef LIBXML_THREAD_ENABLED
XMLPUBFUN xmlStrdupFunc * XMLCALL __xmlMemStrdup(void);
#define xmlMemStrdup \
(*(__xmlMemStrdup()))
#else
XMLPUBVAR xmlStrdupFunc xmlMemStrdup;
#endif
#else /* !LIBXML_THREAD_ALLOC_ENABLED */
XMLPUBVAR xmlMallocFunc xmlMalloc;
XMLPUBVAR xmlMallocFunc xmlMallocAtomic;
XMLPUBVAR xmlReallocFunc xmlRealloc;
XMLPUBVAR xmlFreeFunc xmlFree;
XMLPUBVAR xmlStrdupFunc xmlMemStrdup;
#endif /* LIBXML_THREAD_ALLOC_ENABLED */
#ifdef LIBXML_HTML_ENABLED
XMLPUBFUN xmlSAXHandlerV1 * XMLCALL __htmlDefaultSAXHandler(void);
#ifdef LIBXML_THREAD_ENABLED
#define htmlDefaultSAXHandler \
(*(__htmlDefaultSAXHandler()))
#else
XMLPUBVAR xmlSAXHandlerV1 htmlDefaultSAXHandler;
#endif
#endif
XMLPUBFUN xmlError * XMLCALL __xmlLastError(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlLastError \
(*(__xmlLastError()))
#else
XMLPUBVAR xmlError xmlLastError;
#endif
/*
* Everything starting from the line below is
* Automatically generated by build_glob.py.
* Do not modify the previous line.
*/
XMLPUBFUN int * XMLCALL __oldXMLWDcompatibility(void);
#ifdef LIBXML_THREAD_ENABLED
#define oldXMLWDcompatibility \
(*(__oldXMLWDcompatibility()))
#else
XMLPUBVAR int oldXMLWDcompatibility;
#endif
XMLPUBFUN xmlBufferAllocationScheme * XMLCALL __xmlBufferAllocScheme(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlBufferAllocScheme \
(*(__xmlBufferAllocScheme()))
#else
XMLPUBVAR xmlBufferAllocationScheme xmlBufferAllocScheme;
#endif
XMLPUBFUN xmlBufferAllocationScheme XMLCALL
xmlThrDefBufferAllocScheme(xmlBufferAllocationScheme v);
XMLPUBFUN int * XMLCALL __xmlDefaultBufferSize(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlDefaultBufferSize \
(*(__xmlDefaultBufferSize()))
#else
XMLPUBVAR int xmlDefaultBufferSize;
#endif
XMLPUBFUN int XMLCALL xmlThrDefDefaultBufferSize(int v);
XMLPUBFUN xmlSAXHandlerV1 * XMLCALL __xmlDefaultSAXHandler(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlDefaultSAXHandler \
(*(__xmlDefaultSAXHandler()))
#else
XMLPUBVAR xmlSAXHandlerV1 xmlDefaultSAXHandler;
#endif
XMLPUBFUN xmlSAXLocator * XMLCALL __xmlDefaultSAXLocator(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlDefaultSAXLocator \
(*(__xmlDefaultSAXLocator()))
#else
XMLPUBVAR xmlSAXLocator xmlDefaultSAXLocator;
#endif
XMLPUBFUN int * XMLCALL __xmlDoValidityCheckingDefaultValue(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlDoValidityCheckingDefaultValue \
(*(__xmlDoValidityCheckingDefaultValue()))
#else
XMLPUBVAR int xmlDoValidityCheckingDefaultValue;
#endif
XMLPUBFUN int XMLCALL xmlThrDefDoValidityCheckingDefaultValue(int v);
XMLPUBFUN xmlGenericErrorFunc * XMLCALL __xmlGenericError(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlGenericError \
(*(__xmlGenericError()))
#else
XMLPUBVAR xmlGenericErrorFunc xmlGenericError;
#endif
XMLPUBFUN xmlStructuredErrorFunc * XMLCALL __xmlStructuredError(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlStructuredError \
(*(__xmlStructuredError()))
#else
XMLPUBVAR xmlStructuredErrorFunc xmlStructuredError;
#endif
XMLPUBFUN void * * XMLCALL __xmlGenericErrorContext(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlGenericErrorContext \
(*(__xmlGenericErrorContext()))
#else
XMLPUBVAR void * xmlGenericErrorContext;
#endif
XMLPUBFUN void * * XMLCALL __xmlStructuredErrorContext(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlStructuredErrorContext \
(*(__xmlStructuredErrorContext()))
#else
XMLPUBVAR void * xmlStructuredErrorContext;
#endif
XMLPUBFUN int * XMLCALL __xmlGetWarningsDefaultValue(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlGetWarningsDefaultValue \
(*(__xmlGetWarningsDefaultValue()))
#else
XMLPUBVAR int xmlGetWarningsDefaultValue;
#endif
XMLPUBFUN int XMLCALL xmlThrDefGetWarningsDefaultValue(int v);
XMLPUBFUN int * XMLCALL __xmlIndentTreeOutput(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlIndentTreeOutput \
(*(__xmlIndentTreeOutput()))
#else
XMLPUBVAR int xmlIndentTreeOutput;
#endif
XMLPUBFUN int XMLCALL xmlThrDefIndentTreeOutput(int v);
XMLPUBFUN const char * * XMLCALL __xmlTreeIndentString(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlTreeIndentString \
(*(__xmlTreeIndentString()))
#else
XMLPUBVAR const char * xmlTreeIndentString;
#endif
XMLPUBFUN const char * XMLCALL xmlThrDefTreeIndentString(const char * v);
XMLPUBFUN int * XMLCALL __xmlKeepBlanksDefaultValue(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlKeepBlanksDefaultValue \
(*(__xmlKeepBlanksDefaultValue()))
#else
XMLPUBVAR int xmlKeepBlanksDefaultValue;
#endif
XMLPUBFUN int XMLCALL xmlThrDefKeepBlanksDefaultValue(int v);
XMLPUBFUN int * XMLCALL __xmlLineNumbersDefaultValue(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlLineNumbersDefaultValue \
(*(__xmlLineNumbersDefaultValue()))
#else
XMLPUBVAR int xmlLineNumbersDefaultValue;
#endif
XMLPUBFUN int XMLCALL xmlThrDefLineNumbersDefaultValue(int v);
XMLPUBFUN int * XMLCALL __xmlLoadExtDtdDefaultValue(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlLoadExtDtdDefaultValue \
(*(__xmlLoadExtDtdDefaultValue()))
#else
XMLPUBVAR int xmlLoadExtDtdDefaultValue;
#endif
XMLPUBFUN int XMLCALL xmlThrDefLoadExtDtdDefaultValue(int v);
XMLPUBFUN int * XMLCALL __xmlParserDebugEntities(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlParserDebugEntities \
(*(__xmlParserDebugEntities()))
#else
XMLPUBVAR int xmlParserDebugEntities;
#endif
XMLPUBFUN int XMLCALL xmlThrDefParserDebugEntities(int v);
XMLPUBFUN const char * * XMLCALL __xmlParserVersion(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlParserVersion \
(*(__xmlParserVersion()))
#else
XMLPUBVAR const char * xmlParserVersion;
#endif
XMLPUBFUN int * XMLCALL __xmlPedanticParserDefaultValue(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlPedanticParserDefaultValue \
(*(__xmlPedanticParserDefaultValue()))
#else
XMLPUBVAR int xmlPedanticParserDefaultValue;
#endif
XMLPUBFUN int XMLCALL xmlThrDefPedanticParserDefaultValue(int v);
XMLPUBFUN int * XMLCALL __xmlSaveNoEmptyTags(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlSaveNoEmptyTags \
(*(__xmlSaveNoEmptyTags()))
#else
XMLPUBVAR int xmlSaveNoEmptyTags;
#endif
XMLPUBFUN int XMLCALL xmlThrDefSaveNoEmptyTags(int v);
XMLPUBFUN int * XMLCALL __xmlSubstituteEntitiesDefaultValue(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlSubstituteEntitiesDefaultValue \
(*(__xmlSubstituteEntitiesDefaultValue()))
#else
XMLPUBVAR int xmlSubstituteEntitiesDefaultValue;
#endif
XMLPUBFUN int XMLCALL xmlThrDefSubstituteEntitiesDefaultValue(int v);
XMLPUBFUN xmlRegisterNodeFunc * XMLCALL __xmlRegisterNodeDefaultValue(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlRegisterNodeDefaultValue \
(*(__xmlRegisterNodeDefaultValue()))
#else
XMLPUBVAR xmlRegisterNodeFunc xmlRegisterNodeDefaultValue;
#endif
XMLPUBFUN xmlDeregisterNodeFunc * XMLCALL __xmlDeregisterNodeDefaultValue(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlDeregisterNodeDefaultValue \
(*(__xmlDeregisterNodeDefaultValue()))
#else
XMLPUBVAR xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValue;
#endif
XMLPUBFUN xmlParserInputBufferCreateFilenameFunc * XMLCALL \
__xmlParserInputBufferCreateFilenameValue(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlParserInputBufferCreateFilenameValue \
(*(__xmlParserInputBufferCreateFilenameValue()))
#else
XMLPUBVAR xmlParserInputBufferCreateFilenameFunc xmlParserInputBufferCreateFilenameValue;
#endif
XMLPUBFUN xmlOutputBufferCreateFilenameFunc * XMLCALL __xmlOutputBufferCreateFilenameValue(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlOutputBufferCreateFilenameValue \
(*(__xmlOutputBufferCreateFilenameValue()))
#else
XMLPUBVAR xmlOutputBufferCreateFilenameFunc xmlOutputBufferCreateFilenameValue;
#endif
#ifdef __cplusplus
}
#endif
#endif /* __XML_GLOBALS_H */
/*
* Summary: Unicode character APIs
* Description: API for the Unicode character APIs
*
* This file is automatically generated from the
* UCS description files of the Unicode Character Database
* http://www.unicode.org/Public/4.0-Update1/UCD-4.0.1.html
* using the genUnicode.py Python script.
*
* Generation date: Mon Mar 27 11:09:52 2006
* Sources: Blocks-4.0.1.txt UnicodeData-4.0.1.txt
* Author: Daniel Veillard
*/
#ifndef __XML_UNICODE_H__
#define __XML_UNICODE_H__
#include <libxml/xmlversion.h>
#ifdef LIBXML_UNICODE_ENABLED
#ifdef __cplusplus
extern "C" {
#endif
XMLPUBFUN int XMLCALL xmlUCSIsAegeanNumbers (int code);
XMLPUBFUN int XMLCALL xmlUCSIsAlphabeticPresentationForms (int code);
XMLPUBFUN int XMLCALL xmlUCSIsArabic (int code);
XMLPUBFUN int XMLCALL xmlUCSIsArabicPresentationFormsA (int code);
XMLPUBFUN int XMLCALL xmlUCSIsArabicPresentationFormsB (int code);
XMLPUBFUN int XMLCALL xmlUCSIsArmenian (int code);
XMLPUBFUN int XMLCALL xmlUCSIsArrows (int code);
XMLPUBFUN int XMLCALL xmlUCSIsBasicLatin (int code);
XMLPUBFUN int XMLCALL xmlUCSIsBengali (int code);
XMLPUBFUN int XMLCALL xmlUCSIsBlockElements (int code);
XMLPUBFUN int XMLCALL xmlUCSIsBopomofo (int code);
XMLPUBFUN int XMLCALL xmlUCSIsBopomofoExtended (int code);
XMLPUBFUN int XMLCALL xmlUCSIsBoxDrawing (int code);
XMLPUBFUN int XMLCALL xmlUCSIsBraillePatterns (int code);
XMLPUBFUN int XMLCALL xmlUCSIsBuhid (int code);
XMLPUBFUN int XMLCALL xmlUCSIsByzantineMusicalSymbols (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCJKCompatibility (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCJKCompatibilityForms (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCJKCompatibilityIdeographs (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCJKCompatibilityIdeographsSupplement (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCJKRadicalsSupplement (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCJKSymbolsandPunctuation (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCJKUnifiedIdeographs (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCJKUnifiedIdeographsExtensionA (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCJKUnifiedIdeographsExtensionB (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCherokee (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCombiningDiacriticalMarks (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCombiningDiacriticalMarksforSymbols (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCombiningHalfMarks (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCombiningMarksforSymbols (int code);
XMLPUBFUN int XMLCALL xmlUCSIsControlPictures (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCurrencySymbols (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCypriotSyllabary (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCyrillic (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCyrillicSupplement (int code);
XMLPUBFUN int XMLCALL xmlUCSIsDeseret (int code);
XMLPUBFUN int XMLCALL xmlUCSIsDevanagari (int code);
XMLPUBFUN int XMLCALL xmlUCSIsDingbats (int code);
XMLPUBFUN int XMLCALL xmlUCSIsEnclosedAlphanumerics (int code);
XMLPUBFUN int XMLCALL xmlUCSIsEnclosedCJKLettersandMonths (int code);
XMLPUBFUN int XMLCALL xmlUCSIsEthiopic (int code);
XMLPUBFUN int XMLCALL xmlUCSIsGeneralPunctuation (int code);
XMLPUBFUN int XMLCALL xmlUCSIsGeometricShapes (int code);
XMLPUBFUN int XMLCALL xmlUCSIsGeorgian (int code);
XMLPUBFUN int XMLCALL xmlUCSIsGothic (int code);
XMLPUBFUN int XMLCALL xmlUCSIsGreek (int code);
XMLPUBFUN int XMLCALL xmlUCSIsGreekExtended (int code);
XMLPUBFUN int XMLCALL xmlUCSIsGreekandCoptic (int code);
XMLPUBFUN int XMLCALL xmlUCSIsGujarati (int code);
XMLPUBFUN int XMLCALL xmlUCSIsGurmukhi (int code);
XMLPUBFUN int XMLCALL xmlUCSIsHalfwidthandFullwidthForms (int code);
XMLPUBFUN int XMLCALL xmlUCSIsHangulCompatibilityJamo (int code);
XMLPUBFUN int XMLCALL xmlUCSIsHangulJamo (int code);
XMLPUBFUN int XMLCALL xmlUCSIsHangulSyllables (int code);
XMLPUBFUN int XMLCALL xmlUCSIsHanunoo (int code);
XMLPUBFUN int XMLCALL xmlUCSIsHebrew (int code);
XMLPUBFUN int XMLCALL xmlUCSIsHighPrivateUseSurrogates (int code);
XMLPUBFUN int XMLCALL xmlUCSIsHighSurrogates (int code);
XMLPUBFUN int XMLCALL xmlUCSIsHiragana (int code);
XMLPUBFUN int XMLCALL xmlUCSIsIPAExtensions (int code);
XMLPUBFUN int XMLCALL xmlUCSIsIdeographicDescriptionCharacters (int code);
XMLPUBFUN int XMLCALL xmlUCSIsKanbun (int code);
XMLPUBFUN int XMLCALL xmlUCSIsKangxiRadicals (int code);
XMLPUBFUN int XMLCALL xmlUCSIsKannada (int code);
XMLPUBFUN int XMLCALL xmlUCSIsKatakana (int code);
XMLPUBFUN int XMLCALL xmlUCSIsKatakanaPhoneticExtensions (int code);
XMLPUBFUN int XMLCALL xmlUCSIsKhmer (int code);
XMLPUBFUN int XMLCALL xmlUCSIsKhmerSymbols (int code);
XMLPUBFUN int XMLCALL xmlUCSIsLao (int code);
XMLPUBFUN int XMLCALL xmlUCSIsLatin1Supplement (int code);
XMLPUBFUN int XMLCALL xmlUCSIsLatinExtendedA (int code);
XMLPUBFUN int XMLCALL xmlUCSIsLatinExtendedB (int code);
XMLPUBFUN int XMLCALL xmlUCSIsLatinExtendedAdditional (int code);
XMLPUBFUN int XMLCALL xmlUCSIsLetterlikeSymbols (int code);
XMLPUBFUN int XMLCALL xmlUCSIsLimbu (int code);
XMLPUBFUN int XMLCALL xmlUCSIsLinearBIdeograms (int code);
XMLPUBFUN int XMLCALL xmlUCSIsLinearBSyllabary (int code);
XMLPUBFUN int XMLCALL xmlUCSIsLowSurrogates (int code);
XMLPUBFUN int XMLCALL xmlUCSIsMalayalam (int code);
XMLPUBFUN int XMLCALL xmlUCSIsMathematicalAlphanumericSymbols (int code);
XMLPUBFUN int XMLCALL xmlUCSIsMathematicalOperators (int code);
XMLPUBFUN int XMLCALL xmlUCSIsMiscellaneousMathematicalSymbolsA (int code);
XMLPUBFUN int XMLCALL xmlUCSIsMiscellaneousMathematicalSymbolsB (int code);
XMLPUBFUN int XMLCALL xmlUCSIsMiscellaneousSymbols (int code);
XMLPUBFUN int XMLCALL xmlUCSIsMiscellaneousSymbolsandArrows (int code);
XMLPUBFUN int XMLCALL xmlUCSIsMiscellaneousTechnical (int code);
XMLPUBFUN int XMLCALL xmlUCSIsMongolian (int code);
XMLPUBFUN int XMLCALL xmlUCSIsMusicalSymbols (int code);
XMLPUBFUN int XMLCALL xmlUCSIsMyanmar (int code);
XMLPUBFUN int XMLCALL xmlUCSIsNumberForms (int code);
XMLPUBFUN int XMLCALL xmlUCSIsOgham (int code);
XMLPUBFUN int XMLCALL xmlUCSIsOldItalic (int code);
XMLPUBFUN int XMLCALL xmlUCSIsOpticalCharacterRecognition (int code);
XMLPUBFUN int XMLCALL xmlUCSIsOriya (int code);
XMLPUBFUN int XMLCALL xmlUCSIsOsmanya (int code);
XMLPUBFUN int XMLCALL xmlUCSIsPhoneticExtensions (int code);
XMLPUBFUN int XMLCALL xmlUCSIsPrivateUse (int code);
XMLPUBFUN int XMLCALL xmlUCSIsPrivateUseArea (int code);
XMLPUBFUN int XMLCALL xmlUCSIsRunic (int code);
XMLPUBFUN int XMLCALL xmlUCSIsShavian (int code);
XMLPUBFUN int XMLCALL xmlUCSIsSinhala (int code);
XMLPUBFUN int XMLCALL xmlUCSIsSmallFormVariants (int code);
XMLPUBFUN int XMLCALL xmlUCSIsSpacingModifierLetters (int code);
XMLPUBFUN int XMLCALL xmlUCSIsSpecials (int code);
XMLPUBFUN int XMLCALL xmlUCSIsSuperscriptsandSubscripts (int code);
XMLPUBFUN int XMLCALL xmlUCSIsSupplementalArrowsA (int code);
XMLPUBFUN int XMLCALL xmlUCSIsSupplementalArrowsB (int code);
XMLPUBFUN int XMLCALL xmlUCSIsSupplementalMathematicalOperators (int code);
XMLPUBFUN int XMLCALL xmlUCSIsSupplementaryPrivateUseAreaA (int code);
XMLPUBFUN int XMLCALL xmlUCSIsSupplementaryPrivateUseAreaB (int code);
XMLPUBFUN int XMLCALL xmlUCSIsSyriac (int code);
XMLPUBFUN int XMLCALL xmlUCSIsTagalog (int code);
XMLPUBFUN int XMLCALL xmlUCSIsTagbanwa (int code);
XMLPUBFUN int XMLCALL xmlUCSIsTags (int code);
XMLPUBFUN int XMLCALL xmlUCSIsTaiLe (int code);
XMLPUBFUN int XMLCALL xmlUCSIsTaiXuanJingSymbols (int code);
XMLPUBFUN int XMLCALL xmlUCSIsTamil (int code);
XMLPUBFUN int XMLCALL xmlUCSIsTelugu (int code);
XMLPUBFUN int XMLCALL xmlUCSIsThaana (int code);
XMLPUBFUN int XMLCALL xmlUCSIsThai (int code);
XMLPUBFUN int XMLCALL xmlUCSIsTibetan (int code);
XMLPUBFUN int XMLCALL xmlUCSIsUgaritic (int code);
XMLPUBFUN int XMLCALL xmlUCSIsUnifiedCanadianAboriginalSyllabics (int code);
XMLPUBFUN int XMLCALL xmlUCSIsVariationSelectors (int code);
XMLPUBFUN int XMLCALL xmlUCSIsVariationSelectorsSupplement (int code);
XMLPUBFUN int XMLCALL xmlUCSIsYiRadicals (int code);
XMLPUBFUN int XMLCALL xmlUCSIsYiSyllables (int code);
XMLPUBFUN int XMLCALL xmlUCSIsYijingHexagramSymbols (int code);
XMLPUBFUN int XMLCALL xmlUCSIsBlock (int code, const char *block);
XMLPUBFUN int XMLCALL xmlUCSIsCatC (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatCc (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatCf (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatCo (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatCs (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatL (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatLl (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatLm (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatLo (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatLt (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatLu (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatM (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatMc (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatMe (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatMn (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatN (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatNd (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatNl (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatNo (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatP (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatPc (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatPd (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatPe (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatPf (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatPi (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatPo (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatPs (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatS (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatSc (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatSk (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatSm (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatSo (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatZ (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatZl (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatZp (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCatZs (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCat (int code, const char *cat);
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_UNICODE_ENABLED */
#endif /* __XML_UNICODE_H__ */
/*
* Summary: XML Path Language implementation
* Description: API for the XML Path Language implementation
*
* XML Path Language implementation
* XPath is a language for addressing parts of an XML document,
* designed to be used by both XSLT and XPointer
* http://www.w3.org/TR/xpath
*
* Implements
* W3C Recommendation 16 November 1999
* http://www.w3.org/TR/1999/REC-xpath-19991116
*
* Copy: See Copyright for the status of this software.
*
* Author: Daniel Veillard
*/
#ifndef __XML_XPATH_H__
#define __XML_XPATH_H__
#include <libxml/xmlversion.h>
#ifdef LIBXML_XPATH_ENABLED
#include <libxml/xmlerror.h>
#include <libxml/tree.h>
#include <libxml/hash.h>
#endif /* LIBXML_XPATH_ENABLED */
#if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
#ifdef __cplusplus
extern "C" {
#endif
#endif /* LIBXML_XPATH_ENABLED or LIBXML_SCHEMAS_ENABLED */
#ifdef LIBXML_XPATH_ENABLED
typedef struct _xmlXPathContext xmlXPathContext;
typedef xmlXPathContext *xmlXPathContextPtr;
typedef struct _xmlXPathParserContext xmlXPathParserContext;
typedef xmlXPathParserContext *xmlXPathParserContextPtr;
/**
* The set of XPath error codes.
*/
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,
XPATH_STACK_ERROR,
XPATH_FORBID_VARIABLE_ERROR,
XPATH_OP_LIMIT_EXCEEDED,
XPATH_RECURSION_LIMIT_EXCEEDED
} xmlXPathError;
/*
* A node-set (an unordered collection of nodes without duplicates).
*/
typedef struct _xmlNodeSet xmlNodeSet;
typedef xmlNodeSet *xmlNodeSetPtr;
struct _xmlNodeSet {
int nodeNr; /* number of nodes in the set */
int nodeMax; /* size of the array as allocated */
xmlNodePtr *nodeTab; /* array of nodes in no particular order */
/* @@ with_ns to check whether namespace nodes should be looked at @@ */
};
/*
* An expression is evaluated to yield an object, which
* has one of the following four basic types:
* - node-set
* - boolean
* - number
* - string
*
* @@ XPointer will add more types !
*/
typedef enum {
XPATH_UNDEFINED = 0,
XPATH_NODESET = 1,
XPATH_BOOLEAN = 2,
XPATH_NUMBER = 3,
XPATH_STRING = 4,
#ifdef LIBXML_XPTR_LOCS_ENABLED
XPATH_POINT = 5,
XPATH_RANGE = 6,
XPATH_LOCATIONSET = 7,
#endif
XPATH_USERS = 8,
XPATH_XSLT_TREE = 9 /* An XSLT value tree, non modifiable */
} xmlXPathObjectType;
#ifndef LIBXML_XPTR_LOCS_ENABLED
/** DOC_DISABLE */
#define XPATH_POINT 5
#define XPATH_RANGE 6
#define XPATH_LOCATIONSET 7
/** DOC_ENABLE */
#endif
typedef struct _xmlXPathObject xmlXPathObject;
typedef xmlXPathObject *xmlXPathObjectPtr;
struct _xmlXPathObject {
xmlXPathObjectType type;
xmlNodeSetPtr nodesetval;
int boolval;
double floatval;
xmlChar *stringval;
void *user;
int index;
void *user2;
int index2;
};
/**
* xmlXPathConvertFunc:
* @obj: an XPath object
* @type: the number of the target type
*
* A conversion function is associated to a type and used to cast
* the new type to primitive values.
*
* Returns -1 in case of error, 0 otherwise
*/
typedef int (*xmlXPathConvertFunc) (xmlXPathObjectPtr obj, int type);
/*
* Extra type: a name and a conversion function.
*/
typedef struct _xmlXPathType xmlXPathType;
typedef xmlXPathType *xmlXPathTypePtr;
struct _xmlXPathType {
const xmlChar *name; /* the type name */
xmlXPathConvertFunc func; /* the conversion function */
};
/*
* Extra variable: a name and a value.
*/
typedef struct _xmlXPathVariable xmlXPathVariable;
typedef xmlXPathVariable *xmlXPathVariablePtr;
struct _xmlXPathVariable {
const xmlChar *name; /* the variable name */
xmlXPathObjectPtr value; /* the value */
};
/**
* xmlXPathEvalFunc:
* @ctxt: an XPath parser context
* @nargs: the number of arguments passed to the function
*
* An XPath evaluation function, the parameters are on the XPath context stack.
*/
typedef void (*xmlXPathEvalFunc)(xmlXPathParserContextPtr ctxt,
int nargs);
/*
* Extra function: a name and a evaluation function.
*/
typedef struct _xmlXPathFunct xmlXPathFunct;
typedef xmlXPathFunct *xmlXPathFuncPtr;
struct _xmlXPathFunct {
const xmlChar *name; /* the function name */
xmlXPathEvalFunc func; /* the evaluation function */
};
/**
* xmlXPathAxisFunc:
* @ctxt: the XPath interpreter context
* @cur: the previous node being explored on that axis
*
* An axis traversal function. To traverse an axis, the engine calls
* the first time with cur == NULL and repeat until the function returns
* NULL indicating the end of the axis traversal.
*
* Returns the next node in that axis or NULL if at the end of the axis.
*/
typedef xmlXPathObjectPtr (*xmlXPathAxisFunc) (xmlXPathParserContextPtr ctxt,
xmlXPathObjectPtr cur);
/*
* Extra axis: a name and an axis function.
*/
typedef struct _xmlXPathAxis xmlXPathAxis;
typedef xmlXPathAxis *xmlXPathAxisPtr;
struct _xmlXPathAxis {
const xmlChar *name; /* the axis name */
xmlXPathAxisFunc func; /* the search function */
};
/**
* xmlXPathFunction:
* @ctxt: the XPath interprestation context
* @nargs: the number of arguments
*
* An XPath function.
* The arguments (if any) are popped out from the context stack
* and the result is pushed on the stack.
*/
typedef void (*xmlXPathFunction) (xmlXPathParserContextPtr ctxt, int nargs);
/*
* Function and Variable Lookup.
*/
/**
* xmlXPathVariableLookupFunc:
* @ctxt: an XPath context
* @name: name of the variable
* @ns_uri: the namespace name hosting this variable
*
* Prototype for callbacks used to plug variable lookup in the XPath
* engine.
*
* Returns the XPath object value or NULL if not found.
*/
typedef xmlXPathObjectPtr (*xmlXPathVariableLookupFunc) (void *ctxt,
const xmlChar *name,
const xmlChar *ns_uri);
/**
* xmlXPathFuncLookupFunc:
* @ctxt: an XPath context
* @name: name of the function
* @ns_uri: the namespace name hosting this function
*
* Prototype for callbacks used to plug function lookup in the XPath
* engine.
*
* Returns the XPath function or NULL if not found.
*/
typedef xmlXPathFunction (*xmlXPathFuncLookupFunc) (void *ctxt,
const xmlChar *name,
const xmlChar *ns_uri);
/**
* xmlXPathFlags:
* Flags for XPath engine compilation and runtime
*/
/**
* XML_XPATH_CHECKNS:
*
* check namespaces at compilation
*/
#define XML_XPATH_CHECKNS (1<<0)
/**
* XML_XPATH_NOVAR:
*
* forbid variables in expression
*/
#define XML_XPATH_NOVAR (1<<1)
/**
* xmlXPathContext:
*
* Expression evaluation occurs with respect to a context.
* he context consists of:
* - a node (the context node)
* - a node list (the context node list)
* - a set of variable bindings
* - a function library
* - the set of namespace declarations in scope for the expression
* Following the switch to hash tables, this need to be trimmed up at
* the next binary incompatible release.
* The node may be modified when the context is passed to libxml2
* for an XPath evaluation so you may need to initialize it again
* before the next call.
*/
struct _xmlXPathContext {
xmlDocPtr doc; /* The current document */
xmlNodePtr node; /* The current node */
int nb_variables_unused; /* unused (hash table) */
int max_variables_unused; /* unused (hash table) */
xmlHashTablePtr varHash; /* Hash table of defined variables */
int nb_types; /* number of defined types */
int max_types; /* max number of types */
xmlXPathTypePtr types; /* Array of defined types */
int nb_funcs_unused; /* unused (hash table) */
int max_funcs_unused; /* unused (hash table) */
xmlHashTablePtr funcHash; /* Hash table of defined funcs */
int nb_axis; /* number of defined axis */
int max_axis; /* max number of axis */
xmlXPathAxisPtr axis; /* Array of defined axis */
/* the namespace nodes of the context node */
xmlNsPtr *namespaces; /* Array of namespaces */
int nsNr; /* number of namespace in scope */
void *user; /* function to free */
/* extra variables */
int contextSize; /* the context size */
int proximityPosition; /* the proximity position */
/* extra stuff for XPointer */
int xptr; /* is this an XPointer context? */
xmlNodePtr here; /* for here() */
xmlNodePtr origin; /* for origin() */
/* the set of namespace declarations in scope for the expression */
xmlHashTablePtr nsHash; /* The namespaces hash table */
xmlXPathVariableLookupFunc varLookupFunc;/* variable lookup func */
void *varLookupData; /* variable lookup data */
/* Possibility to link in an extra item */
void *extra; /* needed for XSLT */
/* The function name and URI when calling a function */
const xmlChar *function;
const xmlChar *functionURI;
/* function lookup function and data */
xmlXPathFuncLookupFunc funcLookupFunc;/* function lookup func */
void *funcLookupData; /* function lookup data */
/* temporary namespace lists kept for walking the namespace axis */
xmlNsPtr *tmpNsList; /* Array of namespaces */
int tmpNsNr; /* number of namespaces in scope */
/* error reporting mechanism */
void *userData; /* user specific data block */
xmlStructuredErrorFunc error; /* the callback in case of errors */
xmlError lastError; /* the last error */
xmlNodePtr debugNode; /* the source node XSLT */
/* dictionary */
xmlDictPtr dict; /* dictionary if any */
int flags; /* flags to control compilation */
/* Cache for reusal of XPath objects */
void *cache;
/* Resource limits */
unsigned long opLimit;
unsigned long opCount;
int depth;
};
/*
* The structure of a compiled expression form is not public.
*/
typedef struct _xmlXPathCompExpr xmlXPathCompExpr;
typedef xmlXPathCompExpr *xmlXPathCompExprPtr;
/**
* xmlXPathParserContext:
*
* An XPath parser context. It contains pure parsing information,
* an xmlXPathContext, and the stack of objects.
*/
struct _xmlXPathParserContext {
const xmlChar *cur; /* the current char being parsed */
const xmlChar *base; /* the full expression */
int error; /* error code */
xmlXPathContextPtr context; /* the evaluation context */
xmlXPathObjectPtr value; /* the current value */
int valueNr; /* number of values stacked */
int valueMax; /* max number of values stacked */
xmlXPathObjectPtr *valueTab; /* stack of values */
xmlXPathCompExprPtr comp; /* the precompiled expression */
int xptr; /* it this an XPointer expression */
xmlNodePtr ancestor; /* used for walking preceding axis */
int valueFrame; /* used to limit Pop on the stack */
};
/************************************************************************
* *
* Public API *
* *
************************************************************************/
/**
* Objects and Nodesets handling
*/
XMLPUBVAR double xmlXPathNAN;
XMLPUBVAR double xmlXPathPINF;
XMLPUBVAR double xmlXPathNINF;
/* These macros may later turn into functions */
/**
* xmlXPathNodeSetGetLength:
* @ns: a node-set
*
* Implement a functionality similar to the DOM NodeList.length.
*
* Returns the number of nodes in the node-set.
*/
#define xmlXPathNodeSetGetLength(ns) ((ns) ? (ns)->nodeNr : 0)
/**
* xmlXPathNodeSetItem:
* @ns: a node-set
* @index: index of a node in the set
*
* Implements a functionality similar to the DOM NodeList.item().
*
* Returns the xmlNodePtr at the given @index in @ns or NULL if
* @index is out of range (0 to length-1)
*/
#define xmlXPathNodeSetItem(ns, index) \
((((ns) != NULL) && \
((index) >= 0) && ((index) < (ns)->nodeNr)) ? \
(ns)->nodeTab[(index)] \
: NULL)
/**
* xmlXPathNodeSetIsEmpty:
* @ns: a node-set
*
* Checks whether @ns is empty or not.
*
* Returns %TRUE if @ns is an empty node-set.
*/
#define xmlXPathNodeSetIsEmpty(ns) \
(((ns) == NULL) || ((ns)->nodeNr == 0) || ((ns)->nodeTab == NULL))
XMLPUBFUN void XMLCALL
xmlXPathFreeObject (xmlXPathObjectPtr obj);
XMLPUBFUN xmlNodeSetPtr XMLCALL
xmlXPathNodeSetCreate (xmlNodePtr val);
XMLPUBFUN void XMLCALL
xmlXPathFreeNodeSetList (xmlXPathObjectPtr obj);
XMLPUBFUN void XMLCALL
xmlXPathFreeNodeSet (xmlNodeSetPtr obj);
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPathObjectCopy (xmlXPathObjectPtr val);
XMLPUBFUN int XMLCALL
xmlXPathCmpNodes (xmlNodePtr node1,
xmlNodePtr node2);
/**
* Conversion functions to basic types.
*/
XMLPUBFUN int XMLCALL
xmlXPathCastNumberToBoolean (double val);
XMLPUBFUN int XMLCALL
xmlXPathCastStringToBoolean (const xmlChar * val);
XMLPUBFUN int XMLCALL
xmlXPathCastNodeSetToBoolean(xmlNodeSetPtr ns);
XMLPUBFUN int XMLCALL
xmlXPathCastToBoolean (xmlXPathObjectPtr val);
XMLPUBFUN double XMLCALL
xmlXPathCastBooleanToNumber (int val);
XMLPUBFUN double XMLCALL
xmlXPathCastStringToNumber (const xmlChar * val);
XMLPUBFUN double XMLCALL
xmlXPathCastNodeToNumber (xmlNodePtr node);
XMLPUBFUN double XMLCALL
xmlXPathCastNodeSetToNumber (xmlNodeSetPtr ns);
XMLPUBFUN double XMLCALL
xmlXPathCastToNumber (xmlXPathObjectPtr val);
XMLPUBFUN xmlChar * XMLCALL
xmlXPathCastBooleanToString (int val);
XMLPUBFUN xmlChar * XMLCALL
xmlXPathCastNumberToString (double val);
XMLPUBFUN xmlChar * XMLCALL
xmlXPathCastNodeToString (xmlNodePtr node);
XMLPUBFUN xmlChar * XMLCALL
xmlXPathCastNodeSetToString (xmlNodeSetPtr ns);
XMLPUBFUN xmlChar * XMLCALL
xmlXPathCastToString (xmlXPathObjectPtr val);
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPathConvertBoolean (xmlXPathObjectPtr val);
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPathConvertNumber (xmlXPathObjectPtr val);
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPathConvertString (xmlXPathObjectPtr val);
/**
* Context handling.
*/
XMLPUBFUN xmlXPathContextPtr XMLCALL
xmlXPathNewContext (xmlDocPtr doc);
XMLPUBFUN void XMLCALL
xmlXPathFreeContext (xmlXPathContextPtr ctxt);
XMLPUBFUN int XMLCALL
xmlXPathContextSetCache(xmlXPathContextPtr ctxt,
int active,
int value,
int options);
/**
* Evaluation functions.
*/
XMLPUBFUN long XMLCALL
xmlXPathOrderDocElems (xmlDocPtr doc);
XMLPUBFUN int XMLCALL
xmlXPathSetContextNode (xmlNodePtr node,
xmlXPathContextPtr ctx);
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPathNodeEval (xmlNodePtr node,
const xmlChar *str,
xmlXPathContextPtr ctx);
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPathEval (const xmlChar *str,
xmlXPathContextPtr ctx);
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPathEvalExpression (const xmlChar *str,
xmlXPathContextPtr ctxt);
XMLPUBFUN int XMLCALL
xmlXPathEvalPredicate (xmlXPathContextPtr ctxt,
xmlXPathObjectPtr res);
/**
* Separate compilation/evaluation entry points.
*/
XMLPUBFUN xmlXPathCompExprPtr XMLCALL
xmlXPathCompile (const xmlChar *str);
XMLPUBFUN xmlXPathCompExprPtr XMLCALL
xmlXPathCtxtCompile (xmlXPathContextPtr ctxt,
const xmlChar *str);
XMLPUBFUN xmlXPathObjectPtr XMLCALL
xmlXPathCompiledEval (xmlXPathCompExprPtr comp,
xmlXPathContextPtr ctx);
XMLPUBFUN int XMLCALL
xmlXPathCompiledEvalToBoolean(xmlXPathCompExprPtr comp,
xmlXPathContextPtr ctxt);
XMLPUBFUN void XMLCALL
xmlXPathFreeCompExpr (xmlXPathCompExprPtr comp);
#endif /* LIBXML_XPATH_ENABLED */
#if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
XML_DEPRECATED
XMLPUBFUN void XMLCALL
xmlXPathInit (void);
XMLPUBFUN int XMLCALL
xmlXPathIsNaN (double val);
XMLPUBFUN int XMLCALL
xmlXPathIsInf (double val);
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_XPATH_ENABLED or LIBXML_SCHEMAS_ENABLED*/
#endif /* ! __XML_XPATH_H__ */
/*
* Summary: dynamic module loading
* Description: basic API for dynamic module loading, used by
* libexslt added in 2.6.17
*
* Copy: See Copyright for the status of this software.
*
* Author: Joel W. Reed
*/
#ifndef __XML_MODULE_H__
#define __XML_MODULE_H__
#include <libxml/xmlversion.h>
#ifdef LIBXML_MODULES_ENABLED
#ifdef __cplusplus
extern "C" {
#endif
/**
* xmlModulePtr:
*
* A handle to a dynamically loaded module
*/
typedef struct _xmlModule xmlModule;
typedef xmlModule *xmlModulePtr;
/**
* xmlModuleOption:
*
* enumeration of options that can be passed down to xmlModuleOpen()
*/
typedef enum {
XML_MODULE_LAZY = 1, /* lazy binding */
XML_MODULE_LOCAL= 2 /* local binding */
} xmlModuleOption;
XMLPUBFUN xmlModulePtr XMLCALL xmlModuleOpen (const char *filename,
int options);
XMLPUBFUN int XMLCALL xmlModuleSymbol (xmlModulePtr module,
const char* name,
void **result);
XMLPUBFUN int XMLCALL xmlModuleClose (xmlModulePtr module);
XMLPUBFUN int XMLCALL xmlModuleFree (xmlModulePtr module);
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_MODULES_ENABLED */
#endif /*__XML_MODULE_H__ */
.TH xml2-config 1 "3 April 2022" Version 1.2.0
.SH NAME
xml2-config - script to get information about the installed version of libxml2
.SH SYNOPSIS
.B xml2-config
[\-\-prefix\fI[=DIR]\fP] [\-\-libs] [\-\-cflags] [\-\-version] [\-\-help]
.SH DESCRIPTION
\fIxml2-config\fP is a tool that is used to determine the compile and
linker flags that should be used to compile and link programs that use
\fIlibxml2\fP.
.SH OPTIONS
\fIxml2-config\fP accepts the following options:
.TP 8
.B \-\-version
Print the currently installed version of \fIlibxml2\fP on the standard output.
.TP 8
.B \-\-libs
Print the linker flags that are necessary to link a \fIlibxml2\fP program.
Add \-\-dynamic after \-\-libs to print only shared library linking
information.
.TP 8
.B \-\-cflags
Print the compiler flags that are necessary to compile a \fIlibxml2\fP program.
.TP 8
.B \-\-prefix=PREFIX
If specified, use PREFIX instead of the installation prefix that
\fIlibxml2\fP was built with when computing the output for the
\-\-cflags and \-\-libs options. This option must be specified before
any \-\-libs or \-\-cflags options.
.SH AUTHOR
This manual page was written by Fredrik Hallenberg <hallon@lysator.liu.se>,
for the Debian GNU/linux system (but may be used by others).
'\" t
.\" Title: xmlcatalog
.\" Author: John Fleck <jfleck@inkstain.net>
.\" Generator: DocBook XSL Stylesheets v1.79.1 <http://docbook.sf.net/>
.\" Date: 08/17/2022
.\" Manual: xmlcatalog Manual
.\" Source: libxml2
.\" Language: English
.\"
.TH "XMLCATALOG" "1" "08/17/2022" "libxml2" "xmlcatalog Manual"
.\" -----------------------------------------------------------------
.\" * Define some portability stuff
.\" -----------------------------------------------------------------
.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.\" http://bugs.debian.org/507673
.\" http://lists.gnu.org/archive/html/groff/2009-02/msg00013.html
.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.ie \n(.g .ds Aq \(aq
.el .ds Aq '
.\" -----------------------------------------------------------------
.\" * set default formatting
.\" -----------------------------------------------------------------
.\" disable hyphenation
.nh
.\" disable justification (adjust text to left margin only)
.ad l
.\" -----------------------------------------------------------------
.\" * MAIN CONTENT STARTS HERE *
.\" -----------------------------------------------------------------
.SH "NAME"
xmlcatalog \- Command line tool to parse and manipulate XML or SGML catalog files\&.
.SH "SYNOPSIS"
.HP \w'\fBxmlcatalog\fR\ 'u
\fBxmlcatalog\fR [\fB\-\-sgml\fR | \fB\-\-shell\fR | \fB\-\-create\fR | \fB\-\-del\ \fR\fB\fIVALUE(S)\fR\fR | [\ \fB\-\-add\ \fR\fB\fITYPE\fR\fR\fB\ \fR\fB\fIORIG\fR\fR\fB\ \fR\fB\fIREPLACE\fR\fR\fB\ \fR\ |\ \fB\-\-add\ \fR\fB\fIFILENAME\fR\fR] | \fB\-\-noout\fR | \fB\-\-no\-super\-update\fR | [\fB\-v\fR\ |\ \fB\-\-verbose\fR]] {\fICATALOGFILE\fR} {\fIENTITIES\fR...}
.SH "DESCRIPTION"
.PP
\fBxmlcatalog\fR
is a command line application allowing users to monitor and manipulate
XML
and
SGML
catalogs\&. It is included in
\fBlibxml\fR(3)\&.
.PP
Its functions can be invoked from a single command from the command line, or it can perform multiple functions in interactive mode\&. It can operate on both
XML
and
SGML
files\&.
.SH "OPTIONS"
.PP
\fBxmlcatalog\fR
accepts the following options (in alphabetical order):
.PP
\fB\-\-add \fR\fB\fITYPE\fR\fR\fB \fR\fB\fIORIG\fR\fR\fB \fR\fB\fIREPLACE\fR\fR\fB \fR
.RS 4
Add an entry to
CATALOGFILE\&.
\fITYPE\fR
indicates the type of entry\&. Possible types are:
\fIpublic\fR, \fIsystem\fR, \fIuri\fR, \fIrewriteSystem\fR, \fIrewriteURI\fR, \fIdelegatePublic\fR, \fIdelegateSystem\fR, \fIdelegateURI\fR, \fInextCatalog\fR\&.
\fIORIG\fR
is the original reference to be replaced, and
\fIREPLACE\fR
is the
URI
of the replacement entity to be used\&. The
\fB\-\-add\fR
option will not overwrite
CATALOGFILE, outputting to
stdout, unless
\fB\-\-noout\fR
is used\&. The
\fB\-\-add\fR
will always take three parameters even if some of the
XML
catalog constructs will have only a single argument\&.
.RE
.PP
\fB\-\-add \fR\fB\fIFILENAME\fR\fR
.RS 4
If the
\fB\-\-add\fR
option is used following the
\fB\-\-sgml\fR
option, only a single argument, a
\fIFILENAME\fR, is used\&. This is used to add the name of a catalog file to an
SGML
supercatalog, a file that contains references to other included
SGML
catalog files\&.
.RE
.PP
\fB\-\-create\fR
.RS 4
Create a new
XML
catalog\&. Outputs to
stdout, ignoring
\fIfilename\fR
unless
\fB\-\-noout\fR
is used, in which case it creates a new catalog file
\fIfilename\fR\&.
.RE
.PP
\fB\-\-del \fR\fB\fIVALUE(S)\fR\fR
.RS 4
Remove entries from
\fICATALOGFILE\fR
matching
\fIVALUE(S)\fR\&. The
\fB\-\-del\fR
option will not overwrite
\fICATALOGFILE\fR, outputting to
stdout, unless
\fB\-\-noout\fR
is used\&.
.RE
.PP
\fB\-\-noout\fR
.RS 4
Save output to the named file rather than outputting to
stdout\&.
.RE
.PP
\fB\-\-no\-super\-update\fR
.RS 4
Do not update the
SGML
super catalog\&.
.RE
.PP
\fB\-\-shell\fR
.RS 4
Run a shell allowing interactive queries on catalog file
\fICATALOGFILE\fR\&. For the set of available commands see
the section called \(lqSHELL COMMANDS\(rq\&.
.RE
.PP
\fB\-\-sgml\fR
.RS 4
Uses
SGML
super catalogs for
\fB\-\-add\fR
and
\fB\-\-del\fR
options\&.
.RE
.PP
\fB\-v\fR, \fB\-\-verbose\fR
.RS 4
Output debugging information\&.
.RE
.PP
Invoking
\fBxmlcatalog\fR
non\-interactively without a designated action (imposed with options like
\fB\-\-add\fR) will result in a lookup of the catalog entry for
\fIENTITIES\fR
in the catalog denoted with
\fICATALOGFILE\fR\&. The corresponding entries will be output to the command line\&. This mode of operation, together with
\fB\-\-shell\fR
mode and non\-modifying (i\&.e\&. without
\fB\-\-noout\fR) direct actions, allows for a special shortcut of the void
\fICATALOGFILE\fR
specification (possibly expressed as "" in the shell environment) appointing the default system catalog\&. That simplifies the handling when its exact location is irrelevant but the respective built\-in still needs to be consulted\&.
.SH "SHELL COMMANDS"
.PP
Invoking
\fBxmlcatalog\fR
with the
\fB\-\-shell \fR\fB\fICATALOGFILE\fR\fR
option opens a command line shell allowing interactive access to the catalog file identified by
\fICATALOGFILE\fR\&. Invoking the shell provides a command line prompt after which the following commands (described in alphabetical order) can be entered\&.
.PP
\fBadd \fR\fB\fITYPE\fR\fR\fB \fR\fB\fIORIG\fR\fR\fB \fR\fB\fIREPLACE\fR\fR\fB \fR
.RS 4
Add an entry to the catalog file\&.
\fITYPE\fR
indicates the type of entry\&. Possible types are:
\fIpublic\fR, \fIsystem\fR, \fIuri\fR, \fIrewriteSystem\fR, \fIrewriteURI\fR, \fIdelegatePublic\fR, \fIdelegateSystem\fR, \fIdelegateURI\fR, \fInextCatalog\fR\&.
\fIORIG\fR
is the original reference to be replaced, and
\fIREPLACE\fR
is the
URI
of the replacement entity to be used\&. The
\fB\-\-add\fR
option will not overwrite
CATALOGFILE, outputting to
stdout, unless
\fB\-\-noout\fR
is used\&. The
\fB\-\-add\fR
will always take three parameters even if some of the
XML
catalog constructs will have only a single argument\&.
.RE
.PP
\fBdebug\fR
.RS 4
Print debugging statements showing the steps
\fBxmlcatalog\fR
is executing\&.
.RE
.PP
\fBdel \fR\fB\fIVALUE(S)\fR\fR
.RS 4
Remove the catalog entry corresponding to
\fIVALUE(S)\fR\&.
.RE
.PP
\fBdump\fR
.RS 4
Print the current catalog\&.
.RE
.PP
\fBexit\fR
.RS 4
Quit the shell\&.
.RE
.PP
\fBpublic \fR\fB\fIPUBLIC\-ID\fR\fR
.RS 4
Execute a Formal Public Identifier lookup of the catalog entry for
\fIPUBLIC\-ID\fR\&. The corresponding entry will be output to the command line\&.
.RE
.PP
\fBquiet\fR
.RS 4
Stop printing debugging statements\&.
.RE
.PP
\fBsystem \fR\fB\fISYSTEM\-ID\fR\fR
.RS 4
Execute a Formal Public Identifier lookup of the catalog entry for
\fISYSTEM\-ID\fR\&. The corresponding entry will be output to the command line\&.
.RE
.SH "ENVIRONMENT"
.PP
\fBXML_CATALOG_FILES\fR
.RS 4
XML
catalog behavior can be changed by redirecting queries to the user\*(Aqs own set of catalogs\&. This can be done by setting the
\fBXML_CATALOG_FILES\fR
environment variable to a space\-separated list of catalogs\&. Use percent\-encoding to escape spaces or other characters\&. An empty variable should deactivate loading the default
/etc/xml/catalog
catalog\&.
.RE
.SH "DIAGNOSTICS"
.PP
\fBxmlcatalog\fR
return codes provide information that can be used when calling it from scripts\&.
.PP
\fB0\fR
.RS 4
No error
.RE
.PP
\fB1\fR
.RS 4
Failed to remove an entry from the catalog
.RE
.PP
\fB2\fR
.RS 4
Failed to save to the catalog, check file permissions
.RE
.PP
\fB3\fR
.RS 4
Failed to add an entry to the catalog
.RE
.PP
\fB4\fR
.RS 4
Failed to look up an entry in the catalog
.RE
.SH "SEE ALSO"
.PP
\fBlibxml\fR(3)
.PP
More information can be found at
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
\fBlibxml\fR(3)
web page
\m[blue]\fB\%https://gitlab.gnome.org/GNOME/libxml2\fR\m[]
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
\fBlibxml\fR(3)
catalog support web page at
\m[blue]\fB\%https://gitlab.gnome.org/GNOME/libxml2/-/wikis/Catalog-support\fR\m[]
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
James Clark\*(Aqs
SGML
catalog page
\m[blue]\fB\%http://www.jclark.com/sp/catalog.htm\fR\m[]
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
OASIS
XML
catalog specification
\m[blue]\fB\%http://www.oasis-open.org/committees/entity/spec.html\fR\m[]
.RE
.sp
.SH "AUTHOR"
.PP
\fBJohn Fleck\fR <\&jfleck@inkstain\&.net\&>
.RS 4
Author.
.RE
.SH "COPYRIGHT"
.br
Copyright \(co 2001, 2004
.br
'\" t
.\" Title: xmllint
.\" Author: John Fleck <jfleck@inkstain.net>
.\" Generator: DocBook XSL Stylesheets v1.79.1 <http://docbook.sf.net/>
.\" Date: 08/17/2022
.\" Manual: xmllint Manual
.\" Source: libxml2
.\" Language: English
.\"
.TH "XMLLINT" "1" "08/17/2022" "libxml2" "xmllint Manual"
.\" -----------------------------------------------------------------
.\" * Define some portability stuff
.\" -----------------------------------------------------------------
.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.\" http://bugs.debian.org/507673
.\" http://lists.gnu.org/archive/html/groff/2009-02/msg00013.html
.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.ie \n(.g .ds Aq \(aq
.el .ds Aq '
.\" -----------------------------------------------------------------
.\" * set default formatting
.\" -----------------------------------------------------------------
.\" disable hyphenation
.nh
.\" disable justification (adjust text to left margin only)
.ad l
.\" -----------------------------------------------------------------
.\" * MAIN CONTENT STARTS HERE *
.\" -----------------------------------------------------------------
.SH "NAME"
xmllint \- command line XML tool
.SH "SYNOPSIS"
.HP \w'\fBxmllint\fR\ 'u
\fBxmllint\fR [\fB\-\-version\fR | \fB\-\-debug\fR | \fB\-\-shell\fR | \fB\-\-xpath\ "\fR\fB\fIXPath_expression\fR\fR\fB"\fR | \fB\-\-debugent\fR | \fB\-\-copy\fR | \fB\-\-recover\fR | \fB\-\-noent\fR | \fB\-\-noout\fR | \fB\-\-nonet\fR | \fB\-\-path\ "\fR\fB\fIPATH(S)\fR\fR\fB"\fR | \fB\-\-load\-trace\fR | \fB\-\-htmlout\fR | \fB\-\-nowrap\fR | \fB\-\-valid\fR | \fB\-\-postvalid\fR | \fB\-\-dtdvalid\ \fR\fB\fIURL\fR\fR | \fB\-\-dtdvalidfpi\ \fR\fB\fIFPI\fR\fR | \fB\-\-timing\fR | \fB\-\-output\ \fR\fB\fIFILE\fR\fR | \fB\-\-repeat\fR | \fB\-\-insert\fR | \fB\-\-compress\fR | \fB\-\-html\fR | \fB\-\-xmlout\fR | \fB\-\-push\fR | \fB\-\-memory\fR | \fB\-\-maxmem\ \fR\fB\fINBBYTES\fR\fR | \fB\-\-nowarning\fR | \fB\-\-noblanks\fR | \fB\-\-nocdata\fR | \fB\-\-format\fR | \fB\-\-encode\ \fR\fB\fIENCODING\fR\fR | \fB\-\-dropdtd\fR | \fB\-\-nsclean\fR | \fB\-\-testIO\fR | \fB\-\-catalogs\fR | \fB\-\-nocatalogs\fR | \fB\-\-auto\fR | \fB\-\-xinclude\fR | \fB\-\-noxincludenode\fR | \fB\-\-loaddtd\fR | \fB\-\-dtdattr\fR | \fB\-\-stream\fR | \fB\-\-walker\fR | \fB\-\-pattern\ \fR\fB\fIPATTERNVALUE\fR\fR | \fB\-\-chkregister\fR | \fB\-\-relaxng\ \fR\fB\fISCHEMA\fR\fR | \fB\-\-schema\ \fR\fB\fISCHEMA\fR\fR | \fB\-\-c14n\fR] {\fIXML\-FILE(S)\fR... | \-}
.HP \w'\fBxmllint\fR\ 'u
\fBxmllint\fR \fB\-\-help\fR
.SH "DESCRIPTION"
.PP
The
\fBxmllint\fR
program parses one or more
XML
files, specified on the command line as
\fIXML\-FILE\fR
(or the standard input if the filename provided is
\fB\-\fR
)\&. It prints various types of output, depending upon the options selected\&. It is useful for detecting errors both in
XML
code and in the
XML
parser itself\&.
.PP
\fBxmllint\fR
is included in
\fBlibxml\fR(3)\&.
.SH "OPTIONS"
.PP
\fBxmllint\fR
accepts the following options (in alphabetical order):
.PP
\fB\-\-auto\fR
.RS 4
Generate a small document for testing purposes\&.
.RE
.PP
\fB\-\-catalogs\fR
.RS 4
Use the
SGML
catalog(s) from
\fBSGML_CATALOG_FILES\fR\&. Otherwise
XML
catalogs starting from
/etc/xml/catalog
are used by default\&.
.RE
.PP
\fB\-\-chkregister\fR
.RS 4
Turn on node registration\&. Useful for developers testing
\fBlibxml\fR(3)
node tracking code\&.
.RE
.PP
\fB\-\-compress\fR
.RS 4
Turn on
\fBgzip\fR(1)
compression of output\&.
.RE
.PP
\fB\-\-copy\fR
.RS 4
Test the internal copy implementation\&.
.RE
.PP
\fB\-\-c14n\fR
.RS 4
Use the W3C
XML
Canonicalisation (C14N) to serialize the result of parsing to
stdout\&. It keeps comments in the result\&.
.RE
.PP
\fB\-\-dtdvalid \fR\fB\fIURL\fR\fR
.RS 4
Use the
DTD
specified by an
\fIURL\fR
for validation\&.
.RE
.PP
\fB\-\-dtdvalidfpi \fR\fB\fIFPI\fR\fR
.RS 4
Use the
DTD
specified by a Formal Public Identifier
\fIFPI\fR
for validation, note that this will require a catalog exporting that Formal Public Identifier to work\&.
.RE
.PP
\fB\-\-debug\fR
.RS 4
Parse a file and output an annotated tree of the in\-memory version of the document\&.
.RE
.PP
\fB\-\-debugent\fR
.RS 4
Debug the entities defined in the document\&.
.RE
.PP
\fB\-\-dropdtd\fR
.RS 4
Remove
DTD
from output\&.
.RE
.PP
\fB\-\-dtdattr\fR
.RS 4
Fetch external
DTD
and populate the tree with inherited attributes\&.
.RE
.PP
\fB\-\-encode \fR\fB\fIENCODING\fR\fR
.RS 4
Output in the given encoding\&. Note that this works for full document not fragments or result from XPath queries\&.
.RE
.PP
\fB\-\-format\fR
.RS 4
Reformat and reindent the output\&. The
\fBXMLLINT_INDENT\fR
environment variable controls the indentation\&. The default value is two spaces " ")\&.
.RE
.PP
\fB\-\-help\fR
.RS 4
Print out a short usage summary for
\fBxmllint\fR\&.
.RE
.PP
\fB\-\-html\fR
.RS 4
Use the
HTML
parser\&.
.RE
.PP
\fB\-\-htmlout\fR
.RS 4
Output results as an
HTML
file\&. This causes
\fBxmllint\fR
to output the necessary
HTML
tags surrounding the result tree output so the results can be displayed/viewed in a browser\&.
.RE
.PP
\fB\-\-insert\fR
.RS 4
Test for valid insertions\&.
.RE
.PP
\fB\-\-loaddtd\fR
.RS 4
Fetch an external
DTD\&.
.RE
.PP
\fB\-\-load\-trace\fR
.RS 4
Display all the documents loaded during the processing to
stderr\&.
.RE
.PP
\fB\-\-maxmem \fR\fB\fINNBYTES\fR\fR
.RS 4
Test the parser memory support\&.
\fINNBYTES\fR
is the maximum number of bytes the library is allowed to allocate\&. This can also be used to make sure batch processing of
XML
files will not exhaust the virtual memory of the server running them\&.
.RE
.PP
\fB\-\-memory\fR
.RS 4
Parse from memory\&.
.RE
.PP
\fB\-\-noblanks\fR
.RS 4
Drop ignorable blank spaces\&.
.RE
.PP
\fB\-\-nocatalogs\fR
.RS 4
Do not use any catalogs\&.
.RE
.PP
\fB\-\-nocdata\fR
.RS 4
Substitute CDATA section by equivalent text nodes\&.
.RE
.PP
\fB\-\-noent\fR
.RS 4
Substitute entity values for entity references\&. By default,
\fBxmllint\fR
leaves entity references in place\&.
.RE
.PP
\fB\-\-nonet\fR
.RS 4
Do not use the Internet to fetch
DTDs or entities\&.
.RE
.PP
\fB\-\-noout\fR
.RS 4
Suppress output\&. By default,
\fBxmllint\fR
outputs the result tree\&.
.RE
.PP
\fB\-\-nowarning\fR
.RS 4
Do not emit warnings from the parser and/or validator\&.
.RE
.PP
\fB\-\-nowrap\fR
.RS 4
Do not output
HTML
doc wrapper\&.
.RE
.PP
\fB\-\-noxincludenode\fR
.RS 4
Do XInclude processing but do not generate XInclude start and end nodes\&.
.RE
.PP
\fB\-\-nsclean\fR
.RS 4
Remove redundant namespace declarations\&.
.RE
.PP
\fB\-\-output \fR\fB\fIFILE\fR\fR
.RS 4
Define a file path where
\fBxmllint\fR
will save the result of parsing\&. Usually the programs build a tree and save it on
stdout, with this option the result
XML
instance will be saved onto a file\&.
.RE
.PP
\fB\-\-path "\fR\fB\fIPATH(S)\fR\fR\fB"\fR
.RS 4
Use the (space\- or colon\-separated) list of filesystem paths specified by
\fIPATHS\fR
to load
DTDs or entities\&. Enclose space\-separated lists by quotation marks\&.
.RE
.PP
\fB\-\-pattern \fR\fB\fIPATTERNVALUE\fR\fR
.RS 4
Used to exercise the pattern recognition engine, which can be used with the reader interface to the parser\&. It allows to select some nodes in the document based on an XPath (subset) expression\&. Used for debugging\&.
.RE
.PP
\fB\-\-postvalid\fR
.RS 4
Validate after parsing has completed\&.
.RE
.PP
\fB\-\-push\fR
.RS 4
Use the push mode of the parser\&.
.RE
.PP
\fB\-\-recover\fR
.RS 4
Output any parsable portions of an invalid document\&.
.RE
.PP
\fB\-\-relaxng \fR\fB\fISCHEMA\fR\fR
.RS 4
Use RelaxNG file named
\fISCHEMA\fR
for validation\&.
.RE
.PP
\fB\-\-repeat\fR
.RS 4
Repeat 100 times, for timing or profiling\&.
.RE
.PP
\fB\-\-schema \fR\fB\fISCHEMA\fR\fR
.RS 4
Use a W3C
XML
Schema file named
\fISCHEMA\fR
for validation\&.
.RE
.PP
\fB\-\-shell\fR
.RS 4
Run a navigating shell\&. Details on available commands in shell mode are below (see
the section called \(lqSHELL COMMANDS\(rq)\&.
.RE
.PP
\fB\-\-xpath "\fR\fB\fIXPath_expression\fR\fR\fB"\fR
.RS 4
Run an XPath expression given as argument and print the result\&. In case of a nodeset result, each node in the node set is serialized in full in the output\&. In case of an empty node set the "XPath set is empty" result will be shown and an error exit code will be returned\&.
.RE
.PP
\fB\-\-stream\fR
.RS 4
Use streaming
API
\- useful when used in combination with
\fB\-\-relaxng\fR
or
\fB\-\-valid\fR
options for validation of files that are too large to be held in memory\&.
.RE
.PP
\fB\-\-testIO\fR
.RS 4
Test user input/output support\&.
.RE
.PP
\fB\-\-timing\fR
.RS 4
Output information about the time it takes
\fBxmllint\fR
to perform the various steps\&.
.RE
.PP
\fB\-\-valid\fR
.RS 4
Determine if the document is a valid instance of the included Document Type Definition (DTD)\&. A
DTD
to be validated against also can be specified at the command line using the
\fB\-\-dtdvalid\fR
option\&. By default,
\fBxmllint\fR
also checks to determine if the document is well\-formed\&.
.RE
.PP
\fB\-\-version\fR
.RS 4
Display the version of
\fBlibxml\fR(3)
used\&.
.RE
.PP
\fB\-\-walker\fR
.RS 4
Test the walker module, which is a reader interface but for a document tree, instead of using the reader
API
on an unparsed document it works on an existing in\-memory tree\&. Used for debugging\&.
.RE
.PP
\fB\-\-xinclude\fR
.RS 4
Do XInclude processing\&.
.RE
.PP
\fB\-\-xmlout\fR
.RS 4
Used in conjunction with
\fB\-\-html\fR\&. Usually when
HTML
is parsed the document is saved with the
HTML
serializer\&. But with this option the resulting document is saved with the
XML
serializer\&. This is primarily used to generate
XHTML
from
HTML
input\&.
.RE
.SH "SHELL COMMANDS"
.PP
\fBxmllint\fR
offers an interactive shell mode invoked with the
\fB\-\-shell\fR
command\&. Available commands in shell mode include (in alphabetical order):
.PP
\fBbase\fR
.RS 4
Display
XML
base of the node\&.
.RE
.PP
\fBbye\fR
.RS 4
Leave the shell\&.
.RE
.PP
\fBcat \fR\fB\fINODE\fR\fR
.RS 4
Display the given node or the current one\&.
.RE
.PP
\fBcd \fR\fB\fIPATH\fR\fR
.RS 4
Change the current node to the given path (if unique) or root if no argument is given\&.
.RE
.PP
\fBdir \fR\fB\fIPATH\fR\fR
.RS 4
Dumps information about the node (namespace, attributes, content)\&.
.RE
.PP
\fBdu \fR\fB\fIPATH\fR\fR
.RS 4
Show the structure of the subtree under the given path or the current node\&.
.RE
.PP
\fBexit\fR
.RS 4
Leave the shell\&.
.RE
.PP
\fBhelp\fR
.RS 4
Show this help\&.
.RE
.PP
\fBfree\fR
.RS 4
Display memory usage\&.
.RE
.PP
\fBload \fR\fB\fIFILENAME\fR\fR
.RS 4
Load a new document with the given filename\&.
.RE
.PP
\fBls \fR\fB\fIPATH\fR\fR
.RS 4
List contents of the given path or the current directory\&.
.RE
.PP
\fBpwd\fR
.RS 4
Display the path to the current node\&.
.RE
.PP
\fBquit\fR
.RS 4
Leave the shell\&.
.RE
.PP
\fBsave \fR\fB\fIFILENAME\fR\fR
.RS 4
Save the current document to the given filename or to the original name\&.
.RE
.PP
\fBvalidate\fR
.RS 4
Check the document for errors\&.
.RE
.PP
\fBwrite \fR\fB\fIFILENAME\fR\fR
.RS 4
Write the current node to the given filename\&.
.RE
.SH "ENVIRONMENT"
.PP
\fBSGML_CATALOG_FILES\fR
.RS 4
SGML
catalog behavior can be changed by redirecting queries to the user\*(Aqs own set of catalogs\&. This can be done by setting the
\fBSGML_CATALOG_FILES\fR
environment variable to a list of catalogs\&. An empty one should deactivate loading the default
/etc/sgml/catalog
catalog\&.
.RE
.PP
\fBXML_CATALOG_FILES\fR
.RS 4
XML
catalog behavior can be changed by redirecting queries to the user\*(Aqs own set of catalogs\&. This can be done by setting the
\fBXML_CATALOG_FILES\fR
environment variable to a space\-separated list of catalogs\&. Use percent\-encoding to escape spaces or other characters\&. An empty variable should deactivate loading the default
/etc/xml/catalog
catalog\&.
.RE
.PP
\fBXML_DEBUG_CATALOG\fR
.RS 4
Setting the environment variable
\fBXML_DEBUG_CATALOG\fR
to
\fInon\-zero\fR
using the
\fBexport\fR
command outputs debugging information related to catalog operations\&.
.RE
.PP
\fBXMLLINT_INDENT\fR
.RS 4
Setting the environment variable
\fBXMLLINT_INDENT\fR
controls the indentation\&. The default value is two spaces " "\&.
.RE
.SH "DIAGNOSTICS"
.PP
\fBxmllint\fR
return codes provide information that can be used when calling it from scripts\&.
.PP
\fB0\fR
.RS 4
No error
.RE
.PP
\fB1\fR
.RS 4
Unclassified
.RE
.PP
\fB2\fR
.RS 4
Error in
DTD
.RE
.PP
\fB3\fR
.RS 4
Validation error
.RE
.PP
\fB4\fR
.RS 4
Validation error
.RE
.PP
\fB5\fR
.RS 4
Error in schema compilation
.RE
.PP
\fB6\fR
.RS 4
Error writing output
.RE
.PP
\fB7\fR
.RS 4
Error in pattern (generated when
\fB\-\-pattern\fR
option is used)
.RE
.PP
\fB8\fR
.RS 4
Error in Reader registration (generated when
\fB\-\-chkregister\fR
option is used)
.RE
.PP
\fB9\fR
.RS 4
Out of memory error
.RE
.PP
\fB10\fR
.RS 4
XPath evaluation error
.RE
.SH "SEE ALSO"
.PP
\fBlibxml\fR(3)
.PP
More information can be found at
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
\fBlibxml\fR(3)
web page
\m[blue]\fB\%https://gitlab.gnome.org/GNOME/libxml2\fR\m[]
.RE
.sp
.SH "AUTHORS"
.PP
\fBJohn Fleck\fR <\&jfleck@inkstain\&.net\&>
.RS 4
Author.
.RE
.PP
\fBZiying Sherwin\fR <\&sherwin@nlm\&.nih\&.gov\&>
.RS 4
Author.
.RE
.PP
\fBHeiko Rupp\fR <\&hwr@pilhuhn\&.de\&>
.RS 4
Author.
.RE
.SH "COPYRIGHT"
.br
Copyright \(co 2001, 2004
.br
<?xml version="1.0" encoding="UTF-8"?>
<book xmlns="http://www.devhelp.net/book" title="libxml2 Reference Manual" link="index.html" author="" name="libxml2">
<chapters>
<sub name="API" link="general.html">
<sub name="HTMLparser" link="libxml2-HTMLparser.html"/>
<sub name="HTMLtree" link="libxml2-HTMLtree.html"/>
<sub name="SAX" link="libxml2-SAX.html"/>
<sub name="SAX2" link="libxml2-SAX2.html"/>
<sub name="c14n" link="libxml2-c14n.html"/>
<sub name="catalog" link="libxml2-catalog.html"/>
<sub name="chvalid" link="libxml2-chvalid.html"/>
<sub name="debugXML" link="libxml2-debugXML.html"/>
<sub name="dict" link="libxml2-dict.html"/>
<sub name="encoding" link="libxml2-encoding.html"/>
<sub name="entities" link="libxml2-entities.html"/>
<sub name="globals" link="libxml2-globals.html"/>
<sub name="hash" link="libxml2-hash.html"/>
<sub name="list" link="libxml2-list.html"/>
<sub name="nanoftp" link="libxml2-nanoftp.html"/>
<sub name="nanohttp" link="libxml2-nanohttp.html"/>
<sub name="parser" link="libxml2-parser.html"/>
<sub name="parserInternals" link="libxml2-parserInternals.html"/>
<sub name="pattern" link="libxml2-pattern.html"/>
<sub name="relaxng" link="libxml2-relaxng.html"/>
<sub name="schemasInternals" link="libxml2-schemasInternals.html"/>
<sub name="schematron" link="libxml2-schematron.html"/>
<sub name="threads" link="libxml2-threads.html"/>
<sub name="tree" link="libxml2-tree.html"/>
<sub name="uri" link="libxml2-uri.html"/>
<sub name="valid" link="libxml2-valid.html"/>
<sub name="xinclude" link="libxml2-xinclude.html"/>
<sub name="xlink" link="libxml2-xlink.html"/>
<sub name="xmlIO" link="libxml2-xmlIO.html"/>
<sub name="xmlautomata" link="libxml2-xmlautomata.html"/>
<sub name="xmlerror" link="libxml2-xmlerror.html"/>
<sub name="xmlexports" link="libxml2-xmlexports.html"/>
<sub name="xmlmemory" link="libxml2-xmlmemory.html"/>
<sub name="xmlmodule" link="libxml2-xmlmodule.html"/>
<sub name="xmlreader" link="libxml2-xmlreader.html"/>
<sub name="xmlregexp" link="libxml2-xmlregexp.html"/>
<sub name="xmlsave" link="libxml2-xmlsave.html"/>
<sub name="xmlschemas" link="libxml2-xmlschemas.html"/>
<sub name="xmlschemastypes" link="libxml2-xmlschemastypes.html"/>
<sub name="xmlstring" link="libxml2-xmlstring.html"/>
<sub name="xmlunicode" link="libxml2-xmlunicode.html"/>
<sub name="xmlversion" link="libxml2-xmlversion.html"/>
<sub name="xmlwriter" link="libxml2-xmlwriter.html"/>
<sub name="xpath" link="libxml2-xpath.html"/>
<sub name="xpathInternals" link="libxml2-xpathInternals.html"/>
<sub name="xpointer" link="libxml2-xpointer.html"/>
</sub>
</chapters>
<functions>
<keyword type="macro" name="ATTRIBUTE_UNUSED" link="libxml2-xmlversion.html#ATTRIBUTE_UNUSED"/>
<keyword type="macro" name="BAD_CAST" link="libxml2-xmlstring.html#BAD_CAST"/>
<keyword type="macro" name="BASE_BUFFER_SIZE" link="libxml2-tree.html#BASE_BUFFER_SIZE"/>
<keyword type="macro" name="CAST_TO_BOOLEAN" link="libxml2-xpathInternals.html#CAST_TO_BOOLEAN"/>
<keyword type="macro" name="CAST_TO_NUMBER" link="libxml2-xpathInternals.html#CAST_TO_NUMBER"/>
<keyword type="macro" name="CAST_TO_STRING" link="libxml2-xpathInternals.html#CAST_TO_STRING"/>
<keyword type="macro" name="CHECK_ARITY" link="libxml2-xpathInternals.html#CHECK_ARITY"/>
<keyword type="macro" name="CHECK_ERROR" link="libxml2-xpathInternals.html#CHECK_ERROR"/>
<keyword type="macro" name="CHECK_ERROR0" link="libxml2-xpathInternals.html#CHECK_ERROR0"/>
<keyword type="macro" name="CHECK_TYPE" link="libxml2-xpathInternals.html#CHECK_TYPE"/>
<keyword type="macro" name="CHECK_TYPE0" link="libxml2-xpathInternals.html#CHECK_TYPE0"/>
<keyword type="macro" name="DEBUG_MEMORY" link="libxml2-xmlmemory.html#DEBUG_MEMORY"/>
<keyword type="macro" name="DEBUG_MEMORY_LOCATION" link="libxml2-xmlversion.html#DEBUG_MEMORY_LOCATION"/>
<keyword type="macro" name="HTML_COMMENT_NODE" link="libxml2-HTMLtree.html#HTML_COMMENT_NODE"/>
<keyword type="macro" name="HTML_ENTITY_REF_NODE" link="libxml2-HTMLtree.html#HTML_ENTITY_REF_NODE"/>
<keyword type="macro" name="HTML_PI_NODE" link="libxml2-HTMLtree.html#HTML_PI_NODE"/>
<keyword type="macro" name="HTML_PRESERVE_NODE" link="libxml2-HTMLtree.html#HTML_PRESERVE_NODE"/>
<keyword type="macro" name="HTML_TEXT_NODE" link="libxml2-HTMLtree.html#HTML_TEXT_NODE"/>
<keyword type="macro" name="INPUT_CHUNK" link="libxml2-parserInternals.html#INPUT_CHUNK"/>
<keyword type="macro" name="INVALID_SOCKET" link="libxml2-nanoftp.html#INVALID_SOCKET"/>
<keyword type="macro" name="IS_ASCII_DIGIT" link="libxml2-parserInternals.html#IS_ASCII_DIGIT"/>
<keyword type="macro" name="IS_ASCII_LETTER" link="libxml2-parserInternals.html#IS_ASCII_LETTER"/>
<keyword type="macro" name="IS_BASECHAR" link="libxml2-parserInternals.html#IS_BASECHAR"/>
<keyword type="macro" name="IS_BLANK" link="libxml2-parserInternals.html#IS_BLANK"/>
<keyword type="macro" name="IS_BLANK_CH" link="libxml2-parserInternals.html#IS_BLANK_CH"/>
<keyword type="macro" name="IS_BYTE_CHAR" link="libxml2-parserInternals.html#IS_BYTE_CHAR"/>
<keyword type="macro" name="IS_CHAR" link="libxml2-parserInternals.html#IS_CHAR"/>
<keyword type="macro" name="IS_CHAR_CH" link="libxml2-parserInternals.html#IS_CHAR_CH"/>
<keyword type="macro" name="IS_COMBINING" link="libxml2-parserInternals.html#IS_COMBINING"/>
<keyword type="macro" name="IS_COMBINING_CH" link="libxml2-parserInternals.html#IS_COMBINING_CH"/>
<keyword type="macro" name="IS_DIGIT" link="libxml2-parserInternals.html#IS_DIGIT"/>
<keyword type="macro" name="IS_DIGIT_CH" link="libxml2-parserInternals.html#IS_DIGIT_CH"/>
<keyword type="macro" name="IS_EXTENDER" link="libxml2-parserInternals.html#IS_EXTENDER"/>
<keyword type="macro" name="IS_EXTENDER_CH" link="libxml2-parserInternals.html#IS_EXTENDER_CH"/>
<keyword type="macro" name="IS_IDEOGRAPHIC" link="libxml2-parserInternals.html#IS_IDEOGRAPHIC"/>
<keyword type="macro" name="IS_LETTER" link="libxml2-parserInternals.html#IS_LETTER"/>
<keyword type="macro" name="IS_LETTER_CH" link="libxml2-parserInternals.html#IS_LETTER_CH"/>
<keyword type="macro" name="IS_PUBIDCHAR" link="libxml2-parserInternals.html#IS_PUBIDCHAR"/>
<keyword type="macro" name="IS_PUBIDCHAR_CH" link="libxml2-parserInternals.html#IS_PUBIDCHAR_CH"/>
<keyword type="macro" name="LIBXML2_NEW_BUFFER" link="libxml2-tree.html#LIBXML2_NEW_BUFFER"/>
<keyword type="macro" name="LIBXML_ATTR_ALLOC_SIZE" link="libxml2-xmlversion.html#LIBXML_ATTR_ALLOC_SIZE"/>
<keyword type="macro" name="LIBXML_ATTR_FORMAT" link="libxml2-xmlversion.html#LIBXML_ATTR_FORMAT"/>
<keyword type="macro" name="LIBXML_AUTOMATA_ENABLED" link="libxml2-xmlversion.html#LIBXML_AUTOMATA_ENABLED"/>
<keyword type="macro" name="LIBXML_C14N_ENABLED" link="libxml2-xmlversion.html#LIBXML_C14N_ENABLED"/>
<keyword type="macro" name="LIBXML_CATALOG_ENABLED" link="libxml2-xmlversion.html#LIBXML_CATALOG_ENABLED"/>
<keyword type="macro" name="LIBXML_DEBUG_ENABLED" link="libxml2-xmlversion.html#LIBXML_DEBUG_ENABLED"/>
<keyword type="macro" name="LIBXML_DEBUG_RUNTIME" link="libxml2-xmlversion.html#LIBXML_DEBUG_RUNTIME"/>
<keyword type="macro" name="LIBXML_DLL_IMPORT" link="libxml2-xmlexports.html#LIBXML_DLL_IMPORT"/>
<keyword type="macro" name="LIBXML_DOTTED_VERSION" link="libxml2-xmlversion.html#LIBXML_DOTTED_VERSION"/>
<keyword type="macro" name="LIBXML_EXPR_ENABLED" link="libxml2-xmlversion.html#LIBXML_EXPR_ENABLED"/>
<keyword type="macro" name="LIBXML_FTP_ENABLED" link="libxml2-xmlversion.html#LIBXML_FTP_ENABLED"/>
<keyword type="macro" name="LIBXML_HTML_ENABLED" link="libxml2-xmlversion.html#LIBXML_HTML_ENABLED"/>
<keyword type="macro" name="LIBXML_HTTP_ENABLED" link="libxml2-xmlversion.html#LIBXML_HTTP_ENABLED"/>
<keyword type="macro" name="LIBXML_ICONV_ENABLED" link="libxml2-xmlversion.html#LIBXML_ICONV_ENABLED"/>
<keyword type="macro" name="LIBXML_ICU_ENABLED" link="libxml2-xmlversion.html#LIBXML_ICU_ENABLED"/>
<keyword type="macro" name="LIBXML_ISO8859X_ENABLED" link="libxml2-xmlversion.html#LIBXML_ISO8859X_ENABLED"/>
<keyword type="macro" name="LIBXML_LEGACY_ENABLED" link="libxml2-xmlversion.html#LIBXML_LEGACY_ENABLED"/>
<keyword type="macro" name="LIBXML_LZMA_ENABLED" link="libxml2-xmlversion.html#LIBXML_LZMA_ENABLED"/>
<keyword type="macro" name="LIBXML_MODULES_ENABLED" link="libxml2-xmlversion.html#LIBXML_MODULES_ENABLED"/>
<keyword type="macro" name="LIBXML_MODULE_EXTENSION" link="libxml2-xmlversion.html#LIBXML_MODULE_EXTENSION"/>
<keyword type="macro" name="LIBXML_OUTPUT_ENABLED" link="libxml2-xmlversion.html#LIBXML_OUTPUT_ENABLED"/>
<keyword type="macro" name="LIBXML_PATTERN_ENABLED" link="libxml2-xmlversion.html#LIBXML_PATTERN_ENABLED"/>
<keyword type="macro" name="LIBXML_PUSH_ENABLED" link="libxml2-xmlversion.html#LIBXML_PUSH_ENABLED"/>
<keyword type="macro" name="LIBXML_READER_ENABLED" link="libxml2-xmlversion.html#LIBXML_READER_ENABLED"/>
<keyword type="macro" name="LIBXML_REGEXP_ENABLED" link="libxml2-xmlversion.html#LIBXML_REGEXP_ENABLED"/>
<keyword type="macro" name="LIBXML_SAX1_ENABLED" link="libxml2-xmlversion.html#LIBXML_SAX1_ENABLED"/>
<keyword type="macro" name="LIBXML_SCHEMAS_ENABLED" link="libxml2-xmlversion.html#LIBXML_SCHEMAS_ENABLED"/>
<keyword type="macro" name="LIBXML_SCHEMATRON_ENABLED" link="libxml2-xmlversion.html#LIBXML_SCHEMATRON_ENABLED"/>
<keyword type="macro" name="LIBXML_TEST_VERSION" link="libxml2-xmlversion.html#LIBXML_TEST_VERSION"/>
<keyword type="macro" name="LIBXML_THREAD_ALLOC_ENABLED" link="libxml2-xmlversion.html#LIBXML_THREAD_ALLOC_ENABLED"/>
<keyword type="macro" name="LIBXML_THREAD_ENABLED" link="libxml2-xmlversion.html#LIBXML_THREAD_ENABLED"/>
<keyword type="macro" name="LIBXML_TREE_ENABLED" link="libxml2-xmlversion.html#LIBXML_TREE_ENABLED"/>
<keyword type="macro" name="LIBXML_UNICODE_ENABLED" link="libxml2-xmlversion.html#LIBXML_UNICODE_ENABLED"/>
<keyword type="macro" name="LIBXML_VALID_ENABLED" link="libxml2-xmlversion.html#LIBXML_VALID_ENABLED"/>
<keyword type="macro" name="LIBXML_VERSION" link="libxml2-xmlversion.html#LIBXML_VERSION"/>
<keyword type="macro" name="LIBXML_VERSION_EXTRA" link="libxml2-xmlversion.html#LIBXML_VERSION_EXTRA"/>
<keyword type="macro" name="LIBXML_VERSION_STRING" link="libxml2-xmlversion.html#LIBXML_VERSION_STRING"/>
<keyword type="macro" name="LIBXML_WRITER_ENABLED" link="libxml2-xmlversion.html#LIBXML_WRITER_ENABLED"/>
<keyword type="macro" name="LIBXML_XINCLUDE_ENABLED" link="libxml2-xmlversion.html#LIBXML_XINCLUDE_ENABLED"/>
<keyword type="macro" name="LIBXML_XPATH_ENABLED" link="libxml2-xmlversion.html#LIBXML_XPATH_ENABLED"/>
<keyword type="macro" name="LIBXML_XPTR_ENABLED" link="libxml2-xmlversion.html#LIBXML_XPTR_ENABLED"/>
<keyword type="macro" name="LIBXML_XPTR_LOCS_ENABLED" link="libxml2-xmlversion.html#LIBXML_XPTR_LOCS_ENABLED"/>
<keyword type="macro" name="LIBXML_ZLIB_ENABLED" link="libxml2-xmlversion.html#LIBXML_ZLIB_ENABLED"/>
<keyword type="macro" name="MOVETO_ENDTAG" link="libxml2-parserInternals.html#MOVETO_ENDTAG"/>
<keyword type="macro" name="MOVETO_STARTTAG" link="libxml2-parserInternals.html#MOVETO_STARTTAG"/>
<keyword type="macro" name="SKIP_EOL" link="libxml2-parserInternals.html#SKIP_EOL"/>
<keyword type="macro" name="SOCKET" link="libxml2-nanoftp.html#SOCKET"/>
<keyword type="macro" name="WITHOUT_TRIO" link="libxml2-xmlversion.html#WITHOUT_TRIO"/>
<keyword type="macro" name="WITH_TRIO" link="libxml2-xmlversion.html#WITH_TRIO"/>
<keyword type="macro" name="XINCLUDE_FALLBACK" link="libxml2-xinclude.html#XINCLUDE_FALLBACK"/>
<keyword type="macro" name="XINCLUDE_HREF" link="libxml2-xinclude.html#XINCLUDE_HREF"/>
<keyword type="macro" name="XINCLUDE_NODE" link="libxml2-xinclude.html#XINCLUDE_NODE"/>
<keyword type="macro" name="XINCLUDE_NS" link="libxml2-xinclude.html#XINCLUDE_NS"/>
<keyword type="macro" name="XINCLUDE_OLD_NS" link="libxml2-xinclude.html#XINCLUDE_OLD_NS"/>
<keyword type="macro" name="XINCLUDE_PARSE" link="libxml2-xinclude.html#XINCLUDE_PARSE"/>
<keyword type="macro" name="XINCLUDE_PARSE_ENCODING" link="libxml2-xinclude.html#XINCLUDE_PARSE_ENCODING"/>
<keyword type="macro" name="XINCLUDE_PARSE_TEXT" link="libxml2-xinclude.html#XINCLUDE_PARSE_TEXT"/>
<keyword type="macro" name="XINCLUDE_PARSE_XML" link="libxml2-xinclude.html#XINCLUDE_PARSE_XML"/>
<keyword type="macro" name="XINCLUDE_PARSE_XPOINTER" link="libxml2-xinclude.html#XINCLUDE_PARSE_XPOINTER"/>
<keyword type="macro" name="XMLCALL" link="libxml2-xmlexports.html#XMLCALL"/>
<keyword type="macro" name="XMLCDECL" link="libxml2-xmlexports.html#XMLCDECL"/>
<keyword type="macro" name="XMLPUBFUN" link="libxml2-xmlexports.html#XMLPUBFUN"/>
<keyword type="macro" name="XMLPUBLIC" link="libxml2-xmlexports.html#XMLPUBLIC"/>
<keyword type="macro" name="XMLPUBVAR" link="libxml2-xmlexports.html#XMLPUBVAR"/>
<keyword type="macro" name="XML_CAST_FPTR" link="libxml2-hash.html#XML_CAST_FPTR"/>
<keyword type="macro" name="XML_CATALOGS_NAMESPACE" link="libxml2-catalog.html#XML_CATALOGS_NAMESPACE"/>
<keyword type="macro" name="XML_CATALOG_PI" link="libxml2-catalog.html#XML_CATALOG_PI"/>
<keyword type="macro" name="XML_COMPLETE_ATTRS" link="libxml2-parser.html#XML_COMPLETE_ATTRS"/>
<keyword type="macro" name="XML_DEFAULT_VERSION" link="libxml2-parser.html#XML_DEFAULT_VERSION"/>
<keyword type="macro" name="XML_DEPRECATED" link="libxml2-xmlversion.html#XML_DEPRECATED"/>
<keyword type="macro" name="XML_DETECT_IDS" link="libxml2-parser.html#XML_DETECT_IDS"/>
<keyword type="macro" name="XML_DOCB_DOCUMENT_NODE" link="libxml2-tree.html#XML_DOCB_DOCUMENT_NODE"/>
<keyword type="macro" name="XML_GET_CONTENT" link="libxml2-tree.html#XML_GET_CONTENT"/>
<keyword type="macro" name="XML_GET_LINE" link="libxml2-tree.html#XML_GET_LINE"/>
<keyword type="macro" name="XML_LOCAL_NAMESPACE" link="libxml2-tree.html#XML_LOCAL_NAMESPACE"/>
<keyword type="macro" name="XML_MAX_DICTIONARY_LIMIT" link="libxml2-parserInternals.html#XML_MAX_DICTIONARY_LIMIT"/>
<keyword type="macro" name="XML_MAX_LOOKUP_LIMIT" link="libxml2-parserInternals.html#XML_MAX_LOOKUP_LIMIT"/>
<keyword type="macro" name="XML_MAX_NAMELEN" link="libxml2-parserInternals.html#XML_MAX_NAMELEN"/>
<keyword type="macro" name="XML_MAX_NAME_LENGTH" link="libxml2-parserInternals.html#XML_MAX_NAME_LENGTH"/>
<keyword type="macro" name="XML_MAX_TEXT_LENGTH" link="libxml2-parserInternals.html#XML_MAX_TEXT_LENGTH"/>
<keyword type="macro" name="XML_SAX2_MAGIC" link="libxml2-parser.html#XML_SAX2_MAGIC"/>
<keyword type="macro" name="XML_SCHEMAS_ANYATTR_LAX" link="libxml2-schemasInternals.html#XML_SCHEMAS_ANYATTR_LAX"/>
<keyword type="macro" name="XML_SCHEMAS_ANYATTR_SKIP" link="libxml2-schemasInternals.html#XML_SCHEMAS_ANYATTR_SKIP"/>
<keyword type="macro" name="XML_SCHEMAS_ANYATTR_STRICT" link="libxml2-schemasInternals.html#XML_SCHEMAS_ANYATTR_STRICT"/>
<keyword type="macro" name="XML_SCHEMAS_ANY_LAX" link="libxml2-schemasInternals.html#XML_SCHEMAS_ANY_LAX"/>
<keyword type="macro" name="XML_SCHEMAS_ANY_SKIP" link="libxml2-schemasInternals.html#XML_SCHEMAS_ANY_SKIP"/>
<keyword type="macro" name="XML_SCHEMAS_ANY_STRICT" link="libxml2-schemasInternals.html#XML_SCHEMAS_ANY_STRICT"/>
<keyword type="macro" name="XML_SCHEMAS_ATTRGROUP_GLOBAL" link="libxml2-schemasInternals.html#XML_SCHEMAS_ATTRGROUP_GLOBAL"/>
<keyword type="macro" name="XML_SCHEMAS_ATTRGROUP_HAS_REFS" link="libxml2-schemasInternals.html#XML_SCHEMAS_ATTRGROUP_HAS_REFS"/>
<keyword type="macro" name="XML_SCHEMAS_ATTRGROUP_MARKED" link="libxml2-schemasInternals.html#XML_SCHEMAS_ATTRGROUP_MARKED"/>
<keyword type="macro" name="XML_SCHEMAS_ATTRGROUP_REDEFINED" link="libxml2-schemasInternals.html#XML_SCHEMAS_ATTRGROUP_REDEFINED"/>
<keyword type="macro" name="XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED" link="libxml2-schemasInternals.html#XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED"/>
<keyword type="macro" name="XML_SCHEMAS_ATTR_FIXED" link="libxml2-schemasInternals.html#XML_SCHEMAS_ATTR_FIXED"/>
<keyword type="macro" name="XML_SCHEMAS_ATTR_GLOBAL" link="libxml2-schemasInternals.html#XML_SCHEMAS_ATTR_GLOBAL"/>
<keyword type="macro" name="XML_SCHEMAS_ATTR_INTERNAL_RESOLVED" link="libxml2-schemasInternals.html#XML_SCHEMAS_ATTR_INTERNAL_RESOLVED"/>
<keyword type="macro" name="XML_SCHEMAS_ATTR_NSDEFAULT" link="libxml2-schemasInternals.html#XML_SCHEMAS_ATTR_NSDEFAULT"/>
<keyword type="macro" name="XML_SCHEMAS_ATTR_USE_OPTIONAL" link="libxml2-schemasInternals.html#XML_SCHEMAS_ATTR_USE_OPTIONAL"/>
<keyword type="macro" name="XML_SCHEMAS_ATTR_USE_PROHIBITED" link="libxml2-schemasInternals.html#XML_SCHEMAS_ATTR_USE_PROHIBITED"/>
<keyword type="macro" name="XML_SCHEMAS_ATTR_USE_REQUIRED" link="libxml2-schemasInternals.html#XML_SCHEMAS_ATTR_USE_REQUIRED"/>
<keyword type="macro" name="XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION" link="libxml2-schemasInternals.html#XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION"/>
<keyword type="macro" name="XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION" link="libxml2-schemasInternals.html#XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION"/>
<keyword type="macro" name="XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION" link="libxml2-schemasInternals.html#XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION"/>
<keyword type="macro" name="XML_SCHEMAS_ELEM_ABSTRACT" link="libxml2-schemasInternals.html#XML_SCHEMAS_ELEM_ABSTRACT"/>
<keyword type="macro" name="XML_SCHEMAS_ELEM_BLOCK_ABSENT" link="libxml2-schemasInternals.html#XML_SCHEMAS_ELEM_BLOCK_ABSENT"/>
<keyword type="macro" name="XML_SCHEMAS_ELEM_BLOCK_EXTENSION" link="libxml2-schemasInternals.html#XML_SCHEMAS_ELEM_BLOCK_EXTENSION"/>
<keyword type="macro" name="XML_SCHEMAS_ELEM_BLOCK_RESTRICTION" link="libxml2-schemasInternals.html#XML_SCHEMAS_ELEM_BLOCK_RESTRICTION"/>
<keyword type="macro" name="XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION" link="libxml2-schemasInternals.html#XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION"/>
<keyword type="macro" name="XML_SCHEMAS_ELEM_CIRCULAR" link="libxml2-schemasInternals.html#XML_SCHEMAS_ELEM_CIRCULAR"/>
<keyword type="macro" name="XML_SCHEMAS_ELEM_DEFAULT" link="libxml2-schemasInternals.html#XML_SCHEMAS_ELEM_DEFAULT"/>
<keyword type="macro" name="XML_SCHEMAS_ELEM_FINAL_ABSENT" link="libxml2-schemasInternals.html#XML_SCHEMAS_ELEM_FINAL_ABSENT"/>
<keyword type="macro" name="XML_SCHEMAS_ELEM_FINAL_EXTENSION" link="libxml2-schemasInternals.html#XML_SCHEMAS_ELEM_FINAL_EXTENSION"/>
<keyword type="macro" name="XML_SCHEMAS_ELEM_FINAL_RESTRICTION" link="libxml2-schemasInternals.html#XML_SCHEMAS_ELEM_FINAL_RESTRICTION"/>
<keyword type="macro" name="XML_SCHEMAS_ELEM_FIXED" link="libxml2-schemasInternals.html#XML_SCHEMAS_ELEM_FIXED"/>
<keyword type="macro" name="XML_SCHEMAS_ELEM_GLOBAL" link="libxml2-schemasInternals.html#XML_SCHEMAS_ELEM_GLOBAL"/>
<keyword type="macro" name="XML_SCHEMAS_ELEM_INTERNAL_CHECKED" link="libxml2-schemasInternals.html#XML_SCHEMAS_ELEM_INTERNAL_CHECKED"/>
<keyword type="macro" name="XML_SCHEMAS_ELEM_INTERNAL_RESOLVED" link="libxml2-schemasInternals.html#XML_SCHEMAS_ELEM_INTERNAL_RESOLVED"/>
<keyword type="macro" name="XML_SCHEMAS_ELEM_NILLABLE" link="libxml2-schemasInternals.html#XML_SCHEMAS_ELEM_NILLABLE"/>
<keyword type="macro" name="XML_SCHEMAS_ELEM_NSDEFAULT" link="libxml2-schemasInternals.html#XML_SCHEMAS_ELEM_NSDEFAULT"/>
<keyword type="macro" name="XML_SCHEMAS_ELEM_REF" link="libxml2-schemasInternals.html#XML_SCHEMAS_ELEM_REF"/>
<keyword type="macro" name="XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD" link="libxml2-schemasInternals.html#XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD"/>
<keyword type="macro" name="XML_SCHEMAS_ELEM_TOPLEVEL" link="libxml2-schemasInternals.html#XML_SCHEMAS_ELEM_TOPLEVEL"/>
<keyword type="macro" name="XML_SCHEMAS_FACET_COLLAPSE" link="libxml2-schemasInternals.html#XML_SCHEMAS_FACET_COLLAPSE"/>
<keyword type="macro" name="XML_SCHEMAS_FACET_PRESERVE" link="libxml2-schemasInternals.html#XML_SCHEMAS_FACET_PRESERVE"/>
<keyword type="macro" name="XML_SCHEMAS_FACET_REPLACE" link="libxml2-schemasInternals.html#XML_SCHEMAS_FACET_REPLACE"/>
<keyword type="macro" name="XML_SCHEMAS_FACET_UNKNOWN" link="libxml2-schemasInternals.html#XML_SCHEMAS_FACET_UNKNOWN"/>
<keyword type="macro" name="XML_SCHEMAS_FINAL_DEFAULT_EXTENSION" link="libxml2-schemasInternals.html#XML_SCHEMAS_FINAL_DEFAULT_EXTENSION"/>
<keyword type="macro" name="XML_SCHEMAS_FINAL_DEFAULT_LIST" link="libxml2-schemasInternals.html#XML_SCHEMAS_FINAL_DEFAULT_LIST"/>
<keyword type="macro" name="XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION" link="libxml2-schemasInternals.html#XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION"/>
<keyword type="macro" name="XML_SCHEMAS_FINAL_DEFAULT_UNION" link="libxml2-schemasInternals.html#XML_SCHEMAS_FINAL_DEFAULT_UNION"/>
<keyword type="macro" name="XML_SCHEMAS_INCLUDING_CONVERT_NS" link="libxml2-schemasInternals.html#XML_SCHEMAS_INCLUDING_CONVERT_NS"/>
<keyword type="macro" name="XML_SCHEMAS_QUALIF_ATTR" link="libxml2-schemasInternals.html#XML_SCHEMAS_QUALIF_ATTR"/>
<keyword type="macro" name="XML_SCHEMAS_QUALIF_ELEM" link="libxml2-schemasInternals.html#XML_SCHEMAS_QUALIF_ELEM"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_ABSTRACT" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_ABSTRACT"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_BLOCK_DEFAULT" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_BLOCK_DEFAULT"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_BLOCK_EXTENSION" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_BLOCK_EXTENSION"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_BLOCK_RESTRICTION" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_BLOCK_RESTRICTION"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_FACETSNEEDVALUE" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_FACETSNEEDVALUE"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_FINAL_DEFAULT" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_FINAL_DEFAULT"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_FINAL_EXTENSION" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_FINAL_EXTENSION"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_FINAL_LIST" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_FINAL_LIST"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_FINAL_RESTRICTION" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_FINAL_RESTRICTION"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_FINAL_UNION" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_FINAL_UNION"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_FIXUP_1" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_FIXUP_1"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_GLOBAL" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_GLOBAL"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_HAS_FACETS" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_HAS_FACETS"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_INTERNAL_INVALID" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_INTERNAL_INVALID"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_INTERNAL_RESOLVED" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_INTERNAL_RESOLVED"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_MARKED" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_MARKED"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_MIXED" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_MIXED"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_NORMVALUENEEDED" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_NORMVALUENEEDED"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_REDEFINED" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_REDEFINED"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_VARIETY_ABSENT" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_VARIETY_ABSENT"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_VARIETY_ATOMIC" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_VARIETY_ATOMIC"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_VARIETY_LIST" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_VARIETY_LIST"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_VARIETY_UNION" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_VARIETY_UNION"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE"/>
<keyword type="macro" name="XML_SCHEMAS_TYPE_WHITESPACE_REPLACE" link="libxml2-schemasInternals.html#XML_SCHEMAS_TYPE_WHITESPACE_REPLACE"/>
<keyword type="macro" name="XML_SCHEMAS_WILDCARD_COMPLETE" link="libxml2-schemasInternals.html#XML_SCHEMAS_WILDCARD_COMPLETE"/>
<keyword type="macro" name="XML_SKIP_IDS" link="libxml2-parser.html#XML_SKIP_IDS"/>
<keyword type="macro" name="XML_SUBSTITUTE_BOTH" link="libxml2-parserInternals.html#XML_SUBSTITUTE_BOTH"/>
<keyword type="macro" name="XML_SUBSTITUTE_NONE" link="libxml2-parserInternals.html#XML_SUBSTITUTE_NONE"/>
<keyword type="macro" name="XML_SUBSTITUTE_PEREF" link="libxml2-parserInternals.html#XML_SUBSTITUTE_PEREF"/>
<keyword type="macro" name="XML_SUBSTITUTE_REF" link="libxml2-parserInternals.html#XML_SUBSTITUTE_REF"/>
<keyword type="macro" name="XML_VCTXT_DTD_VALIDATED" link="libxml2-valid.html#XML_VCTXT_DTD_VALIDATED"/>
<keyword type="macro" name="XML_VCTXT_USE_PCTXT" link="libxml2-valid.html#XML_VCTXT_USE_PCTXT"/>
<keyword type="macro" name="XML_XML_ID" link="libxml2-tree.html#XML_XML_ID"/>
<keyword type="macro" name="XML_XML_NAMESPACE" link="libxml2-tree.html#XML_XML_NAMESPACE"/>
<keyword type="macro" name="XML_XPATH_CHECKNS" link="libxml2-xpath.html#XML_XPATH_CHECKNS"/>
<keyword type="macro" name="XML_XPATH_NOVAR" link="libxml2-xpath.html#XML_XPATH_NOVAR"/>
<keyword type="macro" name="XPATH_LOCATIONSET" link="libxml2-xpath.html#XPATH_LOCATIONSET"/>
<keyword type="macro" name="XPATH_POINT" link="libxml2-xpath.html#XPATH_POINT"/>
<keyword type="macro" name="XPATH_RANGE" link="libxml2-xpath.html#XPATH_RANGE"/>
<keyword type="macro" name="XP_ERROR" link="libxml2-xpathInternals.html#XP_ERROR"/>
<keyword type="macro" name="XP_ERROR0" link="libxml2-xpathInternals.html#XP_ERROR0"/>
<keyword type="macro" name="htmlDefaultSubelement" link="libxml2-HTMLparser.html#htmlDefaultSubelement"/>
<keyword type="macro" name="htmlElementAllowedHereDesc" link="libxml2-HTMLparser.html#htmlElementAllowedHereDesc"/>
<keyword type="macro" name="htmlRequiredAttrs" link="libxml2-HTMLparser.html#htmlRequiredAttrs"/>
<keyword type="macro" name="xmlChildrenNode" link="libxml2-tree.html#xmlChildrenNode"/>
<keyword type="macro" name="xmlIsBaseCharQ" link="libxml2-chvalid.html#xmlIsBaseCharQ"/>
<keyword type="macro" name="xmlIsBaseChar_ch" link="libxml2-chvalid.html#xmlIsBaseChar_ch"/>
<keyword type="macro" name="xmlIsBlankQ" link="libxml2-chvalid.html#xmlIsBlankQ"/>
<keyword type="macro" name="xmlIsBlank_ch" link="libxml2-chvalid.html#xmlIsBlank_ch"/>
<keyword type="macro" name="xmlIsCharQ" link="libxml2-chvalid.html#xmlIsCharQ"/>
<keyword type="macro" name="xmlIsChar_ch" link="libxml2-chvalid.html#xmlIsChar_ch"/>
<keyword type="macro" name="xmlIsCombiningQ" link="libxml2-chvalid.html#xmlIsCombiningQ"/>
<keyword type="macro" name="xmlIsDigitQ" link="libxml2-chvalid.html#xmlIsDigitQ"/>
<keyword type="macro" name="xmlIsDigit_ch" link="libxml2-chvalid.html#xmlIsDigit_ch"/>
<keyword type="macro" name="xmlIsExtenderQ" link="libxml2-chvalid.html#xmlIsExtenderQ"/>
<keyword type="macro" name="xmlIsExtender_ch" link="libxml2-chvalid.html#xmlIsExtender_ch"/>
<keyword type="macro" name="xmlIsIdeographicQ" link="libxml2-chvalid.html#xmlIsIdeographicQ"/>
<keyword type="macro" name="xmlIsPubidCharQ" link="libxml2-chvalid.html#xmlIsPubidCharQ"/>
<keyword type="macro" name="xmlIsPubidChar_ch" link="libxml2-chvalid.html#xmlIsPubidChar_ch"/>
<keyword type="macro" name="xmlRootNode" link="libxml2-tree.html#xmlRootNode"/>
<keyword type="macro" name="xmlTextWriterWriteDocType" link="libxml2-xmlwriter.html#xmlTextWriterWriteDocType"/>
<keyword type="macro" name="xmlTextWriterWriteProcessingInstruction" link="libxml2-xmlwriter.html#xmlTextWriterWriteProcessingInstruction"/>
<keyword type="macro" name="xmlXPathCheckError" link="libxml2-xpathInternals.html#xmlXPathCheckError"/>
<keyword type="macro" name="xmlXPathEmptyNodeSet" link="libxml2-xpathInternals.html#xmlXPathEmptyNodeSet"/>
<keyword type="macro" name="xmlXPathGetContextNode" link="libxml2-xpathInternals.html#xmlXPathGetContextNode"/>
<keyword type="macro" name="xmlXPathGetDocument" link="libxml2-xpathInternals.html#xmlXPathGetDocument"/>
<keyword type="macro" name="xmlXPathGetError" link="libxml2-xpathInternals.html#xmlXPathGetError"/>
<keyword type="macro" name="xmlXPathNodeSetGetLength" link="libxml2-xpath.html#xmlXPathNodeSetGetLength"/>
<keyword type="macro" name="xmlXPathNodeSetIsEmpty" link="libxml2-xpath.html#xmlXPathNodeSetIsEmpty"/>
<keyword type="macro" name="xmlXPathNodeSetItem" link="libxml2-xpath.html#xmlXPathNodeSetItem"/>
<keyword type="macro" name="xmlXPathReturnBoolean" link="libxml2-xpathInternals.html#xmlXPathReturnBoolean"/>
<keyword type="macro" name="xmlXPathReturnEmptyNodeSet" link="libxml2-xpathInternals.html#xmlXPathReturnEmptyNodeSet"/>
<keyword type="macro" name="xmlXPathReturnEmptyString" link="libxml2-xpathInternals.html#xmlXPathReturnEmptyString"/>
<keyword type="macro" name="xmlXPathReturnExternal" link="libxml2-xpathInternals.html#xmlXPathReturnExternal"/>
<keyword type="macro" name="xmlXPathReturnFalse" link="libxml2-xpathInternals.html#xmlXPathReturnFalse"/>
<keyword type="macro" name="xmlXPathReturnNodeSet" link="libxml2-xpathInternals.html#xmlXPathReturnNodeSet"/>
<keyword type="macro" name="xmlXPathReturnNumber" link="libxml2-xpathInternals.html#xmlXPathReturnNumber"/>
<keyword type="macro" name="xmlXPathReturnString" link="libxml2-xpathInternals.html#xmlXPathReturnString"/>
<keyword type="macro" name="xmlXPathReturnTrue" link="libxml2-xpathInternals.html#xmlXPathReturnTrue"/>
<keyword type="macro" name="xmlXPathSetArityError" link="libxml2-xpathInternals.html#xmlXPathSetArityError"/>
<keyword type="macro" name="xmlXPathSetError" link="libxml2-xpathInternals.html#xmlXPathSetError"/>
<keyword type="macro" name="xmlXPathSetTypeError" link="libxml2-xpathInternals.html#xmlXPathSetTypeError"/>
<keyword type="macro" name="xmlXPathStackIsExternal" link="libxml2-xpathInternals.html#xmlXPathStackIsExternal"/>
<keyword type="macro" name="xmlXPathStackIsNodeSet" link="libxml2-xpathInternals.html#xmlXPathStackIsNodeSet"/>
<keyword type="enum" name="HTML_DEPRECATED" link="libxml2-HTMLparser.html#HTML_DEPRECATED"/>
<keyword type="enum" name="HTML_INVALID" link="libxml2-HTMLparser.html#HTML_INVALID"/>
<keyword type="enum" name="HTML_NA" link="libxml2-HTMLparser.html#HTML_NA"/>
<keyword type="enum" name="HTML_PARSE_COMPACT" link="libxml2-HTMLparser.html#HTML_PARSE_COMPACT"/>
<keyword type="enum" name="HTML_PARSE_IGNORE_ENC" link="libxml2-HTMLparser.html#HTML_PARSE_IGNORE_ENC"/>
<keyword type="enum" name="HTML_PARSE_NOBLANKS" link="libxml2-HTMLparser.html#HTML_PARSE_NOBLANKS"/>
<keyword type="enum" name="HTML_PARSE_NODEFDTD" link="libxml2-HTMLparser.html#HTML_PARSE_NODEFDTD"/>
<keyword type="enum" name="HTML_PARSE_NOERROR" link="libxml2-HTMLparser.html#HTML_PARSE_NOERROR"/>
<keyword type="enum" name="HTML_PARSE_NOIMPLIED" link="libxml2-HTMLparser.html#HTML_PARSE_NOIMPLIED"/>
<keyword type="enum" name="HTML_PARSE_NONET" link="libxml2-HTMLparser.html#HTML_PARSE_NONET"/>
<keyword type="enum" name="HTML_PARSE_NOWARNING" link="libxml2-HTMLparser.html#HTML_PARSE_NOWARNING"/>
<keyword type="enum" name="HTML_PARSE_PEDANTIC" link="libxml2-HTMLparser.html#HTML_PARSE_PEDANTIC"/>
<keyword type="enum" name="HTML_PARSE_RECOVER" link="libxml2-HTMLparser.html#HTML_PARSE_RECOVER"/>
<keyword type="enum" name="HTML_REQUIRED" link="libxml2-HTMLparser.html#HTML_REQUIRED"/>
<keyword type="enum" name="HTML_VALID" link="libxml2-HTMLparser.html#HTML_VALID"/>
<keyword type="enum" name="XLINK_ACTUATE_AUTO" link="libxml2-xlink.html#XLINK_ACTUATE_AUTO"/>
<keyword type="enum" name="XLINK_ACTUATE_NONE" link="libxml2-xlink.html#XLINK_ACTUATE_NONE"/>
<keyword type="enum" name="XLINK_ACTUATE_ONREQUEST" link="libxml2-xlink.html#XLINK_ACTUATE_ONREQUEST"/>
<keyword type="enum" name="XLINK_SHOW_EMBED" link="libxml2-xlink.html#XLINK_SHOW_EMBED"/>
<keyword type="enum" name="XLINK_SHOW_NEW" link="libxml2-xlink.html#XLINK_SHOW_NEW"/>
<keyword type="enum" name="XLINK_SHOW_NONE" link="libxml2-xlink.html#XLINK_SHOW_NONE"/>
<keyword type="enum" name="XLINK_SHOW_REPLACE" link="libxml2-xlink.html#XLINK_SHOW_REPLACE"/>
<keyword type="enum" name="XLINK_TYPE_EXTENDED" link="libxml2-xlink.html#XLINK_TYPE_EXTENDED"/>
<keyword type="enum" name="XLINK_TYPE_EXTENDED_SET" link="libxml2-xlink.html#XLINK_TYPE_EXTENDED_SET"/>
<keyword type="enum" name="XLINK_TYPE_NONE" link="libxml2-xlink.html#XLINK_TYPE_NONE"/>
<keyword type="enum" name="XLINK_TYPE_SIMPLE" link="libxml2-xlink.html#XLINK_TYPE_SIMPLE"/>
<keyword type="enum" name="XML_ATTRIBUTE_CDATA" link="libxml2-tree.html#XML_ATTRIBUTE_CDATA"/>
<keyword type="enum" name="XML_ATTRIBUTE_DECL" link="libxml2-tree.html#XML_ATTRIBUTE_DECL"/>
<keyword type="enum" name="XML_ATTRIBUTE_ENTITIES" link="libxml2-tree.html#XML_ATTRIBUTE_ENTITIES"/>
<keyword type="enum" name="XML_ATTRIBUTE_ENTITY" link="libxml2-tree.html#XML_ATTRIBUTE_ENTITY"/>
<keyword type="enum" name="XML_ATTRIBUTE_ENUMERATION" link="libxml2-tree.html#XML_ATTRIBUTE_ENUMERATION"/>
<keyword type="enum" name="XML_ATTRIBUTE_FIXED" link="libxml2-tree.html#XML_ATTRIBUTE_FIXED"/>
<keyword type="enum" name="XML_ATTRIBUTE_ID" link="libxml2-tree.html#XML_ATTRIBUTE_ID"/>
<keyword type="enum" name="XML_ATTRIBUTE_IDREF" link="libxml2-tree.html#XML_ATTRIBUTE_IDREF"/>
<keyword type="enum" name="XML_ATTRIBUTE_IDREFS" link="libxml2-tree.html#XML_ATTRIBUTE_IDREFS"/>
<keyword type="enum" name="XML_ATTRIBUTE_IMPLIED" link="libxml2-tree.html#XML_ATTRIBUTE_IMPLIED"/>
<keyword type="enum" name="XML_ATTRIBUTE_NMTOKEN" link="libxml2-tree.html#XML_ATTRIBUTE_NMTOKEN"/>
<keyword type="enum" name="XML_ATTRIBUTE_NMTOKENS" link="libxml2-tree.html#XML_ATTRIBUTE_NMTOKENS"/>
<keyword type="enum" name="XML_ATTRIBUTE_NODE" link="libxml2-tree.html#XML_ATTRIBUTE_NODE"/>
<keyword type="enum" name="XML_ATTRIBUTE_NONE" link="libxml2-tree.html#XML_ATTRIBUTE_NONE"/>
<keyword type="enum" name="XML_ATTRIBUTE_NOTATION" link="libxml2-tree.html#XML_ATTRIBUTE_NOTATION"/>
<keyword type="enum" name="XML_ATTRIBUTE_REQUIRED" link="libxml2-tree.html#XML_ATTRIBUTE_REQUIRED"/>
<keyword type="enum" name="XML_BUFFER_ALLOC_BOUNDED" link="libxml2-tree.html#XML_BUFFER_ALLOC_BOUNDED"/>
<keyword type="enum" name="XML_BUFFER_ALLOC_DOUBLEIT" link="libxml2-tree.html#XML_BUFFER_ALLOC_DOUBLEIT"/>
<keyword type="enum" name="XML_BUFFER_ALLOC_EXACT" link="libxml2-tree.html#XML_BUFFER_ALLOC_EXACT"/>
<keyword type="enum" name="XML_BUFFER_ALLOC_HYBRID" link="libxml2-tree.html#XML_BUFFER_ALLOC_HYBRID"/>
<keyword type="enum" name="XML_BUFFER_ALLOC_IMMUTABLE" link="libxml2-tree.html#XML_BUFFER_ALLOC_IMMUTABLE"/>
<keyword type="enum" name="XML_BUFFER_ALLOC_IO" link="libxml2-tree.html#XML_BUFFER_ALLOC_IO"/>
<keyword type="enum" name="XML_BUF_OVERFLOW" link="libxml2-xmlerror.html#XML_BUF_OVERFLOW"/>
<keyword type="enum" name="XML_C14N_1_0" link="libxml2-c14n.html#XML_C14N_1_0"/>
<keyword type="enum" name="XML_C14N_1_1" link="libxml2-c14n.html#XML_C14N_1_1"/>
<keyword type="enum" name="XML_C14N_CREATE_CTXT" link="libxml2-xmlerror.html#XML_C14N_CREATE_CTXT"/>
<keyword type="enum" name="XML_C14N_CREATE_STACK" link="libxml2-xmlerror.html#XML_C14N_CREATE_STACK"/>
<keyword type="enum" name="XML_C14N_EXCLUSIVE_1_0" link="libxml2-c14n.html#XML_C14N_EXCLUSIVE_1_0"/>
<keyword type="enum" name="XML_C14N_INVALID_NODE" link="libxml2-xmlerror.html#XML_C14N_INVALID_NODE"/>
<keyword type="enum" name="XML_C14N_RELATIVE_NAMESPACE" link="libxml2-xmlerror.html#XML_C14N_RELATIVE_NAMESPACE"/>
<keyword type="enum" name="XML_C14N_REQUIRES_UTF8" link="libxml2-xmlerror.html#XML_C14N_REQUIRES_UTF8"/>
<keyword type="enum" name="XML_C14N_UNKNOW_NODE" link="libxml2-xmlerror.html#XML_C14N_UNKNOW_NODE"/>
<keyword type="enum" name="XML_CATALOG_ENTRY_BROKEN" link="libxml2-xmlerror.html#XML_CATALOG_ENTRY_BROKEN"/>
<keyword type="enum" name="XML_CATALOG_MISSING_ATTR" link="libxml2-xmlerror.html#XML_CATALOG_MISSING_ATTR"/>
<keyword type="enum" name="XML_CATALOG_NOT_CATALOG" link="libxml2-xmlerror.html#XML_CATALOG_NOT_CATALOG"/>
<keyword type="enum" name="XML_CATALOG_PREFER_VALUE" link="libxml2-xmlerror.html#XML_CATALOG_PREFER_VALUE"/>
<keyword type="enum" name="XML_CATALOG_RECURSION" link="libxml2-xmlerror.html#XML_CATALOG_RECURSION"/>
<keyword type="enum" name="XML_CATA_ALLOW_ALL" link="libxml2-catalog.html#XML_CATA_ALLOW_ALL"/>
<keyword type="enum" name="XML_CATA_ALLOW_DOCUMENT" link="libxml2-catalog.html#XML_CATA_ALLOW_DOCUMENT"/>
<keyword type="enum" name="XML_CATA_ALLOW_GLOBAL" link="libxml2-catalog.html#XML_CATA_ALLOW_GLOBAL"/>
<keyword type="enum" name="XML_CATA_ALLOW_NONE" link="libxml2-catalog.html#XML_CATA_ALLOW_NONE"/>
<keyword type="enum" name="XML_CATA_PREFER_NONE" link="libxml2-catalog.html#XML_CATA_PREFER_NONE"/>
<keyword type="enum" name="XML_CATA_PREFER_PUBLIC" link="libxml2-catalog.html#XML_CATA_PREFER_PUBLIC"/>
<keyword type="enum" name="XML_CATA_PREFER_SYSTEM" link="libxml2-catalog.html#XML_CATA_PREFER_SYSTEM"/>
<keyword type="enum" name="XML_CDATA_SECTION_NODE" link="libxml2-tree.html#XML_CDATA_SECTION_NODE"/>
<keyword type="enum" name="XML_CHAR_ENCODING_2022_JP" link="libxml2-encoding.html#XML_CHAR_ENCODING_2022_JP"/>
<keyword type="enum" name="XML_CHAR_ENCODING_8859_1" link="libxml2-encoding.html#XML_CHAR_ENCODING_8859_1"/>
<keyword type="enum" name="XML_CHAR_ENCODING_8859_2" link="libxml2-encoding.html#XML_CHAR_ENCODING_8859_2"/>
<keyword type="enum" name="XML_CHAR_ENCODING_8859_3" link="libxml2-encoding.html#XML_CHAR_ENCODING_8859_3"/>
<keyword type="enum" name="XML_CHAR_ENCODING_8859_4" link="libxml2-encoding.html#XML_CHAR_ENCODING_8859_4"/>
<keyword type="enum" name="XML_CHAR_ENCODING_8859_5" link="libxml2-encoding.html#XML_CHAR_ENCODING_8859_5"/>
<keyword type="enum" name="XML_CHAR_ENCODING_8859_6" link="libxml2-encoding.html#XML_CHAR_ENCODING_8859_6"/>
<keyword type="enum" name="XML_CHAR_ENCODING_8859_7" link="libxml2-encoding.html#XML_CHAR_ENCODING_8859_7"/>
<keyword type="enum" name="XML_CHAR_ENCODING_8859_8" link="libxml2-encoding.html#XML_CHAR_ENCODING_8859_8"/>
<keyword type="enum" name="XML_CHAR_ENCODING_8859_9" link="libxml2-encoding.html#XML_CHAR_ENCODING_8859_9"/>
<keyword type="enum" name="XML_CHAR_ENCODING_ASCII" link="libxml2-encoding.html#XML_CHAR_ENCODING_ASCII"/>
<keyword type="enum" name="XML_CHAR_ENCODING_EBCDIC" link="libxml2-encoding.html#XML_CHAR_ENCODING_EBCDIC"/>
<keyword type="enum" name="XML_CHAR_ENCODING_ERROR" link="libxml2-encoding.html#XML_CHAR_ENCODING_ERROR"/>
<keyword type="enum" name="XML_CHAR_ENCODING_EUC_JP" link="libxml2-encoding.html#XML_CHAR_ENCODING_EUC_JP"/>
<keyword type="enum" name="XML_CHAR_ENCODING_NONE" link="libxml2-encoding.html#XML_CHAR_ENCODING_NONE"/>
<keyword type="enum" name="XML_CHAR_ENCODING_SHIFT_JIS" link="libxml2-encoding.html#XML_CHAR_ENCODING_SHIFT_JIS"/>
<keyword type="enum" name="XML_CHAR_ENCODING_UCS2" link="libxml2-encoding.html#XML_CHAR_ENCODING_UCS2"/>
<keyword type="enum" name="XML_CHAR_ENCODING_UCS4BE" link="libxml2-encoding.html#XML_CHAR_ENCODING_UCS4BE"/>
<keyword type="enum" name="XML_CHAR_ENCODING_UCS4LE" link="libxml2-encoding.html#XML_CHAR_ENCODING_UCS4LE"/>
<keyword type="enum" name="XML_CHAR_ENCODING_UCS4_2143" link="libxml2-encoding.html#XML_CHAR_ENCODING_UCS4_2143"/>
<keyword type="enum" name="XML_CHAR_ENCODING_UCS4_3412" link="libxml2-encoding.html#XML_CHAR_ENCODING_UCS4_3412"/>
<keyword type="enum" name="XML_CHAR_ENCODING_UTF16BE" link="libxml2-encoding.html#XML_CHAR_ENCODING_UTF16BE"/>
<keyword type="enum" name="XML_CHAR_ENCODING_UTF16LE" link="libxml2-encoding.html#XML_CHAR_ENCODING_UTF16LE"/>
<keyword type="enum" name="XML_CHAR_ENCODING_UTF8" link="libxml2-encoding.html#XML_CHAR_ENCODING_UTF8"/>
<keyword type="enum" name="XML_CHECK_ENTITY_TYPE" link="libxml2-xmlerror.html#XML_CHECK_ENTITY_TYPE"/>
<keyword type="enum" name="XML_CHECK_FOUND_ATTRIBUTE" link="libxml2-xmlerror.html#XML_CHECK_FOUND_ATTRIBUTE"/>
<keyword type="enum" name="XML_CHECK_FOUND_CDATA" link="libxml2-xmlerror.html#XML_CHECK_FOUND_CDATA"/>
<keyword type="enum" name="XML_CHECK_FOUND_COMMENT" link="libxml2-xmlerror.html#XML_CHECK_FOUND_COMMENT"/>
<keyword type="enum" name="XML_CHECK_FOUND_DOCTYPE" link="libxml2-xmlerror.html#XML_CHECK_FOUND_DOCTYPE"/>
<keyword type="enum" name="XML_CHECK_FOUND_ELEMENT" link="libxml2-xmlerror.html#XML_CHECK_FOUND_ELEMENT"/>
<keyword type="enum" name="XML_CHECK_FOUND_ENTITY" link="libxml2-xmlerror.html#XML_CHECK_FOUND_ENTITY"/>
<keyword type="enum" name="XML_CHECK_FOUND_ENTITYREF" link="libxml2-xmlerror.html#XML_CHECK_FOUND_ENTITYREF"/>
<keyword type="enum" name="XML_CHECK_FOUND_FRAGMENT" link="libxml2-xmlerror.html#XML_CHECK_FOUND_FRAGMENT"/>
<keyword type="enum" name="XML_CHECK_FOUND_NOTATION" link="libxml2-xmlerror.html#XML_CHECK_FOUND_NOTATION"/>
<keyword type="enum" name="XML_CHECK_FOUND_PI" link="libxml2-xmlerror.html#XML_CHECK_FOUND_PI"/>
<keyword type="enum" name="XML_CHECK_FOUND_TEXT" link="libxml2-xmlerror.html#XML_CHECK_FOUND_TEXT"/>
<keyword type="enum" name="XML_CHECK_NAME_NOT_NULL" link="libxml2-xmlerror.html#XML_CHECK_NAME_NOT_NULL"/>
<keyword type="enum" name="XML_CHECK_NOT_ATTR" link="libxml2-xmlerror.html#XML_CHECK_NOT_ATTR"/>
<keyword type="enum" name="XML_CHECK_NOT_ATTR_DECL" link="libxml2-xmlerror.html#XML_CHECK_NOT_ATTR_DECL"/>
<keyword type="enum" name="XML_CHECK_NOT_DTD" link="libxml2-xmlerror.html#XML_CHECK_NOT_DTD"/>
<keyword type="enum" name="XML_CHECK_NOT_ELEM_DECL" link="libxml2-xmlerror.html#XML_CHECK_NOT_ELEM_DECL"/>
<keyword type="enum" name="XML_CHECK_NOT_ENTITY_DECL" link="libxml2-xmlerror.html#XML_CHECK_NOT_ENTITY_DECL"/>
<keyword type="enum" name="XML_CHECK_NOT_NCNAME" link="libxml2-xmlerror.html#XML_CHECK_NOT_NCNAME"/>
<keyword type="enum" name="XML_CHECK_NOT_NS_DECL" link="libxml2-xmlerror.html#XML_CHECK_NOT_NS_DECL"/>
<keyword type="enum" name="XML_CHECK_NOT_UTF8" link="libxml2-xmlerror.html#XML_CHECK_NOT_UTF8"/>
<keyword type="enum" name="XML_CHECK_NO_DICT" link="libxml2-xmlerror.html#XML_CHECK_NO_DICT"/>
<keyword type="enum" name="XML_CHECK_NO_DOC" link="libxml2-xmlerror.html#XML_CHECK_NO_DOC"/>
<keyword type="enum" name="XML_CHECK_NO_ELEM" link="libxml2-xmlerror.html#XML_CHECK_NO_ELEM"/>
<keyword type="enum" name="XML_CHECK_NO_HREF" link="libxml2-xmlerror.html#XML_CHECK_NO_HREF"/>
<keyword type="enum" name="XML_CHECK_NO_NAME" link="libxml2-xmlerror.html#XML_CHECK_NO_NAME"/>
<keyword type="enum" name="XML_CHECK_NO_NEXT" link="libxml2-xmlerror.html#XML_CHECK_NO_NEXT"/>
<keyword type="enum" name="XML_CHECK_NO_PARENT" link="libxml2-xmlerror.html#XML_CHECK_NO_PARENT"/>
<keyword type="enum" name="XML_CHECK_NO_PREV" link="libxml2-xmlerror.html#XML_CHECK_NO_PREV"/>
<keyword type="enum" name="XML_CHECK_NS_ANCESTOR" link="libxml2-xmlerror.html#XML_CHECK_NS_ANCESTOR"/>
<keyword type="enum" name="XML_CHECK_NS_SCOPE" link="libxml2-xmlerror.html#XML_CHECK_NS_SCOPE"/>
<keyword type="enum" name="XML_CHECK_OUTSIDE_DICT" link="libxml2-xmlerror.html#XML_CHECK_OUTSIDE_DICT"/>
<keyword type="enum" name="XML_CHECK_UNKNOWN_NODE" link="libxml2-xmlerror.html#XML_CHECK_UNKNOWN_NODE"/>
<keyword type="enum" name="XML_CHECK_WRONG_DOC" link="libxml2-xmlerror.html#XML_CHECK_WRONG_DOC"/>
<keyword type="enum" name="XML_CHECK_WRONG_NAME" link="libxml2-xmlerror.html#XML_CHECK_WRONG_NAME"/>
<keyword type="enum" name="XML_CHECK_WRONG_NEXT" link="libxml2-xmlerror.html#XML_CHECK_WRONG_NEXT"/>
<keyword type="enum" name="XML_CHECK_WRONG_PARENT" link="libxml2-xmlerror.html#XML_CHECK_WRONG_PARENT"/>
<keyword type="enum" name="XML_CHECK_WRONG_PREV" link="libxml2-xmlerror.html#XML_CHECK_WRONG_PREV"/>
<keyword type="enum" name="XML_COMMENT_NODE" link="libxml2-tree.html#XML_COMMENT_NODE"/>
<keyword type="enum" name="XML_DOCUMENT_FRAG_NODE" link="libxml2-tree.html#XML_DOCUMENT_FRAG_NODE"/>
<keyword type="enum" name="XML_DOCUMENT_NODE" link="libxml2-tree.html#XML_DOCUMENT_NODE"/>
<keyword type="enum" name="XML_DOCUMENT_TYPE_NODE" link="libxml2-tree.html#XML_DOCUMENT_TYPE_NODE"/>
<keyword type="enum" name="XML_DOC_DTDVALID" link="libxml2-tree.html#XML_DOC_DTDVALID"/>
<keyword type="enum" name="XML_DOC_HTML" link="libxml2-tree.html#XML_DOC_HTML"/>
<keyword type="enum" name="XML_DOC_INTERNAL" link="libxml2-tree.html#XML_DOC_INTERNAL"/>
<keyword type="enum" name="XML_DOC_NSVALID" link="libxml2-tree.html#XML_DOC_NSVALID"/>
<keyword type="enum" name="XML_DOC_OLD10" link="libxml2-tree.html#XML_DOC_OLD10"/>
<keyword type="enum" name="XML_DOC_USERBUILT" link="libxml2-tree.html#XML_DOC_USERBUILT"/>
<keyword type="enum" name="XML_DOC_WELLFORMED" link="libxml2-tree.html#XML_DOC_WELLFORMED"/>
<keyword type="enum" name="XML_DOC_XINCLUDE" link="libxml2-tree.html#XML_DOC_XINCLUDE"/>
<keyword type="enum" name="XML_DTD_ATTRIBUTE_DEFAULT" link="libxml2-xmlerror.html#XML_DTD_ATTRIBUTE_DEFAULT"/>
<keyword type="enum" name="XML_DTD_ATTRIBUTE_REDEFINED" link="libxml2-xmlerror.html#XML_DTD_ATTRIBUTE_REDEFINED"/>
<keyword type="enum" name="XML_DTD_ATTRIBUTE_VALUE" link="libxml2-xmlerror.html#XML_DTD_ATTRIBUTE_VALUE"/>
<keyword type="enum" name="XML_DTD_CONTENT_ERROR" link="libxml2-xmlerror.html#XML_DTD_CONTENT_ERROR"/>
<keyword type="enum" name="XML_DTD_CONTENT_MODEL" link="libxml2-xmlerror.html#XML_DTD_CONTENT_MODEL"/>
<keyword type="enum" name="XML_DTD_CONTENT_NOT_DETERMINIST" link="libxml2-xmlerror.html#XML_DTD_CONTENT_NOT_DETERMINIST"/>
<keyword type="enum" name="XML_DTD_DIFFERENT_PREFIX" link="libxml2-xmlerror.html#XML_DTD_DIFFERENT_PREFIX"/>
<keyword type="enum" name="XML_DTD_DUP_TOKEN" link="libxml2-xmlerror.html#XML_DTD_DUP_TOKEN"/>
<keyword type="enum" name="XML_DTD_ELEM_DEFAULT_NAMESPACE" link="libxml2-xmlerror.html#XML_DTD_ELEM_DEFAULT_NAMESPACE"/>
<keyword type="enum" name="XML_DTD_ELEM_NAMESPACE" link="libxml2-xmlerror.html#XML_DTD_ELEM_NAMESPACE"/>
<keyword type="enum" name="XML_DTD_ELEM_REDEFINED" link="libxml2-xmlerror.html#XML_DTD_ELEM_REDEFINED"/>
<keyword type="enum" name="XML_DTD_EMPTY_NOTATION" link="libxml2-xmlerror.html#XML_DTD_EMPTY_NOTATION"/>
<keyword type="enum" name="XML_DTD_ENTITY_TYPE" link="libxml2-xmlerror.html#XML_DTD_ENTITY_TYPE"/>
<keyword type="enum" name="XML_DTD_ID_FIXED" link="libxml2-xmlerror.html#XML_DTD_ID_FIXED"/>
<keyword type="enum" name="XML_DTD_ID_REDEFINED" link="libxml2-xmlerror.html#XML_DTD_ID_REDEFINED"/>
<keyword type="enum" name="XML_DTD_ID_SUBSET" link="libxml2-xmlerror.html#XML_DTD_ID_SUBSET"/>
<keyword type="enum" name="XML_DTD_INVALID_CHILD" link="libxml2-xmlerror.html#XML_DTD_INVALID_CHILD"/>
<keyword type="enum" name="XML_DTD_INVALID_DEFAULT" link="libxml2-xmlerror.html#XML_DTD_INVALID_DEFAULT"/>
<keyword type="enum" name="XML_DTD_LOAD_ERROR" link="libxml2-xmlerror.html#XML_DTD_LOAD_ERROR"/>
<keyword type="enum" name="XML_DTD_MISSING_ATTRIBUTE" link="libxml2-xmlerror.html#XML_DTD_MISSING_ATTRIBUTE"/>
<keyword type="enum" name="XML_DTD_MIXED_CORRUPT" link="libxml2-xmlerror.html#XML_DTD_MIXED_CORRUPT"/>
<keyword type="enum" name="XML_DTD_MULTIPLE_ID" link="libxml2-xmlerror.html#XML_DTD_MULTIPLE_ID"/>
<keyword type="enum" name="XML_DTD_NODE" link="libxml2-tree.html#XML_DTD_NODE"/>
<keyword type="enum" name="XML_DTD_NOTATION_REDEFINED" link="libxml2-xmlerror.html#XML_DTD_NOTATION_REDEFINED"/>
<keyword type="enum" name="XML_DTD_NOTATION_VALUE" link="libxml2-xmlerror.html#XML_DTD_NOTATION_VALUE"/>
<keyword type="enum" name="XML_DTD_NOT_EMPTY" link="libxml2-xmlerror.html#XML_DTD_NOT_EMPTY"/>
<keyword type="enum" name="XML_DTD_NOT_PCDATA" link="libxml2-xmlerror.html#XML_DTD_NOT_PCDATA"/>
<keyword type="enum" name="XML_DTD_NOT_STANDALONE" link="libxml2-xmlerror.html#XML_DTD_NOT_STANDALONE"/>
<keyword type="enum" name="XML_DTD_NO_DOC" link="libxml2-xmlerror.html#XML_DTD_NO_DOC"/>
<keyword type="enum" name="XML_DTD_NO_DTD" link="libxml2-xmlerror.html#XML_DTD_NO_DTD"/>
<keyword type="enum" name="XML_DTD_NO_ELEM_NAME" link="libxml2-xmlerror.html#XML_DTD_NO_ELEM_NAME"/>
<keyword type="enum" name="XML_DTD_NO_PREFIX" link="libxml2-xmlerror.html#XML_DTD_NO_PREFIX"/>
<keyword type="enum" name="XML_DTD_NO_ROOT" link="libxml2-xmlerror.html#XML_DTD_NO_ROOT"/>
<keyword type="enum" name="XML_DTD_ROOT_NAME" link="libxml2-xmlerror.html#XML_DTD_ROOT_NAME"/>
<keyword type="enum" name="XML_DTD_STANDALONE_DEFAULTED" link="libxml2-xmlerror.html#XML_DTD_STANDALONE_DEFAULTED"/>
<keyword type="enum" name="XML_DTD_STANDALONE_WHITE_SPACE" link="libxml2-xmlerror.html#XML_DTD_STANDALONE_WHITE_SPACE"/>
<keyword type="enum" name="XML_DTD_UNKNOWN_ATTRIBUTE" link="libxml2-xmlerror.html#XML_DTD_UNKNOWN_ATTRIBUTE"/>
<keyword type="enum" name="XML_DTD_UNKNOWN_ELEM" link="libxml2-xmlerror.html#XML_DTD_UNKNOWN_ELEM"/>
<keyword type="enum" name="XML_DTD_UNKNOWN_ENTITY" link="libxml2-xmlerror.html#XML_DTD_UNKNOWN_ENTITY"/>
<keyword type="enum" name="XML_DTD_UNKNOWN_ID" link="libxml2-xmlerror.html#XML_DTD_UNKNOWN_ID"/>
<keyword type="enum" name="XML_DTD_UNKNOWN_NOTATION" link="libxml2-xmlerror.html#XML_DTD_UNKNOWN_NOTATION"/>
<keyword type="enum" name="XML_DTD_XMLID_TYPE" link="libxml2-xmlerror.html#XML_DTD_XMLID_TYPE"/>
<keyword type="enum" name="XML_DTD_XMLID_VALUE" link="libxml2-xmlerror.html#XML_DTD_XMLID_VALUE"/>
<keyword type="enum" name="XML_ELEMENT_CONTENT_ELEMENT" link="libxml2-tree.html#XML_ELEMENT_CONTENT_ELEMENT"/>
<keyword type="enum" name="XML_ELEMENT_CONTENT_MULT" link="libxml2-tree.html#XML_ELEMENT_CONTENT_MULT"/>
<keyword type="enum" name="XML_ELEMENT_CONTENT_ONCE" link="libxml2-tree.html#XML_ELEMENT_CONTENT_ONCE"/>
<keyword type="enum" name="XML_ELEMENT_CONTENT_OPT" link="libxml2-tree.html#XML_ELEMENT_CONTENT_OPT"/>
<keyword type="enum" name="XML_ELEMENT_CONTENT_OR" link="libxml2-tree.html#XML_ELEMENT_CONTENT_OR"/>
<keyword type="enum" name="XML_ELEMENT_CONTENT_PCDATA" link="libxml2-tree.html#XML_ELEMENT_CONTENT_PCDATA"/>
<keyword type="enum" name="XML_ELEMENT_CONTENT_PLUS" link="libxml2-tree.html#XML_ELEMENT_CONTENT_PLUS"/>
<keyword type="enum" name="XML_ELEMENT_CONTENT_SEQ" link="libxml2-tree.html#XML_ELEMENT_CONTENT_SEQ"/>
<keyword type="enum" name="XML_ELEMENT_DECL" link="libxml2-tree.html#XML_ELEMENT_DECL"/>
<keyword type="enum" name="XML_ELEMENT_NODE" link="libxml2-tree.html#XML_ELEMENT_NODE"/>
<keyword type="enum" name="XML_ELEMENT_TYPE_ANY" link="libxml2-tree.html#XML_ELEMENT_TYPE_ANY"/>
<keyword type="enum" name="XML_ELEMENT_TYPE_ELEMENT" link="libxml2-tree.html#XML_ELEMENT_TYPE_ELEMENT"/>
<keyword type="enum" name="XML_ELEMENT_TYPE_EMPTY" link="libxml2-tree.html#XML_ELEMENT_TYPE_EMPTY"/>
<keyword type="enum" name="XML_ELEMENT_TYPE_MIXED" link="libxml2-tree.html#XML_ELEMENT_TYPE_MIXED"/>
<keyword type="enum" name="XML_ELEMENT_TYPE_UNDEFINED" link="libxml2-tree.html#XML_ELEMENT_TYPE_UNDEFINED"/>
<keyword type="enum" name="XML_ENTITY_DECL" link="libxml2-tree.html#XML_ENTITY_DECL"/>
<keyword type="enum" name="XML_ENTITY_NODE" link="libxml2-tree.html#XML_ENTITY_NODE"/>
<keyword type="enum" name="XML_ENTITY_REF_NODE" link="libxml2-tree.html#XML_ENTITY_REF_NODE"/>
<keyword type="enum" name="XML_ERR_ATTLIST_NOT_FINISHED" link="libxml2-xmlerror.html#XML_ERR_ATTLIST_NOT_FINISHED"/>
<keyword type="enum" name="XML_ERR_ATTLIST_NOT_STARTED" link="libxml2-xmlerror.html#XML_ERR_ATTLIST_NOT_STARTED"/>
<keyword type="enum" name="XML_ERR_ATTRIBUTE_NOT_FINISHED" link="libxml2-xmlerror.html#XML_ERR_ATTRIBUTE_NOT_FINISHED"/>
<keyword type="enum" name="XML_ERR_ATTRIBUTE_NOT_STARTED" link="libxml2-xmlerror.html#XML_ERR_ATTRIBUTE_NOT_STARTED"/>
<keyword type="enum" name="XML_ERR_ATTRIBUTE_REDEFINED" link="libxml2-xmlerror.html#XML_ERR_ATTRIBUTE_REDEFINED"/>
<keyword type="enum" name="XML_ERR_ATTRIBUTE_WITHOUT_VALUE" link="libxml2-xmlerror.html#XML_ERR_ATTRIBUTE_WITHOUT_VALUE"/>
<keyword type="enum" name="XML_ERR_CDATA_NOT_FINISHED" link="libxml2-xmlerror.html#XML_ERR_CDATA_NOT_FINISHED"/>
<keyword type="enum" name="XML_ERR_CHARREF_AT_EOF" link="libxml2-xmlerror.html#XML_ERR_CHARREF_AT_EOF"/>
<keyword type="enum" name="XML_ERR_CHARREF_IN_DTD" link="libxml2-xmlerror.html#XML_ERR_CHARREF_IN_DTD"/>
<keyword type="enum" name="XML_ERR_CHARREF_IN_EPILOG" link="libxml2-xmlerror.html#XML_ERR_CHARREF_IN_EPILOG"/>
<keyword type="enum" name="XML_ERR_CHARREF_IN_PROLOG" link="libxml2-xmlerror.html#XML_ERR_CHARREF_IN_PROLOG"/>
<keyword type="enum" name="XML_ERR_COMMENT_ABRUPTLY_ENDED" link="libxml2-xmlerror.html#XML_ERR_COMMENT_ABRUPTLY_ENDED"/>
<keyword type="enum" name="XML_ERR_COMMENT_NOT_FINISHED" link="libxml2-xmlerror.html#XML_ERR_COMMENT_NOT_FINISHED"/>
<keyword type="enum" name="XML_ERR_CONDSEC_INVALID" link="libxml2-xmlerror.html#XML_ERR_CONDSEC_INVALID"/>
<keyword type="enum" name="XML_ERR_CONDSEC_INVALID_KEYWORD" link="libxml2-xmlerror.html#XML_ERR_CONDSEC_INVALID_KEYWORD"/>
<keyword type="enum" name="XML_ERR_CONDSEC_NOT_FINISHED" link="libxml2-xmlerror.html#XML_ERR_CONDSEC_NOT_FINISHED"/>
<keyword type="enum" name="XML_ERR_CONDSEC_NOT_STARTED" link="libxml2-xmlerror.html#XML_ERR_CONDSEC_NOT_STARTED"/>
<keyword type="enum" name="XML_ERR_DOCTYPE_NOT_FINISHED" link="libxml2-xmlerror.html#XML_ERR_DOCTYPE_NOT_FINISHED"/>
<keyword type="enum" name="XML_ERR_DOCUMENT_EMPTY" link="libxml2-xmlerror.html#XML_ERR_DOCUMENT_EMPTY"/>
<keyword type="enum" name="XML_ERR_DOCUMENT_END" link="libxml2-xmlerror.html#XML_ERR_DOCUMENT_END"/>
<keyword type="enum" name="XML_ERR_DOCUMENT_START" link="libxml2-xmlerror.html#XML_ERR_DOCUMENT_START"/>
<keyword type="enum" name="XML_ERR_ELEMCONTENT_NOT_FINISHED" link="libxml2-xmlerror.html#XML_ERR_ELEMCONTENT_NOT_FINISHED"/>
<keyword type="enum" name="XML_ERR_ELEMCONTENT_NOT_STARTED" link="libxml2-xmlerror.html#XML_ERR_ELEMCONTENT_NOT_STARTED"/>
<keyword type="enum" name="XML_ERR_ENCODING_NAME" link="libxml2-xmlerror.html#XML_ERR_ENCODING_NAME"/>
<keyword type="enum" name="XML_ERR_ENTITYREF_AT_EOF" link="libxml2-xmlerror.html#XML_ERR_ENTITYREF_AT_EOF"/>
<keyword type="enum" name="XML_ERR_ENTITYREF_IN_DTD" link="libxml2-xmlerror.html#XML_ERR_ENTITYREF_IN_DTD"/>
<keyword type="enum" name="XML_ERR_ENTITYREF_IN_EPILOG" link="libxml2-xmlerror.html#XML_ERR_ENTITYREF_IN_EPILOG"/>
<keyword type="enum" name="XML_ERR_ENTITYREF_IN_PROLOG" link="libxml2-xmlerror.html#XML_ERR_ENTITYREF_IN_PROLOG"/>
<keyword type="enum" name="XML_ERR_ENTITYREF_NO_NAME" link="libxml2-xmlerror.html#XML_ERR_ENTITYREF_NO_NAME"/>
<keyword type="enum" name="XML_ERR_ENTITYREF_SEMICOL_MISSING" link="libxml2-xmlerror.html#XML_ERR_ENTITYREF_SEMICOL_MISSING"/>
<keyword type="enum" name="XML_ERR_ENTITY_BOUNDARY" link="libxml2-xmlerror.html#XML_ERR_ENTITY_BOUNDARY"/>
<keyword type="enum" name="XML_ERR_ENTITY_CHAR_ERROR" link="libxml2-xmlerror.html#XML_ERR_ENTITY_CHAR_ERROR"/>
<keyword type="enum" name="XML_ERR_ENTITY_IS_EXTERNAL" link="libxml2-xmlerror.html#XML_ERR_ENTITY_IS_EXTERNAL"/>
<keyword type="enum" name="XML_ERR_ENTITY_IS_PARAMETER" link="libxml2-xmlerror.html#XML_ERR_ENTITY_IS_PARAMETER"/>
<keyword type="enum" name="XML_ERR_ENTITY_LOOP" link="libxml2-xmlerror.html#XML_ERR_ENTITY_LOOP"/>
<keyword type="enum" name="XML_ERR_ENTITY_NOT_FINISHED" link="libxml2-xmlerror.html#XML_ERR_ENTITY_NOT_FINISHED"/>
<keyword type="enum" name="XML_ERR_ENTITY_NOT_STARTED" link="libxml2-xmlerror.html#XML_ERR_ENTITY_NOT_STARTED"/>
<keyword type="enum" name="XML_ERR_ENTITY_PE_INTERNAL" link="libxml2-xmlerror.html#XML_ERR_ENTITY_PE_INTERNAL"/>
<keyword type="enum" name="XML_ERR_ENTITY_PROCESSING" link="libxml2-xmlerror.html#XML_ERR_ENTITY_PROCESSING"/>
<keyword type="enum" name="XML_ERR_EQUAL_REQUIRED" link="libxml2-xmlerror.html#XML_ERR_EQUAL_REQUIRED"/>
<keyword type="enum" name="XML_ERR_ERROR" link="libxml2-xmlerror.html#XML_ERR_ERROR"/>
<keyword type="enum" name="XML_ERR_EXTRA_CONTENT" link="libxml2-xmlerror.html#XML_ERR_EXTRA_CONTENT"/>
<keyword type="enum" name="XML_ERR_EXT_ENTITY_STANDALONE" link="libxml2-xmlerror.html#XML_ERR_EXT_ENTITY_STANDALONE"/>
<keyword type="enum" name="XML_ERR_EXT_SUBSET_NOT_FINISHED" link="libxml2-xmlerror.html#XML_ERR_EXT_SUBSET_NOT_FINISHED"/>
<keyword type="enum" name="XML_ERR_FATAL" link="libxml2-xmlerror.html#XML_ERR_FATAL"/>
<keyword type="enum" name="XML_ERR_GT_REQUIRED" link="libxml2-xmlerror.html#XML_ERR_GT_REQUIRED"/>
<keyword type="enum" name="XML_ERR_HYPHEN_IN_COMMENT" link="libxml2-xmlerror.html#XML_ERR_HYPHEN_IN_COMMENT"/>
<keyword type="enum" name="XML_ERR_INTERNAL_ERROR" link="libxml2-xmlerror.html#XML_ERR_INTERNAL_ERROR"/>
<keyword type="enum" name="XML_ERR_INVALID_CHAR" link="libxml2-xmlerror.html#XML_ERR_INVALID_CHAR"/>
<keyword type="enum" name="XML_ERR_INVALID_CHARREF" link="libxml2-xmlerror.html#XML_ERR_INVALID_CHARREF"/>
<keyword type="enum" name="XML_ERR_INVALID_DEC_CHARREF" link="libxml2-xmlerror.html#XML_ERR_INVALID_DEC_CHARREF"/>
<keyword type="enum" name="XML_ERR_INVALID_ENCODING" link="libxml2-xmlerror.html#XML_ERR_INVALID_ENCODING"/>
<keyword type="enum" name="XML_ERR_INVALID_HEX_CHARREF" link="libxml2-xmlerror.html#XML_ERR_INVALID_HEX_CHARREF"/>
<keyword type="enum" name="XML_ERR_INVALID_URI" link="libxml2-xmlerror.html#XML_ERR_INVALID_URI"/>
<keyword type="enum" name="XML_ERR_LITERAL_NOT_FINISHED" link="libxml2-xmlerror.html#XML_ERR_LITERAL_NOT_FINISHED"/>
<keyword type="enum" name="XML_ERR_LITERAL_NOT_STARTED" link="libxml2-xmlerror.html#XML_ERR_LITERAL_NOT_STARTED"/>
<keyword type="enum" name="XML_ERR_LTSLASH_REQUIRED" link="libxml2-xmlerror.html#XML_ERR_LTSLASH_REQUIRED"/>
<keyword type="enum" name="XML_ERR_LT_IN_ATTRIBUTE" link="libxml2-xmlerror.html#XML_ERR_LT_IN_ATTRIBUTE"/>
<keyword type="enum" name="XML_ERR_LT_REQUIRED" link="libxml2-xmlerror.html#XML_ERR_LT_REQUIRED"/>
<keyword type="enum" name="XML_ERR_MISPLACED_CDATA_END" link="libxml2-xmlerror.html#XML_ERR_MISPLACED_CDATA_END"/>
<keyword type="enum" name="XML_ERR_MISSING_ENCODING" link="libxml2-xmlerror.html#XML_ERR_MISSING_ENCODING"/>
<keyword type="enum" name="XML_ERR_MIXED_NOT_FINISHED" link="libxml2-xmlerror.html#XML_ERR_MIXED_NOT_FINISHED"/>
<keyword type="enum" name="XML_ERR_MIXED_NOT_STARTED" link="libxml2-xmlerror.html#XML_ERR_MIXED_NOT_STARTED"/>
<keyword type="enum" name="XML_ERR_NAME_REQUIRED" link="libxml2-xmlerror.html#XML_ERR_NAME_REQUIRED"/>
<keyword type="enum" name="XML_ERR_NAME_TOO_LONG" link="libxml2-xmlerror.html#XML_ERR_NAME_TOO_LONG"/>
<keyword type="enum" name="XML_ERR_NMTOKEN_REQUIRED" link="libxml2-xmlerror.html#XML_ERR_NMTOKEN_REQUIRED"/>
<keyword type="enum" name="XML_ERR_NONE" link="libxml2-xmlerror.html#XML_ERR_NONE"/>
<keyword type="enum" name="XML_ERR_NOTATION_NOT_FINISHED" link="libxml2-xmlerror.html#XML_ERR_NOTATION_NOT_FINISHED"/>
<keyword type="enum" name="XML_ERR_NOTATION_NOT_STARTED" link="libxml2-xmlerror.html#XML_ERR_NOTATION_NOT_STARTED"/>
<keyword type="enum" name="XML_ERR_NOTATION_PROCESSING" link="libxml2-xmlerror.html#XML_ERR_NOTATION_PROCESSING"/>
<keyword type="enum" name="XML_ERR_NOT_STANDALONE" link="libxml2-xmlerror.html#XML_ERR_NOT_STANDALONE"/>
<keyword type="enum" name="XML_ERR_NOT_WELL_BALANCED" link="libxml2-xmlerror.html#XML_ERR_NOT_WELL_BALANCED"/>
<keyword type="enum" name="XML_ERR_NO_DTD" link="libxml2-xmlerror.html#XML_ERR_NO_DTD"/>
<keyword type="enum" name="XML_ERR_NO_MEMORY" link="libxml2-xmlerror.html#XML_ERR_NO_MEMORY"/>
<keyword type="enum" name="XML_ERR_NS_DECL_ERROR" link="libxml2-xmlerror.html#XML_ERR_NS_DECL_ERROR"/>
<keyword type="enum" name="XML_ERR_OK" link="libxml2-xmlerror.html#XML_ERR_OK"/>
<keyword type="enum" name="XML_ERR_PCDATA_REQUIRED" link="libxml2-xmlerror.html#XML_ERR_PCDATA_REQUIRED"/>
<keyword type="enum" name="XML_ERR_PEREF_AT_EOF" link="libxml2-xmlerror.html#XML_ERR_PEREF_AT_EOF"/>
<keyword type="enum" name="XML_ERR_PEREF_IN_EPILOG" link="libxml2-xmlerror.html#XML_ERR_PEREF_IN_EPILOG"/>
<keyword type="enum" name="XML_ERR_PEREF_IN_INT_SUBSET" link="libxml2-xmlerror.html#XML_ERR_PEREF_IN_INT_SUBSET"/>
<keyword type="enum" name="XML_ERR_PEREF_IN_PROLOG" link="libxml2-xmlerror.html#XML_ERR_PEREF_IN_PROLOG"/>
<keyword type="enum" name="XML_ERR_PEREF_NO_NAME" link="libxml2-xmlerror.html#XML_ERR_PEREF_NO_NAME"/>
<keyword type="enum" name="XML_ERR_PEREF_SEMICOL_MISSING" link="libxml2-xmlerror.html#XML_ERR_PEREF_SEMICOL_MISSING"/>
<keyword type="enum" name="XML_ERR_PI_NOT_FINISHED" link="libxml2-xmlerror.html#XML_ERR_PI_NOT_FINISHED"/>
<keyword type="enum" name="XML_ERR_PI_NOT_STARTED" link="libxml2-xmlerror.html#XML_ERR_PI_NOT_STARTED"/>
<keyword type="enum" name="XML_ERR_PUBID_REQUIRED" link="libxml2-xmlerror.html#XML_ERR_PUBID_REQUIRED"/>
<keyword type="enum" name="XML_ERR_RESERVED_XML_NAME" link="libxml2-xmlerror.html#XML_ERR_RESERVED_XML_NAME"/>
<keyword type="enum" name="XML_ERR_SEPARATOR_REQUIRED" link="libxml2-xmlerror.html#XML_ERR_SEPARATOR_REQUIRED"/>
<keyword type="enum" name="XML_ERR_SPACE_REQUIRED" link="libxml2-xmlerror.html#XML_ERR_SPACE_REQUIRED"/>
<keyword type="enum" name="XML_ERR_STANDALONE_VALUE" link="libxml2-xmlerror.html#XML_ERR_STANDALONE_VALUE"/>
<keyword type="enum" name="XML_ERR_STRING_NOT_CLOSED" link="libxml2-xmlerror.html#XML_ERR_STRING_NOT_CLOSED"/>
<keyword type="enum" name="XML_ERR_STRING_NOT_STARTED" link="libxml2-xmlerror.html#XML_ERR_STRING_NOT_STARTED"/>
<keyword type="enum" name="XML_ERR_TAG_NAME_MISMATCH" link="libxml2-xmlerror.html#XML_ERR_TAG_NAME_MISMATCH"/>
<keyword type="enum" name="XML_ERR_TAG_NOT_FINISHED" link="libxml2-xmlerror.html#XML_ERR_TAG_NOT_FINISHED"/>
<keyword type="enum" name="XML_ERR_UNDECLARED_ENTITY" link="libxml2-xmlerror.html#XML_ERR_UNDECLARED_ENTITY"/>
<keyword type="enum" name="XML_ERR_UNKNOWN_ENCODING" link="libxml2-xmlerror.html#XML_ERR_UNKNOWN_ENCODING"/>
<keyword type="enum" name="XML_ERR_UNKNOWN_VERSION" link="libxml2-xmlerror.html#XML_ERR_UNKNOWN_VERSION"/>
<keyword type="enum" name="XML_ERR_UNPARSED_ENTITY" link="libxml2-xmlerror.html#XML_ERR_UNPARSED_ENTITY"/>
<keyword type="enum" name="XML_ERR_UNSUPPORTED_ENCODING" link="libxml2-xmlerror.html#XML_ERR_UNSUPPORTED_ENCODING"/>
<keyword type="enum" name="XML_ERR_URI_FRAGMENT" link="libxml2-xmlerror.html#XML_ERR_URI_FRAGMENT"/>
<keyword type="enum" name="XML_ERR_URI_REQUIRED" link="libxml2-xmlerror.html#XML_ERR_URI_REQUIRED"/>
<keyword type="enum" name="XML_ERR_USER_STOP" link="libxml2-xmlerror.html#XML_ERR_USER_STOP"/>
<keyword type="enum" name="XML_ERR_VALUE_REQUIRED" link="libxml2-xmlerror.html#XML_ERR_VALUE_REQUIRED"/>
<keyword type="enum" name="XML_ERR_VERSION_MISMATCH" link="libxml2-xmlerror.html#XML_ERR_VERSION_MISMATCH"/>
<keyword type="enum" name="XML_ERR_VERSION_MISSING" link="libxml2-xmlerror.html#XML_ERR_VERSION_MISSING"/>
<keyword type="enum" name="XML_ERR_WARNING" link="libxml2-xmlerror.html#XML_ERR_WARNING"/>
<keyword type="enum" name="XML_ERR_XMLDECL_NOT_FINISHED" link="libxml2-xmlerror.html#XML_ERR_XMLDECL_NOT_FINISHED"/>
<keyword type="enum" name="XML_ERR_XMLDECL_NOT_STARTED" link="libxml2-xmlerror.html#XML_ERR_XMLDECL_NOT_STARTED"/>
<keyword type="enum" name="XML_EXP_ATOM" link="libxml2-xmlregexp.html#XML_EXP_ATOM"/>
<keyword type="enum" name="XML_EXP_COUNT" link="libxml2-xmlregexp.html#XML_EXP_COUNT"/>
<keyword type="enum" name="XML_EXP_EMPTY" link="libxml2-xmlregexp.html#XML_EXP_EMPTY"/>
<keyword type="enum" name="XML_EXP_FORBID" link="libxml2-xmlregexp.html#XML_EXP_FORBID"/>
<keyword type="enum" name="XML_EXP_OR" link="libxml2-xmlregexp.html#XML_EXP_OR"/>
<keyword type="enum" name="XML_EXP_SEQ" link="libxml2-xmlregexp.html#XML_EXP_SEQ"/>
<keyword type="enum" name="XML_EXTERNAL_GENERAL_PARSED_ENTITY" link="libxml2-entities.html#XML_EXTERNAL_GENERAL_PARSED_ENTITY"/>
<keyword type="enum" name="XML_EXTERNAL_GENERAL_UNPARSED_ENTITY" link="libxml2-entities.html#XML_EXTERNAL_GENERAL_UNPARSED_ENTITY"/>
<keyword type="enum" name="XML_EXTERNAL_PARAMETER_ENTITY" link="libxml2-entities.html#XML_EXTERNAL_PARAMETER_ENTITY"/>
<keyword type="enum" name="XML_FROM_BUFFER" link="libxml2-xmlerror.html#XML_FROM_BUFFER"/>
<keyword type="enum" name="XML_FROM_C14N" link="libxml2-xmlerror.html#XML_FROM_C14N"/>
<keyword type="enum" name="XML_FROM_CATALOG" link="libxml2-xmlerror.html#XML_FROM_CATALOG"/>
<keyword type="enum" name="XML_FROM_CHECK" link="libxml2-xmlerror.html#XML_FROM_CHECK"/>
<keyword type="enum" name="XML_FROM_DATATYPE" link="libxml2-xmlerror.html#XML_FROM_DATATYPE"/>
<keyword type="enum" name="XML_FROM_DTD" link="libxml2-xmlerror.html#XML_FROM_DTD"/>
<keyword type="enum" name="XML_FROM_FTP" link="libxml2-xmlerror.html#XML_FROM_FTP"/>
<keyword type="enum" name="XML_FROM_HTML" link="libxml2-xmlerror.html#XML_FROM_HTML"/>
<keyword type="enum" name="XML_FROM_HTTP" link="libxml2-xmlerror.html#XML_FROM_HTTP"/>
<keyword type="enum" name="XML_FROM_I18N" link="libxml2-xmlerror.html#XML_FROM_I18N"/>
<keyword type="enum" name="XML_FROM_IO" link="libxml2-xmlerror.html#XML_FROM_IO"/>
<keyword type="enum" name="XML_FROM_MEMORY" link="libxml2-xmlerror.html#XML_FROM_MEMORY"/>
<keyword type="enum" name="XML_FROM_MODULE" link="libxml2-xmlerror.html#XML_FROM_MODULE"/>
<keyword type="enum" name="XML_FROM_NAMESPACE" link="libxml2-xmlerror.html#XML_FROM_NAMESPACE"/>
<keyword type="enum" name="XML_FROM_NONE" link="libxml2-xmlerror.html#XML_FROM_NONE"/>
<keyword type="enum" name="XML_FROM_OUTPUT" link="libxml2-xmlerror.html#XML_FROM_OUTPUT"/>
<keyword type="enum" name="XML_FROM_PARSER" link="libxml2-xmlerror.html#XML_FROM_PARSER"/>
<keyword type="enum" name="XML_FROM_REGEXP" link="libxml2-xmlerror.html#XML_FROM_REGEXP"/>
<keyword type="enum" name="XML_FROM_RELAXNGP" link="libxml2-xmlerror.html#XML_FROM_RELAXNGP"/>
<keyword type="enum" name="XML_FROM_RELAXNGV" link="libxml2-xmlerror.html#XML_FROM_RELAXNGV"/>
<keyword type="enum" name="XML_FROM_SCHEMASP" link="libxml2-xmlerror.html#XML_FROM_SCHEMASP"/>
<keyword type="enum" name="XML_FROM_SCHEMASV" link="libxml2-xmlerror.html#XML_FROM_SCHEMASV"/>
<keyword type="enum" name="XML_FROM_SCHEMATRONV" link="libxml2-xmlerror.html#XML_FROM_SCHEMATRONV"/>
<keyword type="enum" name="XML_FROM_TREE" link="libxml2-xmlerror.html#XML_FROM_TREE"/>
<keyword type="enum" name="XML_FROM_URI" link="libxml2-xmlerror.html#XML_FROM_URI"/>
<keyword type="enum" name="XML_FROM_VALID" link="libxml2-xmlerror.html#XML_FROM_VALID"/>
<keyword type="enum" name="XML_FROM_WRITER" link="libxml2-xmlerror.html#XML_FROM_WRITER"/>
<keyword type="enum" name="XML_FROM_XINCLUDE" link="libxml2-xmlerror.html#XML_FROM_XINCLUDE"/>
<keyword type="enum" name="XML_FROM_XPATH" link="libxml2-xmlerror.html#XML_FROM_XPATH"/>
<keyword type="enum" name="XML_FROM_XPOINTER" link="libxml2-xmlerror.html#XML_FROM_XPOINTER"/>
<keyword type="enum" name="XML_FROM_XSLT" link="libxml2-xmlerror.html#XML_FROM_XSLT"/>
<keyword type="enum" name="XML_FTP_ACCNT" link="libxml2-xmlerror.html#XML_FTP_ACCNT"/>
<keyword type="enum" name="XML_FTP_EPSV_ANSWER" link="libxml2-xmlerror.html#XML_FTP_EPSV_ANSWER"/>
<keyword type="enum" name="XML_FTP_PASV_ANSWER" link="libxml2-xmlerror.html#XML_FTP_PASV_ANSWER"/>
<keyword type="enum" name="XML_FTP_URL_SYNTAX" link="libxml2-xmlerror.html#XML_FTP_URL_SYNTAX"/>
<keyword type="enum" name="XML_HTML_DOCUMENT_NODE" link="libxml2-tree.html#XML_HTML_DOCUMENT_NODE"/>
<keyword type="enum" name="XML_HTML_INCORRECTLY_OPENED_COMMENT" link="libxml2-xmlerror.html#XML_HTML_INCORRECTLY_OPENED_COMMENT"/>
<keyword type="enum" name="XML_HTML_STRUCURE_ERROR" link="libxml2-xmlerror.html#XML_HTML_STRUCURE_ERROR"/>
<keyword type="enum" name="XML_HTML_UNKNOWN_TAG" link="libxml2-xmlerror.html#XML_HTML_UNKNOWN_TAG"/>
<keyword type="enum" name="XML_HTTP_UNKNOWN_HOST" link="libxml2-xmlerror.html#XML_HTTP_UNKNOWN_HOST"/>
<keyword type="enum" name="XML_HTTP_URL_SYNTAX" link="libxml2-xmlerror.html#XML_HTTP_URL_SYNTAX"/>
<keyword type="enum" name="XML_HTTP_USE_IP" link="libxml2-xmlerror.html#XML_HTTP_USE_IP"/>
<keyword type="enum" name="XML_I18N_CONV_FAILED" link="libxml2-xmlerror.html#XML_I18N_CONV_FAILED"/>
<keyword type="enum" name="XML_I18N_EXCESS_HANDLER" link="libxml2-xmlerror.html#XML_I18N_EXCESS_HANDLER"/>
<keyword type="enum" name="XML_I18N_NO_HANDLER" link="libxml2-xmlerror.html#XML_I18N_NO_HANDLER"/>
<keyword type="enum" name="XML_I18N_NO_NAME" link="libxml2-xmlerror.html#XML_I18N_NO_NAME"/>
<keyword type="enum" name="XML_I18N_NO_OUTPUT" link="libxml2-xmlerror.html#XML_I18N_NO_OUTPUT"/>
<keyword type="enum" name="XML_INTERNAL_GENERAL_ENTITY" link="libxml2-entities.html#XML_INTERNAL_GENERAL_ENTITY"/>
<keyword type="enum" name="XML_INTERNAL_PARAMETER_ENTITY" link="libxml2-entities.html#XML_INTERNAL_PARAMETER_ENTITY"/>
<keyword type="enum" name="XML_INTERNAL_PREDEFINED_ENTITY" link="libxml2-entities.html#XML_INTERNAL_PREDEFINED_ENTITY"/>
<keyword type="enum" name="XML_IO_BUFFER_FULL" link="libxml2-xmlerror.html#XML_IO_BUFFER_FULL"/>
<keyword type="enum" name="XML_IO_EACCES" link="libxml2-xmlerror.html#XML_IO_EACCES"/>
<keyword type="enum" name="XML_IO_EADDRINUSE" link="libxml2-xmlerror.html#XML_IO_EADDRINUSE"/>
<keyword type="enum" name="XML_IO_EAFNOSUPPORT" link="libxml2-xmlerror.html#XML_IO_EAFNOSUPPORT"/>
<keyword type="enum" name="XML_IO_EAGAIN" link="libxml2-xmlerror.html#XML_IO_EAGAIN"/>
<keyword type="enum" name="XML_IO_EALREADY" link="libxml2-xmlerror.html#XML_IO_EALREADY"/>
<keyword type="enum" name="XML_IO_EBADF" link="libxml2-xmlerror.html#XML_IO_EBADF"/>
<keyword type="enum" name="XML_IO_EBADMSG" link="libxml2-xmlerror.html#XML_IO_EBADMSG"/>
<keyword type="enum" name="XML_IO_EBUSY" link="libxml2-xmlerror.html#XML_IO_EBUSY"/>
<keyword type="enum" name="XML_IO_ECANCELED" link="libxml2-xmlerror.html#XML_IO_ECANCELED"/>
<keyword type="enum" name="XML_IO_ECHILD" link="libxml2-xmlerror.html#XML_IO_ECHILD"/>
<keyword type="enum" name="XML_IO_ECONNREFUSED" link="libxml2-xmlerror.html#XML_IO_ECONNREFUSED"/>
<keyword type="enum" name="XML_IO_EDEADLK" link="libxml2-xmlerror.html#XML_IO_EDEADLK"/>
<keyword type="enum" name="XML_IO_EDOM" link="libxml2-xmlerror.html#XML_IO_EDOM"/>
<keyword type="enum" name="XML_IO_EEXIST" link="libxml2-xmlerror.html#XML_IO_EEXIST"/>
<keyword type="enum" name="XML_IO_EFAULT" link="libxml2-xmlerror.html#XML_IO_EFAULT"/>
<keyword type="enum" name="XML_IO_EFBIG" link="libxml2-xmlerror.html#XML_IO_EFBIG"/>
<keyword type="enum" name="XML_IO_EINPROGRESS" link="libxml2-xmlerror.html#XML_IO_EINPROGRESS"/>
<keyword type="enum" name="XML_IO_EINTR" link="libxml2-xmlerror.html#XML_IO_EINTR"/>
<keyword type="enum" name="XML_IO_EINVAL" link="libxml2-xmlerror.html#XML_IO_EINVAL"/>
<keyword type="enum" name="XML_IO_EIO" link="libxml2-xmlerror.html#XML_IO_EIO"/>
<keyword type="enum" name="XML_IO_EISCONN" link="libxml2-xmlerror.html#XML_IO_EISCONN"/>
<keyword type="enum" name="XML_IO_EISDIR" link="libxml2-xmlerror.html#XML_IO_EISDIR"/>
<keyword type="enum" name="XML_IO_EMFILE" link="libxml2-xmlerror.html#XML_IO_EMFILE"/>
<keyword type="enum" name="XML_IO_EMLINK" link="libxml2-xmlerror.html#XML_IO_EMLINK"/>
<keyword type="enum" name="XML_IO_EMSGSIZE" link="libxml2-xmlerror.html#XML_IO_EMSGSIZE"/>
<keyword type="enum" name="XML_IO_ENAMETOOLONG" link="libxml2-xmlerror.html#XML_IO_ENAMETOOLONG"/>
<keyword type="enum" name="XML_IO_ENCODER" link="libxml2-xmlerror.html#XML_IO_ENCODER"/>
<keyword type="enum" name="XML_IO_ENETUNREACH" link="libxml2-xmlerror.html#XML_IO_ENETUNREACH"/>
<keyword type="enum" name="XML_IO_ENFILE" link="libxml2-xmlerror.html#XML_IO_ENFILE"/>
<keyword type="enum" name="XML_IO_ENODEV" link="libxml2-xmlerror.html#XML_IO_ENODEV"/>
<keyword type="enum" name="XML_IO_ENOENT" link="libxml2-xmlerror.html#XML_IO_ENOENT"/>
<keyword type="enum" name="XML_IO_ENOEXEC" link="libxml2-xmlerror.html#XML_IO_ENOEXEC"/>
<keyword type="enum" name="XML_IO_ENOLCK" link="libxml2-xmlerror.html#XML_IO_ENOLCK"/>
<keyword type="enum" name="XML_IO_ENOMEM" link="libxml2-xmlerror.html#XML_IO_ENOMEM"/>
<keyword type="enum" name="XML_IO_ENOSPC" link="libxml2-xmlerror.html#XML_IO_ENOSPC"/>
<keyword type="enum" name="XML_IO_ENOSYS" link="libxml2-xmlerror.html#XML_IO_ENOSYS"/>
<keyword type="enum" name="XML_IO_ENOTDIR" link="libxml2-xmlerror.html#XML_IO_ENOTDIR"/>
<keyword type="enum" name="XML_IO_ENOTEMPTY" link="libxml2-xmlerror.html#XML_IO_ENOTEMPTY"/>
<keyword type="enum" name="XML_IO_ENOTSOCK" link="libxml2-xmlerror.html#XML_IO_ENOTSOCK"/>
<keyword type="enum" name="XML_IO_ENOTSUP" link="libxml2-xmlerror.html#XML_IO_ENOTSUP"/>
<keyword type="enum" name="XML_IO_ENOTTY" link="libxml2-xmlerror.html#XML_IO_ENOTTY"/>
<keyword type="enum" name="XML_IO_ENXIO" link="libxml2-xmlerror.html#XML_IO_ENXIO"/>
<keyword type="enum" name="XML_IO_EPERM" link="libxml2-xmlerror.html#XML_IO_EPERM"/>
<keyword type="enum" name="XML_IO_EPIPE" link="libxml2-xmlerror.html#XML_IO_EPIPE"/>
<keyword type="enum" name="XML_IO_ERANGE" link="libxml2-xmlerror.html#XML_IO_ERANGE"/>
<keyword type="enum" name="XML_IO_EROFS" link="libxml2-xmlerror.html#XML_IO_EROFS"/>
<keyword type="enum" name="XML_IO_ESPIPE" link="libxml2-xmlerror.html#XML_IO_ESPIPE"/>
<keyword type="enum" name="XML_IO_ESRCH" link="libxml2-xmlerror.html#XML_IO_ESRCH"/>
<keyword type="enum" name="XML_IO_ETIMEDOUT" link="libxml2-xmlerror.html#XML_IO_ETIMEDOUT"/>
<keyword type="enum" name="XML_IO_EXDEV" link="libxml2-xmlerror.html#XML_IO_EXDEV"/>
<keyword type="enum" name="XML_IO_FLUSH" link="libxml2-xmlerror.html#XML_IO_FLUSH"/>
<keyword type="enum" name="XML_IO_LOAD_ERROR" link="libxml2-xmlerror.html#XML_IO_LOAD_ERROR"/>
<keyword type="enum" name="XML_IO_NETWORK_ATTEMPT" link="libxml2-xmlerror.html#XML_IO_NETWORK_ATTEMPT"/>
<keyword type="enum" name="XML_IO_NO_INPUT" link="libxml2-xmlerror.html#XML_IO_NO_INPUT"/>
<keyword type="enum" name="XML_IO_UNKNOWN" link="libxml2-xmlerror.html#XML_IO_UNKNOWN"/>
<keyword type="enum" name="XML_IO_WRITE" link="libxml2-xmlerror.html#XML_IO_WRITE"/>
<keyword type="enum" name="XML_MODULE_CLOSE" link="libxml2-xmlerror.html#XML_MODULE_CLOSE"/>
<keyword type="enum" name="XML_MODULE_LAZY" link="libxml2-xmlmodule.html#XML_MODULE_LAZY"/>
<keyword type="enum" name="XML_MODULE_LOCAL" link="libxml2-xmlmodule.html#XML_MODULE_LOCAL"/>
<keyword type="enum" name="XML_MODULE_OPEN" link="libxml2-xmlerror.html#XML_MODULE_OPEN"/>
<keyword type="enum" name="XML_NAMESPACE_DECL" link="libxml2-tree.html#XML_NAMESPACE_DECL"/>
<keyword type="enum" name="XML_NOTATION_NODE" link="libxml2-tree.html#XML_NOTATION_NODE"/>
<keyword type="enum" name="XML_NS_ERR_ATTRIBUTE_REDEFINED" link="libxml2-xmlerror.html#XML_NS_ERR_ATTRIBUTE_REDEFINED"/>
<keyword type="enum" name="XML_NS_ERR_COLON" link="libxml2-xmlerror.html#XML_NS_ERR_COLON"/>
<keyword type="enum" name="XML_NS_ERR_EMPTY" link="libxml2-xmlerror.html#XML_NS_ERR_EMPTY"/>
<keyword type="enum" name="XML_NS_ERR_QNAME" link="libxml2-xmlerror.html#XML_NS_ERR_QNAME"/>
<keyword type="enum" name="XML_NS_ERR_UNDEFINED_NAMESPACE" link="libxml2-xmlerror.html#XML_NS_ERR_UNDEFINED_NAMESPACE"/>
<keyword type="enum" name="XML_NS_ERR_XML_NAMESPACE" link="libxml2-xmlerror.html#XML_NS_ERR_XML_NAMESPACE"/>
<keyword type="enum" name="XML_PARSER_ATTRIBUTE_VALUE" link="libxml2-parser.html#XML_PARSER_ATTRIBUTE_VALUE"/>
<keyword type="enum" name="XML_PARSER_CDATA_SECTION" link="libxml2-parser.html#XML_PARSER_CDATA_SECTION"/>
<keyword type="enum" name="XML_PARSER_COMMENT" link="libxml2-parser.html#XML_PARSER_COMMENT"/>
<keyword type="enum" name="XML_PARSER_CONTENT" link="libxml2-parser.html#XML_PARSER_CONTENT"/>
<keyword type="enum" name="XML_PARSER_DEFAULTATTRS" link="libxml2-xmlreader.html#XML_PARSER_DEFAULTATTRS"/>
<keyword type="enum" name="XML_PARSER_DTD" link="libxml2-parser.html#XML_PARSER_DTD"/>
<keyword type="enum" name="XML_PARSER_END_TAG" link="libxml2-parser.html#XML_PARSER_END_TAG"/>
<keyword type="enum" name="XML_PARSER_ENTITY_DECL" link="libxml2-parser.html#XML_PARSER_ENTITY_DECL"/>
<keyword type="enum" name="XML_PARSER_ENTITY_VALUE" link="libxml2-parser.html#XML_PARSER_ENTITY_VALUE"/>
<keyword type="enum" name="XML_PARSER_EOF" link="libxml2-parser.html#XML_PARSER_EOF"/>
<keyword type="enum" name="XML_PARSER_EPILOG" link="libxml2-parser.html#XML_PARSER_EPILOG"/>
<keyword type="enum" name="XML_PARSER_IGNORE" link="libxml2-parser.html#XML_PARSER_IGNORE"/>
<keyword type="enum" name="XML_PARSER_LOADDTD" link="libxml2-xmlreader.html#XML_PARSER_LOADDTD"/>
<keyword type="enum" name="XML_PARSER_MISC" link="libxml2-parser.html#XML_PARSER_MISC"/>
<keyword type="enum" name="XML_PARSER_PI" link="libxml2-parser.html#XML_PARSER_PI"/>
<keyword type="enum" name="XML_PARSER_PROLOG" link="libxml2-parser.html#XML_PARSER_PROLOG"/>
<keyword type="enum" name="XML_PARSER_PUBLIC_LITERAL" link="libxml2-parser.html#XML_PARSER_PUBLIC_LITERAL"/>
<keyword type="enum" name="XML_PARSER_SEVERITY_ERROR" link="libxml2-xmlreader.html#XML_PARSER_SEVERITY_ERROR"/>
<keyword type="enum" name="XML_PARSER_SEVERITY_VALIDITY_ERROR" link="libxml2-xmlreader.html#XML_PARSER_SEVERITY_VALIDITY_ERROR"/>
<keyword type="enum" name="XML_PARSER_SEVERITY_VALIDITY_WARNING" link="libxml2-xmlreader.html#XML_PARSER_SEVERITY_VALIDITY_WARNING"/>
<keyword type="enum" name="XML_PARSER_SEVERITY_WARNING" link="libxml2-xmlreader.html#XML_PARSER_SEVERITY_WARNING"/>
<keyword type="enum" name="XML_PARSER_START" link="libxml2-parser.html#XML_PARSER_START"/>
<keyword type="enum" name="XML_PARSER_START_TAG" link="libxml2-parser.html#XML_PARSER_START_TAG"/>
<keyword type="enum" name="XML_PARSER_SUBST_ENTITIES" link="libxml2-xmlreader.html#XML_PARSER_SUBST_ENTITIES"/>
<keyword type="enum" name="XML_PARSER_SYSTEM_LITERAL" link="libxml2-parser.html#XML_PARSER_SYSTEM_LITERAL"/>
<keyword type="enum" name="XML_PARSER_VALIDATE" link="libxml2-xmlreader.html#XML_PARSER_VALIDATE"/>
<keyword type="enum" name="XML_PARSE_BIG_LINES" link="libxml2-parser.html#XML_PARSE_BIG_LINES"/>
<keyword type="enum" name="XML_PARSE_COMPACT" link="libxml2-parser.html#XML_PARSE_COMPACT"/>
<keyword type="enum" name="XML_PARSE_DOM" link="libxml2-parser.html#XML_PARSE_DOM"/>
<keyword type="enum" name="XML_PARSE_DTDATTR" link="libxml2-parser.html#XML_PARSE_DTDATTR"/>
<keyword type="enum" name="XML_PARSE_DTDLOAD" link="libxml2-parser.html#XML_PARSE_DTDLOAD"/>
<keyword type="enum" name="XML_PARSE_DTDVALID" link="libxml2-parser.html#XML_PARSE_DTDVALID"/>
<keyword type="enum" name="XML_PARSE_HUGE" link="libxml2-parser.html#XML_PARSE_HUGE"/>
<keyword type="enum" name="XML_PARSE_IGNORE_ENC" link="libxml2-parser.html#XML_PARSE_IGNORE_ENC"/>
<keyword type="enum" name="XML_PARSE_NOBASEFIX" link="libxml2-parser.html#XML_PARSE_NOBASEFIX"/>
<keyword type="enum" name="XML_PARSE_NOBLANKS" link="libxml2-parser.html#XML_PARSE_NOBLANKS"/>
<keyword type="enum" name="XML_PARSE_NOCDATA" link="libxml2-parser.html#XML_PARSE_NOCDATA"/>
<keyword type="enum" name="XML_PARSE_NODICT" link="libxml2-parser.html#XML_PARSE_NODICT"/>
<keyword type="enum" name="XML_PARSE_NOENT" link="libxml2-parser.html#XML_PARSE_NOENT"/>
<keyword type="enum" name="XML_PARSE_NOERROR" link="libxml2-parser.html#XML_PARSE_NOERROR"/>
<keyword type="enum" name="XML_PARSE_NONET" link="libxml2-parser.html#XML_PARSE_NONET"/>
<keyword type="enum" name="XML_PARSE_NOWARNING" link="libxml2-parser.html#XML_PARSE_NOWARNING"/>
<keyword type="enum" name="XML_PARSE_NOXINCNODE" link="libxml2-parser.html#XML_PARSE_NOXINCNODE"/>
<keyword type="enum" name="XML_PARSE_NSCLEAN" link="libxml2-parser.html#XML_PARSE_NSCLEAN"/>
<keyword type="enum" name="XML_PARSE_OLD10" link="libxml2-parser.html#XML_PARSE_OLD10"/>
<keyword type="enum" name="XML_PARSE_OLDSAX" link="libxml2-parser.html#XML_PARSE_OLDSAX"/>
<keyword type="enum" name="XML_PARSE_PEDANTIC" link="libxml2-parser.html#XML_PARSE_PEDANTIC"/>
<keyword type="enum" name="XML_PARSE_PUSH_DOM" link="libxml2-parser.html#XML_PARSE_PUSH_DOM"/>
<keyword type="enum" name="XML_PARSE_PUSH_SAX" link="libxml2-parser.html#XML_PARSE_PUSH_SAX"/>
<keyword type="enum" name="XML_PARSE_READER" link="libxml2-parser.html#XML_PARSE_READER"/>
<keyword type="enum" name="XML_PARSE_RECOVER" link="libxml2-parser.html#XML_PARSE_RECOVER"/>
<keyword type="enum" name="XML_PARSE_SAX" link="libxml2-parser.html#XML_PARSE_SAX"/>
<keyword type="enum" name="XML_PARSE_SAX1" link="libxml2-parser.html#XML_PARSE_SAX1"/>
<keyword type="enum" name="XML_PARSE_UNKNOWN" link="libxml2-parser.html#XML_PARSE_UNKNOWN"/>
<keyword type="enum" name="XML_PARSE_XINCLUDE" link="libxml2-parser.html#XML_PARSE_XINCLUDE"/>
<keyword type="enum" name="XML_PATTERN_DEFAULT" link="libxml2-pattern.html#XML_PATTERN_DEFAULT"/>
<keyword type="enum" name="XML_PATTERN_XPATH" link="libxml2-pattern.html#XML_PATTERN_XPATH"/>
<keyword type="enum" name="XML_PATTERN_XSFIELD" link="libxml2-pattern.html#XML_PATTERN_XSFIELD"/>
<keyword type="enum" name="XML_PATTERN_XSSEL" link="libxml2-pattern.html#XML_PATTERN_XSSEL"/>
<keyword type="enum" name="XML_PI_NODE" link="libxml2-tree.html#XML_PI_NODE"/>
<keyword type="enum" name="XML_READER_TYPE_ATTRIBUTE" link="libxml2-xmlreader.html#XML_READER_TYPE_ATTRIBUTE"/>
<keyword type="enum" name="XML_READER_TYPE_CDATA" link="libxml2-xmlreader.html#XML_READER_TYPE_CDATA"/>
<keyword type="enum" name="XML_READER_TYPE_COMMENT" link="libxml2-xmlreader.html#XML_READER_TYPE_COMMENT"/>
<keyword type="enum" name="XML_READER_TYPE_DOCUMENT" link="libxml2-xmlreader.html#XML_READER_TYPE_DOCUMENT"/>
<keyword type="enum" name="XML_READER_TYPE_DOCUMENT_FRAGMENT" link="libxml2-xmlreader.html#XML_READER_TYPE_DOCUMENT_FRAGMENT"/>
<keyword type="enum" name="XML_READER_TYPE_DOCUMENT_TYPE" link="libxml2-xmlreader.html#XML_READER_TYPE_DOCUMENT_TYPE"/>
<keyword type="enum" name="XML_READER_TYPE_ELEMENT" link="libxml2-xmlreader.html#XML_READER_TYPE_ELEMENT"/>
<keyword type="enum" name="XML_READER_TYPE_END_ELEMENT" link="libxml2-xmlreader.html#XML_READER_TYPE_END_ELEMENT"/>
<keyword type="enum" name="XML_READER_TYPE_END_ENTITY" link="libxml2-xmlreader.html#XML_READER_TYPE_END_ENTITY"/>
<keyword type="enum" name="XML_READER_TYPE_ENTITY" link="libxml2-xmlreader.html#XML_READER_TYPE_ENTITY"/>
<keyword type="enum" name="XML_READER_TYPE_ENTITY_REFERENCE" link="libxml2-xmlreader.html#XML_READER_TYPE_ENTITY_REFERENCE"/>
<keyword type="enum" name="XML_READER_TYPE_NONE" link="libxml2-xmlreader.html#XML_READER_TYPE_NONE"/>
<keyword type="enum" name="XML_READER_TYPE_NOTATION" link="libxml2-xmlreader.html#XML_READER_TYPE_NOTATION"/>
<keyword type="enum" name="XML_READER_TYPE_PROCESSING_INSTRUCTION" link="libxml2-xmlreader.html#XML_READER_TYPE_PROCESSING_INSTRUCTION"/>
<keyword type="enum" name="XML_READER_TYPE_SIGNIFICANT_WHITESPACE" link="libxml2-xmlreader.html#XML_READER_TYPE_SIGNIFICANT_WHITESPACE"/>
<keyword type="enum" name="XML_READER_TYPE_TEXT" link="libxml2-xmlreader.html#XML_READER_TYPE_TEXT"/>
<keyword type="enum" name="XML_READER_TYPE_WHITESPACE" link="libxml2-xmlreader.html#XML_READER_TYPE_WHITESPACE"/>
<keyword type="enum" name="XML_READER_TYPE_XML_DECLARATION" link="libxml2-xmlreader.html#XML_READER_TYPE_XML_DECLARATION"/>
<keyword type="enum" name="XML_REGEXP_COMPILE_ERROR" link="libxml2-xmlerror.html#XML_REGEXP_COMPILE_ERROR"/>
<keyword type="enum" name="XML_RELAXNGP_CRNG" link="libxml2-relaxng.html#XML_RELAXNGP_CRNG"/>
<keyword type="enum" name="XML_RELAXNGP_FREE_DOC" link="libxml2-relaxng.html#XML_RELAXNGP_FREE_DOC"/>
<keyword type="enum" name="XML_RELAXNGP_NONE" link="libxml2-relaxng.html#XML_RELAXNGP_NONE"/>
<keyword type="enum" name="XML_RELAXNG_ERR_ATTREXTRANS" link="libxml2-relaxng.html#XML_RELAXNG_ERR_ATTREXTRANS"/>
<keyword type="enum" name="XML_RELAXNG_ERR_ATTRNAME" link="libxml2-relaxng.html#XML_RELAXNG_ERR_ATTRNAME"/>
<keyword type="enum" name="XML_RELAXNG_ERR_ATTRNONS" link="libxml2-relaxng.html#XML_RELAXNG_ERR_ATTRNONS"/>
<keyword type="enum" name="XML_RELAXNG_ERR_ATTRVALID" link="libxml2-relaxng.html#XML_RELAXNG_ERR_ATTRVALID"/>
<keyword type="enum" name="XML_RELAXNG_ERR_ATTRWRONGNS" link="libxml2-relaxng.html#XML_RELAXNG_ERR_ATTRWRONGNS"/>
<keyword type="enum" name="XML_RELAXNG_ERR_CONTENTVALID" link="libxml2-relaxng.html#XML_RELAXNG_ERR_CONTENTVALID"/>
<keyword type="enum" name="XML_RELAXNG_ERR_DATAELEM" link="libxml2-relaxng.html#XML_RELAXNG_ERR_DATAELEM"/>
<keyword type="enum" name="XML_RELAXNG_ERR_DATATYPE" link="libxml2-relaxng.html#XML_RELAXNG_ERR_DATATYPE"/>
<keyword type="enum" name="XML_RELAXNG_ERR_DUPID" link="libxml2-relaxng.html#XML_RELAXNG_ERR_DUPID"/>
<keyword type="enum" name="XML_RELAXNG_ERR_ELEMEXTRANS" link="libxml2-relaxng.html#XML_RELAXNG_ERR_ELEMEXTRANS"/>
<keyword type="enum" name="XML_RELAXNG_ERR_ELEMNAME" link="libxml2-relaxng.html#XML_RELAXNG_ERR_ELEMNAME"/>
<keyword type="enum" name="XML_RELAXNG_ERR_ELEMNONS" link="libxml2-relaxng.html#XML_RELAXNG_ERR_ELEMNONS"/>
<keyword type="enum" name="XML_RELAXNG_ERR_ELEMNOTEMPTY" link="libxml2-relaxng.html#XML_RELAXNG_ERR_ELEMNOTEMPTY"/>
<keyword type="enum" name="XML_RELAXNG_ERR_ELEMWRONG" link="libxml2-relaxng.html#XML_RELAXNG_ERR_ELEMWRONG"/>
<keyword type="enum" name="XML_RELAXNG_ERR_ELEMWRONGNS" link="libxml2-relaxng.html#XML_RELAXNG_ERR_ELEMWRONGNS"/>
<keyword type="enum" name="XML_RELAXNG_ERR_EXTRACONTENT" link="libxml2-relaxng.html#XML_RELAXNG_ERR_EXTRACONTENT"/>
<keyword type="enum" name="XML_RELAXNG_ERR_EXTRADATA" link="libxml2-relaxng.html#XML_RELAXNG_ERR_EXTRADATA"/>
<keyword type="enum" name="XML_RELAXNG_ERR_INTEREXTRA" link="libxml2-relaxng.html#XML_RELAXNG_ERR_INTEREXTRA"/>
<keyword type="enum" name="XML_RELAXNG_ERR_INTERNAL" link="libxml2-relaxng.html#XML_RELAXNG_ERR_INTERNAL"/>
<keyword type="enum" name="XML_RELAXNG_ERR_INTERNODATA" link="libxml2-relaxng.html#XML_RELAXNG_ERR_INTERNODATA"/>
<keyword type="enum" name="XML_RELAXNG_ERR_INTERSEQ" link="libxml2-relaxng.html#XML_RELAXNG_ERR_INTERSEQ"/>
<keyword type="enum" name="XML_RELAXNG_ERR_INVALIDATTR" link="libxml2-relaxng.html#XML_RELAXNG_ERR_INVALIDATTR"/>
<keyword type="enum" name="XML_RELAXNG_ERR_LACKDATA" link="libxml2-relaxng.html#XML_RELAXNG_ERR_LACKDATA"/>
<keyword type="enum" name="XML_RELAXNG_ERR_LIST" link="libxml2-relaxng.html#XML_RELAXNG_ERR_LIST"/>
<keyword type="enum" name="XML_RELAXNG_ERR_LISTELEM" link="libxml2-relaxng.html#XML_RELAXNG_ERR_LISTELEM"/>
<keyword type="enum" name="XML_RELAXNG_ERR_LISTEMPTY" link="libxml2-relaxng.html#XML_RELAXNG_ERR_LISTEMPTY"/>
<keyword type="enum" name="XML_RELAXNG_ERR_LISTEXTRA" link="libxml2-relaxng.html#XML_RELAXNG_ERR_LISTEXTRA"/>
<keyword type="enum" name="XML_RELAXNG_ERR_MEMORY" link="libxml2-relaxng.html#XML_RELAXNG_ERR_MEMORY"/>
<keyword type="enum" name="XML_RELAXNG_ERR_NODEFINE" link="libxml2-relaxng.html#XML_RELAXNG_ERR_NODEFINE"/>
<keyword type="enum" name="XML_RELAXNG_ERR_NOELEM" link="libxml2-relaxng.html#XML_RELAXNG_ERR_NOELEM"/>
<keyword type="enum" name="XML_RELAXNG_ERR_NOGRAMMAR" link="libxml2-relaxng.html#XML_RELAXNG_ERR_NOGRAMMAR"/>
<keyword type="enum" name="XML_RELAXNG_ERR_NOSTATE" link="libxml2-relaxng.html#XML_RELAXNG_ERR_NOSTATE"/>
<keyword type="enum" name="XML_RELAXNG_ERR_NOTELEM" link="libxml2-relaxng.html#XML_RELAXNG_ERR_NOTELEM"/>
<keyword type="enum" name="XML_RELAXNG_ERR_TEXTWRONG" link="libxml2-relaxng.html#XML_RELAXNG_ERR_TEXTWRONG"/>
<keyword type="enum" name="XML_RELAXNG_ERR_TYPE" link="libxml2-relaxng.html#XML_RELAXNG_ERR_TYPE"/>
<keyword type="enum" name="XML_RELAXNG_ERR_TYPECMP" link="libxml2-relaxng.html#XML_RELAXNG_ERR_TYPECMP"/>
<keyword type="enum" name="XML_RELAXNG_ERR_TYPEVAL" link="libxml2-relaxng.html#XML_RELAXNG_ERR_TYPEVAL"/>
<keyword type="enum" name="XML_RELAXNG_ERR_VALELEM" link="libxml2-relaxng.html#XML_RELAXNG_ERR_VALELEM"/>
<keyword type="enum" name="XML_RELAXNG_ERR_VALUE" link="libxml2-relaxng.html#XML_RELAXNG_ERR_VALUE"/>
<keyword type="enum" name="XML_RELAXNG_OK" link="libxml2-relaxng.html#XML_RELAXNG_OK"/>
<keyword type="enum" name="XML_RNGP_ANYNAME_ATTR_ANCESTOR" link="libxml2-xmlerror.html#XML_RNGP_ANYNAME_ATTR_ANCESTOR"/>
<keyword type="enum" name="XML_RNGP_ATTRIBUTE_CHILDREN" link="libxml2-xmlerror.html#XML_RNGP_ATTRIBUTE_CHILDREN"/>
<keyword type="enum" name="XML_RNGP_ATTRIBUTE_CONTENT" link="libxml2-xmlerror.html#XML_RNGP_ATTRIBUTE_CONTENT"/>
<keyword type="enum" name="XML_RNGP_ATTRIBUTE_EMPTY" link="libxml2-xmlerror.html#XML_RNGP_ATTRIBUTE_EMPTY"/>
<keyword type="enum" name="XML_RNGP_ATTRIBUTE_NOOP" link="libxml2-xmlerror.html#XML_RNGP_ATTRIBUTE_NOOP"/>
<keyword type="enum" name="XML_RNGP_ATTR_CONFLICT" link="libxml2-xmlerror.html#XML_RNGP_ATTR_CONFLICT"/>
<keyword type="enum" name="XML_RNGP_CHOICE_CONTENT" link="libxml2-xmlerror.html#XML_RNGP_CHOICE_CONTENT"/>
<keyword type="enum" name="XML_RNGP_CHOICE_EMPTY" link="libxml2-xmlerror.html#XML_RNGP_CHOICE_EMPTY"/>
<keyword type="enum" name="XML_RNGP_CREATE_FAILURE" link="libxml2-xmlerror.html#XML_RNGP_CREATE_FAILURE"/>
<keyword type="enum" name="XML_RNGP_DATA_CONTENT" link="libxml2-xmlerror.html#XML_RNGP_DATA_CONTENT"/>
<keyword type="enum" name="XML_RNGP_DEFINE_CREATE_FAILED" link="libxml2-xmlerror.html#XML_RNGP_DEFINE_CREATE_FAILED"/>
<keyword type="enum" name="XML_RNGP_DEFINE_EMPTY" link="libxml2-xmlerror.html#XML_RNGP_DEFINE_EMPTY"/>
<keyword type="enum" name="XML_RNGP_DEFINE_MISSING" link="libxml2-xmlerror.html#XML_RNGP_DEFINE_MISSING"/>
<keyword type="enum" name="XML_RNGP_DEFINE_NAME_MISSING" link="libxml2-xmlerror.html#XML_RNGP_DEFINE_NAME_MISSING"/>
<keyword type="enum" name="XML_RNGP_DEF_CHOICE_AND_INTERLEAVE" link="libxml2-xmlerror.html#XML_RNGP_DEF_CHOICE_AND_INTERLEAVE"/>
<keyword type="enum" name="XML_RNGP_ELEMENT_CONTENT" link="libxml2-xmlerror.html#XML_RNGP_ELEMENT_CONTENT"/>
<keyword type="enum" name="XML_RNGP_ELEMENT_EMPTY" link="libxml2-xmlerror.html#XML_RNGP_ELEMENT_EMPTY"/>
<keyword type="enum" name="XML_RNGP_ELEMENT_NAME" link="libxml2-xmlerror.html#XML_RNGP_ELEMENT_NAME"/>
<keyword type="enum" name="XML_RNGP_ELEMENT_NO_CONTENT" link="libxml2-xmlerror.html#XML_RNGP_ELEMENT_NO_CONTENT"/>
<keyword type="enum" name="XML_RNGP_ELEM_CONTENT_EMPTY" link="libxml2-xmlerror.html#XML_RNGP_ELEM_CONTENT_EMPTY"/>
<keyword type="enum" name="XML_RNGP_ELEM_CONTENT_ERROR" link="libxml2-xmlerror.html#XML_RNGP_ELEM_CONTENT_ERROR"/>
<keyword type="enum" name="XML_RNGP_ELEM_TEXT_CONFLICT" link="libxml2-xmlerror.html#XML_RNGP_ELEM_TEXT_CONFLICT"/>
<keyword type="enum" name="XML_RNGP_EMPTY" link="libxml2-xmlerror.html#XML_RNGP_EMPTY"/>
<keyword type="enum" name="XML_RNGP_EMPTY_CONSTRUCT" link="libxml2-xmlerror.html#XML_RNGP_EMPTY_CONSTRUCT"/>
<keyword type="enum" name="XML_RNGP_EMPTY_CONTENT" link="libxml2-xmlerror.html#XML_RNGP_EMPTY_CONTENT"/>
<keyword type="enum" name="XML_RNGP_EMPTY_NOT_EMPTY" link="libxml2-xmlerror.html#XML_RNGP_EMPTY_NOT_EMPTY"/>
<keyword type="enum" name="XML_RNGP_ERROR_TYPE_LIB" link="libxml2-xmlerror.html#XML_RNGP_ERROR_TYPE_LIB"/>
<keyword type="enum" name="XML_RNGP_EXCEPT_EMPTY" link="libxml2-xmlerror.html#XML_RNGP_EXCEPT_EMPTY"/>
<keyword type="enum" name="XML_RNGP_EXCEPT_MISSING" link="libxml2-xmlerror.html#XML_RNGP_EXCEPT_MISSING"/>
<keyword type="enum" name="XML_RNGP_EXCEPT_MULTIPLE" link="libxml2-xmlerror.html#XML_RNGP_EXCEPT_MULTIPLE"/>
<keyword type="enum" name="XML_RNGP_EXCEPT_NO_CONTENT" link="libxml2-xmlerror.html#XML_RNGP_EXCEPT_NO_CONTENT"/>
<keyword type="enum" name="XML_RNGP_EXTERNALREF_EMTPY" link="libxml2-xmlerror.html#XML_RNGP_EXTERNALREF_EMTPY"/>
<keyword type="enum" name="XML_RNGP_EXTERNALREF_RECURSE" link="libxml2-xmlerror.html#XML_RNGP_EXTERNALREF_RECURSE"/>
<keyword type="enum" name="XML_RNGP_EXTERNAL_REF_FAILURE" link="libxml2-xmlerror.html#XML_RNGP_EXTERNAL_REF_FAILURE"/>
<keyword type="enum" name="XML_RNGP_FORBIDDEN_ATTRIBUTE" link="libxml2-xmlerror.html#XML_RNGP_FORBIDDEN_ATTRIBUTE"/>
<keyword type="enum" name="XML_RNGP_FOREIGN_ELEMENT" link="libxml2-xmlerror.html#XML_RNGP_FOREIGN_ELEMENT"/>
<keyword type="enum" name="XML_RNGP_GRAMMAR_CONTENT" link="libxml2-xmlerror.html#XML_RNGP_GRAMMAR_CONTENT"/>
<keyword type="enum" name="XML_RNGP_GRAMMAR_EMPTY" link="libxml2-xmlerror.html#XML_RNGP_GRAMMAR_EMPTY"/>
<keyword type="enum" name="XML_RNGP_GRAMMAR_MISSING" link="libxml2-xmlerror.html#XML_RNGP_GRAMMAR_MISSING"/>
<keyword type="enum" name="XML_RNGP_GRAMMAR_NO_START" link="libxml2-xmlerror.html#XML_RNGP_GRAMMAR_NO_START"/>
<keyword type="enum" name="XML_RNGP_GROUP_ATTR_CONFLICT" link="libxml2-xmlerror.html#XML_RNGP_GROUP_ATTR_CONFLICT"/>
<keyword type="enum" name="XML_RNGP_HREF_ERROR" link="libxml2-xmlerror.html#XML_RNGP_HREF_ERROR"/>
<keyword type="enum" name="XML_RNGP_INCLUDE_EMPTY" link="libxml2-xmlerror.html#XML_RNGP_INCLUDE_EMPTY"/>
<keyword type="enum" name="XML_RNGP_INCLUDE_FAILURE" link="libxml2-xmlerror.html#XML_RNGP_INCLUDE_FAILURE"/>
<keyword type="enum" name="XML_RNGP_INCLUDE_RECURSE" link="libxml2-xmlerror.html#XML_RNGP_INCLUDE_RECURSE"/>
<keyword type="enum" name="XML_RNGP_INTERLEAVE_ADD" link="libxml2-xmlerror.html#XML_RNGP_INTERLEAVE_ADD"/>
<keyword type="enum" name="XML_RNGP_INTERLEAVE_CREATE_FAILED" link="libxml2-xmlerror.html#XML_RNGP_INTERLEAVE_CREATE_FAILED"/>
<keyword type="enum" name="XML_RNGP_INTERLEAVE_EMPTY" link="libxml2-xmlerror.html#XML_RNGP_INTERLEAVE_EMPTY"/>
<keyword type="enum" name="XML_RNGP_INTERLEAVE_NO_CONTENT" link="libxml2-xmlerror.html#XML_RNGP_INTERLEAVE_NO_CONTENT"/>
<keyword type="enum" name="XML_RNGP_INVALID_DEFINE_NAME" link="libxml2-xmlerror.html#XML_RNGP_INVALID_DEFINE_NAME"/>
<keyword type="enum" name="XML_RNGP_INVALID_URI" link="libxml2-xmlerror.html#XML_RNGP_INVALID_URI"/>
<keyword type="enum" name="XML_RNGP_INVALID_VALUE" link="libxml2-xmlerror.html#XML_RNGP_INVALID_VALUE"/>
<keyword type="enum" name="XML_RNGP_MISSING_HREF" link="libxml2-xmlerror.html#XML_RNGP_MISSING_HREF"/>
<keyword type="enum" name="XML_RNGP_NAME_MISSING" link="libxml2-xmlerror.html#XML_RNGP_NAME_MISSING"/>
<keyword type="enum" name="XML_RNGP_NEED_COMBINE" link="libxml2-xmlerror.html#XML_RNGP_NEED_COMBINE"/>
<keyword type="enum" name="XML_RNGP_NOTALLOWED_NOT_EMPTY" link="libxml2-xmlerror.html#XML_RNGP_NOTALLOWED_NOT_EMPTY"/>
<keyword type="enum" name="XML_RNGP_NSNAME_ATTR_ANCESTOR" link="libxml2-xmlerror.html#XML_RNGP_NSNAME_ATTR_ANCESTOR"/>
<keyword type="enum" name="XML_RNGP_NSNAME_NO_NS" link="libxml2-xmlerror.html#XML_RNGP_NSNAME_NO_NS"/>
<keyword type="enum" name="XML_RNGP_PARAM_FORBIDDEN" link="libxml2-xmlerror.html#XML_RNGP_PARAM_FORBIDDEN"/>
<keyword type="enum" name="XML_RNGP_PARAM_NAME_MISSING" link="libxml2-xmlerror.html#XML_RNGP_PARAM_NAME_MISSING"/>
<keyword type="enum" name="XML_RNGP_PARENTREF_CREATE_FAILED" link="libxml2-xmlerror.html#XML_RNGP_PARENTREF_CREATE_FAILED"/>
<keyword type="enum" name="XML_RNGP_PARENTREF_NAME_INVALID" link="libxml2-xmlerror.html#XML_RNGP_PARENTREF_NAME_INVALID"/>
<keyword type="enum" name="XML_RNGP_PARENTREF_NOT_EMPTY" link="libxml2-xmlerror.html#XML_RNGP_PARENTREF_NOT_EMPTY"/>
<keyword type="enum" name="XML_RNGP_PARENTREF_NO_NAME" link="libxml2-xmlerror.html#XML_RNGP_PARENTREF_NO_NAME"/>
<keyword type="enum" name="XML_RNGP_PARENTREF_NO_PARENT" link="libxml2-xmlerror.html#XML_RNGP_PARENTREF_NO_PARENT"/>
<keyword type="enum" name="XML_RNGP_PARSE_ERROR" link="libxml2-xmlerror.html#XML_RNGP_PARSE_ERROR"/>
<keyword type="enum" name="XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME" link="libxml2-xmlerror.html#XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME"/>
<keyword type="enum" name="XML_RNGP_PAT_ATTR_ATTR" link="libxml2-xmlerror.html#XML_RNGP_PAT_ATTR_ATTR"/>
<keyword type="enum" name="XML_RNGP_PAT_ATTR_ELEM" link="libxml2-xmlerror.html#XML_RNGP_PAT_ATTR_ELEM"/>
<keyword type="enum" name="XML_RNGP_PAT_DATA_EXCEPT_ATTR" link="libxml2-xmlerror.html#XML_RNGP_PAT_DATA_EXCEPT_ATTR"/>
<keyword type="enum" name="XML_RNGP_PAT_DATA_EXCEPT_ELEM" link="libxml2-xmlerror.html#XML_RNGP_PAT_DATA_EXCEPT_ELEM"/>
<keyword type="enum" name="XML_RNGP_PAT_DATA_EXCEPT_EMPTY" link="libxml2-xmlerror.html#XML_RNGP_PAT_DATA_EXCEPT_EMPTY"/>
<keyword type="enum" name="XML_RNGP_PAT_DATA_EXCEPT_GROUP" link="libxml2-xmlerror.html#XML_RNGP_PAT_DATA_EXCEPT_GROUP"/>
<keyword type="enum" name="XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE" link="libxml2-xmlerror.html#XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE"/>
<keyword type="enum" name="XML_RNGP_PAT_DATA_EXCEPT_LIST" link="libxml2-xmlerror.html#XML_RNGP_PAT_DATA_EXCEPT_LIST"/>
<keyword type="enum" name="XML_RNGP_PAT_DATA_EXCEPT_ONEMORE" link="libxml2-xmlerror.html#XML_RNGP_PAT_DATA_EXCEPT_ONEMORE"/>
<keyword type="enum" name="XML_RNGP_PAT_DATA_EXCEPT_REF" link="libxml2-xmlerror.html#XML_RNGP_PAT_DATA_EXCEPT_REF"/>
<keyword type="enum" name="XML_RNGP_PAT_DATA_EXCEPT_TEXT" link="libxml2-xmlerror.html#XML_RNGP_PAT_DATA_EXCEPT_TEXT"/>
<keyword type="enum" name="XML_RNGP_PAT_LIST_ATTR" link="libxml2-xmlerror.html#XML_RNGP_PAT_LIST_ATTR"/>
<keyword type="enum" name="XML_RNGP_PAT_LIST_ELEM" link="libxml2-xmlerror.html#XML_RNGP_PAT_LIST_ELEM"/>
<keyword type="enum" name="XML_RNGP_PAT_LIST_INTERLEAVE" link="libxml2-xmlerror.html#XML_RNGP_PAT_LIST_INTERLEAVE"/>
<keyword type="enum" name="XML_RNGP_PAT_LIST_LIST" link="libxml2-xmlerror.html#XML_RNGP_PAT_LIST_LIST"/>
<keyword type="enum" name="XML_RNGP_PAT_LIST_REF" link="libxml2-xmlerror.html#XML_RNGP_PAT_LIST_REF"/>
<keyword type="enum" name="XML_RNGP_PAT_LIST_TEXT" link="libxml2-xmlerror.html#XML_RNGP_PAT_LIST_TEXT"/>
<keyword type="enum" name="XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME" link="libxml2-xmlerror.html#XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME"/>
<keyword type="enum" name="XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME" link="libxml2-xmlerror.html#XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME"/>
<keyword type="enum" name="XML_RNGP_PAT_ONEMORE_GROUP_ATTR" link="libxml2-xmlerror.html#XML_RNGP_PAT_ONEMORE_GROUP_ATTR"/>
<keyword type="enum" name="XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR" link="libxml2-xmlerror.html#XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR"/>
<keyword type="enum" name="XML_RNGP_PAT_START_ATTR" link="libxml2-xmlerror.html#XML_RNGP_PAT_START_ATTR"/>
<keyword type="enum" name="XML_RNGP_PAT_START_DATA" link="libxml2-xmlerror.html#XML_RNGP_PAT_START_DATA"/>
<keyword type="enum" name="XML_RNGP_PAT_START_EMPTY" link="libxml2-xmlerror.html#XML_RNGP_PAT_START_EMPTY"/>
<keyword type="enum" name="XML_RNGP_PAT_START_GROUP" link="libxml2-xmlerror.html#XML_RNGP_PAT_START_GROUP"/>
<keyword type="enum" name="XML_RNGP_PAT_START_INTERLEAVE" link="libxml2-xmlerror.html#XML_RNGP_PAT_START_INTERLEAVE"/>
<keyword type="enum" name="XML_RNGP_PAT_START_LIST" link="libxml2-xmlerror.html#XML_RNGP_PAT_START_LIST"/>
<keyword type="enum" name="XML_RNGP_PAT_START_ONEMORE" link="libxml2-xmlerror.html#XML_RNGP_PAT_START_ONEMORE"/>
<keyword type="enum" name="XML_RNGP_PAT_START_TEXT" link="libxml2-xmlerror.html#XML_RNGP_PAT_START_TEXT"/>
<keyword type="enum" name="XML_RNGP_PAT_START_VALUE" link="libxml2-xmlerror.html#XML_RNGP_PAT_START_VALUE"/>
<keyword type="enum" name="XML_RNGP_PREFIX_UNDEFINED" link="libxml2-xmlerror.html#XML_RNGP_PREFIX_UNDEFINED"/>
<keyword type="enum" name="XML_RNGP_REF_CREATE_FAILED" link="libxml2-xmlerror.html#XML_RNGP_REF_CREATE_FAILED"/>
<keyword type="enum" name="XML_RNGP_REF_CYCLE" link="libxml2-xmlerror.html#XML_RNGP_REF_CYCLE"/>
<keyword type="enum" name="XML_RNGP_REF_NAME_INVALID" link="libxml2-xmlerror.html#XML_RNGP_REF_NAME_INVALID"/>
<keyword type="enum" name="XML_RNGP_REF_NOT_EMPTY" link="libxml2-xmlerror.html#XML_RNGP_REF_NOT_EMPTY"/>
<keyword type="enum" name="XML_RNGP_REF_NO_DEF" link="libxml2-xmlerror.html#XML_RNGP_REF_NO_DEF"/>
<keyword type="enum" name="XML_RNGP_REF_NO_NAME" link="libxml2-xmlerror.html#XML_RNGP_REF_NO_NAME"/>
<keyword type="enum" name="XML_RNGP_START_CHOICE_AND_INTERLEAVE" link="libxml2-xmlerror.html#XML_RNGP_START_CHOICE_AND_INTERLEAVE"/>
<keyword type="enum" name="XML_RNGP_START_CONTENT" link="libxml2-xmlerror.html#XML_RNGP_START_CONTENT"/>
<keyword type="enum" name="XML_RNGP_START_EMPTY" link="libxml2-xmlerror.html#XML_RNGP_START_EMPTY"/>
<keyword type="enum" name="XML_RNGP_START_MISSING" link="libxml2-xmlerror.html#XML_RNGP_START_MISSING"/>
<keyword type="enum" name="XML_RNGP_TEXT_EXPECTED" link="libxml2-xmlerror.html#XML_RNGP_TEXT_EXPECTED"/>
<keyword type="enum" name="XML_RNGP_TEXT_HAS_CHILD" link="libxml2-xmlerror.html#XML_RNGP_TEXT_HAS_CHILD"/>
<keyword type="enum" name="XML_RNGP_TYPE_MISSING" link="libxml2-xmlerror.html#XML_RNGP_TYPE_MISSING"/>
<keyword type="enum" name="XML_RNGP_TYPE_NOT_FOUND" link="libxml2-xmlerror.html#XML_RNGP_TYPE_NOT_FOUND"/>
<keyword type="enum" name="XML_RNGP_TYPE_VALUE" link="libxml2-xmlerror.html#XML_RNGP_TYPE_VALUE"/>
<keyword type="enum" name="XML_RNGP_UNKNOWN_ATTRIBUTE" link="libxml2-xmlerror.html#XML_RNGP_UNKNOWN_ATTRIBUTE"/>
<keyword type="enum" name="XML_RNGP_UNKNOWN_COMBINE" link="libxml2-xmlerror.html#XML_RNGP_UNKNOWN_COMBINE"/>
<keyword type="enum" name="XML_RNGP_UNKNOWN_CONSTRUCT" link="libxml2-xmlerror.html#XML_RNGP_UNKNOWN_CONSTRUCT"/>
<keyword type="enum" name="XML_RNGP_UNKNOWN_TYPE_LIB" link="libxml2-xmlerror.html#XML_RNGP_UNKNOWN_TYPE_LIB"/>
<keyword type="enum" name="XML_RNGP_URI_FRAGMENT" link="libxml2-xmlerror.html#XML_RNGP_URI_FRAGMENT"/>
<keyword type="enum" name="XML_RNGP_URI_NOT_ABSOLUTE" link="libxml2-xmlerror.html#XML_RNGP_URI_NOT_ABSOLUTE"/>
<keyword type="enum" name="XML_RNGP_VALUE_EMPTY" link="libxml2-xmlerror.html#XML_RNGP_VALUE_EMPTY"/>
<keyword type="enum" name="XML_RNGP_VALUE_NO_CONTENT" link="libxml2-xmlerror.html#XML_RNGP_VALUE_NO_CONTENT"/>
<keyword type="enum" name="XML_RNGP_XMLNS_NAME" link="libxml2-xmlerror.html#XML_RNGP_XMLNS_NAME"/>
<keyword type="enum" name="XML_RNGP_XML_NS" link="libxml2-xmlerror.html#XML_RNGP_XML_NS"/>
<keyword type="enum" name="XML_SAVE_AS_HTML" link="libxml2-xmlsave.html#XML_SAVE_AS_HTML"/>
<keyword type="enum" name="XML_SAVE_AS_XML" link="libxml2-xmlsave.html#XML_SAVE_AS_XML"/>
<keyword type="enum" name="XML_SAVE_CHAR_INVALID" link="libxml2-xmlerror.html#XML_SAVE_CHAR_INVALID"/>
<keyword type="enum" name="XML_SAVE_FORMAT" link="libxml2-xmlsave.html#XML_SAVE_FORMAT"/>
<keyword type="enum" name="XML_SAVE_NOT_UTF8" link="libxml2-xmlerror.html#XML_SAVE_NOT_UTF8"/>
<keyword type="enum" name="XML_SAVE_NO_DECL" link="libxml2-xmlsave.html#XML_SAVE_NO_DECL"/>
<keyword type="enum" name="XML_SAVE_NO_DOCTYPE" link="libxml2-xmlerror.html#XML_SAVE_NO_DOCTYPE"/>
<keyword type="enum" name="XML_SAVE_NO_EMPTY" link="libxml2-xmlsave.html#XML_SAVE_NO_EMPTY"/>
<keyword type="enum" name="XML_SAVE_NO_XHTML" link="libxml2-xmlsave.html#XML_SAVE_NO_XHTML"/>
<keyword type="enum" name="XML_SAVE_UNKNOWN_ENCODING" link="libxml2-xmlerror.html#XML_SAVE_UNKNOWN_ENCODING"/>
<keyword type="enum" name="XML_SAVE_WSNONSIG" link="libxml2-xmlsave.html#XML_SAVE_WSNONSIG"/>
<keyword type="enum" name="XML_SAVE_XHTML" link="libxml2-xmlsave.html#XML_SAVE_XHTML"/>
<keyword type="enum" name="XML_SCHEMAP_AG_PROPS_CORRECT" link="libxml2-xmlerror.html#XML_SCHEMAP_AG_PROPS_CORRECT"/>
<keyword type="enum" name="XML_SCHEMAP_ATTRFORMDEFAULT_VALUE" link="libxml2-xmlerror.html#XML_SCHEMAP_ATTRFORMDEFAULT_VALUE"/>
<keyword type="enum" name="XML_SCHEMAP_ATTRGRP_NONAME_NOREF" link="libxml2-xmlerror.html#XML_SCHEMAP_ATTRGRP_NONAME_NOREF"/>
<keyword type="enum" name="XML_SCHEMAP_ATTR_NONAME_NOREF" link="libxml2-xmlerror.html#XML_SCHEMAP_ATTR_NONAME_NOREF"/>
<keyword type="enum" name="XML_SCHEMAP_AU_PROPS_CORRECT" link="libxml2-xmlerror.html#XML_SCHEMAP_AU_PROPS_CORRECT"/>
<keyword type="enum" name="XML_SCHEMAP_AU_PROPS_CORRECT_2" link="libxml2-xmlerror.html#XML_SCHEMAP_AU_PROPS_CORRECT_2"/>
<keyword type="enum" name="XML_SCHEMAP_A_PROPS_CORRECT_2" link="libxml2-xmlerror.html#XML_SCHEMAP_A_PROPS_CORRECT_2"/>
<keyword type="enum" name="XML_SCHEMAP_A_PROPS_CORRECT_3" link="libxml2-xmlerror.html#XML_SCHEMAP_A_PROPS_CORRECT_3"/>
<keyword type="enum" name="XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF" link="libxml2-xmlerror.html#XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF"/>
<keyword type="enum" name="XML_SCHEMAP_COS_ALL_LIMITED" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_ALL_LIMITED"/>
<keyword type="enum" name="XML_SCHEMAP_COS_CT_EXTENDS_1_1" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_CT_EXTENDS_1_1"/>
<keyword type="enum" name="XML_SCHEMAP_COS_CT_EXTENDS_1_2" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_CT_EXTENDS_1_2"/>
<keyword type="enum" name="XML_SCHEMAP_COS_CT_EXTENDS_1_3" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_CT_EXTENDS_1_3"/>
<keyword type="enum" name="XML_SCHEMAP_COS_ST_DERIVED_OK_2_1" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_ST_DERIVED_OK_2_1"/>
<keyword type="enum" name="XML_SCHEMAP_COS_ST_DERIVED_OK_2_2" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_ST_DERIVED_OK_2_2"/>
<keyword type="enum" name="XML_SCHEMAP_COS_ST_RESTRICTS_1_1" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_ST_RESTRICTS_1_1"/>
<keyword type="enum" name="XML_SCHEMAP_COS_ST_RESTRICTS_1_2" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_ST_RESTRICTS_1_2"/>
<keyword type="enum" name="XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1"/>
<keyword type="enum" name="XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2"/>
<keyword type="enum" name="XML_SCHEMAP_COS_ST_RESTRICTS_2_1" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_ST_RESTRICTS_2_1"/>
<keyword type="enum" name="XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1"/>
<keyword type="enum" name="XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2"/>
<keyword type="enum" name="XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1"/>
<keyword type="enum" name="XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2"/>
<keyword type="enum" name="XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3"/>
<keyword type="enum" name="XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4"/>
<keyword type="enum" name="XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5"/>
<keyword type="enum" name="XML_SCHEMAP_COS_ST_RESTRICTS_3_1" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_ST_RESTRICTS_3_1"/>
<keyword type="enum" name="XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1"/>
<keyword type="enum" name="XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2"/>
<keyword type="enum" name="XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1"/>
<keyword type="enum" name="XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2"/>
<keyword type="enum" name="XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3"/>
<keyword type="enum" name="XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4"/>
<keyword type="enum" name="XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5"/>
<keyword type="enum" name="XML_SCHEMAP_COS_VALID_DEFAULT_1" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_VALID_DEFAULT_1"/>
<keyword type="enum" name="XML_SCHEMAP_COS_VALID_DEFAULT_2_1" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_VALID_DEFAULT_2_1"/>
<keyword type="enum" name="XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1"/>
<keyword type="enum" name="XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2" link="libxml2-xmlerror.html#XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2"/>
<keyword type="enum" name="XML_SCHEMAP_CT_PROPS_CORRECT_1" link="libxml2-xmlerror.html#XML_SCHEMAP_CT_PROPS_CORRECT_1"/>
<keyword type="enum" name="XML_SCHEMAP_CT_PROPS_CORRECT_2" link="libxml2-xmlerror.html#XML_SCHEMAP_CT_PROPS_CORRECT_2"/>
<keyword type="enum" name="XML_SCHEMAP_CT_PROPS_CORRECT_3" link="libxml2-xmlerror.html#XML_SCHEMAP_CT_PROPS_CORRECT_3"/>
<keyword type="enum" name="XML_SCHEMAP_CT_PROPS_CORRECT_4" link="libxml2-xmlerror.html#XML_SCHEMAP_CT_PROPS_CORRECT_4"/>
<keyword type="enum" name="XML_SCHEMAP_CT_PROPS_CORRECT_5" link="libxml2-xmlerror.html#XML_SCHEMAP_CT_PROPS_CORRECT_5"/>
<keyword type="enum" name="XML_SCHEMAP_CVC_SIMPLE_TYPE" link="libxml2-xmlerror.html#XML_SCHEMAP_CVC_SIMPLE_TYPE"/>
<keyword type="enum" name="XML_SCHEMAP_C_PROPS_CORRECT" link="libxml2-xmlerror.html#XML_SCHEMAP_C_PROPS_CORRECT"/>
<keyword type="enum" name="XML_SCHEMAP_DEF_AND_PREFIX" link="libxml2-xmlerror.html#XML_SCHEMAP_DEF_AND_PREFIX"/>
<keyword type="enum" name="XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1" link="libxml2-xmlerror.html#XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1"/>
<keyword type="enum" name="XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1" link="libxml2-xmlerror.html#XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1"/>
<keyword type="enum" name="XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2" link="libxml2-xmlerror.html#XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2"/>
<keyword type="enum" name="XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3" link="libxml2-xmlerror.html#XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3"/>
<keyword type="enum" name="XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2" link="libxml2-xmlerror.html#XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2"/>
<keyword type="enum" name="XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3" link="libxml2-xmlerror.html#XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3"/>
<keyword type="enum" name="XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1" link="libxml2-xmlerror.html#XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1"/>
<keyword type="enum" name="XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2" link="libxml2-xmlerror.html#XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2"/>
<keyword type="enum" name="XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3" link="libxml2-xmlerror.html#XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3"/>
<keyword type="enum" name="XML_SCHEMAP_ELEMFORMDEFAULT_VALUE" link="libxml2-xmlerror.html#XML_SCHEMAP_ELEMFORMDEFAULT_VALUE"/>
<keyword type="enum" name="XML_SCHEMAP_ELEM_DEFAULT_FIXED" link="libxml2-xmlerror.html#XML_SCHEMAP_ELEM_DEFAULT_FIXED"/>
<keyword type="enum" name="XML_SCHEMAP_ELEM_NONAME_NOREF" link="libxml2-xmlerror.html#XML_SCHEMAP_ELEM_NONAME_NOREF"/>
<keyword type="enum" name="XML_SCHEMAP_EXTENSION_NO_BASE" link="libxml2-xmlerror.html#XML_SCHEMAP_EXTENSION_NO_BASE"/>
<keyword type="enum" name="XML_SCHEMAP_E_PROPS_CORRECT_2" link="libxml2-xmlerror.html#XML_SCHEMAP_E_PROPS_CORRECT_2"/>
<keyword type="enum" name="XML_SCHEMAP_E_PROPS_CORRECT_3" link="libxml2-xmlerror.html#XML_SCHEMAP_E_PROPS_CORRECT_3"/>
<keyword type="enum" name="XML_SCHEMAP_E_PROPS_CORRECT_4" link="libxml2-xmlerror.html#XML_SCHEMAP_E_PROPS_CORRECT_4"/>
<keyword type="enum" name="XML_SCHEMAP_E_PROPS_CORRECT_5" link="libxml2-xmlerror.html#XML_SCHEMAP_E_PROPS_CORRECT_5"/>
<keyword type="enum" name="XML_SCHEMAP_E_PROPS_CORRECT_6" link="libxml2-xmlerror.html#XML_SCHEMAP_E_PROPS_CORRECT_6"/>
<keyword type="enum" name="XML_SCHEMAP_FACET_NO_VALUE" link="libxml2-xmlerror.html#XML_SCHEMAP_FACET_NO_VALUE"/>
<keyword type="enum" name="XML_SCHEMAP_FAILED_BUILD_IMPORT" link="libxml2-xmlerror.html#XML_SCHEMAP_FAILED_BUILD_IMPORT"/>
<keyword type="enum" name="XML_SCHEMAP_FAILED_LOAD" link="libxml2-xmlerror.html#XML_SCHEMAP_FAILED_LOAD"/>
<keyword type="enum" name="XML_SCHEMAP_FAILED_PARSE" link="libxml2-xmlerror.html#XML_SCHEMAP_FAILED_PARSE"/>
<keyword type="enum" name="XML_SCHEMAP_GROUP_NONAME_NOREF" link="libxml2-xmlerror.html#XML_SCHEMAP_GROUP_NONAME_NOREF"/>
<keyword type="enum" name="XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI" link="libxml2-xmlerror.html#XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI"/>
<keyword type="enum" name="XML_SCHEMAP_IMPORT_REDEFINE_NSNAME" link="libxml2-xmlerror.html#XML_SCHEMAP_IMPORT_REDEFINE_NSNAME"/>
<keyword type="enum" name="XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI" link="libxml2-xmlerror.html#XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI"/>
<keyword type="enum" name="XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI" link="libxml2-xmlerror.html#XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI"/>
<keyword type="enum" name="XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI" link="libxml2-xmlerror.html#XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI"/>
<keyword type="enum" name="XML_SCHEMAP_INTERNAL" link="libxml2-xmlerror.html#XML_SCHEMAP_INTERNAL"/>
<keyword type="enum" name="XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE" link="libxml2-xmlerror.html#XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE"/>
<keyword type="enum" name="XML_SCHEMAP_INVALID_ATTR_COMBINATION" link="libxml2-xmlerror.html#XML_SCHEMAP_INVALID_ATTR_COMBINATION"/>
<keyword type="enum" name="XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION" link="libxml2-xmlerror.html#XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION"/>
<keyword type="enum" name="XML_SCHEMAP_INVALID_ATTR_NAME" link="libxml2-xmlerror.html#XML_SCHEMAP_INVALID_ATTR_NAME"/>
<keyword type="enum" name="XML_SCHEMAP_INVALID_ATTR_USE" link="libxml2-xmlerror.html#XML_SCHEMAP_INVALID_ATTR_USE"/>
<keyword type="enum" name="XML_SCHEMAP_INVALID_BOOLEAN" link="libxml2-xmlerror.html#XML_SCHEMAP_INVALID_BOOLEAN"/>
<keyword type="enum" name="XML_SCHEMAP_INVALID_ENUM" link="libxml2-xmlerror.html#XML_SCHEMAP_INVALID_ENUM"/>
<keyword type="enum" name="XML_SCHEMAP_INVALID_FACET" link="libxml2-xmlerror.html#XML_SCHEMAP_INVALID_FACET"/>
<keyword type="enum" name="XML_SCHEMAP_INVALID_FACET_VALUE" link="libxml2-xmlerror.html#XML_SCHEMAP_INVALID_FACET_VALUE"/>
<keyword type="enum" name="XML_SCHEMAP_INVALID_MAXOCCURS" link="libxml2-xmlerror.html#XML_SCHEMAP_INVALID_MAXOCCURS"/>
<keyword type="enum" name="XML_SCHEMAP_INVALID_MINOCCURS" link="libxml2-xmlerror.html#XML_SCHEMAP_INVALID_MINOCCURS"/>
<keyword type="enum" name="XML_SCHEMAP_INVALID_REF_AND_SUBTYPE" link="libxml2-xmlerror.html#XML_SCHEMAP_INVALID_REF_AND_SUBTYPE"/>
<keyword type="enum" name="XML_SCHEMAP_INVALID_WHITE_SPACE" link="libxml2-xmlerror.html#XML_SCHEMAP_INVALID_WHITE_SPACE"/>
<keyword type="enum" name="XML_SCHEMAP_MG_PROPS_CORRECT_1" link="libxml2-xmlerror.html#XML_SCHEMAP_MG_PROPS_CORRECT_1"/>
<keyword type="enum" name="XML_SCHEMAP_MG_PROPS_CORRECT_2" link="libxml2-xmlerror.html#XML_SCHEMAP_MG_PROPS_CORRECT_2"/>
<keyword type="enum" name="XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD" link="libxml2-xmlerror.html#XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD"/>
<keyword type="enum" name="XML_SCHEMAP_NOATTR_NOREF" link="libxml2-xmlerror.html#XML_SCHEMAP_NOATTR_NOREF"/>
<keyword type="enum" name="XML_SCHEMAP_NOROOT" link="libxml2-xmlerror.html#XML_SCHEMAP_NOROOT"/>
<keyword type="enum" name="XML_SCHEMAP_NOTATION_NO_NAME" link="libxml2-xmlerror.html#XML_SCHEMAP_NOTATION_NO_NAME"/>
<keyword type="enum" name="XML_SCHEMAP_NOTHING_TO_PARSE" link="libxml2-xmlerror.html#XML_SCHEMAP_NOTHING_TO_PARSE"/>
<keyword type="enum" name="XML_SCHEMAP_NOTYPE_NOREF" link="libxml2-xmlerror.html#XML_SCHEMAP_NOTYPE_NOREF"/>
<keyword type="enum" name="XML_SCHEMAP_NOT_DETERMINISTIC" link="libxml2-xmlerror.html#XML_SCHEMAP_NOT_DETERMINISTIC"/>
<keyword type="enum" name="XML_SCHEMAP_NOT_SCHEMA" link="libxml2-xmlerror.html#XML_SCHEMAP_NOT_SCHEMA"/>
<keyword type="enum" name="XML_SCHEMAP_NO_XMLNS" link="libxml2-xmlerror.html#XML_SCHEMAP_NO_XMLNS"/>
<keyword type="enum" name="XML_SCHEMAP_NO_XSI" link="libxml2-xmlerror.html#XML_SCHEMAP_NO_XSI"/>
<keyword type="enum" name="XML_SCHEMAP_PREFIX_UNDEFINED" link="libxml2-xmlerror.html#XML_SCHEMAP_PREFIX_UNDEFINED"/>
<keyword type="enum" name="XML_SCHEMAP_P_PROPS_CORRECT_1" link="libxml2-xmlerror.html#XML_SCHEMAP_P_PROPS_CORRECT_1"/>
<keyword type="enum" name="XML_SCHEMAP_P_PROPS_CORRECT_2_1" link="libxml2-xmlerror.html#XML_SCHEMAP_P_PROPS_CORRECT_2_1"/>
<keyword type="enum" name="XML_SCHEMAP_P_PROPS_CORRECT_2_2" link="libxml2-xmlerror.html#XML_SCHEMAP_P_PROPS_CORRECT_2_2"/>
<keyword type="enum" name="XML_SCHEMAP_RECURSIVE" link="libxml2-xmlerror.html#XML_SCHEMAP_RECURSIVE"/>
<keyword type="enum" name="XML_SCHEMAP_REDEFINED_ATTR" link="libxml2-xmlerror.html#XML_SCHEMAP_REDEFINED_ATTR"/>
<keyword type="enum" name="XML_SCHEMAP_REDEFINED_ATTRGROUP" link="libxml2-xmlerror.html#XML_SCHEMAP_REDEFINED_ATTRGROUP"/>
<keyword type="enum" name="XML_SCHEMAP_REDEFINED_ELEMENT" link="libxml2-xmlerror.html#XML_SCHEMAP_REDEFINED_ELEMENT"/>
<keyword type="enum" name="XML_SCHEMAP_REDEFINED_GROUP" link="libxml2-xmlerror.html#XML_SCHEMAP_REDEFINED_GROUP"/>
<keyword type="enum" name="XML_SCHEMAP_REDEFINED_NOTATION" link="libxml2-xmlerror.html#XML_SCHEMAP_REDEFINED_NOTATION"/>
<keyword type="enum" name="XML_SCHEMAP_REDEFINED_TYPE" link="libxml2-xmlerror.html#XML_SCHEMAP_REDEFINED_TYPE"/>
<keyword type="enum" name="XML_SCHEMAP_REF_AND_CONTENT" link="libxml2-xmlerror.html#XML_SCHEMAP_REF_AND_CONTENT"/>
<keyword type="enum" name="XML_SCHEMAP_REF_AND_SUBTYPE" link="libxml2-xmlerror.html#XML_SCHEMAP_REF_AND_SUBTYPE"/>
<keyword type="enum" name="XML_SCHEMAP_REGEXP_INVALID" link="libxml2-xmlerror.html#XML_SCHEMAP_REGEXP_INVALID"/>
<keyword type="enum" name="XML_SCHEMAP_RESTRICTION_NONAME_NOREF" link="libxml2-xmlerror.html#XML_SCHEMAP_RESTRICTION_NONAME_NOREF"/>
<keyword type="enum" name="XML_SCHEMAP_S4S_ATTR_INVALID_VALUE" link="libxml2-xmlerror.html#XML_SCHEMAP_S4S_ATTR_INVALID_VALUE"/>
<keyword type="enum" name="XML_SCHEMAP_S4S_ATTR_MISSING" link="libxml2-xmlerror.html#XML_SCHEMAP_S4S_ATTR_MISSING"/>
<keyword type="enum" name="XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED" link="libxml2-xmlerror.html#XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED"/>
<keyword type="enum" name="XML_SCHEMAP_S4S_ELEM_MISSING" link="libxml2-xmlerror.html#XML_SCHEMAP_S4S_ELEM_MISSING"/>
<keyword type="enum" name="XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED" link="libxml2-xmlerror.html#XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED"/>
<keyword type="enum" name="XML_SCHEMAP_SIMPLETYPE_NONAME" link="libxml2-xmlerror.html#XML_SCHEMAP_SIMPLETYPE_NONAME"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_ATTRIBUTE_1" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_ATTRIBUTE_1"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_ATTRIBUTE_2" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_ATTRIBUTE_2"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_ATTRIBUTE_3_1" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_ATTRIBUTE_3_1"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_ATTRIBUTE_3_2" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_ATTRIBUTE_3_2"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_ATTRIBUTE_4" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_ATTRIBUTE_4"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_CT_1" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_CT_1"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_ELEMENT_1" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_ELEMENT_1"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_ELEMENT_2_1" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_ELEMENT_2_1"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_ELEMENT_2_2" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_ELEMENT_2_2"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_ELEMENT_3" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_ELEMENT_3"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_IMPORT" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_IMPORT"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_IMPORT_1_1" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_IMPORT_1_1"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_IMPORT_1_2" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_IMPORT_1_2"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_IMPORT_2" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_IMPORT_2"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_IMPORT_2_1" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_IMPORT_2_1"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_IMPORT_2_2" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_IMPORT_2_2"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_IMPORT_3_1" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_IMPORT_3_1"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_IMPORT_3_2" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_IMPORT_3_2"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_INCLUDE" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_INCLUDE"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_REDEFINE" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_REDEFINE"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_RESOLVE" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_RESOLVE"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_SIMPLE_TYPE_1" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_SIMPLE_TYPE_1"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_SIMPLE_TYPE_2" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_SIMPLE_TYPE_2"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_SIMPLE_TYPE_3" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_SIMPLE_TYPE_3"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_SIMPLE_TYPE_4" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_SIMPLE_TYPE_4"/>
<keyword type="enum" name="XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES" link="libxml2-xmlerror.html#XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES"/>
<keyword type="enum" name="XML_SCHEMAP_ST_PROPS_CORRECT_1" link="libxml2-xmlerror.html#XML_SCHEMAP_ST_PROPS_CORRECT_1"/>
<keyword type="enum" name="XML_SCHEMAP_ST_PROPS_CORRECT_2" link="libxml2-xmlerror.html#XML_SCHEMAP_ST_PROPS_CORRECT_2"/>
<keyword type="enum" name="XML_SCHEMAP_ST_PROPS_CORRECT_3" link="libxml2-xmlerror.html#XML_SCHEMAP_ST_PROPS_CORRECT_3"/>
<keyword type="enum" name="XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE" link="libxml2-xmlerror.html#XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE"/>
<keyword type="enum" name="XML_SCHEMAP_TYPE_AND_SUBTYPE" link="libxml2-xmlerror.html#XML_SCHEMAP_TYPE_AND_SUBTYPE"/>
<keyword type="enum" name="XML_SCHEMAP_UNION_NOT_EXPRESSIBLE" link="libxml2-xmlerror.html#XML_SCHEMAP_UNION_NOT_EXPRESSIBLE"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_ALL_CHILD" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_ALL_CHILD"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_ATTR_CHILD" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_ATTR_CHILD"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_BASE_TYPE" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_BASE_TYPE"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_CHOICE_CHILD" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_CHOICE_CHILD"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_ELEM_CHILD" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_ELEM_CHILD"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_FACET_CHILD" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_FACET_CHILD"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_FACET_TYPE" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_FACET_TYPE"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_GROUP_CHILD" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_GROUP_CHILD"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_IMPORT_CHILD" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_IMPORT_CHILD"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_LIST_CHILD" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_LIST_CHILD"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_MEMBER_TYPE" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_MEMBER_TYPE"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_NOTATION_CHILD" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_NOTATION_CHILD"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_PREFIX" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_PREFIX"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_REF" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_REF"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_TYPE" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_TYPE"/>
<keyword type="enum" name="XML_SCHEMAP_UNKNOWN_UNION_CHILD" link="libxml2-xmlerror.html#XML_SCHEMAP_UNKNOWN_UNION_CHILD"/>
<keyword type="enum" name="XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH" link="libxml2-xmlerror.html#XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH"/>
<keyword type="enum" name="XML_SCHEMAP_WARN_ATTR_REDECL_PROH" link="libxml2-xmlerror.html#XML_SCHEMAP_WARN_ATTR_REDECL_PROH"/>
<keyword type="enum" name="XML_SCHEMAP_WARN_SKIP_SCHEMA" link="libxml2-xmlerror.html#XML_SCHEMAP_WARN_SKIP_SCHEMA"/>
<keyword type="enum" name="XML_SCHEMAP_WARN_UNLOCATED_SCHEMA" link="libxml2-xmlerror.html#XML_SCHEMAP_WARN_UNLOCATED_SCHEMA"/>
<keyword type="enum" name="XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER" link="libxml2-xmlerror.html#XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER"/>
<keyword type="enum" name="XML_SCHEMAS_ANYSIMPLETYPE" link="libxml2-schemasInternals.html#XML_SCHEMAS_ANYSIMPLETYPE"/>
<keyword type="enum" name="XML_SCHEMAS_ANYTYPE" link="libxml2-schemasInternals.html#XML_SCHEMAS_ANYTYPE"/>
<keyword type="enum" name="XML_SCHEMAS_ANYURI" link="libxml2-schemasInternals.html#XML_SCHEMAS_ANYURI"/>
<keyword type="enum" name="XML_SCHEMAS_BASE64BINARY" link="libxml2-schemasInternals.html#XML_SCHEMAS_BASE64BINARY"/>
<keyword type="enum" name="XML_SCHEMAS_BOOLEAN" link="libxml2-schemasInternals.html#XML_SCHEMAS_BOOLEAN"/>
<keyword type="enum" name="XML_SCHEMAS_BYTE" link="libxml2-schemasInternals.html#XML_SCHEMAS_BYTE"/>
<keyword type="enum" name="XML_SCHEMAS_DATE" link="libxml2-schemasInternals.html#XML_SCHEMAS_DATE"/>
<keyword type="enum" name="XML_SCHEMAS_DATETIME" link="libxml2-schemasInternals.html#XML_SCHEMAS_DATETIME"/>
<keyword type="enum" name="XML_SCHEMAS_DECIMAL" link="libxml2-schemasInternals.html#XML_SCHEMAS_DECIMAL"/>
<keyword type="enum" name="XML_SCHEMAS_DOUBLE" link="libxml2-schemasInternals.html#XML_SCHEMAS_DOUBLE"/>
<keyword type="enum" name="XML_SCHEMAS_DURATION" link="libxml2-schemasInternals.html#XML_SCHEMAS_DURATION"/>
<keyword type="enum" name="XML_SCHEMAS_ENTITIES" link="libxml2-schemasInternals.html#XML_SCHEMAS_ENTITIES"/>
<keyword type="enum" name="XML_SCHEMAS_ENTITY" link="libxml2-schemasInternals.html#XML_SCHEMAS_ENTITY"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_ATTRINVALID" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_ATTRINVALID"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_ATTRUNKNOWN" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_ATTRUNKNOWN"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_CONSTRUCT" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_CONSTRUCT"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_ELEMCONT" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_ELEMCONT"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_EXTRACONTENT" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_EXTRACONTENT"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_FACET" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_FACET"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_HAVEDEFAULT" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_HAVEDEFAULT"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_INTERNAL" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_INTERNAL"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_INVALIDATTR" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_INVALIDATTR"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_INVALIDELEM" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_INVALIDELEM"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_ISABSTRACT" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_ISABSTRACT"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_MISSING" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_MISSING"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_NOROLLBACK" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_NOROLLBACK"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_NOROOT" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_NOROOT"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_NOTDETERMINIST" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_NOTDETERMINIST"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_NOTEMPTY" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_NOTEMPTY"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_NOTNILLABLE" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_NOTNILLABLE"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_NOTSIMPLE" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_NOTSIMPLE"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_NOTTOPLEVEL" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_NOTTOPLEVEL"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_NOTYPE" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_NOTYPE"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_OK" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_OK"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_UNDECLAREDELEM" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_UNDECLAREDELEM"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_VALUE" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_VALUE"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_WRONGELEM" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_WRONGELEM"/>
<keyword type="enum" name="XML_SCHEMAS_ERR_XXX" link="libxml2-xmlschemas.html#XML_SCHEMAS_ERR_XXX"/>
<keyword type="enum" name="XML_SCHEMAS_FLOAT" link="libxml2-schemasInternals.html#XML_SCHEMAS_FLOAT"/>
<keyword type="enum" name="XML_SCHEMAS_GDAY" link="libxml2-schemasInternals.html#XML_SCHEMAS_GDAY"/>
<keyword type="enum" name="XML_SCHEMAS_GMONTH" link="libxml2-schemasInternals.html#XML_SCHEMAS_GMONTH"/>
<keyword type="enum" name="XML_SCHEMAS_GMONTHDAY" link="libxml2-schemasInternals.html#XML_SCHEMAS_GMONTHDAY"/>
<keyword type="enum" name="XML_SCHEMAS_GYEAR" link="libxml2-schemasInternals.html#XML_SCHEMAS_GYEAR"/>
<keyword type="enum" name="XML_SCHEMAS_GYEARMONTH" link="libxml2-schemasInternals.html#XML_SCHEMAS_GYEARMONTH"/>
<keyword type="enum" name="XML_SCHEMAS_HEXBINARY" link="libxml2-schemasInternals.html#XML_SCHEMAS_HEXBINARY"/>
<keyword type="enum" name="XML_SCHEMAS_ID" link="libxml2-schemasInternals.html#XML_SCHEMAS_ID"/>
<keyword type="enum" name="XML_SCHEMAS_IDREF" link="libxml2-schemasInternals.html#XML_SCHEMAS_IDREF"/>
<keyword type="enum" name="XML_SCHEMAS_IDREFS" link="libxml2-schemasInternals.html#XML_SCHEMAS_IDREFS"/>
<keyword type="enum" name="XML_SCHEMAS_INT" link="libxml2-schemasInternals.html#XML_SCHEMAS_INT"/>
<keyword type="enum" name="XML_SCHEMAS_INTEGER" link="libxml2-schemasInternals.html#XML_SCHEMAS_INTEGER"/>
<keyword type="enum" name="XML_SCHEMAS_LANGUAGE" link="libxml2-schemasInternals.html#XML_SCHEMAS_LANGUAGE"/>
<keyword type="enum" name="XML_SCHEMAS_LONG" link="libxml2-schemasInternals.html#XML_SCHEMAS_LONG"/>
<keyword type="enum" name="XML_SCHEMAS_NAME" link="libxml2-schemasInternals.html#XML_SCHEMAS_NAME"/>
<keyword type="enum" name="XML_SCHEMAS_NCNAME" link="libxml2-schemasInternals.html#XML_SCHEMAS_NCNAME"/>
<keyword type="enum" name="XML_SCHEMAS_NINTEGER" link="libxml2-schemasInternals.html#XML_SCHEMAS_NINTEGER"/>
<keyword type="enum" name="XML_SCHEMAS_NMTOKEN" link="libxml2-schemasInternals.html#XML_SCHEMAS_NMTOKEN"/>
<keyword type="enum" name="XML_SCHEMAS_NMTOKENS" link="libxml2-schemasInternals.html#XML_SCHEMAS_NMTOKENS"/>
<keyword type="enum" name="XML_SCHEMAS_NNINTEGER" link="libxml2-schemasInternals.html#XML_SCHEMAS_NNINTEGER"/>
<keyword type="enum" name="XML_SCHEMAS_NORMSTRING" link="libxml2-schemasInternals.html#XML_SCHEMAS_NORMSTRING"/>
<keyword type="enum" name="XML_SCHEMAS_NOTATION" link="libxml2-schemasInternals.html#XML_SCHEMAS_NOTATION"/>
<keyword type="enum" name="XML_SCHEMAS_NPINTEGER" link="libxml2-schemasInternals.html#XML_SCHEMAS_NPINTEGER"/>
<keyword type="enum" name="XML_SCHEMAS_PINTEGER" link="libxml2-schemasInternals.html#XML_SCHEMAS_PINTEGER"/>
<keyword type="enum" name="XML_SCHEMAS_QNAME" link="libxml2-schemasInternals.html#XML_SCHEMAS_QNAME"/>
<keyword type="enum" name="XML_SCHEMAS_SHORT" link="libxml2-schemasInternals.html#XML_SCHEMAS_SHORT"/>
<keyword type="enum" name="XML_SCHEMAS_STRING" link="libxml2-schemasInternals.html#XML_SCHEMAS_STRING"/>
<keyword type="enum" name="XML_SCHEMAS_TIME" link="libxml2-schemasInternals.html#XML_SCHEMAS_TIME"/>
<keyword type="enum" name="XML_SCHEMAS_TOKEN" link="libxml2-schemasInternals.html#XML_SCHEMAS_TOKEN"/>
<keyword type="enum" name="XML_SCHEMAS_UBYTE" link="libxml2-schemasInternals.html#XML_SCHEMAS_UBYTE"/>
<keyword type="enum" name="XML_SCHEMAS_UINT" link="libxml2-schemasInternals.html#XML_SCHEMAS_UINT"/>
<keyword type="enum" name="XML_SCHEMAS_ULONG" link="libxml2-schemasInternals.html#XML_SCHEMAS_ULONG"/>
<keyword type="enum" name="XML_SCHEMAS_UNKNOWN" link="libxml2-schemasInternals.html#XML_SCHEMAS_UNKNOWN"/>
<keyword type="enum" name="XML_SCHEMAS_USHORT" link="libxml2-schemasInternals.html#XML_SCHEMAS_USHORT"/>
<keyword type="enum" name="XML_SCHEMATRONV_ASSERT" link="libxml2-xmlerror.html#XML_SCHEMATRONV_ASSERT"/>
<keyword type="enum" name="XML_SCHEMATRONV_REPORT" link="libxml2-xmlerror.html#XML_SCHEMATRONV_REPORT"/>
<keyword type="enum" name="XML_SCHEMATRON_OUT_BUFFER" link="libxml2-schematron.html#XML_SCHEMATRON_OUT_BUFFER"/>
<keyword type="enum" name="XML_SCHEMATRON_OUT_ERROR" link="libxml2-schematron.html#XML_SCHEMATRON_OUT_ERROR"/>
<keyword type="enum" name="XML_SCHEMATRON_OUT_FILE" link="libxml2-schematron.html#XML_SCHEMATRON_OUT_FILE"/>
<keyword type="enum" name="XML_SCHEMATRON_OUT_IO" link="libxml2-schematron.html#XML_SCHEMATRON_OUT_IO"/>
<keyword type="enum" name="XML_SCHEMATRON_OUT_QUIET" link="libxml2-schematron.html#XML_SCHEMATRON_OUT_QUIET"/>
<keyword type="enum" name="XML_SCHEMATRON_OUT_TEXT" link="libxml2-schematron.html#XML_SCHEMATRON_OUT_TEXT"/>
<keyword type="enum" name="XML_SCHEMATRON_OUT_XML" link="libxml2-schematron.html#XML_SCHEMATRON_OUT_XML"/>
<keyword type="enum" name="XML_SCHEMAV_ATTRINVALID" link="libxml2-xmlerror.html#XML_SCHEMAV_ATTRINVALID"/>
<keyword type="enum" name="XML_SCHEMAV_ATTRUNKNOWN" link="libxml2-xmlerror.html#XML_SCHEMAV_ATTRUNKNOWN"/>
<keyword type="enum" name="XML_SCHEMAV_CONSTRUCT" link="libxml2-xmlerror.html#XML_SCHEMAV_CONSTRUCT"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_ATTRIBUTE_1" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_ATTRIBUTE_1"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_ATTRIBUTE_2" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_ATTRIBUTE_2"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_ATTRIBUTE_3" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_ATTRIBUTE_3"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_ATTRIBUTE_4" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_ATTRIBUTE_4"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_AU" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_AU"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_COMPLEX_TYPE_1" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_COMPLEX_TYPE_1"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_COMPLEX_TYPE_4" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_COMPLEX_TYPE_4"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_ELT_1" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_ELT_1"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_ELT_2" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_ELT_2"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_ELT_3_1" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_ELT_3_1"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_ELT_3_2_1" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_ELT_3_2_1"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_ELT_3_2_2" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_ELT_3_2_2"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_ELT_4_1" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_ELT_4_1"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_ELT_4_2" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_ELT_4_2"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_ELT_4_3" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_ELT_4_3"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_ELT_5_1_1" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_ELT_5_1_1"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_ELT_5_1_2" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_ELT_5_1_2"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_ELT_5_2_1" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_ELT_5_2_1"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_ELT_5_2_2_1" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_ELT_5_2_2_1"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_ELT_5_2_2_2_1" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_ELT_5_2_2_2_1"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_ELT_5_2_2_2_2" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_ELT_5_2_2_2_2"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_ELT_6" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_ELT_6"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_ELT_7" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_ELT_7"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_ENUMERATION_VALID" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_ENUMERATION_VALID"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_FACET_VALID" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_FACET_VALID"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_IDC" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_IDC"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_LENGTH_VALID" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_LENGTH_VALID"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_MAXLENGTH_VALID" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_MAXLENGTH_VALID"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_MININCLUSIVE_VALID" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_MININCLUSIVE_VALID"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_MINLENGTH_VALID" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_MINLENGTH_VALID"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_PATTERN_VALID" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_PATTERN_VALID"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_TOTALDIGITS_VALID" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_TOTALDIGITS_VALID"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_TYPE_1" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_TYPE_1"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_TYPE_2" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_TYPE_2"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_TYPE_3_1_1" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_TYPE_3_1_1"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_TYPE_3_1_2" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_TYPE_3_1_2"/>
<keyword type="enum" name="XML_SCHEMAV_CVC_WILDCARD" link="libxml2-xmlerror.html#XML_SCHEMAV_CVC_WILDCARD"/>
<keyword type="enum" name="XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING" link="libxml2-xmlerror.html#XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING"/>
<keyword type="enum" name="XML_SCHEMAV_ELEMCONT" link="libxml2-xmlerror.html#XML_SCHEMAV_ELEMCONT"/>
<keyword type="enum" name="XML_SCHEMAV_ELEMENT_CONTENT" link="libxml2-xmlerror.html#XML_SCHEMAV_ELEMENT_CONTENT"/>
<keyword type="enum" name="XML_SCHEMAV_EXTRACONTENT" link="libxml2-xmlerror.html#XML_SCHEMAV_EXTRACONTENT"/>
<keyword type="enum" name="XML_SCHEMAV_FACET" link="libxml2-xmlerror.html#XML_SCHEMAV_FACET"/>
<keyword type="enum" name="XML_SCHEMAV_HAVEDEFAULT" link="libxml2-xmlerror.html#XML_SCHEMAV_HAVEDEFAULT"/>
<keyword type="enum" name="XML_SCHEMAV_INTERNAL" link="libxml2-xmlerror.html#XML_SCHEMAV_INTERNAL"/>
<keyword type="enum" name="XML_SCHEMAV_INVALIDATTR" link="libxml2-xmlerror.html#XML_SCHEMAV_INVALIDATTR"/>
<keyword type="enum" name="XML_SCHEMAV_INVALIDELEM" link="libxml2-xmlerror.html#XML_SCHEMAV_INVALIDELEM"/>
<keyword type="enum" name="XML_SCHEMAV_ISABSTRACT" link="libxml2-xmlerror.html#XML_SCHEMAV_ISABSTRACT"/>
<keyword type="enum" name="XML_SCHEMAV_MISC" link="libxml2-xmlerror.html#XML_SCHEMAV_MISC"/>
<keyword type="enum" name="XML_SCHEMAV_MISSING" link="libxml2-xmlerror.html#XML_SCHEMAV_MISSING"/>
<keyword type="enum" name="XML_SCHEMAV_NOROLLBACK" link="libxml2-xmlerror.html#XML_SCHEMAV_NOROLLBACK"/>
<keyword type="enum" name="XML_SCHEMAV_NOROOT" link="libxml2-xmlerror.html#XML_SCHEMAV_NOROOT"/>
<keyword type="enum" name="XML_SCHEMAV_NOTDETERMINIST" link="libxml2-xmlerror.html#XML_SCHEMAV_NOTDETERMINIST"/>
<keyword type="enum" name="XML_SCHEMAV_NOTEMPTY" link="libxml2-xmlerror.html#XML_SCHEMAV_NOTEMPTY"/>
<keyword type="enum" name="XML_SCHEMAV_NOTNILLABLE" link="libxml2-xmlerror.html#XML_SCHEMAV_NOTNILLABLE"/>
<keyword type="enum" name="XML_SCHEMAV_NOTSIMPLE" link="libxml2-xmlerror.html#XML_SCHEMAV_NOTSIMPLE"/>
<keyword type="enum" name="XML_SCHEMAV_NOTTOPLEVEL" link="libxml2-xmlerror.html#XML_SCHEMAV_NOTTOPLEVEL"/>
<keyword type="enum" name="XML_SCHEMAV_NOTYPE" link="libxml2-xmlerror.html#XML_SCHEMAV_NOTYPE"/>
<keyword type="enum" name="XML_SCHEMAV_UNDECLAREDELEM" link="libxml2-xmlerror.html#XML_SCHEMAV_UNDECLAREDELEM"/>
<keyword type="enum" name="XML_SCHEMAV_VALUE" link="libxml2-xmlerror.html#XML_SCHEMAV_VALUE"/>
<keyword type="enum" name="XML_SCHEMAV_WRONGELEM" link="libxml2-xmlerror.html#XML_SCHEMAV_WRONGELEM"/>
<keyword type="enum" name="XML_SCHEMA_CONTENT_ANY" link="libxml2-schemasInternals.html#XML_SCHEMA_CONTENT_ANY"/>
<keyword type="enum" name="XML_SCHEMA_CONTENT_BASIC" link="libxml2-schemasInternals.html#XML_SCHEMA_CONTENT_BASIC"/>
<keyword type="enum" name="XML_SCHEMA_CONTENT_ELEMENTS" link="libxml2-schemasInternals.html#XML_SCHEMA_CONTENT_ELEMENTS"/>
<keyword type="enum" name="XML_SCHEMA_CONTENT_EMPTY" link="libxml2-schemasInternals.html#XML_SCHEMA_CONTENT_EMPTY"/>
<keyword type="enum" name="XML_SCHEMA_CONTENT_MIXED" link="libxml2-schemasInternals.html#XML_SCHEMA_CONTENT_MIXED"/>
<keyword type="enum" name="XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS" link="libxml2-schemasInternals.html#XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS"/>
<keyword type="enum" name="XML_SCHEMA_CONTENT_SIMPLE" link="libxml2-schemasInternals.html#XML_SCHEMA_CONTENT_SIMPLE"/>
<keyword type="enum" name="XML_SCHEMA_CONTENT_UNKNOWN" link="libxml2-schemasInternals.html#XML_SCHEMA_CONTENT_UNKNOWN"/>
<keyword type="enum" name="XML_SCHEMA_EXTRA_ATTR_USE_PROHIB" link="libxml2-schemasInternals.html#XML_SCHEMA_EXTRA_ATTR_USE_PROHIB"/>
<keyword type="enum" name="XML_SCHEMA_EXTRA_QNAMEREF" link="libxml2-schemasInternals.html#XML_SCHEMA_EXTRA_QNAMEREF"/>
<keyword type="enum" name="XML_SCHEMA_FACET_ENUMERATION" link="libxml2-schemasInternals.html#XML_SCHEMA_FACET_ENUMERATION"/>
<keyword type="enum" name="XML_SCHEMA_FACET_FRACTIONDIGITS" link="libxml2-schemasInternals.html#XML_SCHEMA_FACET_FRACTIONDIGITS"/>
<keyword type="enum" name="XML_SCHEMA_FACET_LENGTH" link="libxml2-schemasInternals.html#XML_SCHEMA_FACET_LENGTH"/>
<keyword type="enum" name="XML_SCHEMA_FACET_MAXEXCLUSIVE" link="libxml2-schemasInternals.html#XML_SCHEMA_FACET_MAXEXCLUSIVE"/>
<keyword type="enum" name="XML_SCHEMA_FACET_MAXINCLUSIVE" link="libxml2-schemasInternals.html#XML_SCHEMA_FACET_MAXINCLUSIVE"/>
<keyword type="enum" name="XML_SCHEMA_FACET_MAXLENGTH" link="libxml2-schemasInternals.html#XML_SCHEMA_FACET_MAXLENGTH"/>
<keyword type="enum" name="XML_SCHEMA_FACET_MINEXCLUSIVE" link="libxml2-schemasInternals.html#XML_SCHEMA_FACET_MINEXCLUSIVE"/>
<keyword type="enum" name="XML_SCHEMA_FACET_MININCLUSIVE" link="libxml2-schemasInternals.html#XML_SCHEMA_FACET_MININCLUSIVE"/>
<keyword type="enum" name="XML_SCHEMA_FACET_MINLENGTH" link="libxml2-schemasInternals.html#XML_SCHEMA_FACET_MINLENGTH"/>
<keyword type="enum" name="XML_SCHEMA_FACET_PATTERN" link="libxml2-schemasInternals.html#XML_SCHEMA_FACET_PATTERN"/>
<keyword type="enum" name="XML_SCHEMA_FACET_TOTALDIGITS" link="libxml2-schemasInternals.html#XML_SCHEMA_FACET_TOTALDIGITS"/>
<keyword type="enum" name="XML_SCHEMA_FACET_WHITESPACE" link="libxml2-schemasInternals.html#XML_SCHEMA_FACET_WHITESPACE"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_ALL" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_ALL"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_ANY" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_ANY"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_ANY_ATTRIBUTE" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_ANY_ATTRIBUTE"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_ATTRIBUTE" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_ATTRIBUTE"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_ATTRIBUTEGROUP" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_ATTRIBUTEGROUP"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_ATTRIBUTE_USE" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_ATTRIBUTE_USE"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_BASIC" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_BASIC"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_CHOICE" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_CHOICE"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_COMPLEX" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_COMPLEX"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_COMPLEX_CONTENT" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_COMPLEX_CONTENT"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_ELEMENT" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_ELEMENT"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_EXTENSION" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_EXTENSION"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_FACET" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_FACET"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_GROUP" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_GROUP"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_IDC_KEY" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_IDC_KEY"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_IDC_KEYREF" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_IDC_KEYREF"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_IDC_UNIQUE" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_IDC_UNIQUE"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_LIST" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_LIST"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_NOTATION" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_NOTATION"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_PARTICLE" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_PARTICLE"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_RESTRICTION" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_RESTRICTION"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_SEQUENCE" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_SEQUENCE"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_SIMPLE" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_SIMPLE"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_SIMPLE_CONTENT" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_SIMPLE_CONTENT"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_UNION" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_UNION"/>
<keyword type="enum" name="XML_SCHEMA_TYPE_UR" link="libxml2-schemasInternals.html#XML_SCHEMA_TYPE_UR"/>
<keyword type="enum" name="XML_SCHEMA_VAL_VC_I_CREATE" link="libxml2-xmlschemas.html#XML_SCHEMA_VAL_VC_I_CREATE"/>
<keyword type="enum" name="XML_SCHEMA_WHITESPACE_COLLAPSE" link="libxml2-xmlschemastypes.html#XML_SCHEMA_WHITESPACE_COLLAPSE"/>
<keyword type="enum" name="XML_SCHEMA_WHITESPACE_PRESERVE" link="libxml2-xmlschemastypes.html#XML_SCHEMA_WHITESPACE_PRESERVE"/>
<keyword type="enum" name="XML_SCHEMA_WHITESPACE_REPLACE" link="libxml2-xmlschemastypes.html#XML_SCHEMA_WHITESPACE_REPLACE"/>
<keyword type="enum" name="XML_SCHEMA_WHITESPACE_UNKNOWN" link="libxml2-xmlschemastypes.html#XML_SCHEMA_WHITESPACE_UNKNOWN"/>
<keyword type="enum" name="XML_TEXTREADER_MODE_CLOSED" link="libxml2-xmlreader.html#XML_TEXTREADER_MODE_CLOSED"/>
<keyword type="enum" name="XML_TEXTREADER_MODE_EOF" link="libxml2-xmlreader.html#XML_TEXTREADER_MODE_EOF"/>
<keyword type="enum" name="XML_TEXTREADER_MODE_ERROR" link="libxml2-xmlreader.html#XML_TEXTREADER_MODE_ERROR"/>
<keyword type="enum" name="XML_TEXTREADER_MODE_INITIAL" link="libxml2-xmlreader.html#XML_TEXTREADER_MODE_INITIAL"/>
<keyword type="enum" name="XML_TEXTREADER_MODE_INTERACTIVE" link="libxml2-xmlreader.html#XML_TEXTREADER_MODE_INTERACTIVE"/>
<keyword type="enum" name="XML_TEXTREADER_MODE_READING" link="libxml2-xmlreader.html#XML_TEXTREADER_MODE_READING"/>
<keyword type="enum" name="XML_TEXT_NODE" link="libxml2-tree.html#XML_TEXT_NODE"/>
<keyword type="enum" name="XML_TREE_INVALID_DEC" link="libxml2-xmlerror.html#XML_TREE_INVALID_DEC"/>
<keyword type="enum" name="XML_TREE_INVALID_HEX" link="libxml2-xmlerror.html#XML_TREE_INVALID_HEX"/>
<keyword type="enum" name="XML_TREE_NOT_UTF8" link="libxml2-xmlerror.html#XML_TREE_NOT_UTF8"/>
<keyword type="enum" name="XML_TREE_UNTERMINATED_ENTITY" link="libxml2-xmlerror.html#XML_TREE_UNTERMINATED_ENTITY"/>
<keyword type="enum" name="XML_WAR_CATALOG_PI" link="libxml2-xmlerror.html#XML_WAR_CATALOG_PI"/>
<keyword type="enum" name="XML_WAR_ENTITY_REDEFINED" link="libxml2-xmlerror.html#XML_WAR_ENTITY_REDEFINED"/>
<keyword type="enum" name="XML_WAR_LANG_VALUE" link="libxml2-xmlerror.html#XML_WAR_LANG_VALUE"/>
<keyword type="enum" name="XML_WAR_NS_COLUMN" link="libxml2-xmlerror.html#XML_WAR_NS_COLUMN"/>
<keyword type="enum" name="XML_WAR_NS_URI" link="libxml2-xmlerror.html#XML_WAR_NS_URI"/>
<keyword type="enum" name="XML_WAR_NS_URI_RELATIVE" link="libxml2-xmlerror.html#XML_WAR_NS_URI_RELATIVE"/>
<keyword type="enum" name="XML_WAR_SPACE_VALUE" link="libxml2-xmlerror.html#XML_WAR_SPACE_VALUE"/>
<keyword type="enum" name="XML_WAR_UNDECLARED_ENTITY" link="libxml2-xmlerror.html#XML_WAR_UNDECLARED_ENTITY"/>
<keyword type="enum" name="XML_WAR_UNKNOWN_VERSION" link="libxml2-xmlerror.html#XML_WAR_UNKNOWN_VERSION"/>
<keyword type="enum" name="XML_WITH_AUTOMATA" link="libxml2-parser.html#XML_WITH_AUTOMATA"/>
<keyword type="enum" name="XML_WITH_C14N" link="libxml2-parser.html#XML_WITH_C14N"/>
<keyword type="enum" name="XML_WITH_CATALOG" link="libxml2-parser.html#XML_WITH_CATALOG"/>
<keyword type="enum" name="XML_WITH_DEBUG" link="libxml2-parser.html#XML_WITH_DEBUG"/>
<keyword type="enum" name="XML_WITH_DEBUG_MEM" link="libxml2-parser.html#XML_WITH_DEBUG_MEM"/>
<keyword type="enum" name="XML_WITH_DEBUG_RUN" link="libxml2-parser.html#XML_WITH_DEBUG_RUN"/>
<keyword type="enum" name="XML_WITH_EXPR" link="libxml2-parser.html#XML_WITH_EXPR"/>
<keyword type="enum" name="XML_WITH_FTP" link="libxml2-parser.html#XML_WITH_FTP"/>
<keyword type="enum" name="XML_WITH_HTML" link="libxml2-parser.html#XML_WITH_HTML"/>
<keyword type="enum" name="XML_WITH_HTTP" link="libxml2-parser.html#XML_WITH_HTTP"/>
<keyword type="enum" name="XML_WITH_ICONV" link="libxml2-parser.html#XML_WITH_ICONV"/>
<keyword type="enum" name="XML_WITH_ICU" link="libxml2-parser.html#XML_WITH_ICU"/>
<keyword type="enum" name="XML_WITH_ISO8859X" link="libxml2-parser.html#XML_WITH_ISO8859X"/>
<keyword type="enum" name="XML_WITH_LEGACY" link="libxml2-parser.html#XML_WITH_LEGACY"/>
<keyword type="enum" name="XML_WITH_LZMA" link="libxml2-parser.html#XML_WITH_LZMA"/>
<keyword type="enum" name="XML_WITH_MODULES" link="libxml2-parser.html#XML_WITH_MODULES"/>
<keyword type="enum" name="XML_WITH_NONE" link="libxml2-parser.html#XML_WITH_NONE"/>
<keyword type="enum" name="XML_WITH_OUTPUT" link="libxml2-parser.html#XML_WITH_OUTPUT"/>
<keyword type="enum" name="XML_WITH_PATTERN" link="libxml2-parser.html#XML_WITH_PATTERN"/>
<keyword type="enum" name="XML_WITH_PUSH" link="libxml2-parser.html#XML_WITH_PUSH"/>
<keyword type="enum" name="XML_WITH_READER" link="libxml2-parser.html#XML_WITH_READER"/>
<keyword type="enum" name="XML_WITH_REGEXP" link="libxml2-parser.html#XML_WITH_REGEXP"/>
<keyword type="enum" name="XML_WITH_SAX1" link="libxml2-parser.html#XML_WITH_SAX1"/>
<keyword type="enum" name="XML_WITH_SCHEMAS" link="libxml2-parser.html#XML_WITH_SCHEMAS"/>
<keyword type="enum" name="XML_WITH_SCHEMATRON" link="libxml2-parser.html#XML_WITH_SCHEMATRON"/>
<keyword type="enum" name="XML_WITH_THREAD" link="libxml2-parser.html#XML_WITH_THREAD"/>
<keyword type="enum" name="XML_WITH_TREE" link="libxml2-parser.html#XML_WITH_TREE"/>
<keyword type="enum" name="XML_WITH_UNICODE" link="libxml2-parser.html#XML_WITH_UNICODE"/>
<keyword type="enum" name="XML_WITH_VALID" link="libxml2-parser.html#XML_WITH_VALID"/>
<keyword type="enum" name="XML_WITH_WRITER" link="libxml2-parser.html#XML_WITH_WRITER"/>
<keyword type="enum" name="XML_WITH_XINCLUDE" link="libxml2-parser.html#XML_WITH_XINCLUDE"/>
<keyword type="enum" name="XML_WITH_XPATH" link="libxml2-parser.html#XML_WITH_XPATH"/>
<keyword type="enum" name="XML_WITH_XPTR" link="libxml2-parser.html#XML_WITH_XPTR"/>
<keyword type="enum" name="XML_WITH_ZLIB" link="libxml2-parser.html#XML_WITH_ZLIB"/>
<keyword type="enum" name="XML_XINCLUDE_BUILD_FAILED" link="libxml2-xmlerror.html#XML_XINCLUDE_BUILD_FAILED"/>
<keyword type="enum" name="XML_XINCLUDE_DEPRECATED_NS" link="libxml2-xmlerror.html#XML_XINCLUDE_DEPRECATED_NS"/>
<keyword type="enum" name="XML_XINCLUDE_END" link="libxml2-tree.html#XML_XINCLUDE_END"/>
<keyword type="enum" name="XML_XINCLUDE_ENTITY_DEF_MISMATCH" link="libxml2-xmlerror.html#XML_XINCLUDE_ENTITY_DEF_MISMATCH"/>
<keyword type="enum" name="XML_XINCLUDE_FALLBACKS_IN_INCLUDE" link="libxml2-xmlerror.html#XML_XINCLUDE_FALLBACKS_IN_INCLUDE"/>
<keyword type="enum" name="XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE" link="libxml2-xmlerror.html#XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE"/>
<keyword type="enum" name="XML_XINCLUDE_FRAGMENT_ID" link="libxml2-xmlerror.html#XML_XINCLUDE_FRAGMENT_ID"/>
<keyword type="enum" name="XML_XINCLUDE_HREF_URI" link="libxml2-xmlerror.html#XML_XINCLUDE_HREF_URI"/>
<keyword type="enum" name="XML_XINCLUDE_INCLUDE_IN_INCLUDE" link="libxml2-xmlerror.html#XML_XINCLUDE_INCLUDE_IN_INCLUDE"/>
<keyword type="enum" name="XML_XINCLUDE_INVALID_CHAR" link="libxml2-xmlerror.html#XML_XINCLUDE_INVALID_CHAR"/>
<keyword type="enum" name="XML_XINCLUDE_MULTIPLE_ROOT" link="libxml2-xmlerror.html#XML_XINCLUDE_MULTIPLE_ROOT"/>
<keyword type="enum" name="XML_XINCLUDE_NO_FALLBACK" link="libxml2-xmlerror.html#XML_XINCLUDE_NO_FALLBACK"/>
<keyword type="enum" name="XML_XINCLUDE_NO_HREF" link="libxml2-xmlerror.html#XML_XINCLUDE_NO_HREF"/>
<keyword type="enum" name="XML_XINCLUDE_PARSE_VALUE" link="libxml2-xmlerror.html#XML_XINCLUDE_PARSE_VALUE"/>
<keyword type="enum" name="XML_XINCLUDE_RECURSION" link="libxml2-xmlerror.html#XML_XINCLUDE_RECURSION"/>
<keyword type="enum" name="XML_XINCLUDE_START" link="libxml2-tree.html#XML_XINCLUDE_START"/>
<keyword type="enum" name="XML_XINCLUDE_TEXT_DOCUMENT" link="libxml2-xmlerror.html#XML_XINCLUDE_TEXT_DOCUMENT"/>
<keyword type="enum" name="XML_XINCLUDE_TEXT_FRAGMENT" link="libxml2-xmlerror.html#XML_XINCLUDE_TEXT_FRAGMENT"/>
<keyword type="enum" name="XML_XINCLUDE_UNKNOWN_ENCODING" link="libxml2-xmlerror.html#XML_XINCLUDE_UNKNOWN_ENCODING"/>
<keyword type="enum" name="XML_XINCLUDE_XPTR_FAILED" link="libxml2-xmlerror.html#XML_XINCLUDE_XPTR_FAILED"/>
<keyword type="enum" name="XML_XINCLUDE_XPTR_RESULT" link="libxml2-xmlerror.html#XML_XINCLUDE_XPTR_RESULT"/>
<keyword type="enum" name="XML_XPATH_ENCODING_ERROR" link="libxml2-xmlerror.html#XML_XPATH_ENCODING_ERROR"/>
<keyword type="enum" name="XML_XPATH_EXPRESSION_OK" link="libxml2-xmlerror.html#XML_XPATH_EXPRESSION_OK"/>
<keyword type="enum" name="XML_XPATH_EXPR_ERROR" link="libxml2-xmlerror.html#XML_XPATH_EXPR_ERROR"/>
<keyword type="enum" name="XML_XPATH_INVALID_ARITY" link="libxml2-xmlerror.html#XML_XPATH_INVALID_ARITY"/>
<keyword type="enum" name="XML_XPATH_INVALID_CHAR_ERROR" link="libxml2-xmlerror.html#XML_XPATH_INVALID_CHAR_ERROR"/>
<keyword type="enum" name="XML_XPATH_INVALID_CTXT_POSITION" link="libxml2-xmlerror.html#XML_XPATH_INVALID_CTXT_POSITION"/>
<keyword type="enum" name="XML_XPATH_INVALID_CTXT_SIZE" link="libxml2-xmlerror.html#XML_XPATH_INVALID_CTXT_SIZE"/>
<keyword type="enum" name="XML_XPATH_INVALID_OPERAND" link="libxml2-xmlerror.html#XML_XPATH_INVALID_OPERAND"/>
<keyword type="enum" name="XML_XPATH_INVALID_PREDICATE_ERROR" link="libxml2-xmlerror.html#XML_XPATH_INVALID_PREDICATE_ERROR"/>
<keyword type="enum" name="XML_XPATH_INVALID_TYPE" link="libxml2-xmlerror.html#XML_XPATH_INVALID_TYPE"/>
<keyword type="enum" name="XML_XPATH_MEMORY_ERROR" link="libxml2-xmlerror.html#XML_XPATH_MEMORY_ERROR"/>
<keyword type="enum" name="XML_XPATH_NUMBER_ERROR" link="libxml2-xmlerror.html#XML_XPATH_NUMBER_ERROR"/>
<keyword type="enum" name="XML_XPATH_START_LITERAL_ERROR" link="libxml2-xmlerror.html#XML_XPATH_START_LITERAL_ERROR"/>
<keyword type="enum" name="XML_XPATH_UNCLOSED_ERROR" link="libxml2-xmlerror.html#XML_XPATH_UNCLOSED_ERROR"/>
<keyword type="enum" name="XML_XPATH_UNDEF_PREFIX_ERROR" link="libxml2-xmlerror.html#XML_XPATH_UNDEF_PREFIX_ERROR"/>
<keyword type="enum" name="XML_XPATH_UNDEF_VARIABLE_ERROR" link="libxml2-xmlerror.html#XML_XPATH_UNDEF_VARIABLE_ERROR"/>
<keyword type="enum" name="XML_XPATH_UNFINISHED_LITERAL_ERROR" link="libxml2-xmlerror.html#XML_XPATH_UNFINISHED_LITERAL_ERROR"/>
<keyword type="enum" name="XML_XPATH_UNKNOWN_FUNC_ERROR" link="libxml2-xmlerror.html#XML_XPATH_UNKNOWN_FUNC_ERROR"/>
<keyword type="enum" name="XML_XPATH_VARIABLE_REF_ERROR" link="libxml2-xmlerror.html#XML_XPATH_VARIABLE_REF_ERROR"/>
<keyword type="enum" name="XML_XPTR_CHILDSEQ_START" link="libxml2-xmlerror.html#XML_XPTR_CHILDSEQ_START"/>
<keyword type="enum" name="XML_XPTR_EVAL_FAILED" link="libxml2-xmlerror.html#XML_XPTR_EVAL_FAILED"/>
<keyword type="enum" name="XML_XPTR_EXTRA_OBJECTS" link="libxml2-xmlerror.html#XML_XPTR_EXTRA_OBJECTS"/>
<keyword type="enum" name="XML_XPTR_RESOURCE_ERROR" link="libxml2-xmlerror.html#XML_XPTR_RESOURCE_ERROR"/>
<keyword type="enum" name="XML_XPTR_SUB_RESOURCE_ERROR" link="libxml2-xmlerror.html#XML_XPTR_SUB_RESOURCE_ERROR"/>
<keyword type="enum" name="XML_XPTR_SYNTAX_ERROR" link="libxml2-xmlerror.html#XML_XPTR_SYNTAX_ERROR"/>
<keyword type="enum" name="XML_XPTR_UNKNOWN_SCHEME" link="libxml2-xmlerror.html#XML_XPTR_UNKNOWN_SCHEME"/>
<keyword type="enum" name="XPATH_BOOLEAN" link="libxml2-xpath.html#XPATH_BOOLEAN"/>
<keyword type="enum" name="XPATH_ENCODING_ERROR" link="libxml2-xpath.html#XPATH_ENCODING_ERROR"/>
<keyword type="enum" name="XPATH_EXPRESSION_OK" link="libxml2-xpath.html#XPATH_EXPRESSION_OK"/>
<keyword type="enum" name="XPATH_EXPR_ERROR" link="libxml2-xpath.html#XPATH_EXPR_ERROR"/>
<keyword type="enum" name="XPATH_FORBID_VARIABLE_ERROR" link="libxml2-xpath.html#XPATH_FORBID_VARIABLE_ERROR"/>
<keyword type="enum" name="XPATH_INVALID_ARITY" link="libxml2-xpath.html#XPATH_INVALID_ARITY"/>
<keyword type="enum" name="XPATH_INVALID_CHAR_ERROR" link="libxml2-xpath.html#XPATH_INVALID_CHAR_ERROR"/>
<keyword type="enum" name="XPATH_INVALID_CTXT" link="libxml2-xpath.html#XPATH_INVALID_CTXT"/>
<keyword type="enum" name="XPATH_INVALID_CTXT_POSITION" link="libxml2-xpath.html#XPATH_INVALID_CTXT_POSITION"/>
<keyword type="enum" name="XPATH_INVALID_CTXT_SIZE" link="libxml2-xpath.html#XPATH_INVALID_CTXT_SIZE"/>
<keyword type="enum" name="XPATH_INVALID_OPERAND" link="libxml2-xpath.html#XPATH_INVALID_OPERAND"/>
<keyword type="enum" name="XPATH_INVALID_PREDICATE_ERROR" link="libxml2-xpath.html#XPATH_INVALID_PREDICATE_ERROR"/>
<keyword type="enum" name="XPATH_INVALID_TYPE" link="libxml2-xpath.html#XPATH_INVALID_TYPE"/>
<keyword type="enum" name="XPATH_LOCATIONSET" link="libxml2-xpath.html#XPATH_LOCATIONSET"/>
<keyword type="enum" name="XPATH_MEMORY_ERROR" link="libxml2-xpath.html#XPATH_MEMORY_ERROR"/>
<keyword type="enum" name="XPATH_NODESET" link="libxml2-xpath.html#XPATH_NODESET"/>
<keyword type="enum" name="XPATH_NUMBER" link="libxml2-xpath.html#XPATH_NUMBER"/>
<keyword type="enum" name="XPATH_NUMBER_ERROR" link="libxml2-xpath.html#XPATH_NUMBER_ERROR"/>
<keyword type="enum" name="XPATH_OP_LIMIT_EXCEEDED" link="libxml2-xpath.html#XPATH_OP_LIMIT_EXCEEDED"/>
<keyword type="enum" name="XPATH_POINT" link="libxml2-xpath.html#XPATH_POINT"/>
<keyword type="enum" name="XPATH_RANGE" link="libxml2-xpath.html#XPATH_RANGE"/>
<keyword type="enum" name="XPATH_RECURSION_LIMIT_EXCEEDED" link="libxml2-xpath.html#XPATH_RECURSION_LIMIT_EXCEEDED"/>
<keyword type="enum" name="XPATH_STACK_ERROR" link="libxml2-xpath.html#XPATH_STACK_ERROR"/>
<keyword type="enum" name="XPATH_START_LITERAL_ERROR" link="libxml2-xpath.html#XPATH_START_LITERAL_ERROR"/>
<keyword type="enum" name="XPATH_STRING" link="libxml2-xpath.html#XPATH_STRING"/>
<keyword type="enum" name="XPATH_UNCLOSED_ERROR" link="libxml2-xpath.html#XPATH_UNCLOSED_ERROR"/>
<keyword type="enum" name="XPATH_UNDEFINED" link="libxml2-xpath.html#XPATH_UNDEFINED"/>
<keyword type="enum" name="XPATH_UNDEF_PREFIX_ERROR" link="libxml2-xpath.html#XPATH_UNDEF_PREFIX_ERROR"/>
<keyword type="enum" name="XPATH_UNDEF_VARIABLE_ERROR" link="libxml2-xpath.html#XPATH_UNDEF_VARIABLE_ERROR"/>
<keyword type="enum" name="XPATH_UNFINISHED_LITERAL_ERROR" link="libxml2-xpath.html#XPATH_UNFINISHED_LITERAL_ERROR"/>
<keyword type="enum" name="XPATH_UNKNOWN_FUNC_ERROR" link="libxml2-xpath.html#XPATH_UNKNOWN_FUNC_ERROR"/>
<keyword type="enum" name="XPATH_USERS" link="libxml2-xpath.html#XPATH_USERS"/>
<keyword type="enum" name="XPATH_VARIABLE_REF_ERROR" link="libxml2-xpath.html#XPATH_VARIABLE_REF_ERROR"/>
<keyword type="enum" name="XPATH_XSLT_TREE" link="libxml2-xpath.html#XPATH_XSLT_TREE"/>
<keyword type="enum" name="XPTR_RESOURCE_ERROR" link="libxml2-xpath.html#XPTR_RESOURCE_ERROR"/>
<keyword type="enum" name="XPTR_SUB_RESOURCE_ERROR" link="libxml2-xpath.html#XPTR_SUB_RESOURCE_ERROR"/>
<keyword type="enum" name="XPTR_SYNTAX_ERROR" link="libxml2-xpath.html#XPTR_SYNTAX_ERROR"/>
<keyword type="typedef" name="htmlDocPtr" link="libxml2-HTMLparser.html#htmlDocPtr"/>
<keyword type="typedef" name="htmlElemDescPtr" link="libxml2-HTMLparser.html#htmlElemDescPtr"/>
<keyword type="typedef" name="htmlEntityDescPtr" link="libxml2-HTMLparser.html#htmlEntityDescPtr"/>
<keyword type="typedef" name="htmlNodePtr" link="libxml2-HTMLparser.html#htmlNodePtr"/>
<keyword type="typedef" name="htmlParserCtxt" link="libxml2-HTMLparser.html#htmlParserCtxt"/>
<keyword type="typedef" name="htmlParserCtxtPtr" link="libxml2-HTMLparser.html#htmlParserCtxtPtr"/>
<keyword type="typedef" name="htmlParserInput" link="libxml2-HTMLparser.html#htmlParserInput"/>
<keyword type="typedef" name="htmlParserInputPtr" link="libxml2-HTMLparser.html#htmlParserInputPtr"/>
<keyword type="typedef" name="htmlParserNodeInfo" link="libxml2-HTMLparser.html#htmlParserNodeInfo"/>
<keyword type="typedef" name="htmlParserOption" link="libxml2-HTMLparser.html#htmlParserOption"/>
<keyword type="typedef" name="htmlSAXHandler" link="libxml2-HTMLparser.html#htmlSAXHandler"/>
<keyword type="typedef" name="htmlSAXHandlerPtr" link="libxml2-HTMLparser.html#htmlSAXHandlerPtr"/>
<keyword type="typedef" name="htmlStatus" link="libxml2-HTMLparser.html#htmlStatus"/>
<keyword type="typedef" name="xlinkActuate" link="libxml2-xlink.html#xlinkActuate"/>
<keyword type="typedef" name="xlinkHRef" link="libxml2-xlink.html#xlinkHRef"/>
<keyword type="typedef" name="xlinkHandlerPtr" link="libxml2-xlink.html#xlinkHandlerPtr"/>
<keyword type="typedef" name="xlinkRole" link="libxml2-xlink.html#xlinkRole"/>
<keyword type="typedef" name="xlinkShow" link="libxml2-xlink.html#xlinkShow"/>
<keyword type="typedef" name="xlinkTitle" link="libxml2-xlink.html#xlinkTitle"/>
<keyword type="typedef" name="xlinkType" link="libxml2-xlink.html#xlinkType"/>
<keyword type="typedef" name="xmlAttrPtr" link="libxml2-tree.html#xmlAttrPtr"/>
<keyword type="typedef" name="xmlAttributeDefault" link="libxml2-tree.html#xmlAttributeDefault"/>
<keyword type="typedef" name="xmlAttributePtr" link="libxml2-tree.html#xmlAttributePtr"/>
<keyword type="typedef" name="xmlAttributeTablePtr" link="libxml2-valid.html#xmlAttributeTablePtr"/>
<keyword type="typedef" name="xmlAttributeType" link="libxml2-tree.html#xmlAttributeType"/>
<keyword type="typedef" name="xmlAutomataPtr" link="libxml2-xmlautomata.html#xmlAutomataPtr"/>
<keyword type="typedef" name="xmlAutomataStatePtr" link="libxml2-xmlautomata.html#xmlAutomataStatePtr"/>
<keyword type="typedef" name="xmlBufPtr" link="libxml2-tree.html#xmlBufPtr"/>
<keyword type="typedef" name="xmlBufferAllocationScheme" link="libxml2-tree.html#xmlBufferAllocationScheme"/>
<keyword type="typedef" name="xmlBufferPtr" link="libxml2-tree.html#xmlBufferPtr"/>
<keyword type="typedef" name="xmlC14NMode" link="libxml2-c14n.html#xmlC14NMode"/>
<keyword type="typedef" name="xmlCatalogAllow" link="libxml2-catalog.html#xmlCatalogAllow"/>
<keyword type="typedef" name="xmlCatalogPrefer" link="libxml2-catalog.html#xmlCatalogPrefer"/>
<keyword type="typedef" name="xmlCatalogPtr" link="libxml2-catalog.html#xmlCatalogPtr"/>
<keyword type="typedef" name="xmlChLRangePtr" link="libxml2-chvalid.html#xmlChLRangePtr"/>
<keyword type="typedef" name="xmlChRangeGroupPtr" link="libxml2-chvalid.html#xmlChRangeGroupPtr"/>
<keyword type="typedef" name="xmlChSRangePtr" link="libxml2-chvalid.html#xmlChSRangePtr"/>
<keyword type="typedef" name="xmlChar" link="libxml2-xmlstring.html#xmlChar"/>
<keyword type="typedef" name="xmlCharEncoding" link="libxml2-encoding.html#xmlCharEncoding"/>
<keyword type="typedef" name="xmlCharEncodingHandlerPtr" link="libxml2-encoding.html#xmlCharEncodingHandlerPtr"/>
<keyword type="typedef" name="xmlDOMWrapCtxtPtr" link="libxml2-tree.html#xmlDOMWrapCtxtPtr"/>
<keyword type="typedef" name="xmlDictPtr" link="libxml2-dict.html#xmlDictPtr"/>
<keyword type="typedef" name="xmlDocProperties" link="libxml2-tree.html#xmlDocProperties"/>
<keyword type="typedef" name="xmlDocPtr" link="libxml2-tree.html#xmlDocPtr"/>
<keyword type="typedef" name="xmlDtdPtr" link="libxml2-tree.html#xmlDtdPtr"/>
<keyword type="typedef" name="xmlElementContentOccur" link="libxml2-tree.html#xmlElementContentOccur"/>
<keyword type="typedef" name="xmlElementContentPtr" link="libxml2-tree.html#xmlElementContentPtr"/>
<keyword type="typedef" name="xmlElementContentType" link="libxml2-tree.html#xmlElementContentType"/>
<keyword type="typedef" name="xmlElementPtr" link="libxml2-tree.html#xmlElementPtr"/>
<keyword type="typedef" name="xmlElementTablePtr" link="libxml2-valid.html#xmlElementTablePtr"/>
<keyword type="typedef" name="xmlElementType" link="libxml2-tree.html#xmlElementType"/>
<keyword type="typedef" name="xmlElementTypeVal" link="libxml2-tree.html#xmlElementTypeVal"/>
<keyword type="typedef" name="xmlEntitiesTablePtr" link="libxml2-entities.html#xmlEntitiesTablePtr"/>
<keyword type="typedef" name="xmlEntityPtr" link="libxml2-tree.html#xmlEntityPtr"/>
<keyword type="typedef" name="xmlEntityType" link="libxml2-entities.html#xmlEntityType"/>
<keyword type="typedef" name="xmlEnumerationPtr" link="libxml2-tree.html#xmlEnumerationPtr"/>
<keyword type="typedef" name="xmlErrorDomain" link="libxml2-xmlerror.html#xmlErrorDomain"/>
<keyword type="typedef" name="xmlErrorLevel" link="libxml2-xmlerror.html#xmlErrorLevel"/>
<keyword type="typedef" name="xmlErrorPtr" link="libxml2-xmlerror.html#xmlErrorPtr"/>
<keyword type="typedef" name="xmlExpCtxtPtr" link="libxml2-xmlregexp.html#xmlExpCtxtPtr"/>
<keyword type="typedef" name="xmlExpNodePtr" link="libxml2-xmlregexp.html#xmlExpNodePtr"/>
<keyword type="typedef" name="xmlExpNodeType" link="libxml2-xmlregexp.html#xmlExpNodeType"/>
<keyword type="typedef" name="xmlFeature" link="libxml2-parser.html#xmlFeature"/>
<keyword type="typedef" name="xmlGlobalStatePtr" link="libxml2-globals.html#xmlGlobalStatePtr"/>
<keyword type="typedef" name="xmlHashTablePtr" link="libxml2-hash.html#xmlHashTablePtr"/>
<keyword type="typedef" name="xmlIDPtr" link="libxml2-tree.html#xmlIDPtr"/>
<keyword type="typedef" name="xmlIDTablePtr" link="libxml2-valid.html#xmlIDTablePtr"/>
<keyword type="typedef" name="xmlLinkPtr" link="libxml2-list.html#xmlLinkPtr"/>
<keyword type="typedef" name="xmlListPtr" link="libxml2-list.html#xmlListPtr"/>
<keyword type="typedef" name="xmlLocationSetPtr" link="libxml2-xpointer.html#xmlLocationSetPtr"/>
<keyword type="typedef" name="xmlModuleOption" link="libxml2-xmlmodule.html#xmlModuleOption"/>
<keyword type="typedef" name="xmlModulePtr" link="libxml2-xmlmodule.html#xmlModulePtr"/>
<keyword type="typedef" name="xmlMutexPtr" link="libxml2-threads.html#xmlMutexPtr"/>
<keyword type="typedef" name="xmlNodePtr" link="libxml2-tree.html#xmlNodePtr"/>
<keyword type="typedef" name="xmlNodeSetPtr" link="libxml2-xpath.html#xmlNodeSetPtr"/>
<keyword type="typedef" name="xmlNotationPtr" link="libxml2-tree.html#xmlNotationPtr"/>
<keyword type="typedef" name="xmlNotationTablePtr" link="libxml2-valid.html#xmlNotationTablePtr"/>
<keyword type="typedef" name="xmlNsPtr" link="libxml2-tree.html#xmlNsPtr"/>
<keyword type="typedef" name="xmlNsType" link="libxml2-tree.html#xmlNsType"/>
<keyword type="typedef" name="xmlOutputBufferPtr" link="libxml2-tree.html#xmlOutputBufferPtr"/>
<keyword type="typedef" name="xmlParserCtxtPtr" link="libxml2-tree.html#xmlParserCtxtPtr"/>
<keyword type="typedef" name="xmlParserErrors" link="libxml2-xmlerror.html#xmlParserErrors"/>
<keyword type="typedef" name="xmlParserInputBufferPtr" link="libxml2-tree.html#xmlParserInputBufferPtr"/>
<keyword type="typedef" name="xmlParserInputPtr" link="libxml2-tree.html#xmlParserInputPtr"/>
<keyword type="typedef" name="xmlParserInputState" link="libxml2-parser.html#xmlParserInputState"/>
<keyword type="typedef" name="xmlParserMode" link="libxml2-parser.html#xmlParserMode"/>
<keyword type="typedef" name="xmlParserNodeInfoPtr" link="libxml2-parser.html#xmlParserNodeInfoPtr"/>
<keyword type="typedef" name="xmlParserNodeInfoSeqPtr" link="libxml2-parser.html#xmlParserNodeInfoSeqPtr"/>
<keyword type="typedef" name="xmlParserOption" link="libxml2-parser.html#xmlParserOption"/>
<keyword type="typedef" name="xmlParserProperties" link="libxml2-xmlreader.html#xmlParserProperties"/>
<keyword type="typedef" name="xmlParserSeverities" link="libxml2-xmlreader.html#xmlParserSeverities"/>
<keyword type="typedef" name="xmlPatternFlags" link="libxml2-pattern.html#xmlPatternFlags"/>
<keyword type="typedef" name="xmlPatternPtr" link="libxml2-pattern.html#xmlPatternPtr"/>
<keyword type="typedef" name="xmlRMutexPtr" link="libxml2-threads.html#xmlRMutexPtr"/>
<keyword type="typedef" name="xmlReaderTypes" link="libxml2-xmlreader.html#xmlReaderTypes"/>
<keyword type="typedef" name="xmlRefPtr" link="libxml2-tree.html#xmlRefPtr"/>
<keyword type="typedef" name="xmlRefTablePtr" link="libxml2-valid.html#xmlRefTablePtr"/>
<keyword type="typedef" name="xmlRegExecCtxtPtr" link="libxml2-xmlregexp.html#xmlRegExecCtxtPtr"/>
<keyword type="typedef" name="xmlRegexpPtr" link="libxml2-xmlregexp.html#xmlRegexpPtr"/>
<keyword type="typedef" name="xmlRelaxNGParserCtxtPtr" link="libxml2-relaxng.html#xmlRelaxNGParserCtxtPtr"/>
<keyword type="typedef" name="xmlRelaxNGParserFlag" link="libxml2-relaxng.html#xmlRelaxNGParserFlag"/>
<keyword type="typedef" name="xmlRelaxNGPtr" link="libxml2-relaxng.html#xmlRelaxNGPtr"/>
<keyword type="typedef" name="xmlRelaxNGValidCtxtPtr" link="libxml2-relaxng.html#xmlRelaxNGValidCtxtPtr"/>
<keyword type="typedef" name="xmlRelaxNGValidErr" link="libxml2-relaxng.html#xmlRelaxNGValidErr"/>
<keyword type="typedef" name="xmlSAXHandlerPtr" link="libxml2-tree.html#xmlSAXHandlerPtr"/>
<keyword type="typedef" name="xmlSAXHandlerV1Ptr" link="libxml2-parser.html#xmlSAXHandlerV1Ptr"/>
<keyword type="typedef" name="xmlSAXLocatorPtr" link="libxml2-tree.html#xmlSAXLocatorPtr"/>
<keyword type="typedef" name="xmlSaveCtxtPtr" link="libxml2-xmlsave.html#xmlSaveCtxtPtr"/>
<keyword type="typedef" name="xmlSaveOption" link="libxml2-xmlsave.html#xmlSaveOption"/>
<keyword type="typedef" name="xmlSchemaAnnotPtr" link="libxml2-schemasInternals.html#xmlSchemaAnnotPtr"/>
<keyword type="typedef" name="xmlSchemaAttributeGroupPtr" link="libxml2-schemasInternals.html#xmlSchemaAttributeGroupPtr"/>
<keyword type="typedef" name="xmlSchemaAttributeLinkPtr" link="libxml2-schemasInternals.html#xmlSchemaAttributeLinkPtr"/>
<keyword type="typedef" name="xmlSchemaAttributePtr" link="libxml2-schemasInternals.html#xmlSchemaAttributePtr"/>
<keyword type="typedef" name="xmlSchemaContentType" link="libxml2-schemasInternals.html#xmlSchemaContentType"/>
<keyword type="typedef" name="xmlSchemaElementPtr" link="libxml2-schemasInternals.html#xmlSchemaElementPtr"/>
<keyword type="typedef" name="xmlSchemaFacetLinkPtr" link="libxml2-schemasInternals.html#xmlSchemaFacetLinkPtr"/>
<keyword type="typedef" name="xmlSchemaFacetPtr" link="libxml2-schemasInternals.html#xmlSchemaFacetPtr"/>
<keyword type="typedef" name="xmlSchemaNotationPtr" link="libxml2-schemasInternals.html#xmlSchemaNotationPtr"/>
<keyword type="typedef" name="xmlSchemaParserCtxtPtr" link="libxml2-xmlschemas.html#xmlSchemaParserCtxtPtr"/>
<keyword type="typedef" name="xmlSchemaPtr" link="libxml2-xmlschemas.html#xmlSchemaPtr"/>
<keyword type="typedef" name="xmlSchemaSAXPlugPtr" link="libxml2-xmlschemas.html#xmlSchemaSAXPlugPtr"/>
<keyword type="typedef" name="xmlSchemaTypeLinkPtr" link="libxml2-schemasInternals.html#xmlSchemaTypeLinkPtr"/>
<keyword type="typedef" name="xmlSchemaTypePtr" link="libxml2-schemasInternals.html#xmlSchemaTypePtr"/>
<keyword type="typedef" name="xmlSchemaTypeType" link="libxml2-schemasInternals.html#xmlSchemaTypeType"/>
<keyword type="typedef" name="xmlSchemaValPtr" link="libxml2-schemasInternals.html#xmlSchemaValPtr"/>
<keyword type="typedef" name="xmlSchemaValType" link="libxml2-schemasInternals.html#xmlSchemaValType"/>
<keyword type="typedef" name="xmlSchemaValidCtxtPtr" link="libxml2-xmlschemas.html#xmlSchemaValidCtxtPtr"/>
<keyword type="typedef" name="xmlSchemaValidError" link="libxml2-xmlschemas.html#xmlSchemaValidError"/>
<keyword type="typedef" name="xmlSchemaValidOption" link="libxml2-xmlschemas.html#xmlSchemaValidOption"/>
<keyword type="typedef" name="xmlSchemaWhitespaceValueType" link="libxml2-xmlschemastypes.html#xmlSchemaWhitespaceValueType"/>
<keyword type="typedef" name="xmlSchemaWildcardNsPtr" link="libxml2-schemasInternals.html#xmlSchemaWildcardNsPtr"/>
<keyword type="typedef" name="xmlSchemaWildcardPtr" link="libxml2-schemasInternals.html#xmlSchemaWildcardPtr"/>
<keyword type="typedef" name="xmlSchematronParserCtxtPtr" link="libxml2-schematron.html#xmlSchematronParserCtxtPtr"/>
<keyword type="typedef" name="xmlSchematronPtr" link="libxml2-schematron.html#xmlSchematronPtr"/>
<keyword type="typedef" name="xmlSchematronValidCtxtPtr" link="libxml2-schematron.html#xmlSchematronValidCtxtPtr"/>
<keyword type="typedef" name="xmlSchematronValidOptions" link="libxml2-schematron.html#xmlSchematronValidOptions"/>
<keyword type="typedef" name="xmlShellCtxtPtr" link="libxml2-debugXML.html#xmlShellCtxtPtr"/>
<keyword type="typedef" name="xmlStreamCtxtPtr" link="libxml2-pattern.html#xmlStreamCtxtPtr"/>
<keyword type="typedef" name="xmlTextReaderLocatorPtr" link="libxml2-xmlreader.html#xmlTextReaderLocatorPtr"/>
<keyword type="typedef" name="xmlTextReaderMode" link="libxml2-xmlreader.html#xmlTextReaderMode"/>
<keyword type="typedef" name="xmlTextReaderPtr" link="libxml2-xmlreader.html#xmlTextReaderPtr"/>
<keyword type="typedef" name="xmlTextWriterPtr" link="libxml2-xmlwriter.html#xmlTextWriterPtr"/>
<keyword type="typedef" name="xmlURIPtr" link="libxml2-uri.html#xmlURIPtr"/>
<keyword type="typedef" name="xmlValidCtxtPtr" link="libxml2-valid.html#xmlValidCtxtPtr"/>
<keyword type="typedef" name="xmlValidStatePtr" link="libxml2-valid.html#xmlValidStatePtr"/>
<keyword type="typedef" name="xmlXIncludeCtxtPtr" link="libxml2-xinclude.html#xmlXIncludeCtxtPtr"/>
<keyword type="typedef" name="xmlXPathAxisPtr" link="libxml2-xpath.html#xmlXPathAxisPtr"/>
<keyword type="typedef" name="xmlXPathCompExprPtr" link="libxml2-xpath.html#xmlXPathCompExprPtr"/>
<keyword type="typedef" name="xmlXPathContextPtr" link="libxml2-xpath.html#xmlXPathContextPtr"/>
<keyword type="typedef" name="xmlXPathError" link="libxml2-xpath.html#xmlXPathError"/>
<keyword type="typedef" name="xmlXPathFuncPtr" link="libxml2-xpath.html#xmlXPathFuncPtr"/>
<keyword type="typedef" name="xmlXPathObjectPtr" link="libxml2-xpath.html#xmlXPathObjectPtr"/>
<keyword type="typedef" name="xmlXPathObjectType" link="libxml2-xpath.html#xmlXPathObjectType"/>
<keyword type="typedef" name="xmlXPathParserContextPtr" link="libxml2-xpath.html#xmlXPathParserContextPtr"/>
<keyword type="typedef" name="xmlXPathTypePtr" link="libxml2-xpath.html#xmlXPathTypePtr"/>
<keyword type="typedef" name="xmlXPathVariablePtr" link="libxml2-xpath.html#xmlXPathVariablePtr"/>
<keyword type="struct" name="htmlElemDesc" link="libxml2-HTMLparser.html#htmlElemDesc"/>
<keyword type="struct" name="htmlEntityDesc" link="libxml2-HTMLparser.html#htmlEntityDesc"/>
<keyword type="struct" name="xlinkHandler" link="libxml2-xlink.html#xlinkHandler"/>
<keyword type="struct" name="xmlAttr" link="libxml2-tree.html#xmlAttr"/>
<keyword type="struct" name="xmlAttribute" link="libxml2-tree.html#xmlAttribute"/>
<keyword type="struct" name="xmlAttributeTable" link="libxml2-valid.html#xmlAttributeTable"/>
<keyword type="struct" name="xmlAutomata" link="libxml2-xmlautomata.html#xmlAutomata"/>
<keyword type="struct" name="xmlAutomataState" link="libxml2-xmlautomata.html#xmlAutomataState"/>
<keyword type="struct" name="xmlBuf" link="libxml2-tree.html#xmlBuf"/>
<keyword type="struct" name="xmlBuffer" link="libxml2-tree.html#xmlBuffer"/>
<keyword type="struct" name="xmlCatalog" link="libxml2-catalog.html#xmlCatalog"/>
<keyword type="struct" name="xmlChLRange" link="libxml2-chvalid.html#xmlChLRange"/>
<keyword type="struct" name="xmlChRangeGroup" link="libxml2-chvalid.html#xmlChRangeGroup"/>
<keyword type="struct" name="xmlChSRange" link="libxml2-chvalid.html#xmlChSRange"/>
<keyword type="struct" name="xmlCharEncodingHandler" link="libxml2-encoding.html#xmlCharEncodingHandler"/>
<keyword type="struct" name="xmlDOMWrapCtxt" link="libxml2-tree.html#xmlDOMWrapCtxt"/>
<keyword type="struct" name="xmlDict" link="libxml2-dict.html#xmlDict"/>
<keyword type="struct" name="xmlDoc" link="libxml2-tree.html#xmlDoc"/>
<keyword type="struct" name="xmlDtd" link="libxml2-tree.html#xmlDtd"/>
<keyword type="struct" name="xmlElement" link="libxml2-tree.html#xmlElement"/>
<keyword type="struct" name="xmlElementContent" link="libxml2-tree.html#xmlElementContent"/>
<keyword type="struct" name="xmlElementTable" link="libxml2-valid.html#xmlElementTable"/>
<keyword type="struct" name="xmlEntitiesTable" link="libxml2-entities.html#xmlEntitiesTable"/>
<keyword type="struct" name="xmlEntity" link="libxml2-tree.html#xmlEntity"/>
<keyword type="struct" name="xmlEnumeration" link="libxml2-tree.html#xmlEnumeration"/>
<keyword type="struct" name="xmlError" link="libxml2-xmlerror.html#xmlError"/>
<keyword type="struct" name="xmlExpCtxt" link="libxml2-xmlregexp.html#xmlExpCtxt"/>
<keyword type="struct" name="xmlExpNode" link="libxml2-xmlregexp.html#xmlExpNode"/>
<keyword type="struct" name="xmlGlobalState" link="libxml2-globals.html#xmlGlobalState"/>
<keyword type="struct" name="xmlHashTable" link="libxml2-hash.html#xmlHashTable"/>
<keyword type="struct" name="xmlID" link="libxml2-tree.html#xmlID"/>
<keyword type="struct" name="xmlIDTable" link="libxml2-valid.html#xmlIDTable"/>
<keyword type="struct" name="xmlLink" link="libxml2-list.html#xmlLink"/>
<keyword type="struct" name="xmlList" link="libxml2-list.html#xmlList"/>
<keyword type="struct" name="xmlLocationSet" link="libxml2-xpointer.html#xmlLocationSet"/>
<keyword type="struct" name="xmlModule" link="libxml2-xmlmodule.html#xmlModule"/>
<keyword type="struct" name="xmlMutex" link="libxml2-threads.html#xmlMutex"/>
<keyword type="struct" name="xmlNode" link="libxml2-tree.html#xmlNode"/>
<keyword type="struct" name="xmlNodeSet" link="libxml2-xpath.html#xmlNodeSet"/>
<keyword type="struct" name="xmlNotation" link="libxml2-tree.html#xmlNotation"/>
<keyword type="struct" name="xmlNotationTable" link="libxml2-valid.html#xmlNotationTable"/>
<keyword type="struct" name="xmlNs" link="libxml2-tree.html#xmlNs"/>
<keyword type="struct" name="xmlOutputBuffer" link="libxml2-tree.html#xmlOutputBuffer"/>
<keyword type="struct" name="xmlParserCtxt" link="libxml2-tree.html#xmlParserCtxt"/>
<keyword type="struct" name="xmlParserInput" link="libxml2-tree.html#xmlParserInput"/>
<keyword type="struct" name="xmlParserInputBuffer" link="libxml2-tree.html#xmlParserInputBuffer"/>
<keyword type="struct" name="xmlParserNodeInfo" link="libxml2-parser.html#xmlParserNodeInfo"/>
<keyword type="struct" name="xmlParserNodeInfoSeq" link="libxml2-parser.html#xmlParserNodeInfoSeq"/>
<keyword type="struct" name="xmlPattern" link="libxml2-pattern.html#xmlPattern"/>
<keyword type="struct" name="xmlRMutex" link="libxml2-threads.html#xmlRMutex"/>
<keyword type="struct" name="xmlRef" link="libxml2-tree.html#xmlRef"/>
<keyword type="struct" name="xmlRefTable" link="libxml2-valid.html#xmlRefTable"/>
<keyword type="struct" name="xmlRegExecCtxt" link="libxml2-xmlregexp.html#xmlRegExecCtxt"/>
<keyword type="struct" name="xmlRegexp" link="libxml2-xmlregexp.html#xmlRegexp"/>
<keyword type="struct" name="xmlRelaxNG" link="libxml2-relaxng.html#xmlRelaxNG"/>
<keyword type="struct" name="xmlRelaxNGParserCtxt" link="libxml2-relaxng.html#xmlRelaxNGParserCtxt"/>
<keyword type="struct" name="xmlRelaxNGValidCtxt" link="libxml2-relaxng.html#xmlRelaxNGValidCtxt"/>
<keyword type="struct" name="xmlSAXHandler" link="libxml2-tree.html#xmlSAXHandler"/>
<keyword type="struct" name="xmlSAXHandlerV1" link="libxml2-parser.html#xmlSAXHandlerV1"/>
<keyword type="struct" name="xmlSAXLocator" link="libxml2-tree.html#xmlSAXLocator"/>
<keyword type="struct" name="xmlSaveCtxt" link="libxml2-xmlsave.html#xmlSaveCtxt"/>
<keyword type="struct" name="xmlSchema" link="libxml2-xmlschemas.html#xmlSchema"/>
<keyword type="struct" name="xmlSchemaAnnot" link="libxml2-schemasInternals.html#xmlSchemaAnnot"/>
<keyword type="struct" name="xmlSchemaAttribute" link="libxml2-schemasInternals.html#xmlSchemaAttribute"/>
<keyword type="struct" name="xmlSchemaAttributeGroup" link="libxml2-schemasInternals.html#xmlSchemaAttributeGroup"/>
<keyword type="struct" name="xmlSchemaAttributeLink" link="libxml2-schemasInternals.html#xmlSchemaAttributeLink"/>
<keyword type="struct" name="xmlSchemaElement" link="libxml2-schemasInternals.html#xmlSchemaElement"/>
<keyword type="struct" name="xmlSchemaFacet" link="libxml2-schemasInternals.html#xmlSchemaFacet"/>
<keyword type="struct" name="xmlSchemaFacetLink" link="libxml2-schemasInternals.html#xmlSchemaFacetLink"/>
<keyword type="struct" name="xmlSchemaNotation" link="libxml2-schemasInternals.html#xmlSchemaNotation"/>
<keyword type="struct" name="xmlSchemaParserCtxt" link="libxml2-xmlschemas.html#xmlSchemaParserCtxt"/>
<keyword type="struct" name="xmlSchemaSAXPlugStruct" link="libxml2-xmlschemas.html#xmlSchemaSAXPlugStruct"/>
<keyword type="struct" name="xmlSchemaType" link="libxml2-schemasInternals.html#xmlSchemaType"/>
<keyword type="struct" name="xmlSchemaTypeLink" link="libxml2-schemasInternals.html#xmlSchemaTypeLink"/>
<keyword type="struct" name="xmlSchemaVal" link="libxml2-schemasInternals.html#xmlSchemaVal"/>
<keyword type="struct" name="xmlSchemaValidCtxt" link="libxml2-xmlschemas.html#xmlSchemaValidCtxt"/>
<keyword type="struct" name="xmlSchemaWildcard" link="libxml2-schemasInternals.html#xmlSchemaWildcard"/>
<keyword type="struct" name="xmlSchemaWildcardNs" link="libxml2-schemasInternals.html#xmlSchemaWildcardNs"/>
<keyword type="struct" name="xmlSchematron" link="libxml2-schematron.html#xmlSchematron"/>
<keyword type="struct" name="xmlSchematronParserCtxt" link="libxml2-schematron.html#xmlSchematronParserCtxt"/>
<keyword type="struct" name="xmlSchematronValidCtxt" link="libxml2-schematron.html#xmlSchematronValidCtxt"/>
<keyword type="struct" name="xmlShellCtxt" link="libxml2-debugXML.html#xmlShellCtxt"/>
<keyword type="struct" name="xmlStartTag" link="libxml2-parser.html#xmlStartTag"/>
<keyword type="struct" name="xmlStreamCtxt" link="libxml2-pattern.html#xmlStreamCtxt"/>
<keyword type="struct" name="xmlTextReader" link="libxml2-xmlreader.html#xmlTextReader"/>
<keyword type="struct" name="xmlTextWriter" link="libxml2-xmlwriter.html#xmlTextWriter"/>
<keyword type="struct" name="xmlURI" link="libxml2-uri.html#xmlURI"/>
<keyword type="struct" name="xmlValidCtxt" link="libxml2-valid.html#xmlValidCtxt"/>
<keyword type="struct" name="xmlValidState" link="libxml2-valid.html#xmlValidState"/>
<keyword type="struct" name="xmlXIncludeCtxt" link="libxml2-xinclude.html#xmlXIncludeCtxt"/>
<keyword type="struct" name="xmlXPathAxis" link="libxml2-xpath.html#xmlXPathAxis"/>
<keyword type="struct" name="xmlXPathCompExpr" link="libxml2-xpath.html#xmlXPathCompExpr"/>
<keyword type="struct" name="xmlXPathContext" link="libxml2-xpath.html#xmlXPathContext"/>
<keyword type="struct" name="xmlXPathFunct" link="libxml2-xpath.html#xmlXPathFunct"/>
<keyword type="struct" name="xmlXPathObject" link="libxml2-xpath.html#xmlXPathObject"/>
<keyword type="struct" name="xmlXPathParserContext" link="libxml2-xpath.html#xmlXPathParserContext"/>
<keyword type="struct" name="xmlXPathType" link="libxml2-xpath.html#xmlXPathType"/>
<keyword type="struct" name="xmlXPathVariable" link="libxml2-xpath.html#xmlXPathVariable"/>
<keyword type="function" name="attributeDeclSAXFunc" link="libxml2-parser.html#attributeDeclSAXFunc"/>
<keyword type="function" name="attributeSAXFunc" link="libxml2-parser.html#attributeSAXFunc"/>
<keyword type="function" name="cdataBlockSAXFunc" link="libxml2-parser.html#cdataBlockSAXFunc"/>
<keyword type="function" name="charactersSAXFunc" link="libxml2-parser.html#charactersSAXFunc"/>
<keyword type="function" name="commentSAXFunc" link="libxml2-parser.html#commentSAXFunc"/>
<keyword type="function" name="elementDeclSAXFunc" link="libxml2-parser.html#elementDeclSAXFunc"/>
<keyword type="function" name="endDocumentSAXFunc" link="libxml2-parser.html#endDocumentSAXFunc"/>
<keyword type="function" name="endElementNsSAX2Func" link="libxml2-parser.html#endElementNsSAX2Func"/>
<keyword type="function" name="endElementSAXFunc" link="libxml2-parser.html#endElementSAXFunc"/>
<keyword type="function" name="entityDeclSAXFunc" link="libxml2-parser.html#entityDeclSAXFunc"/>
<keyword type="function" name="errorSAXFunc" link="libxml2-parser.html#errorSAXFunc"/>
<keyword type="function" name="externalSubsetSAXFunc" link="libxml2-parser.html#externalSubsetSAXFunc"/>
<keyword type="function" name="fatalErrorSAXFunc" link="libxml2-parser.html#fatalErrorSAXFunc"/>
<keyword type="function" name="ftpDataCallback" link="libxml2-nanoftp.html#ftpDataCallback"/>
<keyword type="function" name="ftpListCallback" link="libxml2-nanoftp.html#ftpListCallback"/>
<keyword type="function" name="getEntitySAXFunc" link="libxml2-parser.html#getEntitySAXFunc"/>
<keyword type="function" name="getParameterEntitySAXFunc" link="libxml2-parser.html#getParameterEntitySAXFunc"/>
<keyword type="function" name="hasExternalSubsetSAXFunc" link="libxml2-parser.html#hasExternalSubsetSAXFunc"/>
<keyword type="function" name="hasInternalSubsetSAXFunc" link="libxml2-parser.html#hasInternalSubsetSAXFunc"/>
<keyword type="function" name="ignorableWhitespaceSAXFunc" link="libxml2-parser.html#ignorableWhitespaceSAXFunc"/>
<keyword type="function" name="internalSubsetSAXFunc" link="libxml2-parser.html#internalSubsetSAXFunc"/>
<keyword type="function" name="isStandaloneSAXFunc" link="libxml2-parser.html#isStandaloneSAXFunc"/>
<keyword type="function" name="notationDeclSAXFunc" link="libxml2-parser.html#notationDeclSAXFunc"/>
<keyword type="function" name="processingInstructionSAXFunc" link="libxml2-parser.html#processingInstructionSAXFunc"/>
<keyword type="function" name="referenceSAXFunc" link="libxml2-parser.html#referenceSAXFunc"/>
<keyword type="function" name="resolveEntitySAXFunc" link="libxml2-parser.html#resolveEntitySAXFunc"/>
<keyword type="function" name="setDocumentLocatorSAXFunc" link="libxml2-parser.html#setDocumentLocatorSAXFunc"/>
<keyword type="function" name="startDocumentSAXFunc" link="libxml2-parser.html#startDocumentSAXFunc"/>
<keyword type="function" name="startElementNsSAX2Func" link="libxml2-parser.html#startElementNsSAX2Func"/>
<keyword type="function" name="startElementSAXFunc" link="libxml2-parser.html#startElementSAXFunc"/>
<keyword type="function" name="unparsedEntityDeclSAXFunc" link="libxml2-parser.html#unparsedEntityDeclSAXFunc"/>
<keyword type="function" name="warningSAXFunc" link="libxml2-parser.html#warningSAXFunc"/>
<keyword type="function" name="xlinkExtendedLinkFunk" link="libxml2-xlink.html#xlinkExtendedLinkFunk"/>
<keyword type="function" name="xlinkExtendedLinkSetFunk" link="libxml2-xlink.html#xlinkExtendedLinkSetFunk"/>
<keyword type="function" name="xlinkNodeDetectFunc" link="libxml2-xlink.html#xlinkNodeDetectFunc"/>
<keyword type="function" name="xlinkSimpleLinkFunk" link="libxml2-xlink.html#xlinkSimpleLinkFunk"/>
<keyword type="function" name="xmlC14NIsVisibleCallback" link="libxml2-c14n.html#xmlC14NIsVisibleCallback"/>
<keyword type="function" name="xmlCharEncodingInputFunc" link="libxml2-encoding.html#xmlCharEncodingInputFunc"/>
<keyword type="function" name="xmlCharEncodingOutputFunc" link="libxml2-encoding.html#xmlCharEncodingOutputFunc"/>
<keyword type="function" name="xmlDOMWrapAcquireNsFunction" link="libxml2-tree.html#xmlDOMWrapAcquireNsFunction"/>
<keyword type="function" name="xmlDeregisterNodeFunc" link="libxml2-globals.html#xmlDeregisterNodeFunc"/>
<keyword type="function" name="xmlEntityReferenceFunc" link="libxml2-parserInternals.html#xmlEntityReferenceFunc"/>
<keyword type="function" name="xmlExternalEntityLoader" link="libxml2-parser.html#xmlExternalEntityLoader"/>
<keyword type="function" name="xmlFreeFunc" link="libxml2-xmlmemory.html#xmlFreeFunc"/>
<keyword type="function" name="xmlGenericErrorFunc" link="libxml2-xmlerror.html#xmlGenericErrorFunc"/>
<keyword type="function" name="xmlHashCopier" link="libxml2-hash.html#xmlHashCopier"/>
<keyword type="function" name="xmlHashDeallocator" link="libxml2-hash.html#xmlHashDeallocator"/>
<keyword type="function" name="xmlHashScanner" link="libxml2-hash.html#xmlHashScanner"/>
<keyword type="function" name="xmlHashScannerFull" link="libxml2-hash.html#xmlHashScannerFull"/>
<keyword type="function" name="xmlInputCloseCallback" link="libxml2-xmlIO.html#xmlInputCloseCallback"/>
<keyword type="function" name="xmlInputMatchCallback" link="libxml2-xmlIO.html#xmlInputMatchCallback"/>
<keyword type="function" name="xmlInputOpenCallback" link="libxml2-xmlIO.html#xmlInputOpenCallback"/>
<keyword type="function" name="xmlInputReadCallback" link="libxml2-xmlIO.html#xmlInputReadCallback"/>
<keyword type="function" name="xmlListDataCompare" link="libxml2-list.html#xmlListDataCompare"/>
<keyword type="function" name="xmlListDeallocator" link="libxml2-list.html#xmlListDeallocator"/>
<keyword type="function" name="xmlListWalker" link="libxml2-list.html#xmlListWalker"/>
<keyword type="function" name="xmlMallocFunc" link="libxml2-xmlmemory.html#xmlMallocFunc"/>
<keyword type="function" name="xmlOutputBufferCreateFilenameFunc" link="libxml2-globals.html#xmlOutputBufferCreateFilenameFunc"/>
<keyword type="function" name="xmlOutputCloseCallback" link="libxml2-xmlIO.html#xmlOutputCloseCallback"/>
<keyword type="function" name="xmlOutputMatchCallback" link="libxml2-xmlIO.html#xmlOutputMatchCallback"/>
<keyword type="function" name="xmlOutputOpenCallback" link="libxml2-xmlIO.html#xmlOutputOpenCallback"/>
<keyword type="function" name="xmlOutputWriteCallback" link="libxml2-xmlIO.html#xmlOutputWriteCallback"/>
<keyword type="function" name="xmlParserInputBufferCreateFilenameFunc" link="libxml2-globals.html#xmlParserInputBufferCreateFilenameFunc"/>
<keyword type="function" name="xmlParserInputDeallocate" link="libxml2-parser.html#xmlParserInputDeallocate"/>
<keyword type="function" name="xmlReallocFunc" link="libxml2-xmlmemory.html#xmlReallocFunc"/>
<keyword type="function" name="xmlRegExecCallbacks" link="libxml2-xmlregexp.html#xmlRegExecCallbacks"/>
<keyword type="function" name="xmlRegisterNodeFunc" link="libxml2-globals.html#xmlRegisterNodeFunc"/>
<keyword type="function" name="xmlRelaxNGValidityErrorFunc" link="libxml2-relaxng.html#xmlRelaxNGValidityErrorFunc"/>
<keyword type="function" name="xmlRelaxNGValidityWarningFunc" link="libxml2-relaxng.html#xmlRelaxNGValidityWarningFunc"/>
<keyword type="function" name="xmlSchemaValidityErrorFunc" link="libxml2-xmlschemas.html#xmlSchemaValidityErrorFunc"/>
<keyword type="function" name="xmlSchemaValidityLocatorFunc" link="libxml2-xmlschemas.html#xmlSchemaValidityLocatorFunc"/>
<keyword type="function" name="xmlSchemaValidityWarningFunc" link="libxml2-xmlschemas.html#xmlSchemaValidityWarningFunc"/>
<keyword type="function" name="xmlSchematronValidityErrorFunc" link="libxml2-schematron.html#xmlSchematronValidityErrorFunc"/>
<keyword type="function" name="xmlSchematronValidityWarningFunc" link="libxml2-schematron.html#xmlSchematronValidityWarningFunc"/>
<keyword type="function" name="xmlShellCmd" link="libxml2-debugXML.html#xmlShellCmd"/>
<keyword type="function" name="xmlShellReadlineFunc" link="libxml2-debugXML.html#xmlShellReadlineFunc"/>
<keyword type="function" name="xmlStrdupFunc" link="libxml2-xmlmemory.html#xmlStrdupFunc"/>
<keyword type="function" name="xmlStructuredErrorFunc" link="libxml2-xmlerror.html#xmlStructuredErrorFunc"/>
<keyword type="function" name="xmlTextReaderErrorFunc" link="libxml2-xmlreader.html#xmlTextReaderErrorFunc"/>
<keyword type="function" name="xmlValidityErrorFunc" link="libxml2-valid.html#xmlValidityErrorFunc"/>
<keyword type="function" name="xmlValidityWarningFunc" link="libxml2-valid.html#xmlValidityWarningFunc"/>
<keyword type="function" name="xmlXPathAxisFunc" link="libxml2-xpath.html#xmlXPathAxisFunc"/>
<keyword type="function" name="xmlXPathConvertFunc" link="libxml2-xpath.html#xmlXPathConvertFunc"/>
<keyword type="function" name="xmlXPathEvalFunc" link="libxml2-xpath.html#xmlXPathEvalFunc"/>
<keyword type="function" name="xmlXPathFuncLookupFunc" link="libxml2-xpath.html#xmlXPathFuncLookupFunc"/>
<keyword type="function" name="xmlXPathFunction" link="libxml2-xpath.html#xmlXPathFunction"/>
<keyword type="function" name="xmlXPathVariableLookupFunc" link="libxml2-xpath.html#xmlXPathVariableLookupFunc"/>
<keyword type="macro" name="emptyExp" link="libxml2-xmlregexp.html#emptyExp"/>
<keyword type="macro" name="forbiddenExp" link="libxml2-xmlregexp.html#forbiddenExp"/>
<keyword type="macro" name="htmlDefaultSAXHandler" link="libxml2-globals.html#htmlDefaultSAXHandler"/>
<keyword type="macro" name="oldXMLWDcompatibility" link="libxml2-globals.html#oldXMLWDcompatibility"/>
<keyword type="macro" name="xmlBufferAllocScheme" link="libxml2-globals.html#xmlBufferAllocScheme"/>
<keyword type="macro" name="xmlDefaultBufferSize" link="libxml2-globals.html#xmlDefaultBufferSize"/>
<keyword type="macro" name="xmlDefaultSAXHandler" link="libxml2-globals.html#xmlDefaultSAXHandler"/>
<keyword type="macro" name="xmlDefaultSAXLocator" link="libxml2-globals.html#xmlDefaultSAXLocator"/>
<keyword type="macro" name="xmlDeregisterNodeDefaultValue" link="libxml2-globals.html#xmlDeregisterNodeDefaultValue"/>
<keyword type="macro" name="xmlDoValidityCheckingDefaultValue" link="libxml2-globals.html#xmlDoValidityCheckingDefaultValue"/>
<keyword type="macro" name="xmlFree" link="libxml2-globals.html#xmlFree"/>
<keyword type="macro" name="xmlGenericError" link="libxml2-globals.html#xmlGenericError"/>
<keyword type="macro" name="xmlGenericErrorContext" link="libxml2-globals.html#xmlGenericErrorContext"/>
<keyword type="macro" name="xmlGetWarningsDefaultValue" link="libxml2-globals.html#xmlGetWarningsDefaultValue"/>
<keyword type="macro" name="xmlIndentTreeOutput" link="libxml2-globals.html#xmlIndentTreeOutput"/>
<keyword type="macro" name="xmlIsBaseCharGroup" link="libxml2-chvalid.html#xmlIsBaseCharGroup"/>
<keyword type="macro" name="xmlIsCharGroup" link="libxml2-chvalid.html#xmlIsCharGroup"/>
<keyword type="macro" name="xmlIsCombiningGroup" link="libxml2-chvalid.html#xmlIsCombiningGroup"/>
<keyword type="macro" name="xmlIsDigitGroup" link="libxml2-chvalid.html#xmlIsDigitGroup"/>
<keyword type="macro" name="xmlIsExtenderGroup" link="libxml2-chvalid.html#xmlIsExtenderGroup"/>
<keyword type="macro" name="xmlIsIdeographicGroup" link="libxml2-chvalid.html#xmlIsIdeographicGroup"/>
<keyword type="macro" name="xmlIsPubidChar_tab" link="libxml2-chvalid.html#xmlIsPubidChar_tab"/>
<keyword type="macro" name="xmlKeepBlanksDefaultValue" link="libxml2-globals.html#xmlKeepBlanksDefaultValue"/>
<keyword type="macro" name="xmlLastError" link="libxml2-globals.html#xmlLastError"/>
<keyword type="macro" name="xmlLineNumbersDefaultValue" link="libxml2-globals.html#xmlLineNumbersDefaultValue"/>
<keyword type="macro" name="xmlLoadExtDtdDefaultValue" link="libxml2-globals.html#xmlLoadExtDtdDefaultValue"/>
<keyword type="macro" name="xmlMalloc" link="libxml2-globals.html#xmlMalloc"/>
<keyword type="macro" name="xmlMallocAtomic" link="libxml2-globals.html#xmlMallocAtomic"/>
<keyword type="macro" name="xmlMemStrdup" link="libxml2-globals.html#xmlMemStrdup"/>
<keyword type="macro" name="xmlOutputBufferCreateFilenameValue" link="libxml2-globals.html#xmlOutputBufferCreateFilenameValue"/>
<keyword type="macro" name="xmlParserDebugEntities" link="libxml2-globals.html#xmlParserDebugEntities"/>
<keyword type="macro" name="xmlParserInputBufferCreateFilenameValue" link="libxml2-globals.html#xmlParserInputBufferCreateFilenameValue"/>
<keyword type="macro" name="xmlParserMaxDepth" link="libxml2-parserInternals.html#xmlParserMaxDepth"/>
<keyword type="macro" name="xmlParserVersion" link="libxml2-globals.html#xmlParserVersion"/>
<keyword type="macro" name="xmlPedanticParserDefaultValue" link="libxml2-globals.html#xmlPedanticParserDefaultValue"/>
<keyword type="macro" name="xmlRealloc" link="libxml2-globals.html#xmlRealloc"/>
<keyword type="macro" name="xmlRegisterNodeDefaultValue" link="libxml2-globals.html#xmlRegisterNodeDefaultValue"/>
<keyword type="macro" name="xmlSaveNoEmptyTags" link="libxml2-globals.html#xmlSaveNoEmptyTags"/>
<keyword type="macro" name="xmlStringComment" link="libxml2-parserInternals.html#xmlStringComment"/>
<keyword type="macro" name="xmlStringText" link="libxml2-parserInternals.html#xmlStringText"/>
<keyword type="macro" name="xmlStringTextNoenc" link="libxml2-parserInternals.html#xmlStringTextNoenc"/>
<keyword type="macro" name="xmlStructuredError" link="libxml2-globals.html#xmlStructuredError"/>
<keyword type="macro" name="xmlStructuredErrorContext" link="libxml2-globals.html#xmlStructuredErrorContext"/>
<keyword type="macro" name="xmlSubstituteEntitiesDefaultValue" link="libxml2-globals.html#xmlSubstituteEntitiesDefaultValue"/>
<keyword type="macro" name="xmlTreeIndentString" link="libxml2-globals.html#xmlTreeIndentString"/>
<keyword type="macro" name="xmlXPathNAN" link="libxml2-xpath.html#xmlXPathNAN"/>
<keyword type="macro" name="xmlXPathNINF" link="libxml2-xpath.html#xmlXPathNINF"/>
<keyword type="macro" name="xmlXPathPINF" link="libxml2-xpath.html#xmlXPathPINF"/>
<keyword type="function" name="UTF8ToHtml ()" link="libxml2-HTMLparser.html#UTF8ToHtml"/>
<keyword type="function" name="UTF8Toisolat1 ()" link="libxml2-encoding.html#UTF8Toisolat1"/>
<keyword type="function" name="attribute ()" link="libxml2-SAX.html#attribute"/>
<keyword type="function" name="attributeDecl ()" link="libxml2-SAX.html#attributeDecl"/>
<keyword type="function" name="cdataBlock ()" link="libxml2-SAX.html#cdataBlock"/>
<keyword type="function" name="characters ()" link="libxml2-SAX.html#characters"/>
<keyword type="function" name="checkNamespace ()" link="libxml2-SAX.html#checkNamespace"/>
<keyword type="function" name="comment ()" link="libxml2-SAX.html#comment"/>
<keyword type="function" name="elementDecl ()" link="libxml2-SAX.html#elementDecl"/>
<keyword type="function" name="endDocument ()" link="libxml2-SAX.html#endDocument"/>
<keyword type="function" name="endElement ()" link="libxml2-SAX.html#endElement"/>
<keyword type="function" name="entityDecl ()" link="libxml2-SAX.html#entityDecl"/>
<keyword type="function" name="externalSubset ()" link="libxml2-SAX.html#externalSubset"/>
<keyword type="function" name="getColumnNumber ()" link="libxml2-SAX.html#getColumnNumber"/>
<keyword type="function" name="getEntity ()" link="libxml2-SAX.html#getEntity"/>
<keyword type="function" name="getLineNumber ()" link="libxml2-SAX.html#getLineNumber"/>
<keyword type="function" name="getNamespace ()" link="libxml2-SAX.html#getNamespace"/>
<keyword type="function" name="getParameterEntity ()" link="libxml2-SAX.html#getParameterEntity"/>
<keyword type="function" name="getPublicId ()" link="libxml2-SAX.html#getPublicId"/>
<keyword type="function" name="getSystemId ()" link="libxml2-SAX.html#getSystemId"/>
<keyword type="function" name="globalNamespace ()" link="libxml2-SAX.html#globalNamespace"/>
<keyword type="function" name="hasExternalSubset ()" link="libxml2-SAX.html#hasExternalSubset"/>
<keyword type="function" name="hasInternalSubset ()" link="libxml2-SAX.html#hasInternalSubset"/>
<keyword type="function" name="htmlAttrAllowed ()" link="libxml2-HTMLparser.html#htmlAttrAllowed"/>
<keyword type="function" name="htmlAutoCloseTag ()" link="libxml2-HTMLparser.html#htmlAutoCloseTag"/>
<keyword type="function" name="htmlCreateFileParserCtxt ()" link="libxml2-parserInternals.html#htmlCreateFileParserCtxt"/>
<keyword type="function" name="htmlCreateMemoryParserCtxt ()" link="libxml2-HTMLparser.html#htmlCreateMemoryParserCtxt"/>
<keyword type="function" name="htmlCreatePushParserCtxt ()" link="libxml2-HTMLparser.html#htmlCreatePushParserCtxt"/>
<keyword type="function" name="htmlCtxtReadDoc ()" link="libxml2-HTMLparser.html#htmlCtxtReadDoc"/>
<keyword type="function" name="htmlCtxtReadFd ()" link="libxml2-HTMLparser.html#htmlCtxtReadFd"/>
<keyword type="function" name="htmlCtxtReadFile ()" link="libxml2-HTMLparser.html#htmlCtxtReadFile"/>
<keyword type="function" name="htmlCtxtReadIO ()" link="libxml2-HTMLparser.html#htmlCtxtReadIO"/>
<keyword type="function" name="htmlCtxtReadMemory ()" link="libxml2-HTMLparser.html#htmlCtxtReadMemory"/>
<keyword type="function" name="htmlCtxtReset ()" link="libxml2-HTMLparser.html#htmlCtxtReset"/>
<keyword type="function" name="htmlCtxtUseOptions ()" link="libxml2-HTMLparser.html#htmlCtxtUseOptions"/>
<keyword type="function" name="htmlDefaultSAXHandlerInit ()" link="libxml2-SAX2.html#htmlDefaultSAXHandlerInit"/>
<keyword type="function" name="htmlDocContentDumpFormatOutput ()" link="libxml2-HTMLtree.html#htmlDocContentDumpFormatOutput"/>
<keyword type="function" name="htmlDocContentDumpOutput ()" link="libxml2-HTMLtree.html#htmlDocContentDumpOutput"/>
<keyword type="function" name="htmlDocDump ()" link="libxml2-HTMLtree.html#htmlDocDump"/>
<keyword type="function" name="htmlDocDumpMemory ()" link="libxml2-HTMLtree.html#htmlDocDumpMemory"/>
<keyword type="function" name="htmlDocDumpMemoryFormat ()" link="libxml2-HTMLtree.html#htmlDocDumpMemoryFormat"/>
<keyword type="function" name="htmlElementAllowedHere ()" link="libxml2-HTMLparser.html#htmlElementAllowedHere"/>
<keyword type="function" name="htmlElementStatusHere ()" link="libxml2-HTMLparser.html#htmlElementStatusHere"/>
<keyword type="function" name="htmlEncodeEntities ()" link="libxml2-HTMLparser.html#htmlEncodeEntities"/>
<keyword type="function" name="htmlEntityLookup ()" link="libxml2-HTMLparser.html#htmlEntityLookup"/>
<keyword type="function" name="htmlEntityValueLookup ()" link="libxml2-HTMLparser.html#htmlEntityValueLookup"/>
<keyword type="function" name="htmlFreeParserCtxt ()" link="libxml2-HTMLparser.html#htmlFreeParserCtxt"/>
<keyword type="function" name="htmlGetMetaEncoding ()" link="libxml2-HTMLtree.html#htmlGetMetaEncoding"/>
<keyword type="function" name="htmlHandleOmittedElem ()" link="libxml2-HTMLparser.html#htmlHandleOmittedElem"/>
<keyword type="function" name="htmlInitAutoClose ()" link="libxml2-parserInternals.html#htmlInitAutoClose"/>
<keyword type="function" name="htmlIsAutoClosed ()" link="libxml2-HTMLparser.html#htmlIsAutoClosed"/>
<keyword type="function" name="htmlIsBooleanAttr ()" link="libxml2-HTMLtree.html#htmlIsBooleanAttr"/>
<keyword type="function" name="htmlIsScriptAttribute ()" link="libxml2-HTMLparser.html#htmlIsScriptAttribute"/>
<keyword type="function" name="htmlNewDoc ()" link="libxml2-HTMLtree.html#htmlNewDoc"/>
<keyword type="function" name="htmlNewDocNoDtD ()" link="libxml2-HTMLtree.html#htmlNewDocNoDtD"/>
<keyword type="function" name="htmlNewParserCtxt ()" link="libxml2-HTMLparser.html#htmlNewParserCtxt"/>
<keyword type="function" name="htmlNodeDump ()" link="libxml2-HTMLtree.html#htmlNodeDump"/>
<keyword type="function" name="htmlNodeDumpFile ()" link="libxml2-HTMLtree.html#htmlNodeDumpFile"/>
<keyword type="function" name="htmlNodeDumpFileFormat ()" link="libxml2-HTMLtree.html#htmlNodeDumpFileFormat"/>
<keyword type="function" name="htmlNodeDumpFormatOutput ()" link="libxml2-HTMLtree.html#htmlNodeDumpFormatOutput"/>
<keyword type="function" name="htmlNodeDumpOutput ()" link="libxml2-HTMLtree.html#htmlNodeDumpOutput"/>
<keyword type="function" name="htmlNodeStatus ()" link="libxml2-HTMLparser.html#htmlNodeStatus"/>
<keyword type="function" name="htmlParseCharRef ()" link="libxml2-HTMLparser.html#htmlParseCharRef"/>
<keyword type="function" name="htmlParseChunk ()" link="libxml2-HTMLparser.html#htmlParseChunk"/>
<keyword type="function" name="htmlParseDoc ()" link="libxml2-HTMLparser.html#htmlParseDoc"/>
<keyword type="function" name="htmlParseDocument ()" link="libxml2-HTMLparser.html#htmlParseDocument"/>
<keyword type="function" name="htmlParseElement ()" link="libxml2-HTMLparser.html#htmlParseElement"/>
<keyword type="function" name="htmlParseEntityRef ()" link="libxml2-HTMLparser.html#htmlParseEntityRef"/>
<keyword type="function" name="htmlParseFile ()" link="libxml2-HTMLparser.html#htmlParseFile"/>
<keyword type="function" name="htmlReadDoc ()" link="libxml2-HTMLparser.html#htmlReadDoc"/>
<keyword type="function" name="htmlReadFd ()" link="libxml2-HTMLparser.html#htmlReadFd"/>
<keyword type="function" name="htmlReadFile ()" link="libxml2-HTMLparser.html#htmlReadFile"/>
<keyword type="function" name="htmlReadIO ()" link="libxml2-HTMLparser.html#htmlReadIO"/>
<keyword type="function" name="htmlReadMemory ()" link="libxml2-HTMLparser.html#htmlReadMemory"/>
<keyword type="function" name="htmlSAXParseDoc ()" link="libxml2-HTMLparser.html#htmlSAXParseDoc"/>
<keyword type="function" name="htmlSAXParseFile ()" link="libxml2-HTMLparser.html#htmlSAXParseFile"/>
<keyword type="function" name="htmlSaveFile ()" link="libxml2-HTMLtree.html#htmlSaveFile"/>
<keyword type="function" name="htmlSaveFileEnc ()" link="libxml2-HTMLtree.html#htmlSaveFileEnc"/>
<keyword type="function" name="htmlSaveFileFormat ()" link="libxml2-HTMLtree.html#htmlSaveFileFormat"/>
<keyword type="function" name="htmlSetMetaEncoding ()" link="libxml2-HTMLtree.html#htmlSetMetaEncoding"/>
<keyword type="function" name="htmlTagLookup ()" link="libxml2-HTMLparser.html#htmlTagLookup"/>
<keyword type="function" name="ignorableWhitespace ()" link="libxml2-SAX.html#ignorableWhitespace"/>
<keyword type="function" name="initGenericErrorDefaultFunc ()" link="libxml2-xmlerror.html#initGenericErrorDefaultFunc"/>
<keyword type="function" name="inithtmlDefaultSAXHandler ()" link="libxml2-SAX.html#inithtmlDefaultSAXHandler"/>
<keyword type="function" name="initxmlDefaultSAXHandler ()" link="libxml2-SAX.html#initxmlDefaultSAXHandler"/>
<keyword type="function" name="inputPop ()" link="libxml2-parserInternals.html#inputPop"/>
<keyword type="function" name="inputPush ()" link="libxml2-parserInternals.html#inputPush"/>
<keyword type="function" name="internalSubset ()" link="libxml2-SAX.html#internalSubset"/>
<keyword type="function" name="isStandalone ()" link="libxml2-SAX.html#isStandalone"/>
<keyword type="function" name="isolat1ToUTF8 ()" link="libxml2-encoding.html#isolat1ToUTF8"/>
<keyword type="function" name="namePop ()" link="libxml2-parserInternals.html#namePop"/>
<keyword type="function" name="namePush ()" link="libxml2-parserInternals.html#namePush"/>
<keyword type="function" name="namespaceDecl ()" link="libxml2-SAX.html#namespaceDecl"/>
<keyword type="function" name="nodePop ()" link="libxml2-parserInternals.html#nodePop"/>
<keyword type="function" name="nodePush ()" link="libxml2-parserInternals.html#nodePush"/>
<keyword type="function" name="notationDecl ()" link="libxml2-SAX.html#notationDecl"/>
<keyword type="function" name="processingInstruction ()" link="libxml2-SAX.html#processingInstruction"/>
<keyword type="function" name="reference ()" link="libxml2-SAX.html#reference"/>
<keyword type="function" name="resolveEntity ()" link="libxml2-SAX.html#resolveEntity"/>
<keyword type="function" name="setDocumentLocator ()" link="libxml2-SAX.html#setDocumentLocator"/>
<keyword type="function" name="setNamespace ()" link="libxml2-SAX.html#setNamespace"/>
<keyword type="function" name="startDocument ()" link="libxml2-SAX.html#startDocument"/>
<keyword type="function" name="startElement ()" link="libxml2-SAX.html#startElement"/>
<keyword type="function" name="unparsedEntityDecl ()" link="libxml2-SAX.html#unparsedEntityDecl"/>
<keyword type="function" name="valuePop ()" link="libxml2-xpathInternals.html#valuePop"/>
<keyword type="function" name="valuePush ()" link="libxml2-xpathInternals.html#valuePush"/>
<keyword type="function" name="xlinkGetDefaultDetect ()" link="libxml2-xlink.html#xlinkGetDefaultDetect"/>
<keyword type="function" name="xlinkGetDefaultHandler ()" link="libxml2-xlink.html#xlinkGetDefaultHandler"/>
<keyword type="function" name="xlinkIsLink ()" link="libxml2-xlink.html#xlinkIsLink"/>
<keyword type="function" name="xlinkSetDefaultDetect ()" link="libxml2-xlink.html#xlinkSetDefaultDetect"/>
<keyword type="function" name="xlinkSetDefaultHandler ()" link="libxml2-xlink.html#xlinkSetDefaultHandler"/>
<keyword type="function" name="xmlACatalogAdd ()" link="libxml2-catalog.html#xmlACatalogAdd"/>
<keyword type="function" name="xmlACatalogDump ()" link="libxml2-catalog.html#xmlACatalogDump"/>
<keyword type="function" name="xmlACatalogRemove ()" link="libxml2-catalog.html#xmlACatalogRemove"/>
<keyword type="function" name="xmlACatalogResolve ()" link="libxml2-catalog.html#xmlACatalogResolve"/>
<keyword type="function" name="xmlACatalogResolvePublic ()" link="libxml2-catalog.html#xmlACatalogResolvePublic"/>
<keyword type="function" name="xmlACatalogResolveSystem ()" link="libxml2-catalog.html#xmlACatalogResolveSystem"/>
<keyword type="function" name="xmlACatalogResolveURI ()" link="libxml2-catalog.html#xmlACatalogResolveURI"/>
<keyword type="function" name="xmlAddAttributeDecl ()" link="libxml2-valid.html#xmlAddAttributeDecl"/>
<keyword type="function" name="xmlAddChild ()" link="libxml2-tree.html#xmlAddChild"/>
<keyword type="function" name="xmlAddChildList ()" link="libxml2-tree.html#xmlAddChildList"/>
<keyword type="function" name="xmlAddDocEntity ()" link="libxml2-entities.html#xmlAddDocEntity"/>
<keyword type="function" name="xmlAddDtdEntity ()" link="libxml2-entities.html#xmlAddDtdEntity"/>
<keyword type="function" name="xmlAddElementDecl ()" link="libxml2-valid.html#xmlAddElementDecl"/>
<keyword type="function" name="xmlAddEncodingAlias ()" link="libxml2-encoding.html#xmlAddEncodingAlias"/>
<keyword type="function" name="xmlAddID ()" link="libxml2-valid.html#xmlAddID"/>
<keyword type="function" name="xmlAddNextSibling ()" link="libxml2-tree.html#xmlAddNextSibling"/>
<keyword type="function" name="xmlAddNotationDecl ()" link="libxml2-valid.html#xmlAddNotationDecl"/>
<keyword type="function" name="xmlAddPrevSibling ()" link="libxml2-tree.html#xmlAddPrevSibling"/>
<keyword type="function" name="xmlAddRef ()" link="libxml2-valid.html#xmlAddRef"/>
<keyword type="function" name="xmlAddSibling ()" link="libxml2-tree.html#xmlAddSibling"/>
<keyword type="function" name="xmlAllocOutputBuffer ()" link="libxml2-xmlIO.html#xmlAllocOutputBuffer"/>
<keyword type="function" name="xmlAllocParserInputBuffer ()" link="libxml2-xmlIO.html#xmlAllocParserInputBuffer"/>
<keyword type="function" name="xmlAttrSerializeTxtContent ()" link="libxml2-tree.html#xmlAttrSerializeTxtContent"/>
<keyword type="function" name="xmlAutomataCompile ()" link="libxml2-xmlautomata.html#xmlAutomataCompile"/>
<keyword type="function" name="xmlAutomataGetInitState ()" link="libxml2-xmlautomata.html#xmlAutomataGetInitState"/>
<keyword type="function" name="xmlAutomataIsDeterminist ()" link="libxml2-xmlautomata.html#xmlAutomataIsDeterminist"/>
<keyword type="function" name="xmlAutomataNewAllTrans ()" link="libxml2-xmlautomata.html#xmlAutomataNewAllTrans"/>
<keyword type="function" name="xmlAutomataNewCountTrans ()" link="libxml2-xmlautomata.html#xmlAutomataNewCountTrans"/>
<keyword type="function" name="xmlAutomataNewCountTrans2 ()" link="libxml2-xmlautomata.html#xmlAutomataNewCountTrans2"/>
<keyword type="function" name="xmlAutomataNewCountedTrans ()" link="libxml2-xmlautomata.html#xmlAutomataNewCountedTrans"/>
<keyword type="function" name="xmlAutomataNewCounter ()" link="libxml2-xmlautomata.html#xmlAutomataNewCounter"/>
<keyword type="function" name="xmlAutomataNewCounterTrans ()" link="libxml2-xmlautomata.html#xmlAutomataNewCounterTrans"/>
<keyword type="function" name="xmlAutomataNewEpsilon ()" link="libxml2-xmlautomata.html#xmlAutomataNewEpsilon"/>
<keyword type="function" name="xmlAutomataNewNegTrans ()" link="libxml2-xmlautomata.html#xmlAutomataNewNegTrans"/>
<keyword type="function" name="xmlAutomataNewOnceTrans ()" link="libxml2-xmlautomata.html#xmlAutomataNewOnceTrans"/>
<keyword type="function" name="xmlAutomataNewOnceTrans2 ()" link="libxml2-xmlautomata.html#xmlAutomataNewOnceTrans2"/>
<keyword type="function" name="xmlAutomataNewState ()" link="libxml2-xmlautomata.html#xmlAutomataNewState"/>
<keyword type="function" name="xmlAutomataNewTransition ()" link="libxml2-xmlautomata.html#xmlAutomataNewTransition"/>
<keyword type="function" name="xmlAutomataNewTransition2 ()" link="libxml2-xmlautomata.html#xmlAutomataNewTransition2"/>
<keyword type="function" name="xmlAutomataSetFinalState ()" link="libxml2-xmlautomata.html#xmlAutomataSetFinalState"/>
<keyword type="function" name="xmlBoolToText ()" link="libxml2-debugXML.html#xmlBoolToText"/>
<keyword type="function" name="xmlBufContent ()" link="libxml2-tree.html#xmlBufContent"/>
<keyword type="function" name="xmlBufEnd ()" link="libxml2-tree.html#xmlBufEnd"/>
<keyword type="function" name="xmlBufGetNodeContent ()" link="libxml2-tree.html#xmlBufGetNodeContent"/>
<keyword type="function" name="xmlBufNodeDump ()" link="libxml2-tree.html#xmlBufNodeDump"/>
<keyword type="function" name="xmlBufShrink ()" link="libxml2-tree.html#xmlBufShrink"/>
<keyword type="function" name="xmlBufUse ()" link="libxml2-tree.html#xmlBufUse"/>
<keyword type="function" name="xmlBufferAdd ()" link="libxml2-tree.html#xmlBufferAdd"/>
<keyword type="function" name="xmlBufferAddHead ()" link="libxml2-tree.html#xmlBufferAddHead"/>
<keyword type="function" name="xmlBufferCCat ()" link="libxml2-tree.html#xmlBufferCCat"/>
<keyword type="function" name="xmlBufferCat ()" link="libxml2-tree.html#xmlBufferCat"/>
<keyword type="function" name="xmlBufferContent ()" link="libxml2-tree.html#xmlBufferContent"/>
<keyword type="function" name="xmlBufferCreate ()" link="libxml2-tree.html#xmlBufferCreate"/>
<keyword type="function" name="xmlBufferCreateSize ()" link="libxml2-tree.html#xmlBufferCreateSize"/>
<keyword type="function" name="xmlBufferCreateStatic ()" link="libxml2-tree.html#xmlBufferCreateStatic"/>
<keyword type="function" name="xmlBufferDetach ()" link="libxml2-tree.html#xmlBufferDetach"/>
<keyword type="function" name="xmlBufferDump ()" link="libxml2-tree.html#xmlBufferDump"/>
<keyword type="function" name="xmlBufferEmpty ()" link="libxml2-tree.html#xmlBufferEmpty"/>
<keyword type="function" name="xmlBufferFree ()" link="libxml2-tree.html#xmlBufferFree"/>
<keyword type="function" name="xmlBufferGrow ()" link="libxml2-tree.html#xmlBufferGrow"/>
<keyword type="function" name="xmlBufferLength ()" link="libxml2-tree.html#xmlBufferLength"/>
<keyword type="function" name="xmlBufferResize ()" link="libxml2-tree.html#xmlBufferResize"/>
<keyword type="function" name="xmlBufferSetAllocationScheme ()" link="libxml2-tree.html#xmlBufferSetAllocationScheme"/>
<keyword type="function" name="xmlBufferShrink ()" link="libxml2-tree.html#xmlBufferShrink"/>
<keyword type="function" name="xmlBufferWriteCHAR ()" link="libxml2-tree.html#xmlBufferWriteCHAR"/>
<keyword type="function" name="xmlBufferWriteChar ()" link="libxml2-tree.html#xmlBufferWriteChar"/>
<keyword type="function" name="xmlBufferWriteQuotedString ()" link="libxml2-tree.html#xmlBufferWriteQuotedString"/>
<keyword type="function" name="xmlBuildQName ()" link="libxml2-tree.html#xmlBuildQName"/>
<keyword type="function" name="xmlBuildRelativeURI ()" link="libxml2-uri.html#xmlBuildRelativeURI"/>
<keyword type="function" name="xmlBuildURI ()" link="libxml2-uri.html#xmlBuildURI"/>
<keyword type="function" name="xmlByteConsumed ()" link="libxml2-parser.html#xmlByteConsumed"/>
<keyword type="function" name="xmlC14NDocDumpMemory ()" link="libxml2-c14n.html#xmlC14NDocDumpMemory"/>
<keyword type="function" name="xmlC14NDocSave ()" link="libxml2-c14n.html#xmlC14NDocSave"/>
<keyword type="function" name="xmlC14NDocSaveTo ()" link="libxml2-c14n.html#xmlC14NDocSaveTo"/>
<keyword type="function" name="xmlC14NExecute ()" link="libxml2-c14n.html#xmlC14NExecute"/>
<keyword type="function" name="xmlCanonicPath ()" link="libxml2-uri.html#xmlCanonicPath"/>
<keyword type="function" name="xmlCatalogAdd ()" link="libxml2-catalog.html#xmlCatalogAdd"/>
<keyword type="function" name="xmlCatalogAddLocal ()" link="libxml2-catalog.html#xmlCatalogAddLocal"/>
<keyword type="function" name="xmlCatalogCleanup ()" link="libxml2-catalog.html#xmlCatalogCleanup"/>
<keyword type="function" name="xmlCatalogConvert ()" link="libxml2-catalog.html#xmlCatalogConvert"/>
<keyword type="function" name="xmlCatalogDump ()" link="libxml2-catalog.html#xmlCatalogDump"/>
<keyword type="function" name="xmlCatalogFreeLocal ()" link="libxml2-catalog.html#xmlCatalogFreeLocal"/>
<keyword type="function" name="xmlCatalogGetDefaults ()" link="libxml2-catalog.html#xmlCatalogGetDefaults"/>
<keyword type="function" name="xmlCatalogGetPublic ()" link="libxml2-catalog.html#xmlCatalogGetPublic"/>
<keyword type="function" name="xmlCatalogGetSystem ()" link="libxml2-catalog.html#xmlCatalogGetSystem"/>
<keyword type="function" name="xmlCatalogIsEmpty ()" link="libxml2-catalog.html#xmlCatalogIsEmpty"/>
<keyword type="function" name="xmlCatalogLocalResolve ()" link="libxml2-catalog.html#xmlCatalogLocalResolve"/>
<keyword type="function" name="xmlCatalogLocalResolveURI ()" link="libxml2-catalog.html#xmlCatalogLocalResolveURI"/>
<keyword type="function" name="xmlCatalogRemove ()" link="libxml2-catalog.html#xmlCatalogRemove"/>
<keyword type="function" name="xmlCatalogResolve ()" link="libxml2-catalog.html#xmlCatalogResolve"/>
<keyword type="function" name="xmlCatalogResolvePublic ()" link="libxml2-catalog.html#xmlCatalogResolvePublic"/>
<keyword type="function" name="xmlCatalogResolveSystem ()" link="libxml2-catalog.html#xmlCatalogResolveSystem"/>
<keyword type="function" name="xmlCatalogResolveURI ()" link="libxml2-catalog.html#xmlCatalogResolveURI"/>
<keyword type="function" name="xmlCatalogSetDebug ()" link="libxml2-catalog.html#xmlCatalogSetDebug"/>
<keyword type="function" name="xmlCatalogSetDefaultPrefer ()" link="libxml2-catalog.html#xmlCatalogSetDefaultPrefer"/>
<keyword type="function" name="xmlCatalogSetDefaults ()" link="libxml2-catalog.html#xmlCatalogSetDefaults"/>
<keyword type="function" name="xmlCharEncCloseFunc ()" link="libxml2-encoding.html#xmlCharEncCloseFunc"/>
<keyword type="function" name="xmlCharEncFirstLine ()" link="libxml2-encoding.html#xmlCharEncFirstLine"/>
<keyword type="function" name="xmlCharEncInFunc ()" link="libxml2-encoding.html#xmlCharEncInFunc"/>
<keyword type="function" name="xmlCharEncOutFunc ()" link="libxml2-encoding.html#xmlCharEncOutFunc"/>
<keyword type="function" name="xmlCharInRange ()" link="libxml2-chvalid.html#xmlCharInRange"/>
<keyword type="function" name="xmlCharStrdup ()" link="libxml2-xmlstring.html#xmlCharStrdup"/>
<keyword type="function" name="xmlCharStrndup ()" link="libxml2-xmlstring.html#xmlCharStrndup"/>
<keyword type="function" name="xmlCheckFilename ()" link="libxml2-xmlIO.html#xmlCheckFilename"/>
<keyword type="function" name="xmlCheckHTTPInput ()" link="libxml2-xmlIO.html#xmlCheckHTTPInput"/>
<keyword type="function" name="xmlCheckLanguageID ()" link="libxml2-parserInternals.html#xmlCheckLanguageID"/>
<keyword type="function" name="xmlCheckUTF8 ()" link="libxml2-xmlstring.html#xmlCheckUTF8"/>
<keyword type="function" name="xmlCheckVersion ()" link="libxml2-xmlversion.html#xmlCheckVersion"/>
<keyword type="function" name="xmlChildElementCount ()" link="libxml2-tree.html#xmlChildElementCount"/>
<keyword type="function" name="xmlCleanupCharEncodingHandlers ()" link="libxml2-encoding.html#xmlCleanupCharEncodingHandlers"/>
<keyword type="function" name="xmlCleanupEncodingAliases ()" link="libxml2-encoding.html#xmlCleanupEncodingAliases"/>
<keyword type="function" name="xmlCleanupGlobals ()" link="libxml2-globals.html#xmlCleanupGlobals"/>
<keyword type="function" name="xmlCleanupInputCallbacks ()" link="libxml2-xmlIO.html#xmlCleanupInputCallbacks"/>
<keyword type="function" name="xmlCleanupMemory ()" link="libxml2-xmlmemory.html#xmlCleanupMemory"/>
<keyword type="function" name="xmlCleanupOutputCallbacks ()" link="libxml2-xmlIO.html#xmlCleanupOutputCallbacks"/>
<keyword type="function" name="xmlCleanupParser ()" link="libxml2-parser.html#xmlCleanupParser"/>
<keyword type="function" name="xmlCleanupPredefinedEntities ()" link="libxml2-entities.html#xmlCleanupPredefinedEntities"/>
<keyword type="function" name="xmlCleanupThreads ()" link="libxml2-threads.html#xmlCleanupThreads"/>
<keyword type="function" name="xmlClearNodeInfoSeq ()" link="libxml2-parser.html#xmlClearNodeInfoSeq"/>
<keyword type="function" name="xmlClearParserCtxt ()" link="libxml2-parser.html#xmlClearParserCtxt"/>
<keyword type="function" name="xmlConvertSGMLCatalog ()" link="libxml2-catalog.html#xmlConvertSGMLCatalog"/>
<keyword type="function" name="xmlCopyAttributeTable ()" link="libxml2-valid.html#xmlCopyAttributeTable"/>
<keyword type="function" name="xmlCopyChar ()" link="libxml2-parserInternals.html#xmlCopyChar"/>
<keyword type="function" name="xmlCopyCharMultiByte ()" link="libxml2-parserInternals.html#xmlCopyCharMultiByte"/>
<keyword type="function" name="xmlCopyDoc ()" link="libxml2-tree.html#xmlCopyDoc"/>
<keyword type="function" name="xmlCopyDocElementContent ()" link="libxml2-valid.html#xmlCopyDocElementContent"/>
<keyword type="function" name="xmlCopyDtd ()" link="libxml2-tree.html#xmlCopyDtd"/>
<keyword type="function" name="xmlCopyElementContent ()" link="libxml2-valid.html#xmlCopyElementContent"/>
<keyword type="function" name="xmlCopyElementTable ()" link="libxml2-valid.html#xmlCopyElementTable"/>
<keyword type="function" name="xmlCopyEntitiesTable ()" link="libxml2-entities.html#xmlCopyEntitiesTable"/>
<keyword type="function" name="xmlCopyEnumeration ()" link="libxml2-valid.html#xmlCopyEnumeration"/>
<keyword type="function" name="xmlCopyError ()" link="libxml2-xmlerror.html#xmlCopyError"/>
<keyword type="function" name="xmlCopyNamespace ()" link="libxml2-tree.html#xmlCopyNamespace"/>
<keyword type="function" name="xmlCopyNamespaceList ()" link="libxml2-tree.html#xmlCopyNamespaceList"/>
<keyword type="function" name="xmlCopyNode ()" link="libxml2-tree.html#xmlCopyNode"/>
<keyword type="function" name="xmlCopyNodeList ()" link="libxml2-tree.html#xmlCopyNodeList"/>
<keyword type="function" name="xmlCopyNotationTable ()" link="libxml2-valid.html#xmlCopyNotationTable"/>
<keyword type="function" name="xmlCopyProp ()" link="libxml2-tree.html#xmlCopyProp"/>
<keyword type="function" name="xmlCopyPropList ()" link="libxml2-tree.html#xmlCopyPropList"/>
<keyword type="function" name="xmlCreateDocParserCtxt ()" link="libxml2-parser.html#xmlCreateDocParserCtxt"/>
<keyword type="function" name="xmlCreateEntitiesTable ()" link="libxml2-entities.html#xmlCreateEntitiesTable"/>
<keyword type="function" name="xmlCreateEntityParserCtxt ()" link="libxml2-parserInternals.html#xmlCreateEntityParserCtxt"/>
<keyword type="function" name="xmlCreateEnumeration ()" link="libxml2-valid.html#xmlCreateEnumeration"/>
<keyword type="function" name="xmlCreateFileParserCtxt ()" link="libxml2-parserInternals.html#xmlCreateFileParserCtxt"/>
<keyword type="function" name="xmlCreateIOParserCtxt ()" link="libxml2-parser.html#xmlCreateIOParserCtxt"/>
<keyword type="function" name="xmlCreateIntSubset ()" link="libxml2-tree.html#xmlCreateIntSubset"/>
<keyword type="function" name="xmlCreateMemoryParserCtxt ()" link="libxml2-parserInternals.html#xmlCreateMemoryParserCtxt"/>
<keyword type="function" name="xmlCreatePushParserCtxt ()" link="libxml2-parser.html#xmlCreatePushParserCtxt"/>
<keyword type="function" name="xmlCreateURI ()" link="libxml2-uri.html#xmlCreateURI"/>
<keyword type="function" name="xmlCreateURLParserCtxt ()" link="libxml2-parserInternals.html#xmlCreateURLParserCtxt"/>
<keyword type="function" name="xmlCtxtGetLastError ()" link="libxml2-xmlerror.html#xmlCtxtGetLastError"/>
<keyword type="function" name="xmlCtxtReadDoc ()" link="libxml2-parser.html#xmlCtxtReadDoc"/>
<keyword type="function" name="xmlCtxtReadFd ()" link="libxml2-parser.html#xmlCtxtReadFd"/>
<keyword type="function" name="xmlCtxtReadFile ()" link="libxml2-parser.html#xmlCtxtReadFile"/>
<keyword type="function" name="xmlCtxtReadIO ()" link="libxml2-parser.html#xmlCtxtReadIO"/>
<keyword type="function" name="xmlCtxtReadMemory ()" link="libxml2-parser.html#xmlCtxtReadMemory"/>
<keyword type="function" name="xmlCtxtReset ()" link="libxml2-parser.html#xmlCtxtReset"/>
<keyword type="function" name="xmlCtxtResetLastError ()" link="libxml2-xmlerror.html#xmlCtxtResetLastError"/>
<keyword type="function" name="xmlCtxtResetPush ()" link="libxml2-parser.html#xmlCtxtResetPush"/>
<keyword type="function" name="xmlCtxtUseOptions ()" link="libxml2-parser.html#xmlCtxtUseOptions"/>
<keyword type="function" name="xmlCurrentChar ()" link="libxml2-parserInternals.html#xmlCurrentChar"/>
<keyword type="function" name="xmlDOMWrapAdoptNode ()" link="libxml2-tree.html#xmlDOMWrapAdoptNode"/>
<keyword type="function" name="xmlDOMWrapCloneNode ()" link="libxml2-tree.html#xmlDOMWrapCloneNode"/>
<keyword type="function" name="xmlDOMWrapFreeCtxt ()" link="libxml2-tree.html#xmlDOMWrapFreeCtxt"/>
<keyword type="function" name="xmlDOMWrapNewCtxt ()" link="libxml2-tree.html#xmlDOMWrapNewCtxt"/>
<keyword type="function" name="xmlDOMWrapReconcileNamespaces ()" link="libxml2-tree.html#xmlDOMWrapReconcileNamespaces"/>
<keyword type="function" name="xmlDOMWrapRemoveNode ()" link="libxml2-tree.html#xmlDOMWrapRemoveNode"/>
<keyword type="function" name="xmlDebugCheckDocument ()" link="libxml2-debugXML.html#xmlDebugCheckDocument"/>
<keyword type="function" name="xmlDebugDumpAttr ()" link="libxml2-debugXML.html#xmlDebugDumpAttr"/>
<keyword type="function" name="xmlDebugDumpAttrList ()" link="libxml2-debugXML.html#xmlDebugDumpAttrList"/>
<keyword type="function" name="xmlDebugDumpDTD ()" link="libxml2-debugXML.html#xmlDebugDumpDTD"/>
<keyword type="function" name="xmlDebugDumpDocument ()" link="libxml2-debugXML.html#xmlDebugDumpDocument"/>
<keyword type="function" name="xmlDebugDumpDocumentHead ()" link="libxml2-debugXML.html#xmlDebugDumpDocumentHead"/>
<keyword type="function" name="xmlDebugDumpEntities ()" link="libxml2-debugXML.html#xmlDebugDumpEntities"/>
<keyword type="function" name="xmlDebugDumpNode ()" link="libxml2-debugXML.html#xmlDebugDumpNode"/>
<keyword type="function" name="xmlDebugDumpNodeList ()" link="libxml2-debugXML.html#xmlDebugDumpNodeList"/>
<keyword type="function" name="xmlDebugDumpOneNode ()" link="libxml2-debugXML.html#xmlDebugDumpOneNode"/>
<keyword type="function" name="xmlDebugDumpString ()" link="libxml2-debugXML.html#xmlDebugDumpString"/>
<keyword type="function" name="xmlDecodeEntities ()" link="libxml2-parserInternals.html#xmlDecodeEntities"/>
<keyword type="function" name="xmlDefaultSAXHandlerInit ()" link="libxml2-SAX2.html#xmlDefaultSAXHandlerInit"/>
<keyword type="function" name="xmlDelEncodingAlias ()" link="libxml2-encoding.html#xmlDelEncodingAlias"/>
<keyword type="function" name="xmlDeregisterNodeDefault ()" link="libxml2-globals.html#xmlDeregisterNodeDefault"/>
<keyword type="function" name="xmlDetectCharEncoding ()" link="libxml2-encoding.html#xmlDetectCharEncoding"/>
<keyword type="function" name="xmlDictCleanup ()" link="libxml2-dict.html#xmlDictCleanup"/>
<keyword type="function" name="xmlDictCreate ()" link="libxml2-dict.html#xmlDictCreate"/>
<keyword type="function" name="xmlDictCreateSub ()" link="libxml2-dict.html#xmlDictCreateSub"/>
<keyword type="function" name="xmlDictExists ()" link="libxml2-dict.html#xmlDictExists"/>
<keyword type="function" name="xmlDictFree ()" link="libxml2-dict.html#xmlDictFree"/>
<keyword type="function" name="xmlDictGetUsage ()" link="libxml2-dict.html#xmlDictGetUsage"/>
<keyword type="function" name="xmlDictLookup ()" link="libxml2-dict.html#xmlDictLookup"/>
<keyword type="function" name="xmlDictOwns ()" link="libxml2-dict.html#xmlDictOwns"/>
<keyword type="function" name="xmlDictQLookup ()" link="libxml2-dict.html#xmlDictQLookup"/>
<keyword type="function" name="xmlDictReference ()" link="libxml2-dict.html#xmlDictReference"/>
<keyword type="function" name="xmlDictSetLimit ()" link="libxml2-dict.html#xmlDictSetLimit"/>
<keyword type="function" name="xmlDictSize ()" link="libxml2-dict.html#xmlDictSize"/>
<keyword type="function" name="xmlDllMain ()" link="libxml2-threads.html#xmlDllMain"/>
<keyword type="function" name="xmlDocCopyNode ()" link="libxml2-tree.html#xmlDocCopyNode"/>
<keyword type="function" name="xmlDocCopyNodeList ()" link="libxml2-tree.html#xmlDocCopyNodeList"/>
<keyword type="function" name="xmlDocDump ()" link="libxml2-tree.html#xmlDocDump"/>
<keyword type="function" name="xmlDocDumpFormatMemory ()" link="libxml2-tree.html#xmlDocDumpFormatMemory"/>
<keyword type="function" name="xmlDocDumpFormatMemoryEnc ()" link="libxml2-tree.html#xmlDocDumpFormatMemoryEnc"/>
<keyword type="function" name="xmlDocDumpMemory ()" link="libxml2-tree.html#xmlDocDumpMemory"/>
<keyword type="function" name="xmlDocDumpMemoryEnc ()" link="libxml2-tree.html#xmlDocDumpMemoryEnc"/>
<keyword type="function" name="xmlDocFormatDump ()" link="libxml2-tree.html#xmlDocFormatDump"/>
<keyword type="function" name="xmlDocGetRootElement ()" link="libxml2-tree.html#xmlDocGetRootElement"/>
<keyword type="function" name="xmlDocSetRootElement ()" link="libxml2-tree.html#xmlDocSetRootElement"/>
<keyword type="function" name="xmlDumpAttributeDecl ()" link="libxml2-valid.html#xmlDumpAttributeDecl"/>
<keyword type="function" name="xmlDumpAttributeTable ()" link="libxml2-valid.html#xmlDumpAttributeTable"/>
<keyword type="function" name="xmlDumpElementDecl ()" link="libxml2-valid.html#xmlDumpElementDecl"/>
<keyword type="function" name="xmlDumpElementTable ()" link="libxml2-valid.html#xmlDumpElementTable"/>
<keyword type="function" name="xmlDumpEntitiesTable ()" link="libxml2-entities.html#xmlDumpEntitiesTable"/>
<keyword type="function" name="xmlDumpEntityDecl ()" link="libxml2-entities.html#xmlDumpEntityDecl"/>
<keyword type="function" name="xmlDumpNotationDecl ()" link="libxml2-valid.html#xmlDumpNotationDecl"/>
<keyword type="function" name="xmlDumpNotationTable ()" link="libxml2-valid.html#xmlDumpNotationTable"/>
<keyword type="function" name="xmlElemDump ()" link="libxml2-tree.html#xmlElemDump"/>
<keyword type="function" name="xmlEncodeEntities ()" link="libxml2-entities.html#xmlEncodeEntities"/>
<keyword type="function" name="xmlEncodeEntitiesReentrant ()" link="libxml2-entities.html#xmlEncodeEntitiesReentrant"/>
<keyword type="function" name="xmlEncodeSpecialChars ()" link="libxml2-entities.html#xmlEncodeSpecialChars"/>
<keyword type="function" name="xmlErrMemory ()" link="libxml2-parserInternals.html#xmlErrMemory"/>
<keyword type="function" name="xmlExpCtxtNbCons ()" link="libxml2-xmlregexp.html#xmlExpCtxtNbCons"/>
<keyword type="function" name="xmlExpCtxtNbNodes ()" link="libxml2-xmlregexp.html#xmlExpCtxtNbNodes"/>
<keyword type="function" name="xmlExpDump ()" link="libxml2-xmlregexp.html#xmlExpDump"/>
<keyword type="function" name="xmlExpExpDerive ()" link="libxml2-xmlregexp.html#xmlExpExpDerive"/>
<keyword type="function" name="xmlExpFree ()" link="libxml2-xmlregexp.html#xmlExpFree"/>
<keyword type="function" name="xmlExpFreeCtxt ()" link="libxml2-xmlregexp.html#xmlExpFreeCtxt"/>
<keyword type="function" name="xmlExpGetLanguage ()" link="libxml2-xmlregexp.html#xmlExpGetLanguage"/>
<keyword type="function" name="xmlExpGetStart ()" link="libxml2-xmlregexp.html#xmlExpGetStart"/>
<keyword type="function" name="xmlExpIsNillable ()" link="libxml2-xmlregexp.html#xmlExpIsNillable"/>
<keyword type="function" name="xmlExpMaxToken ()" link="libxml2-xmlregexp.html#xmlExpMaxToken"/>
<keyword type="function" name="xmlExpNewAtom ()" link="libxml2-xmlregexp.html#xmlExpNewAtom"/>
<keyword type="function" name="xmlExpNewCtxt ()" link="libxml2-xmlregexp.html#xmlExpNewCtxt"/>
<keyword type="function" name="xmlExpNewOr ()" link="libxml2-xmlregexp.html#xmlExpNewOr"/>
<keyword type="function" name="xmlExpNewRange ()" link="libxml2-xmlregexp.html#xmlExpNewRange"/>
<keyword type="function" name="xmlExpNewSeq ()" link="libxml2-xmlregexp.html#xmlExpNewSeq"/>
<keyword type="function" name="xmlExpParse ()" link="libxml2-xmlregexp.html#xmlExpParse"/>
<keyword type="function" name="xmlExpRef ()" link="libxml2-xmlregexp.html#xmlExpRef"/>
<keyword type="function" name="xmlExpStringDerive ()" link="libxml2-xmlregexp.html#xmlExpStringDerive"/>
<keyword type="function" name="xmlExpSubsume ()" link="libxml2-xmlregexp.html#xmlExpSubsume"/>
<keyword type="function" name="xmlFileClose ()" link="libxml2-xmlIO.html#xmlFileClose"/>
<keyword type="function" name="xmlFileMatch ()" link="libxml2-xmlIO.html#xmlFileMatch"/>
<keyword type="function" name="xmlFileOpen ()" link="libxml2-xmlIO.html#xmlFileOpen"/>
<keyword type="function" name="xmlFileRead ()" link="libxml2-xmlIO.html#xmlFileRead"/>
<keyword type="function" name="xmlFindCharEncodingHandler ()" link="libxml2-encoding.html#xmlFindCharEncodingHandler"/>
<keyword type="function" name="xmlFirstElementChild ()" link="libxml2-tree.html#xmlFirstElementChild"/>
<keyword type="function" name="xmlFreeAttributeTable ()" link="libxml2-valid.html#xmlFreeAttributeTable"/>
<keyword type="function" name="xmlFreeAutomata ()" link="libxml2-xmlautomata.html#xmlFreeAutomata"/>
<keyword type="function" name="xmlFreeCatalog ()" link="libxml2-catalog.html#xmlFreeCatalog"/>
<keyword type="function" name="xmlFreeDoc ()" link="libxml2-tree.html#xmlFreeDoc"/>
<keyword type="function" name="xmlFreeDocElementContent ()" link="libxml2-valid.html#xmlFreeDocElementContent"/>
<keyword type="function" name="xmlFreeDtd ()" link="libxml2-tree.html#xmlFreeDtd"/>
<keyword type="function" name="xmlFreeElementContent ()" link="libxml2-valid.html#xmlFreeElementContent"/>
<keyword type="function" name="xmlFreeElementTable ()" link="libxml2-valid.html#xmlFreeElementTable"/>
<keyword type="function" name="xmlFreeEntitiesTable ()" link="libxml2-entities.html#xmlFreeEntitiesTable"/>
<keyword type="function" name="xmlFreeEnumeration ()" link="libxml2-valid.html#xmlFreeEnumeration"/>
<keyword type="function" name="xmlFreeIDTable ()" link="libxml2-valid.html#xmlFreeIDTable"/>
<keyword type="function" name="xmlFreeInputStream ()" link="libxml2-parserInternals.html#xmlFreeInputStream"/>
<keyword type="function" name="xmlFreeMutex ()" link="libxml2-threads.html#xmlFreeMutex"/>
<keyword type="function" name="xmlFreeNode ()" link="libxml2-tree.html#xmlFreeNode"/>
<keyword type="function" name="xmlFreeNodeList ()" link="libxml2-tree.html#xmlFreeNodeList"/>
<keyword type="function" name="xmlFreeNotationTable ()" link="libxml2-valid.html#xmlFreeNotationTable"/>
<keyword type="function" name="xmlFreeNs ()" link="libxml2-tree.html#xmlFreeNs"/>
<keyword type="function" name="xmlFreeNsList ()" link="libxml2-tree.html#xmlFreeNsList"/>
<keyword type="function" name="xmlFreeParserCtxt ()" link="libxml2-parser.html#xmlFreeParserCtxt"/>
<keyword type="function" name="xmlFreeParserInputBuffer ()" link="libxml2-xmlIO.html#xmlFreeParserInputBuffer"/>
<keyword type="function" name="xmlFreePattern ()" link="libxml2-pattern.html#xmlFreePattern"/>
<keyword type="function" name="xmlFreePatternList ()" link="libxml2-pattern.html#xmlFreePatternList"/>
<keyword type="function" name="xmlFreeProp ()" link="libxml2-tree.html#xmlFreeProp"/>
<keyword type="function" name="xmlFreePropList ()" link="libxml2-tree.html#xmlFreePropList"/>
<keyword type="function" name="xmlFreeRMutex ()" link="libxml2-threads.html#xmlFreeRMutex"/>
<keyword type="function" name="xmlFreeRefTable ()" link="libxml2-valid.html#xmlFreeRefTable"/>
<keyword type="function" name="xmlFreeStreamCtxt ()" link="libxml2-pattern.html#xmlFreeStreamCtxt"/>
<keyword type="function" name="xmlFreeTextReader ()" link="libxml2-xmlreader.html#xmlFreeTextReader"/>
<keyword type="function" name="xmlFreeTextWriter ()" link="libxml2-xmlwriter.html#xmlFreeTextWriter"/>
<keyword type="function" name="xmlFreeURI ()" link="libxml2-uri.html#xmlFreeURI"/>
<keyword type="function" name="xmlFreeValidCtxt ()" link="libxml2-valid.html#xmlFreeValidCtxt"/>
<keyword type="function" name="xmlGcMemGet ()" link="libxml2-xmlmemory.html#xmlGcMemGet"/>
<keyword type="function" name="xmlGcMemSetup ()" link="libxml2-xmlmemory.html#xmlGcMemSetup"/>
<keyword type="function" name="xmlGetBufferAllocationScheme ()" link="libxml2-tree.html#xmlGetBufferAllocationScheme"/>
<keyword type="function" name="xmlGetCharEncodingHandler ()" link="libxml2-encoding.html#xmlGetCharEncodingHandler"/>
<keyword type="function" name="xmlGetCharEncodingName ()" link="libxml2-encoding.html#xmlGetCharEncodingName"/>
<keyword type="function" name="xmlGetCompressMode ()" link="libxml2-tree.html#xmlGetCompressMode"/>
<keyword type="function" name="xmlGetDocCompressMode ()" link="libxml2-tree.html#xmlGetDocCompressMode"/>
<keyword type="function" name="xmlGetDocEntity ()" link="libxml2-entities.html#xmlGetDocEntity"/>
<keyword type="function" name="xmlGetDtdAttrDesc ()" link="libxml2-valid.html#xmlGetDtdAttrDesc"/>
<keyword type="function" name="xmlGetDtdElementDesc ()" link="libxml2-valid.html#xmlGetDtdElementDesc"/>
<keyword type="function" name="xmlGetDtdEntity ()" link="libxml2-entities.html#xmlGetDtdEntity"/>
<keyword type="function" name="xmlGetDtdNotationDesc ()" link="libxml2-valid.html#xmlGetDtdNotationDesc"/>
<keyword type="function" name="xmlGetDtdQAttrDesc ()" link="libxml2-valid.html#xmlGetDtdQAttrDesc"/>
<keyword type="function" name="xmlGetDtdQElementDesc ()" link="libxml2-valid.html#xmlGetDtdQElementDesc"/>
<keyword type="function" name="xmlGetEncodingAlias ()" link="libxml2-encoding.html#xmlGetEncodingAlias"/>
<keyword type="function" name="xmlGetExternalEntityLoader ()" link="libxml2-parser.html#xmlGetExternalEntityLoader"/>
<keyword type="function" name="xmlGetFeature ()" link="libxml2-parser.html#xmlGetFeature"/>
<keyword type="function" name="xmlGetFeaturesList ()" link="libxml2-parser.html#xmlGetFeaturesList"/>
<keyword type="function" name="xmlGetGlobalState ()" link="libxml2-threads.html#xmlGetGlobalState"/>
<keyword type="function" name="xmlGetID ()" link="libxml2-valid.html#xmlGetID"/>
<keyword type="function" name="xmlGetIntSubset ()" link="libxml2-tree.html#xmlGetIntSubset"/>
<keyword type="function" name="xmlGetLastChild ()" link="libxml2-tree.html#xmlGetLastChild"/>
<keyword type="function" name="xmlGetLastError ()" link="libxml2-xmlerror.html#xmlGetLastError"/>
<keyword type="function" name="xmlGetLineNo ()" link="libxml2-tree.html#xmlGetLineNo"/>
<keyword type="function" name="xmlGetNoNsProp ()" link="libxml2-tree.html#xmlGetNoNsProp"/>
<keyword type="function" name="xmlGetNodePath ()" link="libxml2-tree.html#xmlGetNodePath"/>
<keyword type="function" name="xmlGetNsList ()" link="libxml2-tree.html#xmlGetNsList"/>
<keyword type="function" name="xmlGetNsProp ()" link="libxml2-tree.html#xmlGetNsProp"/>
<keyword type="function" name="xmlGetParameterEntity ()" link="libxml2-entities.html#xmlGetParameterEntity"/>
<keyword type="function" name="xmlGetPredefinedEntity ()" link="libxml2-entities.html#xmlGetPredefinedEntity"/>
<keyword type="function" name="xmlGetProp ()" link="libxml2-tree.html#xmlGetProp"/>
<keyword type="function" name="xmlGetRefs ()" link="libxml2-valid.html#xmlGetRefs"/>
<keyword type="function" name="xmlGetThreadId ()" link="libxml2-threads.html#xmlGetThreadId"/>
<keyword type="function" name="xmlGetUTF8Char ()" link="libxml2-xmlstring.html#xmlGetUTF8Char"/>
<keyword type="function" name="xmlHandleEntity ()" link="libxml2-parserInternals.html#xmlHandleEntity"/>
<keyword type="function" name="xmlHasFeature ()" link="libxml2-parser.html#xmlHasFeature"/>
<keyword type="function" name="xmlHasNsProp ()" link="libxml2-tree.html#xmlHasNsProp"/>
<keyword type="function" name="xmlHasProp ()" link="libxml2-tree.html#xmlHasProp"/>
<keyword type="function" name="xmlHashAddEntry ()" link="libxml2-hash.html#xmlHashAddEntry"/>
<keyword type="function" name="xmlHashAddEntry2 ()" link="libxml2-hash.html#xmlHashAddEntry2"/>
<keyword type="function" name="xmlHashAddEntry3 ()" link="libxml2-hash.html#xmlHashAddEntry3"/>
<keyword type="function" name="xmlHashCopy ()" link="libxml2-hash.html#xmlHashCopy"/>
<keyword type="function" name="xmlHashCreate ()" link="libxml2-hash.html#xmlHashCreate"/>
<keyword type="function" name="xmlHashCreateDict ()" link="libxml2-hash.html#xmlHashCreateDict"/>
<keyword type="function" name="xmlHashDefaultDeallocator ()" link="libxml2-hash.html#xmlHashDefaultDeallocator"/>
<keyword type="function" name="xmlHashFree ()" link="libxml2-hash.html#xmlHashFree"/>
<keyword type="function" name="xmlHashLookup ()" link="libxml2-hash.html#xmlHashLookup"/>
<keyword type="function" name="xmlHashLookup2 ()" link="libxml2-hash.html#xmlHashLookup2"/>
<keyword type="function" name="xmlHashLookup3 ()" link="libxml2-hash.html#xmlHashLookup3"/>
<keyword type="function" name="xmlHashQLookup ()" link="libxml2-hash.html#xmlHashQLookup"/>
<keyword type="function" name="xmlHashQLookup2 ()" link="libxml2-hash.html#xmlHashQLookup2"/>
<keyword type="function" name="xmlHashQLookup3 ()" link="libxml2-hash.html#xmlHashQLookup3"/>
<keyword type="function" name="xmlHashRemoveEntry ()" link="libxml2-hash.html#xmlHashRemoveEntry"/>
<keyword type="function" name="xmlHashRemoveEntry2 ()" link="libxml2-hash.html#xmlHashRemoveEntry2"/>
<keyword type="function" name="xmlHashRemoveEntry3 ()" link="libxml2-hash.html#xmlHashRemoveEntry3"/>
<keyword type="function" name="xmlHashScan ()" link="libxml2-hash.html#xmlHashScan"/>
<keyword type="function" name="xmlHashScan3 ()" link="libxml2-hash.html#xmlHashScan3"/>
<keyword type="function" name="xmlHashScanFull ()" link="libxml2-hash.html#xmlHashScanFull"/>
<keyword type="function" name="xmlHashScanFull3 ()" link="libxml2-hash.html#xmlHashScanFull3"/>
<keyword type="function" name="xmlHashSize ()" link="libxml2-hash.html#xmlHashSize"/>
<keyword type="function" name="xmlHashUpdateEntry ()" link="libxml2-hash.html#xmlHashUpdateEntry"/>
<keyword type="function" name="xmlHashUpdateEntry2 ()" link="libxml2-hash.html#xmlHashUpdateEntry2"/>
<keyword type="function" name="xmlHashUpdateEntry3 ()" link="libxml2-hash.html#xmlHashUpdateEntry3"/>
<keyword type="function" name="xmlIOFTPClose ()" link="libxml2-xmlIO.html#xmlIOFTPClose"/>
<keyword type="function" name="xmlIOFTPMatch ()" link="libxml2-xmlIO.html#xmlIOFTPMatch"/>
<keyword type="function" name="xmlIOFTPOpen ()" link="libxml2-xmlIO.html#xmlIOFTPOpen"/>
<keyword type="function" name="xmlIOFTPRead ()" link="libxml2-xmlIO.html#xmlIOFTPRead"/>
<keyword type="function" name="xmlIOHTTPClose ()" link="libxml2-xmlIO.html#xmlIOHTTPClose"/>
<keyword type="function" name="xmlIOHTTPMatch ()" link="libxml2-xmlIO.html#xmlIOHTTPMatch"/>
<keyword type="function" name="xmlIOHTTPOpen ()" link="libxml2-xmlIO.html#xmlIOHTTPOpen"/>
<keyword type="function" name="xmlIOHTTPOpenW ()" link="libxml2-xmlIO.html#xmlIOHTTPOpenW"/>
<keyword type="function" name="xmlIOHTTPRead ()" link="libxml2-xmlIO.html#xmlIOHTTPRead"/>
<keyword type="function" name="xmlIOParseDTD ()" link="libxml2-parser.html#xmlIOParseDTD"/>
<keyword type="function" name="xmlInitCharEncodingHandlers ()" link="libxml2-encoding.html#xmlInitCharEncodingHandlers"/>
<keyword type="function" name="xmlInitGlobals ()" link="libxml2-globals.html#xmlInitGlobals"/>
<keyword type="function" name="xmlInitMemory ()" link="libxml2-xmlmemory.html#xmlInitMemory"/>
<keyword type="function" name="xmlInitNodeInfoSeq ()" link="libxml2-parser.html#xmlInitNodeInfoSeq"/>
<keyword type="function" name="xmlInitParser ()" link="libxml2-parser.html#xmlInitParser"/>
<keyword type="function" name="xmlInitParserCtxt ()" link="libxml2-parser.html#xmlInitParserCtxt"/>
<keyword type="function" name="xmlInitThreads ()" link="libxml2-threads.html#xmlInitThreads"/>
<keyword type="function" name="xmlInitializeCatalog ()" link="libxml2-catalog.html#xmlInitializeCatalog"/>
<keyword type="function" name="xmlInitializeDict ()" link="libxml2-dict.html#xmlInitializeDict"/>
<keyword type="function" name="xmlInitializeGlobalState ()" link="libxml2-globals.html#xmlInitializeGlobalState"/>
<keyword type="function" name="xmlInitializePredefinedEntities ()" link="libxml2-entities.html#xmlInitializePredefinedEntities"/>
<keyword type="function" name="xmlIsBaseChar ()" link="libxml2-chvalid.html#xmlIsBaseChar"/>
<keyword type="function" name="xmlIsBlank ()" link="libxml2-chvalid.html#xmlIsBlank"/>
<keyword type="function" name="xmlIsBlankNode ()" link="libxml2-tree.html#xmlIsBlankNode"/>
<keyword type="function" name="xmlIsChar ()" link="libxml2-chvalid.html#xmlIsChar"/>
<keyword type="function" name="xmlIsCombining ()" link="libxml2-chvalid.html#xmlIsCombining"/>
<keyword type="function" name="xmlIsDigit ()" link="libxml2-chvalid.html#xmlIsDigit"/>
<keyword type="function" name="xmlIsExtender ()" link="libxml2-chvalid.html#xmlIsExtender"/>
<keyword type="function" name="xmlIsID ()" link="libxml2-valid.html#xmlIsID"/>
<keyword type="function" name="xmlIsIdeographic ()" link="libxml2-chvalid.html#xmlIsIdeographic"/>
<keyword type="function" name="xmlIsLetter ()" link="libxml2-parserInternals.html#xmlIsLetter"/>
<keyword type="function" name="xmlIsMainThread ()" link="libxml2-threads.html#xmlIsMainThread"/>
<keyword type="function" name="xmlIsMixedElement ()" link="libxml2-valid.html#xmlIsMixedElement"/>
<keyword type="function" name="xmlIsPubidChar ()" link="libxml2-chvalid.html#xmlIsPubidChar"/>
<keyword type="function" name="xmlIsRef ()" link="libxml2-valid.html#xmlIsRef"/>
<keyword type="function" name="xmlIsXHTML ()" link="libxml2-tree.html#xmlIsXHTML"/>
<keyword type="function" name="xmlKeepBlanksDefault ()" link="libxml2-parser.html#xmlKeepBlanksDefault"/>
<keyword type="function" name="xmlLastElementChild ()" link="libxml2-tree.html#xmlLastElementChild"/>
<keyword type="function" name="xmlLineNumbersDefault ()" link="libxml2-parser.html#xmlLineNumbersDefault"/>
<keyword type="function" name="xmlLinkGetData ()" link="libxml2-list.html#xmlLinkGetData"/>
<keyword type="function" name="xmlListAppend ()" link="libxml2-list.html#xmlListAppend"/>
<keyword type="function" name="xmlListClear ()" link="libxml2-list.html#xmlListClear"/>
<keyword type="function" name="xmlListCopy ()" link="libxml2-list.html#xmlListCopy"/>
<keyword type="function" name="xmlListCreate ()" link="libxml2-list.html#xmlListCreate"/>
<keyword type="function" name="xmlListDelete ()" link="libxml2-list.html#xmlListDelete"/>
<keyword type="function" name="xmlListDup ()" link="libxml2-list.html#xmlListDup"/>
<keyword type="function" name="xmlListEmpty ()" link="libxml2-list.html#xmlListEmpty"/>
<keyword type="function" name="xmlListEnd ()" link="libxml2-list.html#xmlListEnd"/>
<keyword type="function" name="xmlListFront ()" link="libxml2-list.html#xmlListFront"/>
<keyword type="function" name="xmlListInsert ()" link="libxml2-list.html#xmlListInsert"/>
<keyword type="function" name="xmlListMerge ()" link="libxml2-list.html#xmlListMerge"/>
<keyword type="function" name="xmlListPopBack ()" link="libxml2-list.html#xmlListPopBack"/>
<keyword type="function" name="xmlListPopFront ()" link="libxml2-list.html#xmlListPopFront"/>
<keyword type="function" name="xmlListPushBack ()" link="libxml2-list.html#xmlListPushBack"/>
<keyword type="function" name="xmlListPushFront ()" link="libxml2-list.html#xmlListPushFront"/>
<keyword type="function" name="xmlListRemoveAll ()" link="libxml2-list.html#xmlListRemoveAll"/>
<keyword type="function" name="xmlListRemoveFirst ()" link="libxml2-list.html#xmlListRemoveFirst"/>
<keyword type="function" name="xmlListRemoveLast ()" link="libxml2-list.html#xmlListRemoveLast"/>
<keyword type="function" name="xmlListReverse ()" link="libxml2-list.html#xmlListReverse"/>
<keyword type="function" name="xmlListReverseSearch ()" link="libxml2-list.html#xmlListReverseSearch"/>
<keyword type="function" name="xmlListReverseWalk ()" link="libxml2-list.html#xmlListReverseWalk"/>
<keyword type="function" name="xmlListSearch ()" link="libxml2-list.html#xmlListSearch"/>
<keyword type="function" name="xmlListSize ()" link="libxml2-list.html#xmlListSize"/>
<keyword type="function" name="xmlListSort ()" link="libxml2-list.html#xmlListSort"/>
<keyword type="function" name="xmlListWalk ()" link="libxml2-list.html#xmlListWalk"/>
<keyword type="function" name="xmlLoadACatalog ()" link="libxml2-catalog.html#xmlLoadACatalog"/>
<keyword type="function" name="xmlLoadCatalog ()" link="libxml2-catalog.html#xmlLoadCatalog"/>
<keyword type="function" name="xmlLoadCatalogs ()" link="libxml2-catalog.html#xmlLoadCatalogs"/>
<keyword type="function" name="xmlLoadExternalEntity ()" link="libxml2-parser.html#xmlLoadExternalEntity"/>
<keyword type="function" name="xmlLoadSGMLSuperCatalog ()" link="libxml2-catalog.html#xmlLoadSGMLSuperCatalog"/>
<keyword type="function" name="xmlLockLibrary ()" link="libxml2-threads.html#xmlLockLibrary"/>
<keyword type="function" name="xmlLsCountNode ()" link="libxml2-debugXML.html#xmlLsCountNode"/>
<keyword type="function" name="xmlLsOneNode ()" link="libxml2-debugXML.html#xmlLsOneNode"/>
<keyword type="function" name="xmlMallocAtomicLoc ()" link="libxml2-xmlmemory.html#xmlMallocAtomicLoc"/>
<keyword type="function" name="xmlMallocLoc ()" link="libxml2-xmlmemory.html#xmlMallocLoc"/>
<keyword type="function" name="xmlMemBlocks ()" link="libxml2-xmlmemory.html#xmlMemBlocks"/>
<keyword type="function" name="xmlMemDisplay ()" link="libxml2-xmlmemory.html#xmlMemDisplay"/>
<keyword type="function" name="xmlMemDisplayLast ()" link="libxml2-xmlmemory.html#xmlMemDisplayLast"/>
<keyword type="function" name="xmlMemFree ()" link="libxml2-xmlmemory.html#xmlMemFree"/>
<keyword type="function" name="xmlMemGet ()" link="libxml2-xmlmemory.html#xmlMemGet"/>
<keyword type="function" name="xmlMemMalloc ()" link="libxml2-xmlmemory.html#xmlMemMalloc"/>
<keyword type="function" name="xmlMemRealloc ()" link="libxml2-xmlmemory.html#xmlMemRealloc"/>
<keyword type="function" name="xmlMemSetup ()" link="libxml2-xmlmemory.html#xmlMemSetup"/>
<keyword type="function" name="xmlMemShow ()" link="libxml2-xmlmemory.html#xmlMemShow"/>
<keyword type="function" name="xmlMemStrdupLoc ()" link="libxml2-xmlmemory.html#xmlMemStrdupLoc"/>
<keyword type="function" name="xmlMemUsed ()" link="libxml2-xmlmemory.html#xmlMemUsed"/>
<keyword type="function" name="xmlMemoryDump ()" link="libxml2-xmlmemory.html#xmlMemoryDump"/>
<keyword type="function" name="xmlMemoryStrdup ()" link="libxml2-xmlmemory.html#xmlMemoryStrdup"/>
<keyword type="function" name="xmlModuleClose ()" link="libxml2-xmlmodule.html#xmlModuleClose"/>
<keyword type="function" name="xmlModuleFree ()" link="libxml2-xmlmodule.html#xmlModuleFree"/>
<keyword type="function" name="xmlModuleOpen ()" link="libxml2-xmlmodule.html#xmlModuleOpen"/>
<keyword type="function" name="xmlModuleSymbol ()" link="libxml2-xmlmodule.html#xmlModuleSymbol"/>
<keyword type="function" name="xmlMutexLock ()" link="libxml2-threads.html#xmlMutexLock"/>
<keyword type="function" name="xmlMutexUnlock ()" link="libxml2-threads.html#xmlMutexUnlock"/>
<keyword type="function" name="xmlNamespaceParseNCName ()" link="libxml2-parserInternals.html#xmlNamespaceParseNCName"/>
<keyword type="function" name="xmlNamespaceParseNSDef ()" link="libxml2-parserInternals.html#xmlNamespaceParseNSDef"/>
<keyword type="function" name="xmlNamespaceParseQName ()" link="libxml2-parserInternals.html#xmlNamespaceParseQName"/>
<keyword type="function" name="xmlNanoFTPCheckResponse ()" link="libxml2-nanoftp.html#xmlNanoFTPCheckResponse"/>
<keyword type="function" name="xmlNanoFTPCleanup ()" link="libxml2-nanoftp.html#xmlNanoFTPCleanup"/>
<keyword type="function" name="xmlNanoFTPClose ()" link="libxml2-nanoftp.html#xmlNanoFTPClose"/>
<keyword type="function" name="xmlNanoFTPCloseConnection ()" link="libxml2-nanoftp.html#xmlNanoFTPCloseConnection"/>
<keyword type="function" name="xmlNanoFTPConnect ()" link="libxml2-nanoftp.html#xmlNanoFTPConnect"/>
<keyword type="function" name="xmlNanoFTPConnectTo ()" link="libxml2-nanoftp.html#xmlNanoFTPConnectTo"/>
<keyword type="function" name="xmlNanoFTPCwd ()" link="libxml2-nanoftp.html#xmlNanoFTPCwd"/>
<keyword type="function" name="xmlNanoFTPDele ()" link="libxml2-nanoftp.html#xmlNanoFTPDele"/>
<keyword type="function" name="xmlNanoFTPFreeCtxt ()" link="libxml2-nanoftp.html#xmlNanoFTPFreeCtxt"/>
<keyword type="function" name="xmlNanoFTPGet ()" link="libxml2-nanoftp.html#xmlNanoFTPGet"/>
<keyword type="function" name="xmlNanoFTPGetConnection ()" link="libxml2-nanoftp.html#xmlNanoFTPGetConnection"/>
<keyword type="function" name="xmlNanoFTPGetResponse ()" link="libxml2-nanoftp.html#xmlNanoFTPGetResponse"/>
<keyword type="function" name="xmlNanoFTPGetSocket ()" link="libxml2-nanoftp.html#xmlNanoFTPGetSocket"/>
<keyword type="function" name="xmlNanoFTPInit ()" link="libxml2-nanoftp.html#xmlNanoFTPInit"/>
<keyword type="function" name="xmlNanoFTPList ()" link="libxml2-nanoftp.html#xmlNanoFTPList"/>
<keyword type="function" name="xmlNanoFTPNewCtxt ()" link="libxml2-nanoftp.html#xmlNanoFTPNewCtxt"/>
<keyword type="function" name="xmlNanoFTPOpen ()" link="libxml2-nanoftp.html#xmlNanoFTPOpen"/>
<keyword type="function" name="xmlNanoFTPProxy ()" link="libxml2-nanoftp.html#xmlNanoFTPProxy"/>
<keyword type="function" name="xmlNanoFTPQuit ()" link="libxml2-nanoftp.html#xmlNanoFTPQuit"/>
<keyword type="function" name="xmlNanoFTPRead ()" link="libxml2-nanoftp.html#xmlNanoFTPRead"/>
<keyword type="function" name="xmlNanoFTPScanProxy ()" link="libxml2-nanoftp.html#xmlNanoFTPScanProxy"/>
<keyword type="function" name="xmlNanoFTPUpdateURL ()" link="libxml2-nanoftp.html#xmlNanoFTPUpdateURL"/>
<keyword type="function" name="xmlNanoHTTPAuthHeader ()" link="libxml2-nanohttp.html#xmlNanoHTTPAuthHeader"/>
<keyword type="function" name="xmlNanoHTTPCleanup ()" link="libxml2-nanohttp.html#xmlNanoHTTPCleanup"/>
<keyword type="function" name="xmlNanoHTTPClose ()" link="libxml2-nanohttp.html#xmlNanoHTTPClose"/>
<keyword type="function" name="xmlNanoHTTPContentLength ()" link="libxml2-nanohttp.html#xmlNanoHTTPContentLength"/>
<keyword type="function" name="xmlNanoHTTPEncoding ()" link="libxml2-nanohttp.html#xmlNanoHTTPEncoding"/>
<keyword type="function" name="xmlNanoHTTPFetch ()" link="libxml2-nanohttp.html#xmlNanoHTTPFetch"/>
<keyword type="function" name="xmlNanoHTTPInit ()" link="libxml2-nanohttp.html#xmlNanoHTTPInit"/>
<keyword type="function" name="xmlNanoHTTPMethod ()" link="libxml2-nanohttp.html#xmlNanoHTTPMethod"/>
<keyword type="function" name="xmlNanoHTTPMethodRedir ()" link="libxml2-nanohttp.html#xmlNanoHTTPMethodRedir"/>
<keyword type="function" name="xmlNanoHTTPMimeType ()" link="libxml2-nanohttp.html#xmlNanoHTTPMimeType"/>
<keyword type="function" name="xmlNanoHTTPOpen ()" link="libxml2-nanohttp.html#xmlNanoHTTPOpen"/>
<keyword type="function" name="xmlNanoHTTPOpenRedir ()" link="libxml2-nanohttp.html#xmlNanoHTTPOpenRedir"/>
<keyword type="function" name="xmlNanoHTTPRead ()" link="libxml2-nanohttp.html#xmlNanoHTTPRead"/>
<keyword type="function" name="xmlNanoHTTPRedir ()" link="libxml2-nanohttp.html#xmlNanoHTTPRedir"/>
<keyword type="function" name="xmlNanoHTTPReturnCode ()" link="libxml2-nanohttp.html#xmlNanoHTTPReturnCode"/>
<keyword type="function" name="xmlNanoHTTPSave ()" link="libxml2-nanohttp.html#xmlNanoHTTPSave"/>
<keyword type="function" name="xmlNanoHTTPScanProxy ()" link="libxml2-nanohttp.html#xmlNanoHTTPScanProxy"/>
<keyword type="function" name="xmlNewAutomata ()" link="libxml2-xmlautomata.html#xmlNewAutomata"/>
<keyword type="function" name="xmlNewCDataBlock ()" link="libxml2-tree.html#xmlNewCDataBlock"/>
<keyword type="function" name="xmlNewCatalog ()" link="libxml2-catalog.html#xmlNewCatalog"/>
<keyword type="function" name="xmlNewCharEncodingHandler ()" link="libxml2-encoding.html#xmlNewCharEncodingHandler"/>
<keyword type="function" name="xmlNewCharRef ()" link="libxml2-tree.html#xmlNewCharRef"/>
<keyword type="function" name="xmlNewChild ()" link="libxml2-tree.html#xmlNewChild"/>
<keyword type="function" name="xmlNewComment ()" link="libxml2-tree.html#xmlNewComment"/>
<keyword type="function" name="xmlNewDoc ()" link="libxml2-tree.html#xmlNewDoc"/>
<keyword type="function" name="xmlNewDocComment ()" link="libxml2-tree.html#xmlNewDocComment"/>
<keyword type="function" name="xmlNewDocElementContent ()" link="libxml2-valid.html#xmlNewDocElementContent"/>
<keyword type="function" name="xmlNewDocFragment ()" link="libxml2-tree.html#xmlNewDocFragment"/>
<keyword type="function" name="xmlNewDocNode ()" link="libxml2-tree.html#xmlNewDocNode"/>
<keyword type="function" name="xmlNewDocNodeEatName ()" link="libxml2-tree.html#xmlNewDocNodeEatName"/>
<keyword type="function" name="xmlNewDocPI ()" link="libxml2-tree.html#xmlNewDocPI"/>
<keyword type="function" name="xmlNewDocProp ()" link="libxml2-tree.html#xmlNewDocProp"/>
<keyword type="function" name="xmlNewDocRawNode ()" link="libxml2-tree.html#xmlNewDocRawNode"/>
<keyword type="function" name="xmlNewDocText ()" link="libxml2-tree.html#xmlNewDocText"/>
<keyword type="function" name="xmlNewDocTextLen ()" link="libxml2-tree.html#xmlNewDocTextLen"/>
<keyword type="function" name="xmlNewDtd ()" link="libxml2-tree.html#xmlNewDtd"/>
<keyword type="function" name="xmlNewElementContent ()" link="libxml2-valid.html#xmlNewElementContent"/>
<keyword type="function" name="xmlNewEntity ()" link="libxml2-entities.html#xmlNewEntity"/>
<keyword type="function" name="xmlNewEntityInputStream ()" link="libxml2-parserInternals.html#xmlNewEntityInputStream"/>
<keyword type="function" name="xmlNewGlobalNs ()" link="libxml2-tree.html#xmlNewGlobalNs"/>
<keyword type="function" name="xmlNewIOInputStream ()" link="libxml2-parser.html#xmlNewIOInputStream"/>
<keyword type="function" name="xmlNewInputFromFile ()" link="libxml2-parserInternals.html#xmlNewInputFromFile"/>
<keyword type="function" name="xmlNewInputStream ()" link="libxml2-parserInternals.html#xmlNewInputStream"/>
<keyword type="function" name="xmlNewMutex ()" link="libxml2-threads.html#xmlNewMutex"/>
<keyword type="function" name="xmlNewNode ()" link="libxml2-tree.html#xmlNewNode"/>
<keyword type="function" name="xmlNewNodeEatName ()" link="libxml2-tree.html#xmlNewNodeEatName"/>
<keyword type="function" name="xmlNewNs ()" link="libxml2-tree.html#xmlNewNs"/>
<keyword type="function" name="xmlNewNsProp ()" link="libxml2-tree.html#xmlNewNsProp"/>
<keyword type="function" name="xmlNewNsPropEatName ()" link="libxml2-tree.html#xmlNewNsPropEatName"/>
<keyword type="function" name="xmlNewPI ()" link="libxml2-tree.html#xmlNewPI"/>
<keyword type="function" name="xmlNewParserCtxt ()" link="libxml2-parser.html#xmlNewParserCtxt"/>
<keyword type="function" name="xmlNewProp ()" link="libxml2-tree.html#xmlNewProp"/>
<keyword type="function" name="xmlNewRMutex ()" link="libxml2-threads.html#xmlNewRMutex"/>
<keyword type="function" name="xmlNewReference ()" link="libxml2-tree.html#xmlNewReference"/>
<keyword type="function" name="xmlNewStringInputStream ()" link="libxml2-parserInternals.html#xmlNewStringInputStream"/>
<keyword type="function" name="xmlNewText ()" link="libxml2-tree.html#xmlNewText"/>
<keyword type="function" name="xmlNewTextChild ()" link="libxml2-tree.html#xmlNewTextChild"/>
<keyword type="function" name="xmlNewTextLen ()" link="libxml2-tree.html#xmlNewTextLen"/>
<keyword type="function" name="xmlNewTextReader ()" link="libxml2-xmlreader.html#xmlNewTextReader"/>
<keyword type="function" name="xmlNewTextReaderFilename ()" link="libxml2-xmlreader.html#xmlNewTextReaderFilename"/>
<keyword type="function" name="xmlNewTextWriter ()" link="libxml2-xmlwriter.html#xmlNewTextWriter"/>
<keyword type="function" name="xmlNewTextWriterDoc ()" link="libxml2-xmlwriter.html#xmlNewTextWriterDoc"/>
<keyword type="function" name="xmlNewTextWriterFilename ()" link="libxml2-xmlwriter.html#xmlNewTextWriterFilename"/>
<keyword type="function" name="xmlNewTextWriterMemory ()" link="libxml2-xmlwriter.html#xmlNewTextWriterMemory"/>
<keyword type="function" name="xmlNewTextWriterPushParser ()" link="libxml2-xmlwriter.html#xmlNewTextWriterPushParser"/>
<keyword type="function" name="xmlNewTextWriterTree ()" link="libxml2-xmlwriter.html#xmlNewTextWriterTree"/>
<keyword type="function" name="xmlNewValidCtxt ()" link="libxml2-valid.html#xmlNewValidCtxt"/>
<keyword type="function" name="xmlNextChar ()" link="libxml2-parserInternals.html#xmlNextChar"/>
<keyword type="function" name="xmlNextElementSibling ()" link="libxml2-tree.html#xmlNextElementSibling"/>
<keyword type="function" name="xmlNoNetExternalEntityLoader ()" link="libxml2-xmlIO.html#xmlNoNetExternalEntityLoader"/>
<keyword type="function" name="xmlNodeAddContent ()" link="libxml2-tree.html#xmlNodeAddContent"/>
<keyword type="function" name="xmlNodeAddContentLen ()" link="libxml2-tree.html#xmlNodeAddContentLen"/>
<keyword type="function" name="xmlNodeBufGetContent ()" link="libxml2-tree.html#xmlNodeBufGetContent"/>
<keyword type="function" name="xmlNodeDump ()" link="libxml2-tree.html#xmlNodeDump"/>
<keyword type="function" name="xmlNodeDumpOutput ()" link="libxml2-tree.html#xmlNodeDumpOutput"/>
<keyword type="function" name="xmlNodeGetBase ()" link="libxml2-tree.html#xmlNodeGetBase"/>
<keyword type="function" name="xmlNodeGetContent ()" link="libxml2-tree.html#xmlNodeGetContent"/>
<keyword type="function" name="xmlNodeGetLang ()" link="libxml2-tree.html#xmlNodeGetLang"/>
<keyword type="function" name="xmlNodeGetSpacePreserve ()" link="libxml2-tree.html#xmlNodeGetSpacePreserve"/>
<keyword type="function" name="xmlNodeIsText ()" link="libxml2-tree.html#xmlNodeIsText"/>
<keyword type="function" name="xmlNodeListGetRawString ()" link="libxml2-tree.html#xmlNodeListGetRawString"/>
<keyword type="function" name="xmlNodeListGetString ()" link="libxml2-tree.html#xmlNodeListGetString"/>
<keyword type="function" name="xmlNodeSetBase ()" link="libxml2-tree.html#xmlNodeSetBase"/>
<keyword type="function" name="xmlNodeSetContent ()" link="libxml2-tree.html#xmlNodeSetContent"/>
<keyword type="function" name="xmlNodeSetContentLen ()" link="libxml2-tree.html#xmlNodeSetContentLen"/>
<keyword type="function" name="xmlNodeSetLang ()" link="libxml2-tree.html#xmlNodeSetLang"/>
<keyword type="function" name="xmlNodeSetName ()" link="libxml2-tree.html#xmlNodeSetName"/>
<keyword type="function" name="xmlNodeSetSpacePreserve ()" link="libxml2-tree.html#xmlNodeSetSpacePreserve"/>
<keyword type="function" name="xmlNormalizeURIPath ()" link="libxml2-uri.html#xmlNormalizeURIPath"/>
<keyword type="function" name="xmlNormalizeWindowsPath ()" link="libxml2-xmlIO.html#xmlNormalizeWindowsPath"/>
<keyword type="function" name="xmlOutputBufferClose ()" link="libxml2-xmlIO.html#xmlOutputBufferClose"/>
<keyword type="function" name="xmlOutputBufferCreateBuffer ()" link="libxml2-xmlIO.html#xmlOutputBufferCreateBuffer"/>
<keyword type="function" name="xmlOutputBufferCreateFd ()" link="libxml2-xmlIO.html#xmlOutputBufferCreateFd"/>
<keyword type="function" name="xmlOutputBufferCreateFile ()" link="libxml2-xmlIO.html#xmlOutputBufferCreateFile"/>
<keyword type="function" name="xmlOutputBufferCreateFilename ()" link="libxml2-xmlIO.html#xmlOutputBufferCreateFilename"/>
<keyword type="function" name="xmlOutputBufferCreateFilenameDefault ()" link="libxml2-globals.html#xmlOutputBufferCreateFilenameDefault"/>
<keyword type="function" name="xmlOutputBufferCreateIO ()" link="libxml2-xmlIO.html#xmlOutputBufferCreateIO"/>
<keyword type="function" name="xmlOutputBufferFlush ()" link="libxml2-xmlIO.html#xmlOutputBufferFlush"/>
<keyword type="function" name="xmlOutputBufferGetContent ()" link="libxml2-xmlIO.html#xmlOutputBufferGetContent"/>
<keyword type="function" name="xmlOutputBufferGetSize ()" link="libxml2-xmlIO.html#xmlOutputBufferGetSize"/>
<keyword type="function" name="xmlOutputBufferWrite ()" link="libxml2-xmlIO.html#xmlOutputBufferWrite"/>
<keyword type="function" name="xmlOutputBufferWriteEscape ()" link="libxml2-xmlIO.html#xmlOutputBufferWriteEscape"/>
<keyword type="function" name="xmlOutputBufferWriteString ()" link="libxml2-xmlIO.html#xmlOutputBufferWriteString"/>
<keyword type="function" name="xmlParseAttValue ()" link="libxml2-parserInternals.html#xmlParseAttValue"/>
<keyword type="function" name="xmlParseAttribute ()" link="libxml2-parserInternals.html#xmlParseAttribute"/>
<keyword type="function" name="xmlParseAttributeListDecl ()" link="libxml2-parserInternals.html#xmlParseAttributeListDecl"/>
<keyword type="function" name="xmlParseAttributeType ()" link="libxml2-parserInternals.html#xmlParseAttributeType"/>
<keyword type="function" name="xmlParseBalancedChunkMemory ()" link="libxml2-parser.html#xmlParseBalancedChunkMemory"/>
<keyword type="function" name="xmlParseBalancedChunkMemoryRecover ()" link="libxml2-parser.html#xmlParseBalancedChunkMemoryRecover"/>
<keyword type="function" name="xmlParseCDSect ()" link="libxml2-parserInternals.html#xmlParseCDSect"/>
<keyword type="function" name="xmlParseCatalogFile ()" link="libxml2-catalog.html#xmlParseCatalogFile"/>
<keyword type="function" name="xmlParseCharData ()" link="libxml2-parserInternals.html#xmlParseCharData"/>
<keyword type="function" name="xmlParseCharEncoding ()" link="libxml2-encoding.html#xmlParseCharEncoding"/>
<keyword type="function" name="xmlParseCharRef ()" link="libxml2-parserInternals.html#xmlParseCharRef"/>
<keyword type="function" name="xmlParseChunk ()" link="libxml2-parser.html#xmlParseChunk"/>
<keyword type="function" name="xmlParseComment ()" link="libxml2-parserInternals.html#xmlParseComment"/>
<keyword type="function" name="xmlParseContent ()" link="libxml2-parserInternals.html#xmlParseContent"/>
<keyword type="function" name="xmlParseCtxtExternalEntity ()" link="libxml2-parser.html#xmlParseCtxtExternalEntity"/>
<keyword type="function" name="xmlParseDTD ()" link="libxml2-parser.html#xmlParseDTD"/>
<keyword type="function" name="xmlParseDefaultDecl ()" link="libxml2-parserInternals.html#xmlParseDefaultDecl"/>
<keyword type="function" name="xmlParseDoc ()" link="libxml2-parser.html#xmlParseDoc"/>
<keyword type="function" name="xmlParseDocTypeDecl ()" link="libxml2-parserInternals.html#xmlParseDocTypeDecl"/>
<keyword type="function" name="xmlParseDocument ()" link="libxml2-parser.html#xmlParseDocument"/>
<keyword type="function" name="xmlParseElement ()" link="libxml2-parserInternals.html#xmlParseElement"/>
<keyword type="function" name="xmlParseElementChildrenContentDecl ()" link="libxml2-parserInternals.html#xmlParseElementChildrenContentDecl"/>
<keyword type="function" name="xmlParseElementContentDecl ()" link="libxml2-parserInternals.html#xmlParseElementContentDecl"/>
<keyword type="function" name="xmlParseElementDecl ()" link="libxml2-parserInternals.html#xmlParseElementDecl"/>
<keyword type="function" name="xmlParseElementMixedContentDecl ()" link="libxml2-parserInternals.html#xmlParseElementMixedContentDecl"/>
<keyword type="function" name="xmlParseEncName ()" link="libxml2-parserInternals.html#xmlParseEncName"/>
<keyword type="function" name="xmlParseEncodingDecl ()" link="libxml2-parserInternals.html#xmlParseEncodingDecl"/>
<keyword type="function" name="xmlParseEndTag ()" link="libxml2-parserInternals.html#xmlParseEndTag"/>
<keyword type="function" name="xmlParseEntity ()" link="libxml2-parser.html#xmlParseEntity"/>
<keyword type="function" name="xmlParseEntityDecl ()" link="libxml2-parserInternals.html#xmlParseEntityDecl"/>
<keyword type="function" name="xmlParseEntityRef ()" link="libxml2-parserInternals.html#xmlParseEntityRef"/>
<keyword type="function" name="xmlParseEntityValue ()" link="libxml2-parserInternals.html#xmlParseEntityValue"/>
<keyword type="function" name="xmlParseEnumeratedType ()" link="libxml2-parserInternals.html#xmlParseEnumeratedType"/>
<keyword type="function" name="xmlParseEnumerationType ()" link="libxml2-parserInternals.html#xmlParseEnumerationType"/>
<keyword type="function" name="xmlParseExtParsedEnt ()" link="libxml2-parser.html#xmlParseExtParsedEnt"/>
<keyword type="function" name="xmlParseExternalEntity ()" link="libxml2-parser.html#xmlParseExternalEntity"/>
<keyword type="function" name="xmlParseExternalID ()" link="libxml2-parserInternals.html#xmlParseExternalID"/>
<keyword type="function" name="xmlParseExternalSubset ()" link="libxml2-parserInternals.html#xmlParseExternalSubset"/>
<keyword type="function" name="xmlParseFile ()" link="libxml2-parser.html#xmlParseFile"/>
<keyword type="function" name="xmlParseInNodeContext ()" link="libxml2-parser.html#xmlParseInNodeContext"/>
<keyword type="function" name="xmlParseMarkupDecl ()" link="libxml2-parserInternals.html#xmlParseMarkupDecl"/>
<keyword type="function" name="xmlParseMemory ()" link="libxml2-parser.html#xmlParseMemory"/>
<keyword type="function" name="xmlParseMisc ()" link="libxml2-parserInternals.html#xmlParseMisc"/>
<keyword type="function" name="xmlParseName ()" link="libxml2-parserInternals.html#xmlParseName"/>
<keyword type="function" name="xmlParseNamespace ()" link="libxml2-parserInternals.html#xmlParseNamespace"/>
<keyword type="function" name="xmlParseNmtoken ()" link="libxml2-parserInternals.html#xmlParseNmtoken"/>
<keyword type="function" name="xmlParseNotationDecl ()" link="libxml2-parserInternals.html#xmlParseNotationDecl"/>
<keyword type="function" name="xmlParseNotationType ()" link="libxml2-parserInternals.html#xmlParseNotationType"/>
<keyword type="function" name="xmlParsePEReference ()" link="libxml2-parserInternals.html#xmlParsePEReference"/>
<keyword type="function" name="xmlParsePI ()" link="libxml2-parserInternals.html#xmlParsePI"/>
<keyword type="function" name="xmlParsePITarget ()" link="libxml2-parserInternals.html#xmlParsePITarget"/>
<keyword type="function" name="xmlParsePubidLiteral ()" link="libxml2-parserInternals.html#xmlParsePubidLiteral"/>
<keyword type="function" name="xmlParseQuotedString ()" link="libxml2-parserInternals.html#xmlParseQuotedString"/>
<keyword type="function" name="xmlParseReference ()" link="libxml2-parserInternals.html#xmlParseReference"/>
<keyword type="function" name="xmlParseSDDecl ()" link="libxml2-parserInternals.html#xmlParseSDDecl"/>
<keyword type="function" name="xmlParseStartTag ()" link="libxml2-parserInternals.html#xmlParseStartTag"/>
<keyword type="function" name="xmlParseSystemLiteral ()" link="libxml2-parserInternals.html#xmlParseSystemLiteral"/>
<keyword type="function" name="xmlParseTextDecl ()" link="libxml2-parserInternals.html#xmlParseTextDecl"/>
<keyword type="function" name="xmlParseURI ()" link="libxml2-uri.html#xmlParseURI"/>
<keyword type="function" name="xmlParseURIRaw ()" link="libxml2-uri.html#xmlParseURIRaw"/>
<keyword type="function" name="xmlParseURIReference ()" link="libxml2-uri.html#xmlParseURIReference"/>
<keyword type="function" name="xmlParseVersionInfo ()" link="libxml2-parserInternals.html#xmlParseVersionInfo"/>
<keyword type="function" name="xmlParseVersionNum ()" link="libxml2-parserInternals.html#xmlParseVersionNum"/>
<keyword type="function" name="xmlParseXMLDecl ()" link="libxml2-parserInternals.html#xmlParseXMLDecl"/>
<keyword type="function" name="xmlParserAddNodeInfo ()" link="libxml2-parser.html#xmlParserAddNodeInfo"/>
<keyword type="function" name="xmlParserError ()" link="libxml2-xmlerror.html#xmlParserError"/>
<keyword type="function" name="xmlParserFindNodeInfo ()" link="libxml2-parser.html#xmlParserFindNodeInfo"/>
<keyword type="function" name="xmlParserFindNodeInfoIndex ()" link="libxml2-parser.html#xmlParserFindNodeInfoIndex"/>
<keyword type="function" name="xmlParserGetDirectory ()" link="libxml2-xmlIO.html#xmlParserGetDirectory"/>
<keyword type="function" name="xmlParserHandlePEReference ()" link="libxml2-parserInternals.html#xmlParserHandlePEReference"/>
<keyword type="function" name="xmlParserHandleReference ()" link="libxml2-parserInternals.html#xmlParserHandleReference"/>
<keyword type="function" name="xmlParserInputBufferCreateFd ()" link="libxml2-xmlIO.html#xmlParserInputBufferCreateFd"/>
<keyword type="function" name="xmlParserInputBufferCreateFile ()" link="libxml2-xmlIO.html#xmlParserInputBufferCreateFile"/>
<keyword type="function" name="xmlParserInputBufferCreateFilename ()" link="libxml2-xmlIO.html#xmlParserInputBufferCreateFilename"/>
<keyword type="function" name="xmlParserInputBufferCreateFilenameDefault ()" link="libxml2-globals.html#xmlParserInputBufferCreateFilenameDefault"/>
<keyword type="function" name="xmlParserInputBufferCreateIO ()" link="libxml2-xmlIO.html#xmlParserInputBufferCreateIO"/>
<keyword type="function" name="xmlParserInputBufferCreateMem ()" link="libxml2-xmlIO.html#xmlParserInputBufferCreateMem"/>
<keyword type="function" name="xmlParserInputBufferCreateStatic ()" link="libxml2-xmlIO.html#xmlParserInputBufferCreateStatic"/>
<keyword type="function" name="xmlParserInputBufferGrow ()" link="libxml2-xmlIO.html#xmlParserInputBufferGrow"/>
<keyword type="function" name="xmlParserInputBufferPush ()" link="libxml2-xmlIO.html#xmlParserInputBufferPush"/>
<keyword type="function" name="xmlParserInputBufferRead ()" link="libxml2-xmlIO.html#xmlParserInputBufferRead"/>
<keyword type="function" name="xmlParserInputGrow ()" link="libxml2-parser.html#xmlParserInputGrow"/>
<keyword type="function" name="xmlParserInputRead ()" link="libxml2-parser.html#xmlParserInputRead"/>
<keyword type="function" name="xmlParserInputShrink ()" link="libxml2-parserInternals.html#xmlParserInputShrink"/>
<keyword type="function" name="xmlParserPrintFileContext ()" link="libxml2-xmlerror.html#xmlParserPrintFileContext"/>
<keyword type="function" name="xmlParserPrintFileInfo ()" link="libxml2-xmlerror.html#xmlParserPrintFileInfo"/>
<keyword type="function" name="xmlParserValidityError ()" link="libxml2-xmlerror.html#xmlParserValidityError"/>
<keyword type="function" name="xmlParserValidityWarning ()" link="libxml2-xmlerror.html#xmlParserValidityWarning"/>
<keyword type="function" name="xmlParserWarning ()" link="libxml2-xmlerror.html#xmlParserWarning"/>
<keyword type="function" name="xmlPathToURI ()" link="libxml2-uri.html#xmlPathToURI"/>
<keyword type="function" name="xmlPatternFromRoot ()" link="libxml2-pattern.html#xmlPatternFromRoot"/>
<keyword type="function" name="xmlPatternGetStreamCtxt ()" link="libxml2-pattern.html#xmlPatternGetStreamCtxt"/>
<keyword type="function" name="xmlPatternMatch ()" link="libxml2-pattern.html#xmlPatternMatch"/>
<keyword type="function" name="xmlPatternMaxDepth ()" link="libxml2-pattern.html#xmlPatternMaxDepth"/>
<keyword type="function" name="xmlPatternMinDepth ()" link="libxml2-pattern.html#xmlPatternMinDepth"/>
<keyword type="function" name="xmlPatternStreamable ()" link="libxml2-pattern.html#xmlPatternStreamable"/>
<keyword type="function" name="xmlPatterncompile ()" link="libxml2-pattern.html#xmlPatterncompile"/>
<keyword type="function" name="xmlPedanticParserDefault ()" link="libxml2-parser.html#xmlPedanticParserDefault"/>
<keyword type="function" name="xmlPopInput ()" link="libxml2-parserInternals.html#xmlPopInput"/>
<keyword type="function" name="xmlPopInputCallbacks ()" link="libxml2-xmlIO.html#xmlPopInputCallbacks"/>
<keyword type="function" name="xmlPopOutputCallbacks ()" link="libxml2-xmlIO.html#xmlPopOutputCallbacks"/>
<keyword type="function" name="xmlPreviousElementSibling ()" link="libxml2-tree.html#xmlPreviousElementSibling"/>
<keyword type="function" name="xmlPrintURI ()" link="libxml2-uri.html#xmlPrintURI"/>
<keyword type="function" name="xmlPushInput ()" link="libxml2-parserInternals.html#xmlPushInput"/>
<keyword type="function" name="xmlRMutexLock ()" link="libxml2-threads.html#xmlRMutexLock"/>
<keyword type="function" name="xmlRMutexUnlock ()" link="libxml2-threads.html#xmlRMutexUnlock"/>
<keyword type="function" name="xmlReadDoc ()" link="libxml2-parser.html#xmlReadDoc"/>
<keyword type="function" name="xmlReadFd ()" link="libxml2-parser.html#xmlReadFd"/>
<keyword type="function" name="xmlReadFile ()" link="libxml2-parser.html#xmlReadFile"/>
<keyword type="function" name="xmlReadIO ()" link="libxml2-parser.html#xmlReadIO"/>
<keyword type="function" name="xmlReadMemory ()" link="libxml2-parser.html#xmlReadMemory"/>
<keyword type="function" name="xmlReaderForDoc ()" link="libxml2-xmlreader.html#xmlReaderForDoc"/>
<keyword type="function" name="xmlReaderForFd ()" link="libxml2-xmlreader.html#xmlReaderForFd"/>
<keyword type="function" name="xmlReaderForFile ()" link="libxml2-xmlreader.html#xmlReaderForFile"/>
<keyword type="function" name="xmlReaderForIO ()" link="libxml2-xmlreader.html#xmlReaderForIO"/>
<keyword type="function" name="xmlReaderForMemory ()" link="libxml2-xmlreader.html#xmlReaderForMemory"/>
<keyword type="function" name="xmlReaderNewDoc ()" link="libxml2-xmlreader.html#xmlReaderNewDoc"/>
<keyword type="function" name="xmlReaderNewFd ()" link="libxml2-xmlreader.html#xmlReaderNewFd"/>
<keyword type="function" name="xmlReaderNewFile ()" link="libxml2-xmlreader.html#xmlReaderNewFile"/>
<keyword type="function" name="xmlReaderNewIO ()" link="libxml2-xmlreader.html#xmlReaderNewIO"/>
<keyword type="function" name="xmlReaderNewMemory ()" link="libxml2-xmlreader.html#xmlReaderNewMemory"/>
<keyword type="function" name="xmlReaderNewWalker ()" link="libxml2-xmlreader.html#xmlReaderNewWalker"/>
<keyword type="function" name="xmlReaderWalker ()" link="libxml2-xmlreader.html#xmlReaderWalker"/>
<keyword type="function" name="xmlReallocLoc ()" link="libxml2-xmlmemory.html#xmlReallocLoc"/>
<keyword type="function" name="xmlReconciliateNs ()" link="libxml2-tree.html#xmlReconciliateNs"/>
<keyword type="function" name="xmlRecoverDoc ()" link="libxml2-parser.html#xmlRecoverDoc"/>
<keyword type="function" name="xmlRecoverFile ()" link="libxml2-parser.html#xmlRecoverFile"/>
<keyword type="function" name="xmlRecoverMemory ()" link="libxml2-parser.html#xmlRecoverMemory"/>
<keyword type="function" name="xmlRegExecErrInfo ()" link="libxml2-xmlregexp.html#xmlRegExecErrInfo"/>
<keyword type="function" name="xmlRegExecNextValues ()" link="libxml2-xmlregexp.html#xmlRegExecNextValues"/>
<keyword type="function" name="xmlRegExecPushString ()" link="libxml2-xmlregexp.html#xmlRegExecPushString"/>
<keyword type="function" name="xmlRegExecPushString2 ()" link="libxml2-xmlregexp.html#xmlRegExecPushString2"/>
<keyword type="function" name="xmlRegFreeExecCtxt ()" link="libxml2-xmlregexp.html#xmlRegFreeExecCtxt"/>
<keyword type="function" name="xmlRegFreeRegexp ()" link="libxml2-xmlregexp.html#xmlRegFreeRegexp"/>
<keyword type="function" name="xmlRegNewExecCtxt ()" link="libxml2-xmlregexp.html#xmlRegNewExecCtxt"/>
<keyword type="function" name="xmlRegexpCompile ()" link="libxml2-xmlregexp.html#xmlRegexpCompile"/>
<keyword type="function" name="xmlRegexpExec ()" link="libxml2-xmlregexp.html#xmlRegexpExec"/>
<keyword type="function" name="xmlRegexpIsDeterminist ()" link="libxml2-xmlregexp.html#xmlRegexpIsDeterminist"/>
<keyword type="function" name="xmlRegexpPrint ()" link="libxml2-xmlregexp.html#xmlRegexpPrint"/>
<keyword type="function" name="xmlRegisterCharEncodingHandler ()" link="libxml2-encoding.html#xmlRegisterCharEncodingHandler"/>
<keyword type="function" name="xmlRegisterDefaultInputCallbacks ()" link="libxml2-xmlIO.html#xmlRegisterDefaultInputCallbacks"/>
<keyword type="function" name="xmlRegisterDefaultOutputCallbacks ()" link="libxml2-xmlIO.html#xmlRegisterDefaultOutputCallbacks"/>
<keyword type="function" name="xmlRegisterHTTPPostCallbacks ()" link="libxml2-xmlIO.html#xmlRegisterHTTPPostCallbacks"/>
<keyword type="function" name="xmlRegisterInputCallbacks ()" link="libxml2-xmlIO.html#xmlRegisterInputCallbacks"/>
<keyword type="function" name="xmlRegisterNodeDefault ()" link="libxml2-globals.html#xmlRegisterNodeDefault"/>
<keyword type="function" name="xmlRegisterOutputCallbacks ()" link="libxml2-xmlIO.html#xmlRegisterOutputCallbacks"/>
<keyword type="function" name="xmlRelaxNGCleanupTypes ()" link="libxml2-relaxng.html#xmlRelaxNGCleanupTypes"/>
<keyword type="function" name="xmlRelaxNGDump ()" link="libxml2-relaxng.html#xmlRelaxNGDump"/>
<keyword type="function" name="xmlRelaxNGDumpTree ()" link="libxml2-relaxng.html#xmlRelaxNGDumpTree"/>
<keyword type="function" name="xmlRelaxNGFree ()" link="libxml2-relaxng.html#xmlRelaxNGFree"/>
<keyword type="function" name="xmlRelaxNGFreeParserCtxt ()" link="libxml2-relaxng.html#xmlRelaxNGFreeParserCtxt"/>
<keyword type="function" name="xmlRelaxNGFreeValidCtxt ()" link="libxml2-relaxng.html#xmlRelaxNGFreeValidCtxt"/>
<keyword type="function" name="xmlRelaxNGGetParserErrors ()" link="libxml2-relaxng.html#xmlRelaxNGGetParserErrors"/>
<keyword type="function" name="xmlRelaxNGGetValidErrors ()" link="libxml2-relaxng.html#xmlRelaxNGGetValidErrors"/>
<keyword type="function" name="xmlRelaxNGInitTypes ()" link="libxml2-relaxng.html#xmlRelaxNGInitTypes"/>
<keyword type="function" name="xmlRelaxNGNewDocParserCtxt ()" link="libxml2-relaxng.html#xmlRelaxNGNewDocParserCtxt"/>
<keyword type="function" name="xmlRelaxNGNewMemParserCtxt ()" link="libxml2-relaxng.html#xmlRelaxNGNewMemParserCtxt"/>
<keyword type="function" name="xmlRelaxNGNewParserCtxt ()" link="libxml2-relaxng.html#xmlRelaxNGNewParserCtxt"/>
<keyword type="function" name="xmlRelaxNGNewValidCtxt ()" link="libxml2-relaxng.html#xmlRelaxNGNewValidCtxt"/>
<keyword type="function" name="xmlRelaxNGParse ()" link="libxml2-relaxng.html#xmlRelaxNGParse"/>
<keyword type="function" name="xmlRelaxNGSetParserErrors ()" link="libxml2-relaxng.html#xmlRelaxNGSetParserErrors"/>
<keyword type="function" name="xmlRelaxNGSetParserStructuredErrors ()" link="libxml2-relaxng.html#xmlRelaxNGSetParserStructuredErrors"/>
<keyword type="function" name="xmlRelaxNGSetValidErrors ()" link="libxml2-relaxng.html#xmlRelaxNGSetValidErrors"/>
<keyword type="function" name="xmlRelaxNGSetValidStructuredErrors ()" link="libxml2-relaxng.html#xmlRelaxNGSetValidStructuredErrors"/>
<keyword type="function" name="xmlRelaxNGValidateDoc ()" link="libxml2-relaxng.html#xmlRelaxNGValidateDoc"/>
<keyword type="function" name="xmlRelaxNGValidateFullElement ()" link="libxml2-relaxng.html#xmlRelaxNGValidateFullElement"/>
<keyword type="function" name="xmlRelaxNGValidatePopElement ()" link="libxml2-relaxng.html#xmlRelaxNGValidatePopElement"/>
<keyword type="function" name="xmlRelaxNGValidatePushCData ()" link="libxml2-relaxng.html#xmlRelaxNGValidatePushCData"/>
<keyword type="function" name="xmlRelaxNGValidatePushElement ()" link="libxml2-relaxng.html#xmlRelaxNGValidatePushElement"/>
<keyword type="function" name="xmlRelaxParserSetFlag ()" link="libxml2-relaxng.html#xmlRelaxParserSetFlag"/>
<keyword type="function" name="xmlRemoveID ()" link="libxml2-valid.html#xmlRemoveID"/>
<keyword type="function" name="xmlRemoveProp ()" link="libxml2-tree.html#xmlRemoveProp"/>
<keyword type="function" name="xmlRemoveRef ()" link="libxml2-valid.html#xmlRemoveRef"/>
<keyword type="function" name="xmlReplaceNode ()" link="libxml2-tree.html#xmlReplaceNode"/>
<keyword type="function" name="xmlResetError ()" link="libxml2-xmlerror.html#xmlResetError"/>
<keyword type="function" name="xmlResetLastError ()" link="libxml2-xmlerror.html#xmlResetLastError"/>
<keyword type="function" name="xmlSAX2AttributeDecl ()" link="libxml2-SAX2.html#xmlSAX2AttributeDecl"/>
<keyword type="function" name="xmlSAX2CDataBlock ()" link="libxml2-SAX2.html#xmlSAX2CDataBlock"/>
<keyword type="function" name="xmlSAX2Characters ()" link="libxml2-SAX2.html#xmlSAX2Characters"/>
<keyword type="function" name="xmlSAX2Comment ()" link="libxml2-SAX2.html#xmlSAX2Comment"/>
<keyword type="function" name="xmlSAX2ElementDecl ()" link="libxml2-SAX2.html#xmlSAX2ElementDecl"/>
<keyword type="function" name="xmlSAX2EndDocument ()" link="libxml2-SAX2.html#xmlSAX2EndDocument"/>
<keyword type="function" name="xmlSAX2EndElement ()" link="libxml2-SAX2.html#xmlSAX2EndElement"/>
<keyword type="function" name="xmlSAX2EndElementNs ()" link="libxml2-SAX2.html#xmlSAX2EndElementNs"/>
<keyword type="function" name="xmlSAX2EntityDecl ()" link="libxml2-SAX2.html#xmlSAX2EntityDecl"/>
<keyword type="function" name="xmlSAX2ExternalSubset ()" link="libxml2-SAX2.html#xmlSAX2ExternalSubset"/>
<keyword type="function" name="xmlSAX2GetColumnNumber ()" link="libxml2-SAX2.html#xmlSAX2GetColumnNumber"/>
<keyword type="function" name="xmlSAX2GetEntity ()" link="libxml2-SAX2.html#xmlSAX2GetEntity"/>
<keyword type="function" name="xmlSAX2GetLineNumber ()" link="libxml2-SAX2.html#xmlSAX2GetLineNumber"/>
<keyword type="function" name="xmlSAX2GetParameterEntity ()" link="libxml2-SAX2.html#xmlSAX2GetParameterEntity"/>
<keyword type="function" name="xmlSAX2GetPublicId ()" link="libxml2-SAX2.html#xmlSAX2GetPublicId"/>
<keyword type="function" name="xmlSAX2GetSystemId ()" link="libxml2-SAX2.html#xmlSAX2GetSystemId"/>
<keyword type="function" name="xmlSAX2HasExternalSubset ()" link="libxml2-SAX2.html#xmlSAX2HasExternalSubset"/>
<keyword type="function" name="xmlSAX2HasInternalSubset ()" link="libxml2-SAX2.html#xmlSAX2HasInternalSubset"/>
<keyword type="function" name="xmlSAX2IgnorableWhitespace ()" link="libxml2-SAX2.html#xmlSAX2IgnorableWhitespace"/>
<keyword type="function" name="xmlSAX2InitDefaultSAXHandler ()" link="libxml2-SAX2.html#xmlSAX2InitDefaultSAXHandler"/>
<keyword type="function" name="xmlSAX2InitHtmlDefaultSAXHandler ()" link="libxml2-SAX2.html#xmlSAX2InitHtmlDefaultSAXHandler"/>
<keyword type="function" name="xmlSAX2InternalSubset ()" link="libxml2-SAX2.html#xmlSAX2InternalSubset"/>
<keyword type="function" name="xmlSAX2IsStandalone ()" link="libxml2-SAX2.html#xmlSAX2IsStandalone"/>
<keyword type="function" name="xmlSAX2NotationDecl ()" link="libxml2-SAX2.html#xmlSAX2NotationDecl"/>
<keyword type="function" name="xmlSAX2ProcessingInstruction ()" link="libxml2-SAX2.html#xmlSAX2ProcessingInstruction"/>
<keyword type="function" name="xmlSAX2Reference ()" link="libxml2-SAX2.html#xmlSAX2Reference"/>
<keyword type="function" name="xmlSAX2ResolveEntity ()" link="libxml2-SAX2.html#xmlSAX2ResolveEntity"/>
<keyword type="function" name="xmlSAX2SetDocumentLocator ()" link="libxml2-SAX2.html#xmlSAX2SetDocumentLocator"/>
<keyword type="function" name="xmlSAX2StartDocument ()" link="libxml2-SAX2.html#xmlSAX2StartDocument"/>
<keyword type="function" name="xmlSAX2StartElement ()" link="libxml2-SAX2.html#xmlSAX2StartElement"/>
<keyword type="function" name="xmlSAX2StartElementNs ()" link="libxml2-SAX2.html#xmlSAX2StartElementNs"/>
<keyword type="function" name="xmlSAX2UnparsedEntityDecl ()" link="libxml2-SAX2.html#xmlSAX2UnparsedEntityDecl"/>
<keyword type="function" name="xmlSAXDefaultVersion ()" link="libxml2-SAX2.html#xmlSAXDefaultVersion"/>
<keyword type="function" name="xmlSAXParseDTD ()" link="libxml2-parser.html#xmlSAXParseDTD"/>
<keyword type="function" name="xmlSAXParseDoc ()" link="libxml2-parser.html#xmlSAXParseDoc"/>
<keyword type="function" name="xmlSAXParseEntity ()" link="libxml2-parser.html#xmlSAXParseEntity"/>
<keyword type="function" name="xmlSAXParseFile ()" link="libxml2-parser.html#xmlSAXParseFile"/>
<keyword type="function" name="xmlSAXParseFileWithData ()" link="libxml2-parser.html#xmlSAXParseFileWithData"/>
<keyword type="function" name="xmlSAXParseMemory ()" link="libxml2-parser.html#xmlSAXParseMemory"/>
<keyword type="function" name="xmlSAXParseMemoryWithData ()" link="libxml2-parser.html#xmlSAXParseMemoryWithData"/>
<keyword type="function" name="xmlSAXUserParseFile ()" link="libxml2-parser.html#xmlSAXUserParseFile"/>
<keyword type="function" name="xmlSAXUserParseMemory ()" link="libxml2-parser.html#xmlSAXUserParseMemory"/>
<keyword type="function" name="xmlSAXVersion ()" link="libxml2-SAX2.html#xmlSAXVersion"/>
<keyword type="function" name="xmlSaveClose ()" link="libxml2-xmlsave.html#xmlSaveClose"/>
<keyword type="function" name="xmlSaveDoc ()" link="libxml2-xmlsave.html#xmlSaveDoc"/>
<keyword type="function" name="xmlSaveFile ()" link="libxml2-tree.html#xmlSaveFile"/>
<keyword type="function" name="xmlSaveFileEnc ()" link="libxml2-tree.html#xmlSaveFileEnc"/>
<keyword type="function" name="xmlSaveFileTo ()" link="libxml2-tree.html#xmlSaveFileTo"/>
<keyword type="function" name="xmlSaveFlush ()" link="libxml2-xmlsave.html#xmlSaveFlush"/>
<keyword type="function" name="xmlSaveFormatFile ()" link="libxml2-tree.html#xmlSaveFormatFile"/>
<keyword type="function" name="xmlSaveFormatFileEnc ()" link="libxml2-tree.html#xmlSaveFormatFileEnc"/>
<keyword type="function" name="xmlSaveFormatFileTo ()" link="libxml2-tree.html#xmlSaveFormatFileTo"/>
<keyword type="function" name="xmlSaveSetAttrEscape ()" link="libxml2-xmlsave.html#xmlSaveSetAttrEscape"/>
<keyword type="function" name="xmlSaveSetEscape ()" link="libxml2-xmlsave.html#xmlSaveSetEscape"/>
<keyword type="function" name="xmlSaveToBuffer ()" link="libxml2-xmlsave.html#xmlSaveToBuffer"/>
<keyword type="function" name="xmlSaveToFd ()" link="libxml2-xmlsave.html#xmlSaveToFd"/>
<keyword type="function" name="xmlSaveToFilename ()" link="libxml2-xmlsave.html#xmlSaveToFilename"/>
<keyword type="function" name="xmlSaveToIO ()" link="libxml2-xmlsave.html#xmlSaveToIO"/>
<keyword type="function" name="xmlSaveTree ()" link="libxml2-xmlsave.html#xmlSaveTree"/>
<keyword type="function" name="xmlSaveUri ()" link="libxml2-uri.html#xmlSaveUri"/>
<keyword type="function" name="xmlScanName ()" link="libxml2-parserInternals.html#xmlScanName"/>
<keyword type="function" name="xmlSchemaCheckFacet ()" link="libxml2-xmlschemastypes.html#xmlSchemaCheckFacet"/>
<keyword type="function" name="xmlSchemaCleanupTypes ()" link="libxml2-xmlschemastypes.html#xmlSchemaCleanupTypes"/>
<keyword type="function" name="xmlSchemaCollapseString ()" link="libxml2-xmlschemastypes.html#xmlSchemaCollapseString"/>
<keyword type="function" name="xmlSchemaCompareValues ()" link="libxml2-xmlschemastypes.html#xmlSchemaCompareValues"/>
<keyword type="function" name="xmlSchemaCompareValuesWhtsp ()" link="libxml2-xmlschemastypes.html#xmlSchemaCompareValuesWhtsp"/>
<keyword type="function" name="xmlSchemaCopyValue ()" link="libxml2-xmlschemastypes.html#xmlSchemaCopyValue"/>
<keyword type="function" name="xmlSchemaDump ()" link="libxml2-xmlschemas.html#xmlSchemaDump"/>
<keyword type="function" name="xmlSchemaFree ()" link="libxml2-xmlschemas.html#xmlSchemaFree"/>
<keyword type="function" name="xmlSchemaFreeFacet ()" link="libxml2-xmlschemastypes.html#xmlSchemaFreeFacet"/>
<keyword type="function" name="xmlSchemaFreeParserCtxt ()" link="libxml2-xmlschemas.html#xmlSchemaFreeParserCtxt"/>
<keyword type="function" name="xmlSchemaFreeType ()" link="libxml2-schemasInternals.html#xmlSchemaFreeType"/>
<keyword type="function" name="xmlSchemaFreeValidCtxt ()" link="libxml2-xmlschemas.html#xmlSchemaFreeValidCtxt"/>
<keyword type="function" name="xmlSchemaFreeValue ()" link="libxml2-xmlschemastypes.html#xmlSchemaFreeValue"/>
<keyword type="function" name="xmlSchemaFreeWildcard ()" link="libxml2-schemasInternals.html#xmlSchemaFreeWildcard"/>
<keyword type="function" name="xmlSchemaGetBuiltInListSimpleTypeItemType ()" link="libxml2-xmlschemastypes.html#xmlSchemaGetBuiltInListSimpleTypeItemType"/>
<keyword type="function" name="xmlSchemaGetBuiltInType ()" link="libxml2-xmlschemastypes.html#xmlSchemaGetBuiltInType"/>
<keyword type="function" name="xmlSchemaGetCanonValue ()" link="libxml2-xmlschemastypes.html#xmlSchemaGetCanonValue"/>
<keyword type="function" name="xmlSchemaGetCanonValueWhtsp ()" link="libxml2-xmlschemastypes.html#xmlSchemaGetCanonValueWhtsp"/>
<keyword type="function" name="xmlSchemaGetFacetValueAsULong ()" link="libxml2-xmlschemastypes.html#xmlSchemaGetFacetValueAsULong"/>
<keyword type="function" name="xmlSchemaGetParserErrors ()" link="libxml2-xmlschemas.html#xmlSchemaGetParserErrors"/>
<keyword type="function" name="xmlSchemaGetPredefinedType ()" link="libxml2-xmlschemastypes.html#xmlSchemaGetPredefinedType"/>
<keyword type="function" name="xmlSchemaGetValType ()" link="libxml2-xmlschemastypes.html#xmlSchemaGetValType"/>
<keyword type="function" name="xmlSchemaGetValidErrors ()" link="libxml2-xmlschemas.html#xmlSchemaGetValidErrors"/>
<keyword type="function" name="xmlSchemaInitTypes ()" link="libxml2-xmlschemastypes.html#xmlSchemaInitTypes"/>
<keyword type="function" name="xmlSchemaIsBuiltInTypeFacet ()" link="libxml2-xmlschemastypes.html#xmlSchemaIsBuiltInTypeFacet"/>
<keyword type="function" name="xmlSchemaIsValid ()" link="libxml2-xmlschemas.html#xmlSchemaIsValid"/>
<keyword type="function" name="xmlSchemaNewDocParserCtxt ()" link="libxml2-xmlschemas.html#xmlSchemaNewDocParserCtxt"/>
<keyword type="function" name="xmlSchemaNewFacet ()" link="libxml2-xmlschemastypes.html#xmlSchemaNewFacet"/>
<keyword type="function" name="xmlSchemaNewMemParserCtxt ()" link="libxml2-xmlschemas.html#xmlSchemaNewMemParserCtxt"/>
<keyword type="function" name="xmlSchemaNewNOTATIONValue ()" link="libxml2-xmlschemastypes.html#xmlSchemaNewNOTATIONValue"/>
<keyword type="function" name="xmlSchemaNewParserCtxt ()" link="libxml2-xmlschemas.html#xmlSchemaNewParserCtxt"/>
<keyword type="function" name="xmlSchemaNewQNameValue ()" link="libxml2-xmlschemastypes.html#xmlSchemaNewQNameValue"/>
<keyword type="function" name="xmlSchemaNewStringValue ()" link="libxml2-xmlschemastypes.html#xmlSchemaNewStringValue"/>
<keyword type="function" name="xmlSchemaNewValidCtxt ()" link="libxml2-xmlschemas.html#xmlSchemaNewValidCtxt"/>
<keyword type="function" name="xmlSchemaParse ()" link="libxml2-xmlschemas.html#xmlSchemaParse"/>
<keyword type="function" name="xmlSchemaSAXPlug ()" link="libxml2-xmlschemas.html#xmlSchemaSAXPlug"/>
<keyword type="function" name="xmlSchemaSAXUnplug ()" link="libxml2-xmlschemas.html#xmlSchemaSAXUnplug"/>
<keyword type="function" name="xmlSchemaSetParserErrors ()" link="libxml2-xmlschemas.html#xmlSchemaSetParserErrors"/>
<keyword type="function" name="xmlSchemaSetParserStructuredErrors ()" link="libxml2-xmlschemas.html#xmlSchemaSetParserStructuredErrors"/>
<keyword type="function" name="xmlSchemaSetValidErrors ()" link="libxml2-xmlschemas.html#xmlSchemaSetValidErrors"/>
<keyword type="function" name="xmlSchemaSetValidOptions ()" link="libxml2-xmlschemas.html#xmlSchemaSetValidOptions"/>
<keyword type="function" name="xmlSchemaSetValidStructuredErrors ()" link="libxml2-xmlschemas.html#xmlSchemaSetValidStructuredErrors"/>
<keyword type="function" name="xmlSchemaValPredefTypeNode ()" link="libxml2-xmlschemastypes.html#xmlSchemaValPredefTypeNode"/>
<keyword type="function" name="xmlSchemaValPredefTypeNodeNoNorm ()" link="libxml2-xmlschemastypes.html#xmlSchemaValPredefTypeNodeNoNorm"/>
<keyword type="function" name="xmlSchemaValidCtxtGetOptions ()" link="libxml2-xmlschemas.html#xmlSchemaValidCtxtGetOptions"/>
<keyword type="function" name="xmlSchemaValidCtxtGetParserCtxt ()" link="libxml2-xmlschemas.html#xmlSchemaValidCtxtGetParserCtxt"/>
<keyword type="function" name="xmlSchemaValidateDoc ()" link="libxml2-xmlschemas.html#xmlSchemaValidateDoc"/>
<keyword type="function" name="xmlSchemaValidateFacet ()" link="libxml2-xmlschemastypes.html#xmlSchemaValidateFacet"/>
<keyword type="function" name="xmlSchemaValidateFacetWhtsp ()" link="libxml2-xmlschemastypes.html#xmlSchemaValidateFacetWhtsp"/>
<keyword type="function" name="xmlSchemaValidateFile ()" link="libxml2-xmlschemas.html#xmlSchemaValidateFile"/>
<keyword type="function" name="xmlSchemaValidateLengthFacet ()" link="libxml2-xmlschemastypes.html#xmlSchemaValidateLengthFacet"/>
<keyword type="function" name="xmlSchemaValidateLengthFacetWhtsp ()" link="libxml2-xmlschemastypes.html#xmlSchemaValidateLengthFacetWhtsp"/>
<keyword type="function" name="xmlSchemaValidateListSimpleTypeFacet ()" link="libxml2-xmlschemastypes.html#xmlSchemaValidateListSimpleTypeFacet"/>
<keyword type="function" name="xmlSchemaValidateOneElement ()" link="libxml2-xmlschemas.html#xmlSchemaValidateOneElement"/>
<keyword type="function" name="xmlSchemaValidatePredefinedType ()" link="libxml2-xmlschemastypes.html#xmlSchemaValidatePredefinedType"/>
<keyword type="function" name="xmlSchemaValidateSetFilename ()" link="libxml2-xmlschemas.html#xmlSchemaValidateSetFilename"/>
<keyword type="function" name="xmlSchemaValidateSetLocator ()" link="libxml2-xmlschemas.html#xmlSchemaValidateSetLocator"/>
<keyword type="function" name="xmlSchemaValidateStream ()" link="libxml2-xmlschemas.html#xmlSchemaValidateStream"/>
<keyword type="function" name="xmlSchemaValueAppend ()" link="libxml2-xmlschemastypes.html#xmlSchemaValueAppend"/>
<keyword type="function" name="xmlSchemaValueGetAsBoolean ()" link="libxml2-xmlschemastypes.html#xmlSchemaValueGetAsBoolean"/>
<keyword type="function" name="xmlSchemaValueGetAsString ()" link="libxml2-xmlschemastypes.html#xmlSchemaValueGetAsString"/>
<keyword type="function" name="xmlSchemaValueGetNext ()" link="libxml2-xmlschemastypes.html#xmlSchemaValueGetNext"/>
<keyword type="function" name="xmlSchemaWhiteSpaceReplace ()" link="libxml2-xmlschemastypes.html#xmlSchemaWhiteSpaceReplace"/>
<keyword type="function" name="xmlSchematronFree ()" link="libxml2-schematron.html#xmlSchematronFree"/>
<keyword type="function" name="xmlSchematronFreeParserCtxt ()" link="libxml2-schematron.html#xmlSchematronFreeParserCtxt"/>
<keyword type="function" name="xmlSchematronFreeValidCtxt ()" link="libxml2-schematron.html#xmlSchematronFreeValidCtxt"/>
<keyword type="function" name="xmlSchematronNewDocParserCtxt ()" link="libxml2-schematron.html#xmlSchematronNewDocParserCtxt"/>
<keyword type="function" name="xmlSchematronNewMemParserCtxt ()" link="libxml2-schematron.html#xmlSchematronNewMemParserCtxt"/>
<keyword type="function" name="xmlSchematronNewParserCtxt ()" link="libxml2-schematron.html#xmlSchematronNewParserCtxt"/>
<keyword type="function" name="xmlSchematronNewValidCtxt ()" link="libxml2-schematron.html#xmlSchematronNewValidCtxt"/>
<keyword type="function" name="xmlSchematronParse ()" link="libxml2-schematron.html#xmlSchematronParse"/>
<keyword type="function" name="xmlSchematronSetValidStructuredErrors ()" link="libxml2-schematron.html#xmlSchematronSetValidStructuredErrors"/>
<keyword type="function" name="xmlSchematronValidateDoc ()" link="libxml2-schematron.html#xmlSchematronValidateDoc"/>
<keyword type="function" name="xmlSearchNs ()" link="libxml2-tree.html#xmlSearchNs"/>
<keyword type="function" name="xmlSearchNsByHref ()" link="libxml2-tree.html#xmlSearchNsByHref"/>
<keyword type="function" name="xmlSetBufferAllocationScheme ()" link="libxml2-tree.html#xmlSetBufferAllocationScheme"/>
<keyword type="function" name="xmlSetCompressMode ()" link="libxml2-tree.html#xmlSetCompressMode"/>
<keyword type="function" name="xmlSetDocCompressMode ()" link="libxml2-tree.html#xmlSetDocCompressMode"/>
<keyword type="function" name="xmlSetEntityReferenceFunc ()" link="libxml2-parserInternals.html#xmlSetEntityReferenceFunc"/>
<keyword type="function" name="xmlSetExternalEntityLoader ()" link="libxml2-parser.html#xmlSetExternalEntityLoader"/>
<keyword type="function" name="xmlSetFeature ()" link="libxml2-parser.html#xmlSetFeature"/>
<keyword type="function" name="xmlSetGenericErrorFunc ()" link="libxml2-xmlerror.html#xmlSetGenericErrorFunc"/>
<keyword type="function" name="xmlSetListDoc ()" link="libxml2-tree.html#xmlSetListDoc"/>
<keyword type="function" name="xmlSetNs ()" link="libxml2-tree.html#xmlSetNs"/>
<keyword type="function" name="xmlSetNsProp ()" link="libxml2-tree.html#xmlSetNsProp"/>
<keyword type="function" name="xmlSetProp ()" link="libxml2-tree.html#xmlSetProp"/>
<keyword type="function" name="xmlSetStructuredErrorFunc ()" link="libxml2-xmlerror.html#xmlSetStructuredErrorFunc"/>
<keyword type="function" name="xmlSetTreeDoc ()" link="libxml2-tree.html#xmlSetTreeDoc"/>
<keyword type="function" name="xmlSetupParserForBuffer ()" link="libxml2-parser.html#xmlSetupParserForBuffer"/>
<keyword type="function" name="xmlShell ()" link="libxml2-debugXML.html#xmlShell"/>
<keyword type="function" name="xmlShellBase ()" link="libxml2-debugXML.html#xmlShellBase"/>
<keyword type="function" name="xmlShellCat ()" link="libxml2-debugXML.html#xmlShellCat"/>
<keyword type="function" name="xmlShellDir ()" link="libxml2-debugXML.html#xmlShellDir"/>
<keyword type="function" name="xmlShellDu ()" link="libxml2-debugXML.html#xmlShellDu"/>
<keyword type="function" name="xmlShellList ()" link="libxml2-debugXML.html#xmlShellList"/>
<keyword type="function" name="xmlShellLoad ()" link="libxml2-debugXML.html#xmlShellLoad"/>
<keyword type="function" name="xmlShellPrintNode ()" link="libxml2-debugXML.html#xmlShellPrintNode"/>
<keyword type="function" name="xmlShellPrintXPathError ()" link="libxml2-debugXML.html#xmlShellPrintXPathError"/>
<keyword type="function" name="xmlShellPrintXPathResult ()" link="libxml2-debugXML.html#xmlShellPrintXPathResult"/>
<keyword type="function" name="xmlShellPwd ()" link="libxml2-debugXML.html#xmlShellPwd"/>
<keyword type="function" name="xmlShellSave ()" link="libxml2-debugXML.html#xmlShellSave"/>
<keyword type="function" name="xmlShellValidate ()" link="libxml2-debugXML.html#xmlShellValidate"/>
<keyword type="function" name="xmlShellWrite ()" link="libxml2-debugXML.html#xmlShellWrite"/>
<keyword type="function" name="xmlSkipBlankChars ()" link="libxml2-parserInternals.html#xmlSkipBlankChars"/>
<keyword type="function" name="xmlSnprintfElementContent ()" link="libxml2-valid.html#xmlSnprintfElementContent"/>
<keyword type="function" name="xmlSplitQName ()" link="libxml2-parserInternals.html#xmlSplitQName"/>
<keyword type="function" name="xmlSplitQName2 ()" link="libxml2-tree.html#xmlSplitQName2"/>
<keyword type="function" name="xmlSplitQName3 ()" link="libxml2-tree.html#xmlSplitQName3"/>
<keyword type="function" name="xmlSprintfElementContent ()" link="libxml2-valid.html#xmlSprintfElementContent"/>
<keyword type="function" name="xmlStopParser ()" link="libxml2-parser.html#xmlStopParser"/>
<keyword type="function" name="xmlStrEqual ()" link="libxml2-xmlstring.html#xmlStrEqual"/>
<keyword type="function" name="xmlStrPrintf ()" link="libxml2-xmlstring.html#xmlStrPrintf"/>
<keyword type="function" name="xmlStrQEqual ()" link="libxml2-xmlstring.html#xmlStrQEqual"/>
<keyword type="function" name="xmlStrVPrintf ()" link="libxml2-xmlstring.html#xmlStrVPrintf"/>
<keyword type="function" name="xmlStrcasecmp ()" link="libxml2-xmlstring.html#xmlStrcasecmp"/>
<keyword type="function" name="xmlStrcasestr ()" link="libxml2-xmlstring.html#xmlStrcasestr"/>
<keyword type="function" name="xmlStrcat ()" link="libxml2-xmlstring.html#xmlStrcat"/>
<keyword type="function" name="xmlStrchr ()" link="libxml2-xmlstring.html#xmlStrchr"/>
<keyword type="function" name="xmlStrcmp ()" link="libxml2-xmlstring.html#xmlStrcmp"/>
<keyword type="function" name="xmlStrdup ()" link="libxml2-xmlstring.html#xmlStrdup"/>
<keyword type="function" name="xmlStreamPop ()" link="libxml2-pattern.html#xmlStreamPop"/>
<keyword type="function" name="xmlStreamPush ()" link="libxml2-pattern.html#xmlStreamPush"/>
<keyword type="function" name="xmlStreamPushAttr ()" link="libxml2-pattern.html#xmlStreamPushAttr"/>
<keyword type="function" name="xmlStreamPushNode ()" link="libxml2-pattern.html#xmlStreamPushNode"/>
<keyword type="function" name="xmlStreamWantsAnyNode ()" link="libxml2-pattern.html#xmlStreamWantsAnyNode"/>
<keyword type="function" name="xmlStringCurrentChar ()" link="libxml2-parserInternals.html#xmlStringCurrentChar"/>
<keyword type="function" name="xmlStringDecodeEntities ()" link="libxml2-parserInternals.html#xmlStringDecodeEntities"/>
<keyword type="function" name="xmlStringGetNodeList ()" link="libxml2-tree.html#xmlStringGetNodeList"/>
<keyword type="function" name="xmlStringLenDecodeEntities ()" link="libxml2-parserInternals.html#xmlStringLenDecodeEntities"/>
<keyword type="function" name="xmlStringLenGetNodeList ()" link="libxml2-tree.html#xmlStringLenGetNodeList"/>
<keyword type="function" name="xmlStrlen ()" link="libxml2-xmlstring.html#xmlStrlen"/>
<keyword type="function" name="xmlStrncasecmp ()" link="libxml2-xmlstring.html#xmlStrncasecmp"/>
<keyword type="function" name="xmlStrncat ()" link="libxml2-xmlstring.html#xmlStrncat"/>
<keyword type="function" name="xmlStrncatNew ()" link="libxml2-xmlstring.html#xmlStrncatNew"/>
<keyword type="function" name="xmlStrncmp ()" link="libxml2-xmlstring.html#xmlStrncmp"/>
<keyword type="function" name="xmlStrndup ()" link="libxml2-xmlstring.html#xmlStrndup"/>
<keyword type="function" name="xmlStrstr ()" link="libxml2-xmlstring.html#xmlStrstr"/>
<keyword type="function" name="xmlStrsub ()" link="libxml2-xmlstring.html#xmlStrsub"/>
<keyword type="function" name="xmlSubstituteEntitiesDefault ()" link="libxml2-parser.html#xmlSubstituteEntitiesDefault"/>
<keyword type="function" name="xmlSwitchEncoding ()" link="libxml2-parserInternals.html#xmlSwitchEncoding"/>
<keyword type="function" name="xmlSwitchInputEncoding ()" link="libxml2-parserInternals.html#xmlSwitchInputEncoding"/>
<keyword type="function" name="xmlSwitchToEncoding ()" link="libxml2-parserInternals.html#xmlSwitchToEncoding"/>
<keyword type="function" name="xmlTextConcat ()" link="libxml2-tree.html#xmlTextConcat"/>
<keyword type="function" name="xmlTextMerge ()" link="libxml2-tree.html#xmlTextMerge"/>
<keyword type="function" name="xmlTextReaderAttributeCount ()" link="libxml2-xmlreader.html#xmlTextReaderAttributeCount"/>
<keyword type="function" name="xmlTextReaderBaseUri ()" link="libxml2-xmlreader.html#xmlTextReaderBaseUri"/>
<keyword type="function" name="xmlTextReaderByteConsumed ()" link="libxml2-xmlreader.html#xmlTextReaderByteConsumed"/>
<keyword type="function" name="xmlTextReaderClose ()" link="libxml2-xmlreader.html#xmlTextReaderClose"/>
<keyword type="function" name="xmlTextReaderConstBaseUri ()" link="libxml2-xmlreader.html#xmlTextReaderConstBaseUri"/>
<keyword type="function" name="xmlTextReaderConstEncoding ()" link="libxml2-xmlreader.html#xmlTextReaderConstEncoding"/>
<keyword type="function" name="xmlTextReaderConstLocalName ()" link="libxml2-xmlreader.html#xmlTextReaderConstLocalName"/>
<keyword type="function" name="xmlTextReaderConstName ()" link="libxml2-xmlreader.html#xmlTextReaderConstName"/>
<keyword type="function" name="xmlTextReaderConstNamespaceUri ()" link="libxml2-xmlreader.html#xmlTextReaderConstNamespaceUri"/>
<keyword type="function" name="xmlTextReaderConstPrefix ()" link="libxml2-xmlreader.html#xmlTextReaderConstPrefix"/>
<keyword type="function" name="xmlTextReaderConstString ()" link="libxml2-xmlreader.html#xmlTextReaderConstString"/>
<keyword type="function" name="xmlTextReaderConstValue ()" link="libxml2-xmlreader.html#xmlTextReaderConstValue"/>
<keyword type="function" name="xmlTextReaderConstXmlLang ()" link="libxml2-xmlreader.html#xmlTextReaderConstXmlLang"/>
<keyword type="function" name="xmlTextReaderConstXmlVersion ()" link="libxml2-xmlreader.html#xmlTextReaderConstXmlVersion"/>
<keyword type="function" name="xmlTextReaderCurrentDoc ()" link="libxml2-xmlreader.html#xmlTextReaderCurrentDoc"/>
<keyword type="function" name="xmlTextReaderCurrentNode ()" link="libxml2-xmlreader.html#xmlTextReaderCurrentNode"/>
<keyword type="function" name="xmlTextReaderDepth ()" link="libxml2-xmlreader.html#xmlTextReaderDepth"/>
<keyword type="function" name="xmlTextReaderExpand ()" link="libxml2-xmlreader.html#xmlTextReaderExpand"/>
<keyword type="function" name="xmlTextReaderGetAttribute ()" link="libxml2-xmlreader.html#xmlTextReaderGetAttribute"/>
<keyword type="function" name="xmlTextReaderGetAttributeNo ()" link="libxml2-xmlreader.html#xmlTextReaderGetAttributeNo"/>
<keyword type="function" name="xmlTextReaderGetAttributeNs ()" link="libxml2-xmlreader.html#xmlTextReaderGetAttributeNs"/>
<keyword type="function" name="xmlTextReaderGetErrorHandler ()" link="libxml2-xmlreader.html#xmlTextReaderGetErrorHandler"/>
<keyword type="function" name="xmlTextReaderGetParserColumnNumber ()" link="libxml2-xmlreader.html#xmlTextReaderGetParserColumnNumber"/>
<keyword type="function" name="xmlTextReaderGetParserLineNumber ()" link="libxml2-xmlreader.html#xmlTextReaderGetParserLineNumber"/>
<keyword type="function" name="xmlTextReaderGetParserProp ()" link="libxml2-xmlreader.html#xmlTextReaderGetParserProp"/>
<keyword type="function" name="xmlTextReaderGetRemainder ()" link="libxml2-xmlreader.html#xmlTextReaderGetRemainder"/>
<keyword type="function" name="xmlTextReaderHasAttributes ()" link="libxml2-xmlreader.html#xmlTextReaderHasAttributes"/>
<keyword type="function" name="xmlTextReaderHasValue ()" link="libxml2-xmlreader.html#xmlTextReaderHasValue"/>
<keyword type="function" name="xmlTextReaderIsDefault ()" link="libxml2-xmlreader.html#xmlTextReaderIsDefault"/>
<keyword type="function" name="xmlTextReaderIsEmptyElement ()" link="libxml2-xmlreader.html#xmlTextReaderIsEmptyElement"/>
<keyword type="function" name="xmlTextReaderIsNamespaceDecl ()" link="libxml2-xmlreader.html#xmlTextReaderIsNamespaceDecl"/>
<keyword type="function" name="xmlTextReaderIsValid ()" link="libxml2-xmlreader.html#xmlTextReaderIsValid"/>
<keyword type="function" name="xmlTextReaderLocalName ()" link="libxml2-xmlreader.html#xmlTextReaderLocalName"/>
<keyword type="function" name="xmlTextReaderLocatorBaseURI ()" link="libxml2-xmlreader.html#xmlTextReaderLocatorBaseURI"/>
<keyword type="function" name="xmlTextReaderLocatorLineNumber ()" link="libxml2-xmlreader.html#xmlTextReaderLocatorLineNumber"/>
<keyword type="function" name="xmlTextReaderLookupNamespace ()" link="libxml2-xmlreader.html#xmlTextReaderLookupNamespace"/>
<keyword type="function" name="xmlTextReaderMoveToAttribute ()" link="libxml2-xmlreader.html#xmlTextReaderMoveToAttribute"/>
<keyword type="function" name="xmlTextReaderMoveToAttributeNo ()" link="libxml2-xmlreader.html#xmlTextReaderMoveToAttributeNo"/>
<keyword type="function" name="xmlTextReaderMoveToAttributeNs ()" link="libxml2-xmlreader.html#xmlTextReaderMoveToAttributeNs"/>
<keyword type="function" name="xmlTextReaderMoveToElement ()" link="libxml2-xmlreader.html#xmlTextReaderMoveToElement"/>
<keyword type="function" name="xmlTextReaderMoveToFirstAttribute ()" link="libxml2-xmlreader.html#xmlTextReaderMoveToFirstAttribute"/>
<keyword type="function" name="xmlTextReaderMoveToNextAttribute ()" link="libxml2-xmlreader.html#xmlTextReaderMoveToNextAttribute"/>
<keyword type="function" name="xmlTextReaderName ()" link="libxml2-xmlreader.html#xmlTextReaderName"/>
<keyword type="function" name="xmlTextReaderNamespaceUri ()" link="libxml2-xmlreader.html#xmlTextReaderNamespaceUri"/>
<keyword type="function" name="xmlTextReaderNext ()" link="libxml2-xmlreader.html#xmlTextReaderNext"/>
<keyword type="function" name="xmlTextReaderNextSibling ()" link="libxml2-xmlreader.html#xmlTextReaderNextSibling"/>
<keyword type="function" name="xmlTextReaderNodeType ()" link="libxml2-xmlreader.html#xmlTextReaderNodeType"/>
<keyword type="function" name="xmlTextReaderNormalization ()" link="libxml2-xmlreader.html#xmlTextReaderNormalization"/>
<keyword type="function" name="xmlTextReaderPrefix ()" link="libxml2-xmlreader.html#xmlTextReaderPrefix"/>
<keyword type="function" name="xmlTextReaderPreserve ()" link="libxml2-xmlreader.html#xmlTextReaderPreserve"/>
<keyword type="function" name="xmlTextReaderPreservePattern ()" link="libxml2-xmlreader.html#xmlTextReaderPreservePattern"/>
<keyword type="function" name="xmlTextReaderQuoteChar ()" link="libxml2-xmlreader.html#xmlTextReaderQuoteChar"/>
<keyword type="function" name="xmlTextReaderRead ()" link="libxml2-xmlreader.html#xmlTextReaderRead"/>
<keyword type="function" name="xmlTextReaderReadAttributeValue ()" link="libxml2-xmlreader.html#xmlTextReaderReadAttributeValue"/>
<keyword type="function" name="xmlTextReaderReadInnerXml ()" link="libxml2-xmlreader.html#xmlTextReaderReadInnerXml"/>
<keyword type="function" name="xmlTextReaderReadOuterXml ()" link="libxml2-xmlreader.html#xmlTextReaderReadOuterXml"/>
<keyword type="function" name="xmlTextReaderReadState ()" link="libxml2-xmlreader.html#xmlTextReaderReadState"/>
<keyword type="function" name="xmlTextReaderReadString ()" link="libxml2-xmlreader.html#xmlTextReaderReadString"/>
<keyword type="function" name="xmlTextReaderRelaxNGSetSchema ()" link="libxml2-xmlreader.html#xmlTextReaderRelaxNGSetSchema"/>
<keyword type="function" name="xmlTextReaderRelaxNGValidate ()" link="libxml2-xmlreader.html#xmlTextReaderRelaxNGValidate"/>
<keyword type="function" name="xmlTextReaderRelaxNGValidateCtxt ()" link="libxml2-xmlreader.html#xmlTextReaderRelaxNGValidateCtxt"/>
<keyword type="function" name="xmlTextReaderSchemaValidate ()" link="libxml2-xmlreader.html#xmlTextReaderSchemaValidate"/>
<keyword type="function" name="xmlTextReaderSchemaValidateCtxt ()" link="libxml2-xmlreader.html#xmlTextReaderSchemaValidateCtxt"/>
<keyword type="function" name="xmlTextReaderSetErrorHandler ()" link="libxml2-xmlreader.html#xmlTextReaderSetErrorHandler"/>
<keyword type="function" name="xmlTextReaderSetParserProp ()" link="libxml2-xmlreader.html#xmlTextReaderSetParserProp"/>
<keyword type="function" name="xmlTextReaderSetSchema ()" link="libxml2-xmlreader.html#xmlTextReaderSetSchema"/>
<keyword type="function" name="xmlTextReaderSetStructuredErrorHandler ()" link="libxml2-xmlreader.html#xmlTextReaderSetStructuredErrorHandler"/>
<keyword type="function" name="xmlTextReaderSetup ()" link="libxml2-xmlreader.html#xmlTextReaderSetup"/>
<keyword type="function" name="xmlTextReaderStandalone ()" link="libxml2-xmlreader.html#xmlTextReaderStandalone"/>
<keyword type="function" name="xmlTextReaderValue ()" link="libxml2-xmlreader.html#xmlTextReaderValue"/>
<keyword type="function" name="xmlTextReaderXmlLang ()" link="libxml2-xmlreader.html#xmlTextReaderXmlLang"/>
<keyword type="function" name="xmlTextWriterEndAttribute ()" link="libxml2-xmlwriter.html#xmlTextWriterEndAttribute"/>
<keyword type="function" name="xmlTextWriterEndCDATA ()" link="libxml2-xmlwriter.html#xmlTextWriterEndCDATA"/>
<keyword type="function" name="xmlTextWriterEndComment ()" link="libxml2-xmlwriter.html#xmlTextWriterEndComment"/>
<keyword type="function" name="xmlTextWriterEndDTD ()" link="libxml2-xmlwriter.html#xmlTextWriterEndDTD"/>
<keyword type="function" name="xmlTextWriterEndDTDAttlist ()" link="libxml2-xmlwriter.html#xmlTextWriterEndDTDAttlist"/>
<keyword type="function" name="xmlTextWriterEndDTDElement ()" link="libxml2-xmlwriter.html#xmlTextWriterEndDTDElement"/>
<keyword type="function" name="xmlTextWriterEndDTDEntity ()" link="libxml2-xmlwriter.html#xmlTextWriterEndDTDEntity"/>
<keyword type="function" name="xmlTextWriterEndDocument ()" link="libxml2-xmlwriter.html#xmlTextWriterEndDocument"/>
<keyword type="function" name="xmlTextWriterEndElement ()" link="libxml2-xmlwriter.html#xmlTextWriterEndElement"/>
<keyword type="function" name="xmlTextWriterEndPI ()" link="libxml2-xmlwriter.html#xmlTextWriterEndPI"/>
<keyword type="function" name="xmlTextWriterFlush ()" link="libxml2-xmlwriter.html#xmlTextWriterFlush"/>
<keyword type="function" name="xmlTextWriterFullEndElement ()" link="libxml2-xmlwriter.html#xmlTextWriterFullEndElement"/>
<keyword type="function" name="xmlTextWriterSetIndent ()" link="libxml2-xmlwriter.html#xmlTextWriterSetIndent"/>
<keyword type="function" name="xmlTextWriterSetIndentString ()" link="libxml2-xmlwriter.html#xmlTextWriterSetIndentString"/>
<keyword type="function" name="xmlTextWriterSetQuoteChar ()" link="libxml2-xmlwriter.html#xmlTextWriterSetQuoteChar"/>
<keyword type="function" name="xmlTextWriterStartAttribute ()" link="libxml2-xmlwriter.html#xmlTextWriterStartAttribute"/>
<keyword type="function" name="xmlTextWriterStartAttributeNS ()" link="libxml2-xmlwriter.html#xmlTextWriterStartAttributeNS"/>
<keyword type="function" name="xmlTextWriterStartCDATA ()" link="libxml2-xmlwriter.html#xmlTextWriterStartCDATA"/>
<keyword type="function" name="xmlTextWriterStartComment ()" link="libxml2-xmlwriter.html#xmlTextWriterStartComment"/>
<keyword type="function" name="xmlTextWriterStartDTD ()" link="libxml2-xmlwriter.html#xmlTextWriterStartDTD"/>
<keyword type="function" name="xmlTextWriterStartDTDAttlist ()" link="libxml2-xmlwriter.html#xmlTextWriterStartDTDAttlist"/>
<keyword type="function" name="xmlTextWriterStartDTDElement ()" link="libxml2-xmlwriter.html#xmlTextWriterStartDTDElement"/>
<keyword type="function" name="xmlTextWriterStartDTDEntity ()" link="libxml2-xmlwriter.html#xmlTextWriterStartDTDEntity"/>
<keyword type="function" name="xmlTextWriterStartDocument ()" link="libxml2-xmlwriter.html#xmlTextWriterStartDocument"/>
<keyword type="function" name="xmlTextWriterStartElement ()" link="libxml2-xmlwriter.html#xmlTextWriterStartElement"/>
<keyword type="function" name="xmlTextWriterStartElementNS ()" link="libxml2-xmlwriter.html#xmlTextWriterStartElementNS"/>
<keyword type="function" name="xmlTextWriterStartPI ()" link="libxml2-xmlwriter.html#xmlTextWriterStartPI"/>
<keyword type="function" name="xmlTextWriterWriteAttribute ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteAttribute"/>
<keyword type="function" name="xmlTextWriterWriteAttributeNS ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteAttributeNS"/>
<keyword type="function" name="xmlTextWriterWriteBase64 ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteBase64"/>
<keyword type="function" name="xmlTextWriterWriteBinHex ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteBinHex"/>
<keyword type="function" name="xmlTextWriterWriteCDATA ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteCDATA"/>
<keyword type="function" name="xmlTextWriterWriteComment ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteComment"/>
<keyword type="function" name="xmlTextWriterWriteDTD ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteDTD"/>
<keyword type="function" name="xmlTextWriterWriteDTDAttlist ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteDTDAttlist"/>
<keyword type="function" name="xmlTextWriterWriteDTDElement ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteDTDElement"/>
<keyword type="function" name="xmlTextWriterWriteDTDEntity ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteDTDEntity"/>
<keyword type="function" name="xmlTextWriterWriteDTDExternalEntity ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteDTDExternalEntity"/>
<keyword type="function" name="xmlTextWriterWriteDTDExternalEntityContents ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteDTDExternalEntityContents"/>
<keyword type="function" name="xmlTextWriterWriteDTDInternalEntity ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteDTDInternalEntity"/>
<keyword type="function" name="xmlTextWriterWriteDTDNotation ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteDTDNotation"/>
<keyword type="function" name="xmlTextWriterWriteElement ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteElement"/>
<keyword type="function" name="xmlTextWriterWriteElementNS ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteElementNS"/>
<keyword type="function" name="xmlTextWriterWriteFormatAttribute ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteFormatAttribute"/>
<keyword type="function" name="xmlTextWriterWriteFormatAttributeNS ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteFormatAttributeNS"/>
<keyword type="function" name="xmlTextWriterWriteFormatCDATA ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteFormatCDATA"/>
<keyword type="function" name="xmlTextWriterWriteFormatComment ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteFormatComment"/>
<keyword type="function" name="xmlTextWriterWriteFormatDTD ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteFormatDTD"/>
<keyword type="function" name="xmlTextWriterWriteFormatDTDAttlist ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteFormatDTDAttlist"/>
<keyword type="function" name="xmlTextWriterWriteFormatDTDElement ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteFormatDTDElement"/>
<keyword type="function" name="xmlTextWriterWriteFormatDTDInternalEntity ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteFormatDTDInternalEntity"/>
<keyword type="function" name="xmlTextWriterWriteFormatElement ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteFormatElement"/>
<keyword type="function" name="xmlTextWriterWriteFormatElementNS ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteFormatElementNS"/>
<keyword type="function" name="xmlTextWriterWriteFormatPI ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteFormatPI"/>
<keyword type="function" name="xmlTextWriterWriteFormatRaw ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteFormatRaw"/>
<keyword type="function" name="xmlTextWriterWriteFormatString ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteFormatString"/>
<keyword type="function" name="xmlTextWriterWritePI ()" link="libxml2-xmlwriter.html#xmlTextWriterWritePI"/>
<keyword type="function" name="xmlTextWriterWriteRaw ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteRaw"/>
<keyword type="function" name="xmlTextWriterWriteRawLen ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteRawLen"/>
<keyword type="function" name="xmlTextWriterWriteString ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteString"/>
<keyword type="function" name="xmlTextWriterWriteVFormatAttribute ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteVFormatAttribute"/>
<keyword type="function" name="xmlTextWriterWriteVFormatAttributeNS ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteVFormatAttributeNS"/>
<keyword type="function" name="xmlTextWriterWriteVFormatCDATA ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteVFormatCDATA"/>
<keyword type="function" name="xmlTextWriterWriteVFormatComment ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteVFormatComment"/>
<keyword type="function" name="xmlTextWriterWriteVFormatDTD ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteVFormatDTD"/>
<keyword type="function" name="xmlTextWriterWriteVFormatDTDAttlist ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteVFormatDTDAttlist"/>
<keyword type="function" name="xmlTextWriterWriteVFormatDTDElement ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteVFormatDTDElement"/>
<keyword type="function" name="xmlTextWriterWriteVFormatDTDInternalEntity ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteVFormatDTDInternalEntity"/>
<keyword type="function" name="xmlTextWriterWriteVFormatElement ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteVFormatElement"/>
<keyword type="function" name="xmlTextWriterWriteVFormatElementNS ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteVFormatElementNS"/>
<keyword type="function" name="xmlTextWriterWriteVFormatPI ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteVFormatPI"/>
<keyword type="function" name="xmlTextWriterWriteVFormatRaw ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteVFormatRaw"/>
<keyword type="function" name="xmlTextWriterWriteVFormatString ()" link="libxml2-xmlwriter.html#xmlTextWriterWriteVFormatString"/>
<keyword type="function" name="xmlThrDefBufferAllocScheme ()" link="libxml2-globals.html#xmlThrDefBufferAllocScheme"/>
<keyword type="function" name="xmlThrDefDefaultBufferSize ()" link="libxml2-globals.html#xmlThrDefDefaultBufferSize"/>
<keyword type="function" name="xmlThrDefDeregisterNodeDefault ()" link="libxml2-globals.html#xmlThrDefDeregisterNodeDefault"/>
<keyword type="function" name="xmlThrDefDoValidityCheckingDefaultValue ()" link="libxml2-globals.html#xmlThrDefDoValidityCheckingDefaultValue"/>
<keyword type="function" name="xmlThrDefGetWarningsDefaultValue ()" link="libxml2-globals.html#xmlThrDefGetWarningsDefaultValue"/>
<keyword type="function" name="xmlThrDefIndentTreeOutput ()" link="libxml2-globals.html#xmlThrDefIndentTreeOutput"/>
<keyword type="function" name="xmlThrDefKeepBlanksDefaultValue ()" link="libxml2-globals.html#xmlThrDefKeepBlanksDefaultValue"/>
<keyword type="function" name="xmlThrDefLineNumbersDefaultValue ()" link="libxml2-globals.html#xmlThrDefLineNumbersDefaultValue"/>
<keyword type="function" name="xmlThrDefLoadExtDtdDefaultValue ()" link="libxml2-globals.html#xmlThrDefLoadExtDtdDefaultValue"/>
<keyword type="function" name="xmlThrDefOutputBufferCreateFilenameDefault ()" link="libxml2-globals.html#xmlThrDefOutputBufferCreateFilenameDefault"/>
<keyword type="function" name="xmlThrDefParserDebugEntities ()" link="libxml2-globals.html#xmlThrDefParserDebugEntities"/>
<keyword type="function" name="xmlThrDefParserInputBufferCreateFilenameDefault ()" link="libxml2-globals.html#xmlThrDefParserInputBufferCreateFilenameDefault"/>
<keyword type="function" name="xmlThrDefPedanticParserDefaultValue ()" link="libxml2-globals.html#xmlThrDefPedanticParserDefaultValue"/>
<keyword type="function" name="xmlThrDefRegisterNodeDefault ()" link="libxml2-globals.html#xmlThrDefRegisterNodeDefault"/>
<keyword type="function" name="xmlThrDefSaveNoEmptyTags ()" link="libxml2-globals.html#xmlThrDefSaveNoEmptyTags"/>
<keyword type="function" name="xmlThrDefSetGenericErrorFunc ()" link="libxml2-globals.html#xmlThrDefSetGenericErrorFunc"/>
<keyword type="function" name="xmlThrDefSetStructuredErrorFunc ()" link="libxml2-globals.html#xmlThrDefSetStructuredErrorFunc"/>
<keyword type="function" name="xmlThrDefSubstituteEntitiesDefaultValue ()" link="libxml2-globals.html#xmlThrDefSubstituteEntitiesDefaultValue"/>
<keyword type="function" name="xmlThrDefTreeIndentString ()" link="libxml2-globals.html#xmlThrDefTreeIndentString"/>
<keyword type="function" name="xmlUCSIsAegeanNumbers ()" link="libxml2-xmlunicode.html#xmlUCSIsAegeanNumbers"/>
<keyword type="function" name="xmlUCSIsAlphabeticPresentationForms ()" link="libxml2-xmlunicode.html#xmlUCSIsAlphabeticPresentationForms"/>
<keyword type="function" name="xmlUCSIsArabic ()" link="libxml2-xmlunicode.html#xmlUCSIsArabic"/>
<keyword type="function" name="xmlUCSIsArabicPresentationFormsA ()" link="libxml2-xmlunicode.html#xmlUCSIsArabicPresentationFormsA"/>
<keyword type="function" name="xmlUCSIsArabicPresentationFormsB ()" link="libxml2-xmlunicode.html#xmlUCSIsArabicPresentationFormsB"/>
<keyword type="function" name="xmlUCSIsArmenian ()" link="libxml2-xmlunicode.html#xmlUCSIsArmenian"/>
<keyword type="function" name="xmlUCSIsArrows ()" link="libxml2-xmlunicode.html#xmlUCSIsArrows"/>
<keyword type="function" name="xmlUCSIsBasicLatin ()" link="libxml2-xmlunicode.html#xmlUCSIsBasicLatin"/>
<keyword type="function" name="xmlUCSIsBengali ()" link="libxml2-xmlunicode.html#xmlUCSIsBengali"/>
<keyword type="function" name="xmlUCSIsBlock ()" link="libxml2-xmlunicode.html#xmlUCSIsBlock"/>
<keyword type="function" name="xmlUCSIsBlockElements ()" link="libxml2-xmlunicode.html#xmlUCSIsBlockElements"/>
<keyword type="function" name="xmlUCSIsBopomofo ()" link="libxml2-xmlunicode.html#xmlUCSIsBopomofo"/>
<keyword type="function" name="xmlUCSIsBopomofoExtended ()" link="libxml2-xmlunicode.html#xmlUCSIsBopomofoExtended"/>
<keyword type="function" name="xmlUCSIsBoxDrawing ()" link="libxml2-xmlunicode.html#xmlUCSIsBoxDrawing"/>
<keyword type="function" name="xmlUCSIsBraillePatterns ()" link="libxml2-xmlunicode.html#xmlUCSIsBraillePatterns"/>
<keyword type="function" name="xmlUCSIsBuhid ()" link="libxml2-xmlunicode.html#xmlUCSIsBuhid"/>
<keyword type="function" name="xmlUCSIsByzantineMusicalSymbols ()" link="libxml2-xmlunicode.html#xmlUCSIsByzantineMusicalSymbols"/>
<keyword type="function" name="xmlUCSIsCJKCompatibility ()" link="libxml2-xmlunicode.html#xmlUCSIsCJKCompatibility"/>
<keyword type="function" name="xmlUCSIsCJKCompatibilityForms ()" link="libxml2-xmlunicode.html#xmlUCSIsCJKCompatibilityForms"/>
<keyword type="function" name="xmlUCSIsCJKCompatibilityIdeographs ()" link="libxml2-xmlunicode.html#xmlUCSIsCJKCompatibilityIdeographs"/>
<keyword type="function" name="xmlUCSIsCJKCompatibilityIdeographsSupplement ()" link="libxml2-xmlunicode.html#xmlUCSIsCJKCompatibilityIdeographsSupplement"/>
<keyword type="function" name="xmlUCSIsCJKRadicalsSupplement ()" link="libxml2-xmlunicode.html#xmlUCSIsCJKRadicalsSupplement"/>
<keyword type="function" name="xmlUCSIsCJKSymbolsandPunctuation ()" link="libxml2-xmlunicode.html#xmlUCSIsCJKSymbolsandPunctuation"/>
<keyword type="function" name="xmlUCSIsCJKUnifiedIdeographs ()" link="libxml2-xmlunicode.html#xmlUCSIsCJKUnifiedIdeographs"/>
<keyword type="function" name="xmlUCSIsCJKUnifiedIdeographsExtensionA ()" link="libxml2-xmlunicode.html#xmlUCSIsCJKUnifiedIdeographsExtensionA"/>
<keyword type="function" name="xmlUCSIsCJKUnifiedIdeographsExtensionB ()" link="libxml2-xmlunicode.html#xmlUCSIsCJKUnifiedIdeographsExtensionB"/>
<keyword type="function" name="xmlUCSIsCat ()" link="libxml2-xmlunicode.html#xmlUCSIsCat"/>
<keyword type="function" name="xmlUCSIsCatC ()" link="libxml2-xmlunicode.html#xmlUCSIsCatC"/>
<keyword type="function" name="xmlUCSIsCatCc ()" link="libxml2-xmlunicode.html#xmlUCSIsCatCc"/>
<keyword type="function" name="xmlUCSIsCatCf ()" link="libxml2-xmlunicode.html#xmlUCSIsCatCf"/>
<keyword type="function" name="xmlUCSIsCatCo ()" link="libxml2-xmlunicode.html#xmlUCSIsCatCo"/>
<keyword type="function" name="xmlUCSIsCatCs ()" link="libxml2-xmlunicode.html#xmlUCSIsCatCs"/>
<keyword type="function" name="xmlUCSIsCatL ()" link="libxml2-xmlunicode.html#xmlUCSIsCatL"/>
<keyword type="function" name="xmlUCSIsCatLl ()" link="libxml2-xmlunicode.html#xmlUCSIsCatLl"/>
<keyword type="function" name="xmlUCSIsCatLm ()" link="libxml2-xmlunicode.html#xmlUCSIsCatLm"/>
<keyword type="function" name="xmlUCSIsCatLo ()" link="libxml2-xmlunicode.html#xmlUCSIsCatLo"/>
<keyword type="function" name="xmlUCSIsCatLt ()" link="libxml2-xmlunicode.html#xmlUCSIsCatLt"/>
<keyword type="function" name="xmlUCSIsCatLu ()" link="libxml2-xmlunicode.html#xmlUCSIsCatLu"/>
<keyword type="function" name="xmlUCSIsCatM ()" link="libxml2-xmlunicode.html#xmlUCSIsCatM"/>
<keyword type="function" name="xmlUCSIsCatMc ()" link="libxml2-xmlunicode.html#xmlUCSIsCatMc"/>
<keyword type="function" name="xmlUCSIsCatMe ()" link="libxml2-xmlunicode.html#xmlUCSIsCatMe"/>
<keyword type="function" name="xmlUCSIsCatMn ()" link="libxml2-xmlunicode.html#xmlUCSIsCatMn"/>
<keyword type="function" name="xmlUCSIsCatN ()" link="libxml2-xmlunicode.html#xmlUCSIsCatN"/>
<keyword type="function" name="xmlUCSIsCatNd ()" link="libxml2-xmlunicode.html#xmlUCSIsCatNd"/>
<keyword type="function" name="xmlUCSIsCatNl ()" link="libxml2-xmlunicode.html#xmlUCSIsCatNl"/>
<keyword type="function" name="xmlUCSIsCatNo ()" link="libxml2-xmlunicode.html#xmlUCSIsCatNo"/>
<keyword type="function" name="xmlUCSIsCatP ()" link="libxml2-xmlunicode.html#xmlUCSIsCatP"/>
<keyword type="function" name="xmlUCSIsCatPc ()" link="libxml2-xmlunicode.html#xmlUCSIsCatPc"/>
<keyword type="function" name="xmlUCSIsCatPd ()" link="libxml2-xmlunicode.html#xmlUCSIsCatPd"/>
<keyword type="function" name="xmlUCSIsCatPe ()" link="libxml2-xmlunicode.html#xmlUCSIsCatPe"/>
<keyword type="function" name="xmlUCSIsCatPf ()" link="libxml2-xmlunicode.html#xmlUCSIsCatPf"/>
<keyword type="function" name="xmlUCSIsCatPi ()" link="libxml2-xmlunicode.html#xmlUCSIsCatPi"/>
<keyword type="function" name="xmlUCSIsCatPo ()" link="libxml2-xmlunicode.html#xmlUCSIsCatPo"/>
<keyword type="function" name="xmlUCSIsCatPs ()" link="libxml2-xmlunicode.html#xmlUCSIsCatPs"/>
<keyword type="function" name="xmlUCSIsCatS ()" link="libxml2-xmlunicode.html#xmlUCSIsCatS"/>
<keyword type="function" name="xmlUCSIsCatSc ()" link="libxml2-xmlunicode.html#xmlUCSIsCatSc"/>
<keyword type="function" name="xmlUCSIsCatSk ()" link="libxml2-xmlunicode.html#xmlUCSIsCatSk"/>
<keyword type="function" name="xmlUCSIsCatSm ()" link="libxml2-xmlunicode.html#xmlUCSIsCatSm"/>
<keyword type="function" name="xmlUCSIsCatSo ()" link="libxml2-xmlunicode.html#xmlUCSIsCatSo"/>
<keyword type="function" name="xmlUCSIsCatZ ()" link="libxml2-xmlunicode.html#xmlUCSIsCatZ"/>
<keyword type="function" name="xmlUCSIsCatZl ()" link="libxml2-xmlunicode.html#xmlUCSIsCatZl"/>
<keyword type="function" name="xmlUCSIsCatZp ()" link="libxml2-xmlunicode.html#xmlUCSIsCatZp"/>
<keyword type="function" name="xmlUCSIsCatZs ()" link="libxml2-xmlunicode.html#xmlUCSIsCatZs"/>
<keyword type="function" name="xmlUCSIsCherokee ()" link="libxml2-xmlunicode.html#xmlUCSIsCherokee"/>
<keyword type="function" name="xmlUCSIsCombiningDiacriticalMarks ()" link="libxml2-xmlunicode.html#xmlUCSIsCombiningDiacriticalMarks"/>
<keyword type="function" name="xmlUCSIsCombiningDiacriticalMarksforSymbols ()" link="libxml2-xmlunicode.html#xmlUCSIsCombiningDiacriticalMarksforSymbols"/>
<keyword type="function" name="xmlUCSIsCombiningHalfMarks ()" link="libxml2-xmlunicode.html#xmlUCSIsCombiningHalfMarks"/>
<keyword type="function" name="xmlUCSIsCombiningMarksforSymbols ()" link="libxml2-xmlunicode.html#xmlUCSIsCombiningMarksforSymbols"/>
<keyword type="function" name="xmlUCSIsControlPictures ()" link="libxml2-xmlunicode.html#xmlUCSIsControlPictures"/>
<keyword type="function" name="xmlUCSIsCurrencySymbols ()" link="libxml2-xmlunicode.html#xmlUCSIsCurrencySymbols"/>
<keyword type="function" name="xmlUCSIsCypriotSyllabary ()" link="libxml2-xmlunicode.html#xmlUCSIsCypriotSyllabary"/>
<keyword type="function" name="xmlUCSIsCyrillic ()" link="libxml2-xmlunicode.html#xmlUCSIsCyrillic"/>
<keyword type="function" name="xmlUCSIsCyrillicSupplement ()" link="libxml2-xmlunicode.html#xmlUCSIsCyrillicSupplement"/>
<keyword type="function" name="xmlUCSIsDeseret ()" link="libxml2-xmlunicode.html#xmlUCSIsDeseret"/>
<keyword type="function" name="xmlUCSIsDevanagari ()" link="libxml2-xmlunicode.html#xmlUCSIsDevanagari"/>
<keyword type="function" name="xmlUCSIsDingbats ()" link="libxml2-xmlunicode.html#xmlUCSIsDingbats"/>
<keyword type="function" name="xmlUCSIsEnclosedAlphanumerics ()" link="libxml2-xmlunicode.html#xmlUCSIsEnclosedAlphanumerics"/>
<keyword type="function" name="xmlUCSIsEnclosedCJKLettersandMonths ()" link="libxml2-xmlunicode.html#xmlUCSIsEnclosedCJKLettersandMonths"/>
<keyword type="function" name="xmlUCSIsEthiopic ()" link="libxml2-xmlunicode.html#xmlUCSIsEthiopic"/>
<keyword type="function" name="xmlUCSIsGeneralPunctuation ()" link="libxml2-xmlunicode.html#xmlUCSIsGeneralPunctuation"/>
<keyword type="function" name="xmlUCSIsGeometricShapes ()" link="libxml2-xmlunicode.html#xmlUCSIsGeometricShapes"/>
<keyword type="function" name="xmlUCSIsGeorgian ()" link="libxml2-xmlunicode.html#xmlUCSIsGeorgian"/>
<keyword type="function" name="xmlUCSIsGothic ()" link="libxml2-xmlunicode.html#xmlUCSIsGothic"/>
<keyword type="function" name="xmlUCSIsGreek ()" link="libxml2-xmlunicode.html#xmlUCSIsGreek"/>
<keyword type="function" name="xmlUCSIsGreekExtended ()" link="libxml2-xmlunicode.html#xmlUCSIsGreekExtended"/>
<keyword type="function" name="xmlUCSIsGreekandCoptic ()" link="libxml2-xmlunicode.html#xmlUCSIsGreekandCoptic"/>
<keyword type="function" name="xmlUCSIsGujarati ()" link="libxml2-xmlunicode.html#xmlUCSIsGujarati"/>
<keyword type="function" name="xmlUCSIsGurmukhi ()" link="libxml2-xmlunicode.html#xmlUCSIsGurmukhi"/>
<keyword type="function" name="xmlUCSIsHalfwidthandFullwidthForms ()" link="libxml2-xmlunicode.html#xmlUCSIsHalfwidthandFullwidthForms"/>
<keyword type="function" name="xmlUCSIsHangulCompatibilityJamo ()" link="libxml2-xmlunicode.html#xmlUCSIsHangulCompatibilityJamo"/>
<keyword type="function" name="xmlUCSIsHangulJamo ()" link="libxml2-xmlunicode.html#xmlUCSIsHangulJamo"/>
<keyword type="function" name="xmlUCSIsHangulSyllables ()" link="libxml2-xmlunicode.html#xmlUCSIsHangulSyllables"/>
<keyword type="function" name="xmlUCSIsHanunoo ()" link="libxml2-xmlunicode.html#xmlUCSIsHanunoo"/>
<keyword type="function" name="xmlUCSIsHebrew ()" link="libxml2-xmlunicode.html#xmlUCSIsHebrew"/>
<keyword type="function" name="xmlUCSIsHighPrivateUseSurrogates ()" link="libxml2-xmlunicode.html#xmlUCSIsHighPrivateUseSurrogates"/>
<keyword type="function" name="xmlUCSIsHighSurrogates ()" link="libxml2-xmlunicode.html#xmlUCSIsHighSurrogates"/>
<keyword type="function" name="xmlUCSIsHiragana ()" link="libxml2-xmlunicode.html#xmlUCSIsHiragana"/>
<keyword type="function" name="xmlUCSIsIPAExtensions ()" link="libxml2-xmlunicode.html#xmlUCSIsIPAExtensions"/>
<keyword type="function" name="xmlUCSIsIdeographicDescriptionCharacters ()" link="libxml2-xmlunicode.html#xmlUCSIsIdeographicDescriptionCharacters"/>
<keyword type="function" name="xmlUCSIsKanbun ()" link="libxml2-xmlunicode.html#xmlUCSIsKanbun"/>
<keyword type="function" name="xmlUCSIsKangxiRadicals ()" link="libxml2-xmlunicode.html#xmlUCSIsKangxiRadicals"/>
<keyword type="function" name="xmlUCSIsKannada ()" link="libxml2-xmlunicode.html#xmlUCSIsKannada"/>
<keyword type="function" name="xmlUCSIsKatakana ()" link="libxml2-xmlunicode.html#xmlUCSIsKatakana"/>
<keyword type="function" name="xmlUCSIsKatakanaPhoneticExtensions ()" link="libxml2-xmlunicode.html#xmlUCSIsKatakanaPhoneticExtensions"/>
<keyword type="function" name="xmlUCSIsKhmer ()" link="libxml2-xmlunicode.html#xmlUCSIsKhmer"/>
<keyword type="function" name="xmlUCSIsKhmerSymbols ()" link="libxml2-xmlunicode.html#xmlUCSIsKhmerSymbols"/>
<keyword type="function" name="xmlUCSIsLao ()" link="libxml2-xmlunicode.html#xmlUCSIsLao"/>
<keyword type="function" name="xmlUCSIsLatin1Supplement ()" link="libxml2-xmlunicode.html#xmlUCSIsLatin1Supplement"/>
<keyword type="function" name="xmlUCSIsLatinExtendedA ()" link="libxml2-xmlunicode.html#xmlUCSIsLatinExtendedA"/>
<keyword type="function" name="xmlUCSIsLatinExtendedAdditional ()" link="libxml2-xmlunicode.html#xmlUCSIsLatinExtendedAdditional"/>
<keyword type="function" name="xmlUCSIsLatinExtendedB ()" link="libxml2-xmlunicode.html#xmlUCSIsLatinExtendedB"/>
<keyword type="function" name="xmlUCSIsLetterlikeSymbols ()" link="libxml2-xmlunicode.html#xmlUCSIsLetterlikeSymbols"/>
<keyword type="function" name="xmlUCSIsLimbu ()" link="libxml2-xmlunicode.html#xmlUCSIsLimbu"/>
<keyword type="function" name="xmlUCSIsLinearBIdeograms ()" link="libxml2-xmlunicode.html#xmlUCSIsLinearBIdeograms"/>
<keyword type="function" name="xmlUCSIsLinearBSyllabary ()" link="libxml2-xmlunicode.html#xmlUCSIsLinearBSyllabary"/>
<keyword type="function" name="xmlUCSIsLowSurrogates ()" link="libxml2-xmlunicode.html#xmlUCSIsLowSurrogates"/>
<keyword type="function" name="xmlUCSIsMalayalam ()" link="libxml2-xmlunicode.html#xmlUCSIsMalayalam"/>
<keyword type="function" name="xmlUCSIsMathematicalAlphanumericSymbols ()" link="libxml2-xmlunicode.html#xmlUCSIsMathematicalAlphanumericSymbols"/>
<keyword type="function" name="xmlUCSIsMathematicalOperators ()" link="libxml2-xmlunicode.html#xmlUCSIsMathematicalOperators"/>
<keyword type="function" name="xmlUCSIsMiscellaneousMathematicalSymbolsA ()" link="libxml2-xmlunicode.html#xmlUCSIsMiscellaneousMathematicalSymbolsA"/>
<keyword type="function" name="xmlUCSIsMiscellaneousMathematicalSymbolsB ()" link="libxml2-xmlunicode.html#xmlUCSIsMiscellaneousMathematicalSymbolsB"/>
<keyword type="function" name="xmlUCSIsMiscellaneousSymbols ()" link="libxml2-xmlunicode.html#xmlUCSIsMiscellaneousSymbols"/>
<keyword type="function" name="xmlUCSIsMiscellaneousSymbolsandArrows ()" link="libxml2-xmlunicode.html#xmlUCSIsMiscellaneousSymbolsandArrows"/>
<keyword type="function" name="xmlUCSIsMiscellaneousTechnical ()" link="libxml2-xmlunicode.html#xmlUCSIsMiscellaneousTechnical"/>
<keyword type="function" name="xmlUCSIsMongolian ()" link="libxml2-xmlunicode.html#xmlUCSIsMongolian"/>
<keyword type="function" name="xmlUCSIsMusicalSymbols ()" link="libxml2-xmlunicode.html#xmlUCSIsMusicalSymbols"/>
<keyword type="function" name="xmlUCSIsMyanmar ()" link="libxml2-xmlunicode.html#xmlUCSIsMyanmar"/>
<keyword type="function" name="xmlUCSIsNumberForms ()" link="libxml2-xmlunicode.html#xmlUCSIsNumberForms"/>
<keyword type="function" name="xmlUCSIsOgham ()" link="libxml2-xmlunicode.html#xmlUCSIsOgham"/>
<keyword type="function" name="xmlUCSIsOldItalic ()" link="libxml2-xmlunicode.html#xmlUCSIsOldItalic"/>
<keyword type="function" name="xmlUCSIsOpticalCharacterRecognition ()" link="libxml2-xmlunicode.html#xmlUCSIsOpticalCharacterRecognition"/>
<keyword type="function" name="xmlUCSIsOriya ()" link="libxml2-xmlunicode.html#xmlUCSIsOriya"/>
<keyword type="function" name="xmlUCSIsOsmanya ()" link="libxml2-xmlunicode.html#xmlUCSIsOsmanya"/>
<keyword type="function" name="xmlUCSIsPhoneticExtensions ()" link="libxml2-xmlunicode.html#xmlUCSIsPhoneticExtensions"/>
<keyword type="function" name="xmlUCSIsPrivateUse ()" link="libxml2-xmlunicode.html#xmlUCSIsPrivateUse"/>
<keyword type="function" name="xmlUCSIsPrivateUseArea ()" link="libxml2-xmlunicode.html#xmlUCSIsPrivateUseArea"/>
<keyword type="function" name="xmlUCSIsRunic ()" link="libxml2-xmlunicode.html#xmlUCSIsRunic"/>
<keyword type="function" name="xmlUCSIsShavian ()" link="libxml2-xmlunicode.html#xmlUCSIsShavian"/>
<keyword type="function" name="xmlUCSIsSinhala ()" link="libxml2-xmlunicode.html#xmlUCSIsSinhala"/>
<keyword type="function" name="xmlUCSIsSmallFormVariants ()" link="libxml2-xmlunicode.html#xmlUCSIsSmallFormVariants"/>
<keyword type="function" name="xmlUCSIsSpacingModifierLetters ()" link="libxml2-xmlunicode.html#xmlUCSIsSpacingModifierLetters"/>
<keyword type="function" name="xmlUCSIsSpecials ()" link="libxml2-xmlunicode.html#xmlUCSIsSpecials"/>
<keyword type="function" name="xmlUCSIsSuperscriptsandSubscripts ()" link="libxml2-xmlunicode.html#xmlUCSIsSuperscriptsandSubscripts"/>
<keyword type="function" name="xmlUCSIsSupplementalArrowsA ()" link="libxml2-xmlunicode.html#xmlUCSIsSupplementalArrowsA"/>
<keyword type="function" name="xmlUCSIsSupplementalArrowsB ()" link="libxml2-xmlunicode.html#xmlUCSIsSupplementalArrowsB"/>
<keyword type="function" name="xmlUCSIsSupplementalMathematicalOperators ()" link="libxml2-xmlunicode.html#xmlUCSIsSupplementalMathematicalOperators"/>
<keyword type="function" name="xmlUCSIsSupplementaryPrivateUseAreaA ()" link="libxml2-xmlunicode.html#xmlUCSIsSupplementaryPrivateUseAreaA"/>
<keyword type="function" name="xmlUCSIsSupplementaryPrivateUseAreaB ()" link="libxml2-xmlunicode.html#xmlUCSIsSupplementaryPrivateUseAreaB"/>
<keyword type="function" name="xmlUCSIsSyriac ()" link="libxml2-xmlunicode.html#xmlUCSIsSyriac"/>
<keyword type="function" name="xmlUCSIsTagalog ()" link="libxml2-xmlunicode.html#xmlUCSIsTagalog"/>
<keyword type="function" name="xmlUCSIsTagbanwa ()" link="libxml2-xmlunicode.html#xmlUCSIsTagbanwa"/>
<keyword type="function" name="xmlUCSIsTags ()" link="libxml2-xmlunicode.html#xmlUCSIsTags"/>
<keyword type="function" name="xmlUCSIsTaiLe ()" link="libxml2-xmlunicode.html#xmlUCSIsTaiLe"/>
<keyword type="function" name="xmlUCSIsTaiXuanJingSymbols ()" link="libxml2-xmlunicode.html#xmlUCSIsTaiXuanJingSymbols"/>
<keyword type="function" name="xmlUCSIsTamil ()" link="libxml2-xmlunicode.html#xmlUCSIsTamil"/>
<keyword type="function" name="xmlUCSIsTelugu ()" link="libxml2-xmlunicode.html#xmlUCSIsTelugu"/>
<keyword type="function" name="xmlUCSIsThaana ()" link="libxml2-xmlunicode.html#xmlUCSIsThaana"/>
<keyword type="function" name="xmlUCSIsThai ()" link="libxml2-xmlunicode.html#xmlUCSIsThai"/>
<keyword type="function" name="xmlUCSIsTibetan ()" link="libxml2-xmlunicode.html#xmlUCSIsTibetan"/>
<keyword type="function" name="xmlUCSIsUgaritic ()" link="libxml2-xmlunicode.html#xmlUCSIsUgaritic"/>
<keyword type="function" name="xmlUCSIsUnifiedCanadianAboriginalSyllabics ()" link="libxml2-xmlunicode.html#xmlUCSIsUnifiedCanadianAboriginalSyllabics"/>
<keyword type="function" name="xmlUCSIsVariationSelectors ()" link="libxml2-xmlunicode.html#xmlUCSIsVariationSelectors"/>
<keyword type="function" name="xmlUCSIsVariationSelectorsSupplement ()" link="libxml2-xmlunicode.html#xmlUCSIsVariationSelectorsSupplement"/>
<keyword type="function" name="xmlUCSIsYiRadicals ()" link="libxml2-xmlunicode.html#xmlUCSIsYiRadicals"/>
<keyword type="function" name="xmlUCSIsYiSyllables ()" link="libxml2-xmlunicode.html#xmlUCSIsYiSyllables"/>
<keyword type="function" name="xmlUCSIsYijingHexagramSymbols ()" link="libxml2-xmlunicode.html#xmlUCSIsYijingHexagramSymbols"/>
<keyword type="function" name="xmlURIEscape ()" link="libxml2-uri.html#xmlURIEscape"/>
<keyword type="function" name="xmlURIEscapeStr ()" link="libxml2-uri.html#xmlURIEscapeStr"/>
<keyword type="function" name="xmlURIUnescapeString ()" link="libxml2-uri.html#xmlURIUnescapeString"/>
<keyword type="function" name="xmlUTF8Charcmp ()" link="libxml2-xmlstring.html#xmlUTF8Charcmp"/>
<keyword type="function" name="xmlUTF8Size ()" link="libxml2-xmlstring.html#xmlUTF8Size"/>
<keyword type="function" name="xmlUTF8Strlen ()" link="libxml2-xmlstring.html#xmlUTF8Strlen"/>
<keyword type="function" name="xmlUTF8Strloc ()" link="libxml2-xmlstring.html#xmlUTF8Strloc"/>
<keyword type="function" name="xmlUTF8Strndup ()" link="libxml2-xmlstring.html#xmlUTF8Strndup"/>
<keyword type="function" name="xmlUTF8Strpos ()" link="libxml2-xmlstring.html#xmlUTF8Strpos"/>
<keyword type="function" name="xmlUTF8Strsize ()" link="libxml2-xmlstring.html#xmlUTF8Strsize"/>
<keyword type="function" name="xmlUTF8Strsub ()" link="libxml2-xmlstring.html#xmlUTF8Strsub"/>
<keyword type="function" name="xmlUnlinkNode ()" link="libxml2-tree.html#xmlUnlinkNode"/>
<keyword type="function" name="xmlUnlockLibrary ()" link="libxml2-threads.html#xmlUnlockLibrary"/>
<keyword type="function" name="xmlUnsetNsProp ()" link="libxml2-tree.html#xmlUnsetNsProp"/>
<keyword type="function" name="xmlUnsetProp ()" link="libxml2-tree.html#xmlUnsetProp"/>
<keyword type="function" name="xmlValidBuildContentModel ()" link="libxml2-valid.html#xmlValidBuildContentModel"/>
<keyword type="function" name="xmlValidCtxtNormalizeAttributeValue ()" link="libxml2-valid.html#xmlValidCtxtNormalizeAttributeValue"/>
<keyword type="function" name="xmlValidGetPotentialChildren ()" link="libxml2-valid.html#xmlValidGetPotentialChildren"/>
<keyword type="function" name="xmlValidGetValidElements ()" link="libxml2-valid.html#xmlValidGetValidElements"/>
<keyword type="function" name="xmlValidNormalizeAttributeValue ()" link="libxml2-valid.html#xmlValidNormalizeAttributeValue"/>
<keyword type="function" name="xmlValidateAttributeDecl ()" link="libxml2-valid.html#xmlValidateAttributeDecl"/>
<keyword type="function" name="xmlValidateAttributeValue ()" link="libxml2-valid.html#xmlValidateAttributeValue"/>
<keyword type="function" name="xmlValidateDocument ()" link="libxml2-valid.html#xmlValidateDocument"/>
<keyword type="function" name="xmlValidateDocumentFinal ()" link="libxml2-valid.html#xmlValidateDocumentFinal"/>
<keyword type="function" name="xmlValidateDtd ()" link="libxml2-valid.html#xmlValidateDtd"/>
<keyword type="function" name="xmlValidateDtdFinal ()" link="libxml2-valid.html#xmlValidateDtdFinal"/>
<keyword type="function" name="xmlValidateElement ()" link="libxml2-valid.html#xmlValidateElement"/>
<keyword type="function" name="xmlValidateElementDecl ()" link="libxml2-valid.html#xmlValidateElementDecl"/>
<keyword type="function" name="xmlValidateNCName ()" link="libxml2-tree.html#xmlValidateNCName"/>
<keyword type="function" name="xmlValidateNMToken ()" link="libxml2-tree.html#xmlValidateNMToken"/>
<keyword type="function" name="xmlValidateName ()" link="libxml2-tree.html#xmlValidateName"/>
<keyword type="function" name="xmlValidateNameValue ()" link="libxml2-valid.html#xmlValidateNameValue"/>
<keyword type="function" name="xmlValidateNamesValue ()" link="libxml2-valid.html#xmlValidateNamesValue"/>
<keyword type="function" name="xmlValidateNmtokenValue ()" link="libxml2-valid.html#xmlValidateNmtokenValue"/>
<keyword type="function" name="xmlValidateNmtokensValue ()" link="libxml2-valid.html#xmlValidateNmtokensValue"/>
<keyword type="function" name="xmlValidateNotationDecl ()" link="libxml2-valid.html#xmlValidateNotationDecl"/>
<keyword type="function" name="xmlValidateNotationUse ()" link="libxml2-valid.html#xmlValidateNotationUse"/>
<keyword type="function" name="xmlValidateOneAttribute ()" link="libxml2-valid.html#xmlValidateOneAttribute"/>
<keyword type="function" name="xmlValidateOneElement ()" link="libxml2-valid.html#xmlValidateOneElement"/>
<keyword type="function" name="xmlValidateOneNamespace ()" link="libxml2-valid.html#xmlValidateOneNamespace"/>
<keyword type="function" name="xmlValidatePopElement ()" link="libxml2-valid.html#xmlValidatePopElement"/>
<keyword type="function" name="xmlValidatePushCData ()" link="libxml2-valid.html#xmlValidatePushCData"/>
<keyword type="function" name="xmlValidatePushElement ()" link="libxml2-valid.html#xmlValidatePushElement"/>
<keyword type="function" name="xmlValidateQName ()" link="libxml2-tree.html#xmlValidateQName"/>
<keyword type="function" name="xmlValidateRoot ()" link="libxml2-valid.html#xmlValidateRoot"/>
<keyword type="function" name="xmlXIncludeFreeContext ()" link="libxml2-xinclude.html#xmlXIncludeFreeContext"/>
<keyword type="function" name="xmlXIncludeNewContext ()" link="libxml2-xinclude.html#xmlXIncludeNewContext"/>
<keyword type="function" name="xmlXIncludeProcess ()" link="libxml2-xinclude.html#xmlXIncludeProcess"/>
<keyword type="function" name="xmlXIncludeProcessFlags ()" link="libxml2-xinclude.html#xmlXIncludeProcessFlags"/>
<keyword type="function" name="xmlXIncludeProcessFlagsData ()" link="libxml2-xinclude.html#xmlXIncludeProcessFlagsData"/>
<keyword type="function" name="xmlXIncludeProcessNode ()" link="libxml2-xinclude.html#xmlXIncludeProcessNode"/>
<keyword type="function" name="xmlXIncludeProcessTree ()" link="libxml2-xinclude.html#xmlXIncludeProcessTree"/>
<keyword type="function" name="xmlXIncludeProcessTreeFlags ()" link="libxml2-xinclude.html#xmlXIncludeProcessTreeFlags"/>
<keyword type="function" name="xmlXIncludeProcessTreeFlagsData ()" link="libxml2-xinclude.html#xmlXIncludeProcessTreeFlagsData"/>
<keyword type="function" name="xmlXIncludeSetFlags ()" link="libxml2-xinclude.html#xmlXIncludeSetFlags"/>
<keyword type="function" name="xmlXPathAddValues ()" link="libxml2-xpathInternals.html#xmlXPathAddValues"/>
<keyword type="function" name="xmlXPathBooleanFunction ()" link="libxml2-xpathInternals.html#xmlXPathBooleanFunction"/>
<keyword type="function" name="xmlXPathCastBooleanToNumber ()" link="libxml2-xpath.html#xmlXPathCastBooleanToNumber"/>
<keyword type="function" name="xmlXPathCastBooleanToString ()" link="libxml2-xpath.html#xmlXPathCastBooleanToString"/>
<keyword type="function" name="xmlXPathCastNodeSetToBoolean ()" link="libxml2-xpath.html#xmlXPathCastNodeSetToBoolean"/>
<keyword type="function" name="xmlXPathCastNodeSetToNumber ()" link="libxml2-xpath.html#xmlXPathCastNodeSetToNumber"/>
<keyword type="function" name="xmlXPathCastNodeSetToString ()" link="libxml2-xpath.html#xmlXPathCastNodeSetToString"/>
<keyword type="function" name="xmlXPathCastNodeToNumber ()" link="libxml2-xpath.html#xmlXPathCastNodeToNumber"/>
<keyword type="function" name="xmlXPathCastNodeToString ()" link="libxml2-xpath.html#xmlXPathCastNodeToString"/>
<keyword type="function" name="xmlXPathCastNumberToBoolean ()" link="libxml2-xpath.html#xmlXPathCastNumberToBoolean"/>
<keyword type="function" name="xmlXPathCastNumberToString ()" link="libxml2-xpath.html#xmlXPathCastNumberToString"/>
<keyword type="function" name="xmlXPathCastStringToBoolean ()" link="libxml2-xpath.html#xmlXPathCastStringToBoolean"/>
<keyword type="function" name="xmlXPathCastStringToNumber ()" link="libxml2-xpath.html#xmlXPathCastStringToNumber"/>
<keyword type="function" name="xmlXPathCastToBoolean ()" link="libxml2-xpath.html#xmlXPathCastToBoolean"/>
<keyword type="function" name="xmlXPathCastToNumber ()" link="libxml2-xpath.html#xmlXPathCastToNumber"/>
<keyword type="function" name="xmlXPathCastToString ()" link="libxml2-xpath.html#xmlXPathCastToString"/>
<keyword type="function" name="xmlXPathCeilingFunction ()" link="libxml2-xpathInternals.html#xmlXPathCeilingFunction"/>
<keyword type="function" name="xmlXPathCmpNodes ()" link="libxml2-xpath.html#xmlXPathCmpNodes"/>
<keyword type="function" name="xmlXPathCompareValues ()" link="libxml2-xpathInternals.html#xmlXPathCompareValues"/>
<keyword type="function" name="xmlXPathCompile ()" link="libxml2-xpath.html#xmlXPathCompile"/>
<keyword type="function" name="xmlXPathCompiledEval ()" link="libxml2-xpath.html#xmlXPathCompiledEval"/>
<keyword type="function" name="xmlXPathCompiledEvalToBoolean ()" link="libxml2-xpath.html#xmlXPathCompiledEvalToBoolean"/>
<keyword type="function" name="xmlXPathConcatFunction ()" link="libxml2-xpathInternals.html#xmlXPathConcatFunction"/>
<keyword type="function" name="xmlXPathContainsFunction ()" link="libxml2-xpathInternals.html#xmlXPathContainsFunction"/>
<keyword type="function" name="xmlXPathContextSetCache ()" link="libxml2-xpath.html#xmlXPathContextSetCache"/>
<keyword type="function" name="xmlXPathConvertBoolean ()" link="libxml2-xpath.html#xmlXPathConvertBoolean"/>
<keyword type="function" name="xmlXPathConvertNumber ()" link="libxml2-xpath.html#xmlXPathConvertNumber"/>
<keyword type="function" name="xmlXPathConvertString ()" link="libxml2-xpath.html#xmlXPathConvertString"/>
<keyword type="function" name="xmlXPathCountFunction ()" link="libxml2-xpathInternals.html#xmlXPathCountFunction"/>
<keyword type="function" name="xmlXPathCtxtCompile ()" link="libxml2-xpath.html#xmlXPathCtxtCompile"/>
<keyword type="function" name="xmlXPathDebugDumpCompExpr ()" link="libxml2-xpathInternals.html#xmlXPathDebugDumpCompExpr"/>
<keyword type="function" name="xmlXPathDebugDumpObject ()" link="libxml2-xpathInternals.html#xmlXPathDebugDumpObject"/>
<keyword type="function" name="xmlXPathDifference ()" link="libxml2-xpathInternals.html#xmlXPathDifference"/>
<keyword type="function" name="xmlXPathDistinct ()" link="libxml2-xpathInternals.html#xmlXPathDistinct"/>
<keyword type="function" name="xmlXPathDistinctSorted ()" link="libxml2-xpathInternals.html#xmlXPathDistinctSorted"/>
<keyword type="function" name="xmlXPathDivValues ()" link="libxml2-xpathInternals.html#xmlXPathDivValues"/>
<keyword type="function" name="xmlXPathEqualValues ()" link="libxml2-xpathInternals.html#xmlXPathEqualValues"/>
<keyword type="function" name="xmlXPathErr ()" link="libxml2-xpathInternals.html#xmlXPathErr"/>
<keyword type="function" name="xmlXPathEval ()" link="libxml2-xpath.html#xmlXPathEval"/>
<keyword type="function" name="xmlXPathEvalExpr ()" link="libxml2-xpathInternals.html#xmlXPathEvalExpr"/>
<keyword type="function" name="xmlXPathEvalExpression ()" link="libxml2-xpath.html#xmlXPathEvalExpression"/>
<keyword type="function" name="xmlXPathEvalPredicate ()" link="libxml2-xpath.html#xmlXPathEvalPredicate"/>
<keyword type="function" name="xmlXPathEvaluatePredicateResult ()" link="libxml2-xpathInternals.html#xmlXPathEvaluatePredicateResult"/>
<keyword type="function" name="xmlXPathFalseFunction ()" link="libxml2-xpathInternals.html#xmlXPathFalseFunction"/>
<keyword type="function" name="xmlXPathFloorFunction ()" link="libxml2-xpathInternals.html#xmlXPathFloorFunction"/>
<keyword type="function" name="xmlXPathFreeCompExpr ()" link="libxml2-xpath.html#xmlXPathFreeCompExpr"/>
<keyword type="function" name="xmlXPathFreeContext ()" link="libxml2-xpath.html#xmlXPathFreeContext"/>
<keyword type="function" name="xmlXPathFreeNodeSet ()" link="libxml2-xpath.html#xmlXPathFreeNodeSet"/>
<keyword type="function" name="xmlXPathFreeNodeSetList ()" link="libxml2-xpath.html#xmlXPathFreeNodeSetList"/>
<keyword type="function" name="xmlXPathFreeObject ()" link="libxml2-xpath.html#xmlXPathFreeObject"/>
<keyword type="function" name="xmlXPathFreeParserContext ()" link="libxml2-xpathInternals.html#xmlXPathFreeParserContext"/>
<keyword type="function" name="xmlXPathFunctionLookup ()" link="libxml2-xpathInternals.html#xmlXPathFunctionLookup"/>
<keyword type="function" name="xmlXPathFunctionLookupNS ()" link="libxml2-xpathInternals.html#xmlXPathFunctionLookupNS"/>
<keyword type="function" name="xmlXPathHasSameNodes ()" link="libxml2-xpathInternals.html#xmlXPathHasSameNodes"/>
<keyword type="function" name="xmlXPathIdFunction ()" link="libxml2-xpathInternals.html#xmlXPathIdFunction"/>
<keyword type="function" name="xmlXPathInit ()" link="libxml2-xpath.html#xmlXPathInit"/>
<keyword type="function" name="xmlXPathIntersection ()" link="libxml2-xpathInternals.html#xmlXPathIntersection"/>
<keyword type="function" name="xmlXPathIsInf ()" link="libxml2-xpath.html#xmlXPathIsInf"/>
<keyword type="function" name="xmlXPathIsNaN ()" link="libxml2-xpath.html#xmlXPathIsNaN"/>
<keyword type="function" name="xmlXPathIsNodeType ()" link="libxml2-xpathInternals.html#xmlXPathIsNodeType"/>
<keyword type="function" name="xmlXPathLangFunction ()" link="libxml2-xpathInternals.html#xmlXPathLangFunction"/>
<keyword type="function" name="xmlXPathLastFunction ()" link="libxml2-xpathInternals.html#xmlXPathLastFunction"/>
<keyword type="function" name="xmlXPathLeading ()" link="libxml2-xpathInternals.html#xmlXPathLeading"/>
<keyword type="function" name="xmlXPathLeadingSorted ()" link="libxml2-xpathInternals.html#xmlXPathLeadingSorted"/>
<keyword type="function" name="xmlXPathLocalNameFunction ()" link="libxml2-xpathInternals.html#xmlXPathLocalNameFunction"/>
<keyword type="function" name="xmlXPathModValues ()" link="libxml2-xpathInternals.html#xmlXPathModValues"/>
<keyword type="function" name="xmlXPathMultValues ()" link="libxml2-xpathInternals.html#xmlXPathMultValues"/>
<keyword type="function" name="xmlXPathNamespaceURIFunction ()" link="libxml2-xpathInternals.html#xmlXPathNamespaceURIFunction"/>
<keyword type="function" name="xmlXPathNewBoolean ()" link="libxml2-xpathInternals.html#xmlXPathNewBoolean"/>
<keyword type="function" name="xmlXPathNewCString ()" link="libxml2-xpathInternals.html#xmlXPathNewCString"/>
<keyword type="function" name="xmlXPathNewContext ()" link="libxml2-xpath.html#xmlXPathNewContext"/>
<keyword type="function" name="xmlXPathNewFloat ()" link="libxml2-xpathInternals.html#xmlXPathNewFloat"/>
<keyword type="function" name="xmlXPathNewNodeSet ()" link="libxml2-xpathInternals.html#xmlXPathNewNodeSet"/>
<keyword type="function" name="xmlXPathNewNodeSetList ()" link="libxml2-xpathInternals.html#xmlXPathNewNodeSetList"/>
<keyword type="function" name="xmlXPathNewParserContext ()" link="libxml2-xpathInternals.html#xmlXPathNewParserContext"/>
<keyword type="function" name="xmlXPathNewString ()" link="libxml2-xpathInternals.html#xmlXPathNewString"/>
<keyword type="function" name="xmlXPathNewValueTree ()" link="libxml2-xpathInternals.html#xmlXPathNewValueTree"/>
<keyword type="function" name="xmlXPathNextAncestor ()" link="libxml2-xpathInternals.html#xmlXPathNextAncestor"/>
<keyword type="function" name="xmlXPathNextAncestorOrSelf ()" link="libxml2-xpathInternals.html#xmlXPathNextAncestorOrSelf"/>
<keyword type="function" name="xmlXPathNextAttribute ()" link="libxml2-xpathInternals.html#xmlXPathNextAttribute"/>
<keyword type="function" name="xmlXPathNextChild ()" link="libxml2-xpathInternals.html#xmlXPathNextChild"/>
<keyword type="function" name="xmlXPathNextDescendant ()" link="libxml2-xpathInternals.html#xmlXPathNextDescendant"/>
<keyword type="function" name="xmlXPathNextDescendantOrSelf ()" link="libxml2-xpathInternals.html#xmlXPathNextDescendantOrSelf"/>
<keyword type="function" name="xmlXPathNextFollowing ()" link="libxml2-xpathInternals.html#xmlXPathNextFollowing"/>
<keyword type="function" name="xmlXPathNextFollowingSibling ()" link="libxml2-xpathInternals.html#xmlXPathNextFollowingSibling"/>
<keyword type="function" name="xmlXPathNextNamespace ()" link="libxml2-xpathInternals.html#xmlXPathNextNamespace"/>
<keyword type="function" name="xmlXPathNextParent ()" link="libxml2-xpathInternals.html#xmlXPathNextParent"/>
<keyword type="function" name="xmlXPathNextPreceding ()" link="libxml2-xpathInternals.html#xmlXPathNextPreceding"/>
<keyword type="function" name="xmlXPathNextPrecedingSibling ()" link="libxml2-xpathInternals.html#xmlXPathNextPrecedingSibling"/>
<keyword type="function" name="xmlXPathNextSelf ()" link="libxml2-xpathInternals.html#xmlXPathNextSelf"/>
<keyword type="function" name="xmlXPathNodeEval ()" link="libxml2-xpath.html#xmlXPathNodeEval"/>
<keyword type="function" name="xmlXPathNodeLeading ()" link="libxml2-xpathInternals.html#xmlXPathNodeLeading"/>
<keyword type="function" name="xmlXPathNodeLeadingSorted ()" link="libxml2-xpathInternals.html#xmlXPathNodeLeadingSorted"/>
<keyword type="function" name="xmlXPathNodeSetAdd ()" link="libxml2-xpathInternals.html#xmlXPathNodeSetAdd"/>
<keyword type="function" name="xmlXPathNodeSetAddNs ()" link="libxml2-xpathInternals.html#xmlXPathNodeSetAddNs"/>
<keyword type="function" name="xmlXPathNodeSetAddUnique ()" link="libxml2-xpathInternals.html#xmlXPathNodeSetAddUnique"/>
<keyword type="function" name="xmlXPathNodeSetContains ()" link="libxml2-xpathInternals.html#xmlXPathNodeSetContains"/>
<keyword type="function" name="xmlXPathNodeSetCreate ()" link="libxml2-xpath.html#xmlXPathNodeSetCreate"/>
<keyword type="function" name="xmlXPathNodeSetDel ()" link="libxml2-xpathInternals.html#xmlXPathNodeSetDel"/>
<keyword type="function" name="xmlXPathNodeSetFreeNs ()" link="libxml2-xpathInternals.html#xmlXPathNodeSetFreeNs"/>
<keyword type="function" name="xmlXPathNodeSetMerge ()" link="libxml2-xpathInternals.html#xmlXPathNodeSetMerge"/>
<keyword type="function" name="xmlXPathNodeSetRemove ()" link="libxml2-xpathInternals.html#xmlXPathNodeSetRemove"/>
<keyword type="function" name="xmlXPathNodeSetSort ()" link="libxml2-xpathInternals.html#xmlXPathNodeSetSort"/>
<keyword type="function" name="xmlXPathNodeTrailing ()" link="libxml2-xpathInternals.html#xmlXPathNodeTrailing"/>
<keyword type="function" name="xmlXPathNodeTrailingSorted ()" link="libxml2-xpathInternals.html#xmlXPathNodeTrailingSorted"/>
<keyword type="function" name="xmlXPathNormalizeFunction ()" link="libxml2-xpathInternals.html#xmlXPathNormalizeFunction"/>
<keyword type="function" name="xmlXPathNotEqualValues ()" link="libxml2-xpathInternals.html#xmlXPathNotEqualValues"/>
<keyword type="function" name="xmlXPathNotFunction ()" link="libxml2-xpathInternals.html#xmlXPathNotFunction"/>
<keyword type="function" name="xmlXPathNsLookup ()" link="libxml2-xpathInternals.html#xmlXPathNsLookup"/>
<keyword type="function" name="xmlXPathNumberFunction ()" link="libxml2-xpathInternals.html#xmlXPathNumberFunction"/>
<keyword type="function" name="xmlXPathObjectCopy ()" link="libxml2-xpath.html#xmlXPathObjectCopy"/>
<keyword type="function" name="xmlXPathOrderDocElems ()" link="libxml2-xpath.html#xmlXPathOrderDocElems"/>
<keyword type="function" name="xmlXPathParseNCName ()" link="libxml2-xpathInternals.html#xmlXPathParseNCName"/>
<keyword type="function" name="xmlXPathParseName ()" link="libxml2-xpathInternals.html#xmlXPathParseName"/>
<keyword type="function" name="xmlXPathPopBoolean ()" link="libxml2-xpathInternals.html#xmlXPathPopBoolean"/>
<keyword type="function" name="xmlXPathPopExternal ()" link="libxml2-xpathInternals.html#xmlXPathPopExternal"/>
<keyword type="function" name="xmlXPathPopNodeSet ()" link="libxml2-xpathInternals.html#xmlXPathPopNodeSet"/>
<keyword type="function" name="xmlXPathPopNumber ()" link="libxml2-xpathInternals.html#xmlXPathPopNumber"/>
<keyword type="function" name="xmlXPathPopString ()" link="libxml2-xpathInternals.html#xmlXPathPopString"/>
<keyword type="function" name="xmlXPathPositionFunction ()" link="libxml2-xpathInternals.html#xmlXPathPositionFunction"/>
<keyword type="function" name="xmlXPathRegisterAllFunctions ()" link="libxml2-xpathInternals.html#xmlXPathRegisterAllFunctions"/>
<keyword type="function" name="xmlXPathRegisterFunc ()" link="libxml2-xpathInternals.html#xmlXPathRegisterFunc"/>
<keyword type="function" name="xmlXPathRegisterFuncLookup ()" link="libxml2-xpathInternals.html#xmlXPathRegisterFuncLookup"/>
<keyword type="function" name="xmlXPathRegisterFuncNS ()" link="libxml2-xpathInternals.html#xmlXPathRegisterFuncNS"/>
<keyword type="function" name="xmlXPathRegisterNs ()" link="libxml2-xpathInternals.html#xmlXPathRegisterNs"/>
<keyword type="function" name="xmlXPathRegisterVariable ()" link="libxml2-xpathInternals.html#xmlXPathRegisterVariable"/>
<keyword type="function" name="xmlXPathRegisterVariableLookup ()" link="libxml2-xpathInternals.html#xmlXPathRegisterVariableLookup"/>
<keyword type="function" name="xmlXPathRegisterVariableNS ()" link="libxml2-xpathInternals.html#xmlXPathRegisterVariableNS"/>
<keyword type="function" name="xmlXPathRegisteredFuncsCleanup ()" link="libxml2-xpathInternals.html#xmlXPathRegisteredFuncsCleanup"/>
<keyword type="function" name="xmlXPathRegisteredNsCleanup ()" link="libxml2-xpathInternals.html#xmlXPathRegisteredNsCleanup"/>
<keyword type="function" name="xmlXPathRegisteredVariablesCleanup ()" link="libxml2-xpathInternals.html#xmlXPathRegisteredVariablesCleanup"/>
<keyword type="function" name="xmlXPathRoot ()" link="libxml2-xpathInternals.html#xmlXPathRoot"/>
<keyword type="function" name="xmlXPathRoundFunction ()" link="libxml2-xpathInternals.html#xmlXPathRoundFunction"/>
<keyword type="function" name="xmlXPathSetContextNode ()" link="libxml2-xpath.html#xmlXPathSetContextNode"/>
<keyword type="function" name="xmlXPathStartsWithFunction ()" link="libxml2-xpathInternals.html#xmlXPathStartsWithFunction"/>
<keyword type="function" name="xmlXPathStringEvalNumber ()" link="libxml2-xpathInternals.html#xmlXPathStringEvalNumber"/>
<keyword type="function" name="xmlXPathStringFunction ()" link="libxml2-xpathInternals.html#xmlXPathStringFunction"/>
<keyword type="function" name="xmlXPathStringLengthFunction ()" link="libxml2-xpathInternals.html#xmlXPathStringLengthFunction"/>
<keyword type="function" name="xmlXPathSubValues ()" link="libxml2-xpathInternals.html#xmlXPathSubValues"/>
<keyword type="function" name="xmlXPathSubstringAfterFunction ()" link="libxml2-xpathInternals.html#xmlXPathSubstringAfterFunction"/>
<keyword type="function" name="xmlXPathSubstringBeforeFunction ()" link="libxml2-xpathInternals.html#xmlXPathSubstringBeforeFunction"/>
<keyword type="function" name="xmlXPathSubstringFunction ()" link="libxml2-xpathInternals.html#xmlXPathSubstringFunction"/>
<keyword type="function" name="xmlXPathSumFunction ()" link="libxml2-xpathInternals.html#xmlXPathSumFunction"/>
<keyword type="function" name="xmlXPathTrailing ()" link="libxml2-xpathInternals.html#xmlXPathTrailing"/>
<keyword type="function" name="xmlXPathTrailingSorted ()" link="libxml2-xpathInternals.html#xmlXPathTrailingSorted"/>
<keyword type="function" name="xmlXPathTranslateFunction ()" link="libxml2-xpathInternals.html#xmlXPathTranslateFunction"/>
<keyword type="function" name="xmlXPathTrueFunction ()" link="libxml2-xpathInternals.html#xmlXPathTrueFunction"/>
<keyword type="function" name="xmlXPathValueFlipSign ()" link="libxml2-xpathInternals.html#xmlXPathValueFlipSign"/>
<keyword type="function" name="xmlXPathVariableLookup ()" link="libxml2-xpathInternals.html#xmlXPathVariableLookup"/>
<keyword type="function" name="xmlXPathVariableLookupNS ()" link="libxml2-xpathInternals.html#xmlXPathVariableLookupNS"/>
<keyword type="function" name="xmlXPathWrapCString ()" link="libxml2-xpathInternals.html#xmlXPathWrapCString"/>
<keyword type="function" name="xmlXPathWrapExternal ()" link="libxml2-xpathInternals.html#xmlXPathWrapExternal"/>
<keyword type="function" name="xmlXPathWrapNodeSet ()" link="libxml2-xpathInternals.html#xmlXPathWrapNodeSet"/>
<keyword type="function" name="xmlXPathWrapString ()" link="libxml2-xpathInternals.html#xmlXPathWrapString"/>
<keyword type="function" name="xmlXPatherror ()" link="libxml2-xpathInternals.html#xmlXPatherror"/>
<keyword type="function" name="xmlXPtrBuildNodeList ()" link="libxml2-xpointer.html#xmlXPtrBuildNodeList"/>
<keyword type="function" name="xmlXPtrEval ()" link="libxml2-xpointer.html#xmlXPtrEval"/>
<keyword type="function" name="xmlXPtrEvalRangePredicate ()" link="libxml2-xpointer.html#xmlXPtrEvalRangePredicate"/>
<keyword type="function" name="xmlXPtrFreeLocationSet ()" link="libxml2-xpointer.html#xmlXPtrFreeLocationSet"/>
<keyword type="function" name="xmlXPtrLocationSetAdd ()" link="libxml2-xpointer.html#xmlXPtrLocationSetAdd"/>
<keyword type="function" name="xmlXPtrLocationSetCreate ()" link="libxml2-xpointer.html#xmlXPtrLocationSetCreate"/>
<keyword type="function" name="xmlXPtrLocationSetDel ()" link="libxml2-xpointer.html#xmlXPtrLocationSetDel"/>
<keyword type="function" name="xmlXPtrLocationSetMerge ()" link="libxml2-xpointer.html#xmlXPtrLocationSetMerge"/>
<keyword type="function" name="xmlXPtrLocationSetRemove ()" link="libxml2-xpointer.html#xmlXPtrLocationSetRemove"/>
<keyword type="function" name="xmlXPtrNewCollapsedRange ()" link="libxml2-xpointer.html#xmlXPtrNewCollapsedRange"/>
<keyword type="function" name="xmlXPtrNewContext ()" link="libxml2-xpointer.html#xmlXPtrNewContext"/>
<keyword type="function" name="xmlXPtrNewLocationSetNodeSet ()" link="libxml2-xpointer.html#xmlXPtrNewLocationSetNodeSet"/>
<keyword type="function" name="xmlXPtrNewLocationSetNodes ()" link="libxml2-xpointer.html#xmlXPtrNewLocationSetNodes"/>
<keyword type="function" name="xmlXPtrNewRange ()" link="libxml2-xpointer.html#xmlXPtrNewRange"/>
<keyword type="function" name="xmlXPtrNewRangeNodeObject ()" link="libxml2-xpointer.html#xmlXPtrNewRangeNodeObject"/>
<keyword type="function" name="xmlXPtrNewRangeNodePoint ()" link="libxml2-xpointer.html#xmlXPtrNewRangeNodePoint"/>
<keyword type="function" name="xmlXPtrNewRangeNodes ()" link="libxml2-xpointer.html#xmlXPtrNewRangeNodes"/>
<keyword type="function" name="xmlXPtrNewRangePointNode ()" link="libxml2-xpointer.html#xmlXPtrNewRangePointNode"/>
<keyword type="function" name="xmlXPtrNewRangePoints ()" link="libxml2-xpointer.html#xmlXPtrNewRangePoints"/>
<keyword type="function" name="xmlXPtrRangeToFunction ()" link="libxml2-xpointer.html#xmlXPtrRangeToFunction"/>
<keyword type="function" name="xmlXPtrWrapLocationSet ()" link="libxml2-xpointer.html#xmlXPtrWrapLocationSet"/>
</functions>
</book>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>schematron: XML Schematron implementation</title>
<meta name="generator" content="Libxml2 devhelp stylesheet">
<link rel="start" href="index.html" title="libxml2 Reference Manual">
<link rel="up" href="general.html" title="API">
<link rel="stylesheet" href="style.css" type="text/css">
<link rel="chapter" href="general.html" title="API">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table class="navigation" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"><tr valign="middle">
<td><a accesskey="p" href="libxml2-schemasInternals.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
<td><a accesskey="u" href="general.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
<td><a accesskey="n" href="libxml2-threads.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
<th width="100%" align="center">libxml2 Reference Manual</th>
</tr></table>
<h2><span class="refentrytitle">schematron</span></h2>
<p>schematron - XML Schematron implementation</p>
<p>interface to the XML Schematron validity checking. </p>
<p>Author(s): Daniel Veillard </p>
<div class="refsynopsisdiv">
<h2>Synopsis</h2>
<pre class="synopsis">typedef struct _xmlSchematron <a href="#xmlSchematron">xmlSchematron</a>;
typedef struct _xmlSchematronParserCtxt <a href="#xmlSchematronParserCtxt">xmlSchematronParserCtxt</a>;
typedef <a href="libxml2-schematron.html#xmlSchematronParserCtxt">xmlSchematronParserCtxt</a> * <a href="#xmlSchematronParserCtxtPtr">xmlSchematronParserCtxtPtr</a>;
typedef <a href="libxml2-schematron.html#xmlSchematron">xmlSchematron</a> * <a href="#xmlSchematronPtr">xmlSchematronPtr</a>;
typedef struct _xmlSchematronValidCtxt <a href="#xmlSchematronValidCtxt">xmlSchematronValidCtxt</a>;
typedef <a href="libxml2-schematron.html#xmlSchematronValidCtxt">xmlSchematronValidCtxt</a> * <a href="#xmlSchematronValidCtxtPtr">xmlSchematronValidCtxtPtr</a>;
typedef enum <a href="#xmlSchematronValidOptions">xmlSchematronValidOptions</a>;
void <a href="#xmlSchematronFree">xmlSchematronFree</a> (<a href="libxml2-schematron.html#xmlSchematronPtr">xmlSchematronPtr</a> schema);
void <a href="#xmlSchematronFreeParserCtxt">xmlSchematronFreeParserCtxt</a> (<a href="libxml2-schematron.html#xmlSchematronParserCtxtPtr">xmlSchematronParserCtxtPtr</a> ctxt);
void <a href="#xmlSchematronFreeValidCtxt">xmlSchematronFreeValidCtxt</a> (<a href="libxml2-schematron.html#xmlSchematronValidCtxtPtr">xmlSchematronValidCtxtPtr</a> ctxt);
<a href="libxml2-schematron.html#xmlSchematronParserCtxtPtr">xmlSchematronParserCtxtPtr</a> <a href="#xmlSchematronNewDocParserCtxt">xmlSchematronNewDocParserCtxt</a> (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc);
<a href="libxml2-schematron.html#xmlSchematronParserCtxtPtr">xmlSchematronParserCtxtPtr</a> <a href="#xmlSchematronNewMemParserCtxt">xmlSchematronNewMemParserCtxt</a> (const char * buffer, <br> int size);
<a href="libxml2-schematron.html#xmlSchematronParserCtxtPtr">xmlSchematronParserCtxtPtr</a> <a href="#xmlSchematronNewParserCtxt">xmlSchematronNewParserCtxt</a> (const char * URL);
<a href="libxml2-schematron.html#xmlSchematronValidCtxtPtr">xmlSchematronValidCtxtPtr</a> <a href="#xmlSchematronNewValidCtxt">xmlSchematronNewValidCtxt</a> (<a href="libxml2-schematron.html#xmlSchematronPtr">xmlSchematronPtr</a> schema, <br> int options);
<a href="libxml2-schematron.html#xmlSchematronPtr">xmlSchematronPtr</a> <a href="#xmlSchematronParse">xmlSchematronParse</a> (<a href="libxml2-schematron.html#xmlSchematronParserCtxtPtr">xmlSchematronParserCtxtPtr</a> ctxt);
void <a href="#xmlSchematronSetValidStructuredErrors">xmlSchematronSetValidStructuredErrors</a> (<a href="libxml2-schematron.html#xmlSchematronValidCtxtPtr">xmlSchematronValidCtxtPtr</a> ctxt, <br> <a href="libxml2-xmlerror.html#xmlStructuredErrorFunc">xmlStructuredErrorFunc</a> serror, <br> void * ctx);
int <a href="#xmlSchematronValidateDoc">xmlSchematronValidateDoc</a> (<a href="libxml2-schematron.html#xmlSchematronValidCtxtPtr">xmlSchematronValidCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> instance);
typedef void <a href="#xmlSchematronValidityErrorFunc">xmlSchematronValidityErrorFunc</a> (void * ctx, <br> const char * msg, <br> ... ...);
typedef void <a href="#xmlSchematronValidityWarningFunc">xmlSchematronValidityWarningFunc</a> (void * ctx, <br> const char * msg, <br> ... ...);
</pre>
</div>
<div class="refsect1" lang="en"><h2>Description</h2></div>
<div class="refsect1" lang="en">
<h2>Details</h2>
<div class="refsect2" lang="en">
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchematron">Structure </a>xmlSchematron</h3>
<pre class="programlisting">struct _xmlSchematron {
The content of this structure is not made public by the API.
} xmlSchematron;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchematronParserCtxt">Structure </a>xmlSchematronParserCtxt</h3>
<pre class="programlisting">struct _xmlSchematronParserCtxt {
The content of this structure is not made public by the API.
} xmlSchematronParserCtxt;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchematronParserCtxtPtr">Typedef </a>xmlSchematronParserCtxtPtr</h3>
<pre class="programlisting"><a href="libxml2-schematron.html#xmlSchematronParserCtxt">xmlSchematronParserCtxt</a> * xmlSchematronParserCtxtPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchematronPtr">Typedef </a>xmlSchematronPtr</h3>
<pre class="programlisting"><a href="libxml2-schematron.html#xmlSchematron">xmlSchematron</a> * xmlSchematronPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchematronValidCtxt">Structure </a>xmlSchematronValidCtxt</h3>
<pre class="programlisting">struct _xmlSchematronValidCtxt {
The content of this structure is not made public by the API.
} xmlSchematronValidCtxt;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchematronValidCtxtPtr">Typedef </a>xmlSchematronValidCtxtPtr</h3>
<pre class="programlisting"><a href="libxml2-schematron.html#xmlSchematronValidCtxt">xmlSchematronValidCtxt</a> * xmlSchematronValidCtxtPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchematronValidOptions">Enum </a>xmlSchematronValidOptions</h3>
<pre class="programlisting">enum <a href="#xmlSchematronValidOptions">xmlSchematronValidOptions</a> {
<a name="XML_SCHEMATRON_OUT_QUIET">XML_SCHEMATRON_OUT_QUIET</a> = 1 /* quiet no report */
<a name="XML_SCHEMATRON_OUT_TEXT">XML_SCHEMATRON_OUT_TEXT</a> = 2 /* build a textual report */
<a name="XML_SCHEMATRON_OUT_XML">XML_SCHEMATRON_OUT_XML</a> = 4 /* output SVRL */
<a name="XML_SCHEMATRON_OUT_ERROR">XML_SCHEMATRON_OUT_ERROR</a> = 8 /* output via xmlStructuredErrorFunc */
<a name="XML_SCHEMATRON_OUT_FILE">XML_SCHEMATRON_OUT_FILE</a> = 256 /* output to a file descriptor */
<a name="XML_SCHEMATRON_OUT_BUFFER">XML_SCHEMATRON_OUT_BUFFER</a> = 512 /* output to a buffer */
<a name="XML_SCHEMATRON_OUT_IO">XML_SCHEMATRON_OUT_IO</a> = 1024 /* output to I/O mechanism */
};
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchematronValidityErrorFunc"></a>Function type xmlSchematronValidityErrorFunc</h3>
<pre class="programlisting">void xmlSchematronValidityErrorFunc (void * ctx, <br> const char * msg, <br> ... ...)<br>
</pre>
<p>Signature of an error callback from a Schematron validation</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctx</tt></i>:</span></td>
<td>the validation context</td>
</tr>
<tr>
<td><span class="term"><i><tt>msg</tt></i>:</span></td>
<td>the message</td>
</tr>
<tr>
<td><span class="term"><i><tt>...</tt></i>:</span></td>
<td>extra arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchematronValidityWarningFunc"></a>Function type xmlSchematronValidityWarningFunc</h3>
<pre class="programlisting">void xmlSchematronValidityWarningFunc (void * ctx, <br> const char * msg, <br> ... ...)<br>
</pre>
<p>Signature of a warning callback from a Schematron validation</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctx</tt></i>:</span></td>
<td>the validation context</td>
</tr>
<tr>
<td><span class="term"><i><tt>msg</tt></i>:</span></td>
<td>the message</td>
</tr>
<tr>
<td><span class="term"><i><tt>...</tt></i>:</span></td>
<td>extra arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchematronFree"></a>xmlSchematronFree ()</h3>
<pre class="programlisting">void xmlSchematronFree (<a href="libxml2-schematron.html#xmlSchematronPtr">xmlSchematronPtr</a> schema)<br>
</pre>
<p>Deallocate a Schematron structure.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>schema</tt></i>:</span></td>
<td>a schema structure</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchematronFreeParserCtxt"></a>xmlSchematronFreeParserCtxt ()</h3>
<pre class="programlisting">void xmlSchematronFreeParserCtxt (<a href="libxml2-schematron.html#xmlSchematronParserCtxtPtr">xmlSchematronParserCtxtPtr</a> ctxt)<br>
</pre>
<p>Free the resources associated to the schema parser context</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the schema parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchematronFreeValidCtxt"></a>xmlSchematronFreeValidCtxt ()</h3>
<pre class="programlisting">void xmlSchematronFreeValidCtxt (<a href="libxml2-schematron.html#xmlSchematronValidCtxtPtr">xmlSchematronValidCtxtPtr</a> ctxt)<br>
</pre>
<p>Free the resources associated to the schema validation context</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the schema validation context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchematronNewDocParserCtxt"></a>xmlSchematronNewDocParserCtxt ()</h3>
<pre class="programlisting"><a href="libxml2-schematron.html#xmlSchematronParserCtxtPtr">xmlSchematronParserCtxtPtr</a> xmlSchematronNewDocParserCtxt (<a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc)<br>
</pre>
<p>Create an XML Schematrons parse context for that document. NB. The document may be modified during the parsing process.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>a preparsed document tree</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the parser context or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchematronNewMemParserCtxt"></a>xmlSchematronNewMemParserCtxt ()</h3>
<pre class="programlisting"><a href="libxml2-schematron.html#xmlSchematronParserCtxtPtr">xmlSchematronParserCtxtPtr</a> xmlSchematronNewMemParserCtxt (const char * buffer, <br> int size)<br>
</pre>
<p>Create an XML Schematrons parse context for that memory buffer expected to contain an XML Schematrons file.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buffer</tt></i>:</span></td>
<td>a pointer to a char array containing the schemas</td>
</tr>
<tr>
<td><span class="term"><i><tt>size</tt></i>:</span></td>
<td>the size of the array</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the parser context or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchematronNewParserCtxt"></a>xmlSchematronNewParserCtxt ()</h3>
<pre class="programlisting"><a href="libxml2-schematron.html#xmlSchematronParserCtxtPtr">xmlSchematronParserCtxtPtr</a> xmlSchematronNewParserCtxt (const char * URL)<br>
</pre>
<p>Create an XML Schematrons parse context for that file/resource expected to contain an XML Schematrons file.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>URL</tt></i>:</span></td>
<td>the location of the schema</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the parser context or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchematronNewValidCtxt"></a>xmlSchematronNewValidCtxt ()</h3>
<pre class="programlisting"><a href="libxml2-schematron.html#xmlSchematronValidCtxtPtr">xmlSchematronValidCtxtPtr</a> xmlSchematronNewValidCtxt (<a href="libxml2-schematron.html#xmlSchematronPtr">xmlSchematronPtr</a> schema, <br> int options)<br>
</pre>
<p>Create an XML Schematrons validation context based on the given schema.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>schema</tt></i>:</span></td>
<td>a precompiled XML Schematrons</td>
</tr>
<tr>
<td><span class="term"><i><tt>options</tt></i>:</span></td>
<td>a set of <a href="libxml2-schematron.html#xmlSchematronValidOptions">xmlSchematronValidOptions</a>
</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the validation context or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchematronParse"></a>xmlSchematronParse ()</h3>
<pre class="programlisting"><a href="libxml2-schematron.html#xmlSchematronPtr">xmlSchematronPtr</a> xmlSchematronParse (<a href="libxml2-schematron.html#xmlSchematronParserCtxtPtr">xmlSchematronParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse a schema definition resource and build an internal XML Schema structure which can be used to validate instances.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>a schema validation context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the internal XML Schematron structure built from the resource or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchematronSetValidStructuredErrors"></a>xmlSchematronSetValidStructuredErrors ()</h3>
<pre class="programlisting">void xmlSchematronSetValidStructuredErrors (<a href="libxml2-schematron.html#xmlSchematronValidCtxtPtr">xmlSchematronValidCtxtPtr</a> ctxt, <br> <a href="libxml2-xmlerror.html#xmlStructuredErrorFunc">xmlStructuredErrorFunc</a> serror, <br> void * ctx)<br>
</pre>
<p>Set the structured error callback</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>a Schematron validation context</td>
</tr>
<tr>
<td><span class="term"><i><tt>serror</tt></i>:</span></td>
<td>the structured error function</td>
</tr>
<tr>
<td><span class="term"><i><tt>ctx</tt></i>:</span></td>
<td>the functions context</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchematronValidateDoc"></a>xmlSchematronValidateDoc ()</h3>
<pre class="programlisting">int xmlSchematronValidateDoc (<a href="libxml2-schematron.html#xmlSchematronValidCtxtPtr">xmlSchematronValidCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> instance)<br>
</pre>
<p>Validate a tree instance against the schematron</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the schema validation context</td>
</tr>
<tr>
<td><span class="term"><i><tt>instance</tt></i>:</span></td>
<td>the document instance tree</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 in case of success, -1 in case of internal error and an error count otherwise.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
</div>
</div>
</body>
</html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>schemasInternals: internal interfaces for XML Schemas</title>
<meta name="generator" content="Libxml2 devhelp stylesheet">
<link rel="start" href="index.html" title="libxml2 Reference Manual">
<link rel="up" href="general.html" title="API">
<link rel="stylesheet" href="style.css" type="text/css">
<link rel="chapter" href="general.html" title="API">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table class="navigation" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"><tr valign="middle">
<td><a accesskey="p" href="libxml2-relaxng.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
<td><a accesskey="u" href="general.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
<td><a accesskey="n" href="libxml2-schematron.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
<th width="100%" align="center">libxml2 Reference Manual</th>
</tr></table>
<h2><span class="refentrytitle">schemasInternals</span></h2>
<p>schemasInternals - internal interfaces for XML Schemas</p>
<p>internal interfaces for the XML Schemas handling and schema validity checking The Schemas development is a Work In Progress. Some of those interfaces are not guaranteed to be API or ABI stable ! </p>
<p>Author(s): Daniel Veillard </p>
<div class="refsynopsisdiv">
<h2>Synopsis</h2>
<pre class="synopsis">#define <a href="#XML_SCHEMAS_ANYATTR_LAX">XML_SCHEMAS_ANYATTR_LAX</a>;
#define <a href="#XML_SCHEMAS_ANYATTR_SKIP">XML_SCHEMAS_ANYATTR_SKIP</a>;
#define <a href="#XML_SCHEMAS_ANYATTR_STRICT">XML_SCHEMAS_ANYATTR_STRICT</a>;
#define <a href="#XML_SCHEMAS_ANY_LAX">XML_SCHEMAS_ANY_LAX</a>;
#define <a href="#XML_SCHEMAS_ANY_SKIP">XML_SCHEMAS_ANY_SKIP</a>;
#define <a href="#XML_SCHEMAS_ANY_STRICT">XML_SCHEMAS_ANY_STRICT</a>;
#define <a href="#XML_SCHEMAS_ATTRGROUP_GLOBAL">XML_SCHEMAS_ATTRGROUP_GLOBAL</a>;
#define <a href="#XML_SCHEMAS_ATTRGROUP_HAS_REFS">XML_SCHEMAS_ATTRGROUP_HAS_REFS</a>;
#define <a href="#XML_SCHEMAS_ATTRGROUP_MARKED">XML_SCHEMAS_ATTRGROUP_MARKED</a>;
#define <a href="#XML_SCHEMAS_ATTRGROUP_REDEFINED">XML_SCHEMAS_ATTRGROUP_REDEFINED</a>;
#define <a href="#XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED">XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED</a>;
#define <a href="#XML_SCHEMAS_ATTR_FIXED">XML_SCHEMAS_ATTR_FIXED</a>;
#define <a href="#XML_SCHEMAS_ATTR_GLOBAL">XML_SCHEMAS_ATTR_GLOBAL</a>;
#define <a href="#XML_SCHEMAS_ATTR_INTERNAL_RESOLVED">XML_SCHEMAS_ATTR_INTERNAL_RESOLVED</a>;
#define <a href="#XML_SCHEMAS_ATTR_NSDEFAULT">XML_SCHEMAS_ATTR_NSDEFAULT</a>;
#define <a href="#XML_SCHEMAS_ATTR_USE_OPTIONAL">XML_SCHEMAS_ATTR_USE_OPTIONAL</a>;
#define <a href="#XML_SCHEMAS_ATTR_USE_PROHIBITED">XML_SCHEMAS_ATTR_USE_PROHIBITED</a>;
#define <a href="#XML_SCHEMAS_ATTR_USE_REQUIRED">XML_SCHEMAS_ATTR_USE_REQUIRED</a>;
#define <a href="#XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION">XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION</a>;
#define <a href="#XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION">XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION</a>;
#define <a href="#XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION">XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION</a>;
#define <a href="#XML_SCHEMAS_ELEM_ABSTRACT">XML_SCHEMAS_ELEM_ABSTRACT</a>;
#define <a href="#XML_SCHEMAS_ELEM_BLOCK_ABSENT">XML_SCHEMAS_ELEM_BLOCK_ABSENT</a>;
#define <a href="#XML_SCHEMAS_ELEM_BLOCK_EXTENSION">XML_SCHEMAS_ELEM_BLOCK_EXTENSION</a>;
#define <a href="#XML_SCHEMAS_ELEM_BLOCK_RESTRICTION">XML_SCHEMAS_ELEM_BLOCK_RESTRICTION</a>;
#define <a href="#XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION">XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION</a>;
#define <a href="#XML_SCHEMAS_ELEM_CIRCULAR">XML_SCHEMAS_ELEM_CIRCULAR</a>;
#define <a href="#XML_SCHEMAS_ELEM_DEFAULT">XML_SCHEMAS_ELEM_DEFAULT</a>;
#define <a href="#XML_SCHEMAS_ELEM_FINAL_ABSENT">XML_SCHEMAS_ELEM_FINAL_ABSENT</a>;
#define <a href="#XML_SCHEMAS_ELEM_FINAL_EXTENSION">XML_SCHEMAS_ELEM_FINAL_EXTENSION</a>;
#define <a href="#XML_SCHEMAS_ELEM_FINAL_RESTRICTION">XML_SCHEMAS_ELEM_FINAL_RESTRICTION</a>;
#define <a href="#XML_SCHEMAS_ELEM_FIXED">XML_SCHEMAS_ELEM_FIXED</a>;
#define <a href="#XML_SCHEMAS_ELEM_GLOBAL">XML_SCHEMAS_ELEM_GLOBAL</a>;
#define <a href="#XML_SCHEMAS_ELEM_INTERNAL_CHECKED">XML_SCHEMAS_ELEM_INTERNAL_CHECKED</a>;
#define <a href="#XML_SCHEMAS_ELEM_INTERNAL_RESOLVED">XML_SCHEMAS_ELEM_INTERNAL_RESOLVED</a>;
#define <a href="#XML_SCHEMAS_ELEM_NILLABLE">XML_SCHEMAS_ELEM_NILLABLE</a>;
#define <a href="#XML_SCHEMAS_ELEM_NSDEFAULT">XML_SCHEMAS_ELEM_NSDEFAULT</a>;
#define <a href="#XML_SCHEMAS_ELEM_REF">XML_SCHEMAS_ELEM_REF</a>;
#define <a href="#XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD">XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD</a>;
#define <a href="#XML_SCHEMAS_ELEM_TOPLEVEL">XML_SCHEMAS_ELEM_TOPLEVEL</a>;
#define <a href="#XML_SCHEMAS_FACET_COLLAPSE">XML_SCHEMAS_FACET_COLLAPSE</a>;
#define <a href="#XML_SCHEMAS_FACET_PRESERVE">XML_SCHEMAS_FACET_PRESERVE</a>;
#define <a href="#XML_SCHEMAS_FACET_REPLACE">XML_SCHEMAS_FACET_REPLACE</a>;
#define <a href="#XML_SCHEMAS_FACET_UNKNOWN">XML_SCHEMAS_FACET_UNKNOWN</a>;
#define <a href="#XML_SCHEMAS_FINAL_DEFAULT_EXTENSION">XML_SCHEMAS_FINAL_DEFAULT_EXTENSION</a>;
#define <a href="#XML_SCHEMAS_FINAL_DEFAULT_LIST">XML_SCHEMAS_FINAL_DEFAULT_LIST</a>;
#define <a href="#XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION">XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION</a>;
#define <a href="#XML_SCHEMAS_FINAL_DEFAULT_UNION">XML_SCHEMAS_FINAL_DEFAULT_UNION</a>;
#define <a href="#XML_SCHEMAS_INCLUDING_CONVERT_NS">XML_SCHEMAS_INCLUDING_CONVERT_NS</a>;
#define <a href="#XML_SCHEMAS_QUALIF_ATTR">XML_SCHEMAS_QUALIF_ATTR</a>;
#define <a href="#XML_SCHEMAS_QUALIF_ELEM">XML_SCHEMAS_QUALIF_ELEM</a>;
#define <a href="#XML_SCHEMAS_TYPE_ABSTRACT">XML_SCHEMAS_TYPE_ABSTRACT</a>;
#define <a href="#XML_SCHEMAS_TYPE_BLOCK_DEFAULT">XML_SCHEMAS_TYPE_BLOCK_DEFAULT</a>;
#define <a href="#XML_SCHEMAS_TYPE_BLOCK_EXTENSION">XML_SCHEMAS_TYPE_BLOCK_EXTENSION</a>;
#define <a href="#XML_SCHEMAS_TYPE_BLOCK_RESTRICTION">XML_SCHEMAS_TYPE_BLOCK_RESTRICTION</a>;
#define <a href="#XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE">XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE</a>;
#define <a href="#XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION">XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION</a>;
#define <a href="#XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION">XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION</a>;
#define <a href="#XML_SCHEMAS_TYPE_FACETSNEEDVALUE">XML_SCHEMAS_TYPE_FACETSNEEDVALUE</a>;
#define <a href="#XML_SCHEMAS_TYPE_FINAL_DEFAULT">XML_SCHEMAS_TYPE_FINAL_DEFAULT</a>;
#define <a href="#XML_SCHEMAS_TYPE_FINAL_EXTENSION">XML_SCHEMAS_TYPE_FINAL_EXTENSION</a>;
#define <a href="#XML_SCHEMAS_TYPE_FINAL_LIST">XML_SCHEMAS_TYPE_FINAL_LIST</a>;
#define <a href="#XML_SCHEMAS_TYPE_FINAL_RESTRICTION">XML_SCHEMAS_TYPE_FINAL_RESTRICTION</a>;
#define <a href="#XML_SCHEMAS_TYPE_FINAL_UNION">XML_SCHEMAS_TYPE_FINAL_UNION</a>;
#define <a href="#XML_SCHEMAS_TYPE_FIXUP_1">XML_SCHEMAS_TYPE_FIXUP_1</a>;
#define <a href="#XML_SCHEMAS_TYPE_GLOBAL">XML_SCHEMAS_TYPE_GLOBAL</a>;
#define <a href="#XML_SCHEMAS_TYPE_HAS_FACETS">XML_SCHEMAS_TYPE_HAS_FACETS</a>;
#define <a href="#XML_SCHEMAS_TYPE_INTERNAL_INVALID">XML_SCHEMAS_TYPE_INTERNAL_INVALID</a>;
#define <a href="#XML_SCHEMAS_TYPE_INTERNAL_RESOLVED">XML_SCHEMAS_TYPE_INTERNAL_RESOLVED</a>;
#define <a href="#XML_SCHEMAS_TYPE_MARKED">XML_SCHEMAS_TYPE_MARKED</a>;
#define <a href="#XML_SCHEMAS_TYPE_MIXED">XML_SCHEMAS_TYPE_MIXED</a>;
#define <a href="#XML_SCHEMAS_TYPE_NORMVALUENEEDED">XML_SCHEMAS_TYPE_NORMVALUENEEDED</a>;
#define <a href="#XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD">XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD</a>;
#define <a href="#XML_SCHEMAS_TYPE_REDEFINED">XML_SCHEMAS_TYPE_REDEFINED</a>;
#define <a href="#XML_SCHEMAS_TYPE_VARIETY_ABSENT">XML_SCHEMAS_TYPE_VARIETY_ABSENT</a>;
#define <a href="#XML_SCHEMAS_TYPE_VARIETY_ATOMIC">XML_SCHEMAS_TYPE_VARIETY_ATOMIC</a>;
#define <a href="#XML_SCHEMAS_TYPE_VARIETY_LIST">XML_SCHEMAS_TYPE_VARIETY_LIST</a>;
#define <a href="#XML_SCHEMAS_TYPE_VARIETY_UNION">XML_SCHEMAS_TYPE_VARIETY_UNION</a>;
#define <a href="#XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE">XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE</a>;
#define <a href="#XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE">XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE</a>;
#define <a href="#XML_SCHEMAS_TYPE_WHITESPACE_REPLACE">XML_SCHEMAS_TYPE_WHITESPACE_REPLACE</a>;
#define <a href="#XML_SCHEMAS_WILDCARD_COMPLETE">XML_SCHEMAS_WILDCARD_COMPLETE</a>;
typedef struct _xmlSchemaAnnot <a href="#xmlSchemaAnnot">xmlSchemaAnnot</a>;
typedef <a href="libxml2-schemasInternals.html#xmlSchemaAnnot">xmlSchemaAnnot</a> * <a href="#xmlSchemaAnnotPtr">xmlSchemaAnnotPtr</a>;
typedef struct _xmlSchemaAttribute <a href="#xmlSchemaAttribute">xmlSchemaAttribute</a>;
typedef struct _xmlSchemaAttributeGroup <a href="#xmlSchemaAttributeGroup">xmlSchemaAttributeGroup</a>;
typedef <a href="libxml2-schemasInternals.html#xmlSchemaAttributeGroup">xmlSchemaAttributeGroup</a> * <a href="#xmlSchemaAttributeGroupPtr">xmlSchemaAttributeGroupPtr</a>;
typedef struct _xmlSchemaAttributeLink <a href="#xmlSchemaAttributeLink">xmlSchemaAttributeLink</a>;
typedef <a href="libxml2-schemasInternals.html#xmlSchemaAttributeLink">xmlSchemaAttributeLink</a> * <a href="#xmlSchemaAttributeLinkPtr">xmlSchemaAttributeLinkPtr</a>;
typedef <a href="libxml2-schemasInternals.html#xmlSchemaAttribute">xmlSchemaAttribute</a> * <a href="#xmlSchemaAttributePtr">xmlSchemaAttributePtr</a>;
typedef enum <a href="#xmlSchemaContentType">xmlSchemaContentType</a>;
typedef struct _xmlSchemaElement <a href="#xmlSchemaElement">xmlSchemaElement</a>;
typedef <a href="libxml2-schemasInternals.html#xmlSchemaElement">xmlSchemaElement</a> * <a href="#xmlSchemaElementPtr">xmlSchemaElementPtr</a>;
typedef struct _xmlSchemaFacet <a href="#xmlSchemaFacet">xmlSchemaFacet</a>;
typedef struct _xmlSchemaFacetLink <a href="#xmlSchemaFacetLink">xmlSchemaFacetLink</a>;
typedef <a href="libxml2-schemasInternals.html#xmlSchemaFacetLink">xmlSchemaFacetLink</a> * <a href="#xmlSchemaFacetLinkPtr">xmlSchemaFacetLinkPtr</a>;
typedef <a href="libxml2-schemasInternals.html#xmlSchemaFacet">xmlSchemaFacet</a> * <a href="#xmlSchemaFacetPtr">xmlSchemaFacetPtr</a>;
typedef struct _xmlSchemaNotation <a href="#xmlSchemaNotation">xmlSchemaNotation</a>;
typedef <a href="libxml2-schemasInternals.html#xmlSchemaNotation">xmlSchemaNotation</a> * <a href="#xmlSchemaNotationPtr">xmlSchemaNotationPtr</a>;
typedef struct _xmlSchemaType <a href="#xmlSchemaType">xmlSchemaType</a>;
typedef struct _xmlSchemaTypeLink <a href="#xmlSchemaTypeLink">xmlSchemaTypeLink</a>;
typedef <a href="libxml2-schemasInternals.html#xmlSchemaTypeLink">xmlSchemaTypeLink</a> * <a href="#xmlSchemaTypeLinkPtr">xmlSchemaTypeLinkPtr</a>;
typedef <a href="libxml2-schemasInternals.html#xmlSchemaType">xmlSchemaType</a> * <a href="#xmlSchemaTypePtr">xmlSchemaTypePtr</a>;
typedef enum <a href="#xmlSchemaTypeType">xmlSchemaTypeType</a>;
typedef struct _xmlSchemaVal <a href="#xmlSchemaVal">xmlSchemaVal</a>;
typedef <a href="libxml2-schemasInternals.html#xmlSchemaVal">xmlSchemaVal</a> * <a href="#xmlSchemaValPtr">xmlSchemaValPtr</a>;
typedef enum <a href="#xmlSchemaValType">xmlSchemaValType</a>;
typedef struct _xmlSchemaWildcard <a href="#xmlSchemaWildcard">xmlSchemaWildcard</a>;
typedef struct _xmlSchemaWildcardNs <a href="#xmlSchemaWildcardNs">xmlSchemaWildcardNs</a>;
typedef <a href="libxml2-schemasInternals.html#xmlSchemaWildcardNs">xmlSchemaWildcardNs</a> * <a href="#xmlSchemaWildcardNsPtr">xmlSchemaWildcardNsPtr</a>;
typedef <a href="libxml2-schemasInternals.html#xmlSchemaWildcard">xmlSchemaWildcard</a> * <a href="#xmlSchemaWildcardPtr">xmlSchemaWildcardPtr</a>;
void <a href="#xmlSchemaFreeType">xmlSchemaFreeType</a> (<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> type);
void <a href="#xmlSchemaFreeWildcard">xmlSchemaFreeWildcard</a> (<a href="libxml2-schemasInternals.html#xmlSchemaWildcardPtr">xmlSchemaWildcardPtr</a> wildcard);
</pre>
</div>
<div class="refsect1" lang="en"><h2>Description</h2></div>
<div class="refsect1" lang="en">
<h2>Details</h2>
<div class="refsect2" lang="en">
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ANYATTR_LAX">Macro </a>XML_SCHEMAS_ANYATTR_LAX</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ANYATTR_LAX">XML_SCHEMAS_ANYATTR_LAX</a>;
</pre>
<p>Ignore validation non definition on attributes Obsolete, not used anymore.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ANYATTR_SKIP">Macro </a>XML_SCHEMAS_ANYATTR_SKIP</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ANYATTR_SKIP">XML_SCHEMAS_ANYATTR_SKIP</a>;
</pre>
<p>Skip unknown <a href="libxml2-SAX.html#attribute">attribute</a> from validation Obsolete, not used anymore.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ANYATTR_STRICT">Macro </a>XML_SCHEMAS_ANYATTR_STRICT</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ANYATTR_STRICT">XML_SCHEMAS_ANYATTR_STRICT</a>;
</pre>
<p>Apply strict validation rules on attributes Obsolete, not used anymore.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ANY_LAX">Macro </a>XML_SCHEMAS_ANY_LAX</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ANY_LAX">XML_SCHEMAS_ANY_LAX</a>;
</pre>
<p>Used by wildcards. Validate if type found, don't worry if not found</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ANY_SKIP">Macro </a>XML_SCHEMAS_ANY_SKIP</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ANY_SKIP">XML_SCHEMAS_ANY_SKIP</a>;
</pre>
<p>Skip unknown <a href="libxml2-SAX.html#attribute">attribute</a> from validation</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ANY_STRICT">Macro </a>XML_SCHEMAS_ANY_STRICT</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ANY_STRICT">XML_SCHEMAS_ANY_STRICT</a>;
</pre>
<p>Used by wildcards. Apply strict validation rules</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ATTRGROUP_GLOBAL">Macro </a>XML_SCHEMAS_ATTRGROUP_GLOBAL</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ATTRGROUP_GLOBAL">XML_SCHEMAS_ATTRGROUP_GLOBAL</a>;
</pre>
<p>The <a href="libxml2-SAX.html#attribute">attribute</a> group has been defined.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ATTRGROUP_HAS_REFS">Macro </a>XML_SCHEMAS_ATTRGROUP_HAS_REFS</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ATTRGROUP_HAS_REFS">XML_SCHEMAS_ATTRGROUP_HAS_REFS</a>;
</pre>
<p>Whether this attr. group contains attr. group references.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ATTRGROUP_MARKED">Macro </a>XML_SCHEMAS_ATTRGROUP_MARKED</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ATTRGROUP_MARKED">XML_SCHEMAS_ATTRGROUP_MARKED</a>;
</pre>
<p>Marks the attr group as marked; used for circular checks.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ATTRGROUP_REDEFINED">Macro </a>XML_SCHEMAS_ATTRGROUP_REDEFINED</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ATTRGROUP_REDEFINED">XML_SCHEMAS_ATTRGROUP_REDEFINED</a>;
</pre>
<p>The attr group was redefined.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED">Macro </a>XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED">XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED</a>;
</pre>
<p>The <a href="libxml2-SAX.html#attribute">attribute</a> wildcard has been built.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ATTR_FIXED">Macro </a>XML_SCHEMAS_ATTR_FIXED</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ATTR_FIXED">XML_SCHEMAS_ATTR_FIXED</a>;
</pre>
<p>the <a href="libxml2-SAX.html#attribute">attribute</a> has a fixed value</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ATTR_GLOBAL">Macro </a>XML_SCHEMAS_ATTR_GLOBAL</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ATTR_GLOBAL">XML_SCHEMAS_ATTR_GLOBAL</a>;
</pre>
<p>allow elements in no namespace</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ATTR_INTERNAL_RESOLVED">Macro </a>XML_SCHEMAS_ATTR_INTERNAL_RESOLVED</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ATTR_INTERNAL_RESOLVED">XML_SCHEMAS_ATTR_INTERNAL_RESOLVED</a>;
</pre>
<p>this is set when the "type" and "ref" references have been resolved.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ATTR_NSDEFAULT">Macro </a>XML_SCHEMAS_ATTR_NSDEFAULT</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ATTR_NSDEFAULT">XML_SCHEMAS_ATTR_NSDEFAULT</a>;
</pre>
<p>allow elements in no namespace</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ATTR_USE_OPTIONAL">Macro </a>XML_SCHEMAS_ATTR_USE_OPTIONAL</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ATTR_USE_OPTIONAL">XML_SCHEMAS_ATTR_USE_OPTIONAL</a>;
</pre>
<p>The <a href="libxml2-SAX.html#attribute">attribute</a> is optional.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ATTR_USE_PROHIBITED">Macro </a>XML_SCHEMAS_ATTR_USE_PROHIBITED</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ATTR_USE_PROHIBITED">XML_SCHEMAS_ATTR_USE_PROHIBITED</a>;
</pre>
<p>Used by wildcards. The <a href="libxml2-SAX.html#attribute">attribute</a> is prohibited.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ATTR_USE_REQUIRED">Macro </a>XML_SCHEMAS_ATTR_USE_REQUIRED</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ATTR_USE_REQUIRED">XML_SCHEMAS_ATTR_USE_REQUIRED</a>;
</pre>
<p>The <a href="libxml2-SAX.html#attribute">attribute</a> is required.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION">Macro </a>XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION">XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION</a>;
</pre>
<p>the schema has "extension" in the set of blockDefault.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION">Macro </a>XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION">XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION</a>;
</pre>
<p>the schema has "restriction" in the set of blockDefault.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION">Macro </a>XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION">XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION</a>;
</pre>
<p>the schema has "substitution" in the set of blockDefault.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ELEM_ABSTRACT">Macro </a>XML_SCHEMAS_ELEM_ABSTRACT</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ELEM_ABSTRACT">XML_SCHEMAS_ELEM_ABSTRACT</a>;
</pre>
<p>the element is abstract</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ELEM_BLOCK_ABSENT">Macro </a>XML_SCHEMAS_ELEM_BLOCK_ABSENT</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ELEM_BLOCK_ABSENT">XML_SCHEMAS_ELEM_BLOCK_ABSENT</a>;
</pre>
<p>the "block" <a href="libxml2-SAX.html#attribute">attribute</a> is absent</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ELEM_BLOCK_EXTENSION">Macro </a>XML_SCHEMAS_ELEM_BLOCK_EXTENSION</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ELEM_BLOCK_EXTENSION">XML_SCHEMAS_ELEM_BLOCK_EXTENSION</a>;
</pre>
<p>disallowed substitutions are absent</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ELEM_BLOCK_RESTRICTION">Macro </a>XML_SCHEMAS_ELEM_BLOCK_RESTRICTION</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ELEM_BLOCK_RESTRICTION">XML_SCHEMAS_ELEM_BLOCK_RESTRICTION</a>;
</pre>
<p>disallowed substitutions: "restriction"</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION">Macro </a>XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION">XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION</a>;
</pre>
<p>disallowed substitutions: "substitution"</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ELEM_CIRCULAR">Macro </a>XML_SCHEMAS_ELEM_CIRCULAR</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ELEM_CIRCULAR">XML_SCHEMAS_ELEM_CIRCULAR</a>;
</pre>
<p>a helper flag for the search of circular references.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ELEM_DEFAULT">Macro </a>XML_SCHEMAS_ELEM_DEFAULT</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ELEM_DEFAULT">XML_SCHEMAS_ELEM_DEFAULT</a>;
</pre>
<p>the element has a default value</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ELEM_FINAL_ABSENT">Macro </a>XML_SCHEMAS_ELEM_FINAL_ABSENT</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ELEM_FINAL_ABSENT">XML_SCHEMAS_ELEM_FINAL_ABSENT</a>;
</pre>
<p>substitution group exclusions are absent</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ELEM_FINAL_EXTENSION">Macro </a>XML_SCHEMAS_ELEM_FINAL_EXTENSION</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ELEM_FINAL_EXTENSION">XML_SCHEMAS_ELEM_FINAL_EXTENSION</a>;
</pre>
<p>substitution group exclusions: "extension"</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ELEM_FINAL_RESTRICTION">Macro </a>XML_SCHEMAS_ELEM_FINAL_RESTRICTION</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ELEM_FINAL_RESTRICTION">XML_SCHEMAS_ELEM_FINAL_RESTRICTION</a>;
</pre>
<p>substitution group exclusions: "restriction"</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ELEM_FIXED">Macro </a>XML_SCHEMAS_ELEM_FIXED</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ELEM_FIXED">XML_SCHEMAS_ELEM_FIXED</a>;
</pre>
<p>the element has a fixed value</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ELEM_GLOBAL">Macro </a>XML_SCHEMAS_ELEM_GLOBAL</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ELEM_GLOBAL">XML_SCHEMAS_ELEM_GLOBAL</a>;
</pre>
<p>the element is global</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ELEM_INTERNAL_CHECKED">Macro </a>XML_SCHEMAS_ELEM_INTERNAL_CHECKED</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ELEM_INTERNAL_CHECKED">XML_SCHEMAS_ELEM_INTERNAL_CHECKED</a>;
</pre>
<p>this is set when the elem decl has been checked against all constraints</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ELEM_INTERNAL_RESOLVED">Macro </a>XML_SCHEMAS_ELEM_INTERNAL_RESOLVED</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ELEM_INTERNAL_RESOLVED">XML_SCHEMAS_ELEM_INTERNAL_RESOLVED</a>;
</pre>
<p>this is set when "type", "ref", "substitutionGroup" references have been resolved.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ELEM_NILLABLE">Macro </a>XML_SCHEMAS_ELEM_NILLABLE</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ELEM_NILLABLE">XML_SCHEMAS_ELEM_NILLABLE</a>;
</pre>
<p>the element is nillable</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ELEM_NSDEFAULT">Macro </a>XML_SCHEMAS_ELEM_NSDEFAULT</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ELEM_NSDEFAULT">XML_SCHEMAS_ELEM_NSDEFAULT</a>;
</pre>
<p>allow elements in no namespace Obsolete, not used anymore.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ELEM_REF">Macro </a>XML_SCHEMAS_ELEM_REF</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ELEM_REF">XML_SCHEMAS_ELEM_REF</a>;
</pre>
<p>the element is a <a href="libxml2-SAX.html#reference">reference</a> to a type</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD">Macro </a>XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD">XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD</a>;
</pre>
<p>the declaration is a substitution group head</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_ELEM_TOPLEVEL">Macro </a>XML_SCHEMAS_ELEM_TOPLEVEL</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_ELEM_TOPLEVEL">XML_SCHEMAS_ELEM_TOPLEVEL</a>;
</pre>
<p>the element is top level obsolete: use <a href="libxml2-schemasInternals.html#XML_SCHEMAS_ELEM_GLOBAL">XML_SCHEMAS_ELEM_GLOBAL</a> instead</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_FACET_COLLAPSE">Macro </a>XML_SCHEMAS_FACET_COLLAPSE</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_FACET_COLLAPSE">XML_SCHEMAS_FACET_COLLAPSE</a>;
</pre>
<p>collapse the types of the facet</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_FACET_PRESERVE">Macro </a>XML_SCHEMAS_FACET_PRESERVE</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_FACET_PRESERVE">XML_SCHEMAS_FACET_PRESERVE</a>;
</pre>
<p>preserve the type of the facet</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_FACET_REPLACE">Macro </a>XML_SCHEMAS_FACET_REPLACE</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_FACET_REPLACE">XML_SCHEMAS_FACET_REPLACE</a>;
</pre>
<p>replace the type of the facet</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_FACET_UNKNOWN">Macro </a>XML_SCHEMAS_FACET_UNKNOWN</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_FACET_UNKNOWN">XML_SCHEMAS_FACET_UNKNOWN</a>;
</pre>
<p>unknown facet handling</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_FINAL_DEFAULT_EXTENSION">Macro </a>XML_SCHEMAS_FINAL_DEFAULT_EXTENSION</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_FINAL_DEFAULT_EXTENSION">XML_SCHEMAS_FINAL_DEFAULT_EXTENSION</a>;
</pre>
<p>the schema has "extension" in the set of finalDefault.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_FINAL_DEFAULT_LIST">Macro </a>XML_SCHEMAS_FINAL_DEFAULT_LIST</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_FINAL_DEFAULT_LIST">XML_SCHEMAS_FINAL_DEFAULT_LIST</a>;
</pre>
<p>the schema has "list" in the set of finalDefault.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION">Macro </a>XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION">XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION</a>;
</pre>
<p>the schema has "restriction" in the set of finalDefault.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_FINAL_DEFAULT_UNION">Macro </a>XML_SCHEMAS_FINAL_DEFAULT_UNION</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_FINAL_DEFAULT_UNION">XML_SCHEMAS_FINAL_DEFAULT_UNION</a>;
</pre>
<p>the schema has "union" in the set of finalDefault.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_INCLUDING_CONVERT_NS">Macro </a>XML_SCHEMAS_INCLUDING_CONVERT_NS</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_INCLUDING_CONVERT_NS">XML_SCHEMAS_INCLUDING_CONVERT_NS</a>;
</pre>
<p>the schema is currently including an other schema with no target namespace.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_QUALIF_ATTR">Macro </a>XML_SCHEMAS_QUALIF_ATTR</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_QUALIF_ATTR">XML_SCHEMAS_QUALIF_ATTR</a>;
</pre>
<p>Reflects attributeFormDefault == qualified in an XML schema document.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_QUALIF_ELEM">Macro </a>XML_SCHEMAS_QUALIF_ELEM</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_QUALIF_ELEM">XML_SCHEMAS_QUALIF_ELEM</a>;
</pre>
<p>Reflects elementFormDefault == qualified in an XML schema document.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_ABSTRACT">Macro </a>XML_SCHEMAS_TYPE_ABSTRACT</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_ABSTRACT">XML_SCHEMAS_TYPE_ABSTRACT</a>;
</pre>
<p>the simple/complexType is abstract.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_BLOCK_DEFAULT">Macro </a>XML_SCHEMAS_TYPE_BLOCK_DEFAULT</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_BLOCK_DEFAULT">XML_SCHEMAS_TYPE_BLOCK_DEFAULT</a>;
</pre>
<p>the complexType did not specify 'block' so use the default of the <schema> item.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_BLOCK_EXTENSION">Macro </a>XML_SCHEMAS_TYPE_BLOCK_EXTENSION</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_BLOCK_EXTENSION">XML_SCHEMAS_TYPE_BLOCK_EXTENSION</a>;
</pre>
<p>the complexType has a 'block' of "extension".</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_BLOCK_RESTRICTION">Macro </a>XML_SCHEMAS_TYPE_BLOCK_RESTRICTION</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_BLOCK_RESTRICTION">XML_SCHEMAS_TYPE_BLOCK_RESTRICTION</a>;
</pre>
<p>the complexType has a 'block' of "restriction".</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE">Macro </a>XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE">XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE</a>;
</pre>
<p>Marks the item as a builtin primitive.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION">Macro </a>XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION">XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION</a>;
</pre>
<p>the simple or complex type has a derivation method of "extension".</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION">Macro </a>XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION">XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION</a>;
</pre>
<p>the simple or complex type has a derivation method of "restriction".</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_FACETSNEEDVALUE">Macro </a>XML_SCHEMAS_TYPE_FACETSNEEDVALUE</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_FACETSNEEDVALUE">XML_SCHEMAS_TYPE_FACETSNEEDVALUE</a>;
</pre>
<p>indicates if the facets need a computed value</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_FINAL_DEFAULT">Macro </a>XML_SCHEMAS_TYPE_FINAL_DEFAULT</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_FINAL_DEFAULT">XML_SCHEMAS_TYPE_FINAL_DEFAULT</a>;
</pre>
<p>the simpleType has a final of "default".</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_FINAL_EXTENSION">Macro </a>XML_SCHEMAS_TYPE_FINAL_EXTENSION</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_FINAL_EXTENSION">XML_SCHEMAS_TYPE_FINAL_EXTENSION</a>;
</pre>
<p>the complexType has a final of "extension".</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_FINAL_LIST">Macro </a>XML_SCHEMAS_TYPE_FINAL_LIST</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_FINAL_LIST">XML_SCHEMAS_TYPE_FINAL_LIST</a>;
</pre>
<p>the simpleType has a final of "list".</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_FINAL_RESTRICTION">Macro </a>XML_SCHEMAS_TYPE_FINAL_RESTRICTION</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_FINAL_RESTRICTION">XML_SCHEMAS_TYPE_FINAL_RESTRICTION</a>;
</pre>
<p>the simpleType/complexType has a final of "restriction".</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_FINAL_UNION">Macro </a>XML_SCHEMAS_TYPE_FINAL_UNION</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_FINAL_UNION">XML_SCHEMAS_TYPE_FINAL_UNION</a>;
</pre>
<p>the simpleType has a final of "union".</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_FIXUP_1">Macro </a>XML_SCHEMAS_TYPE_FIXUP_1</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_FIXUP_1">XML_SCHEMAS_TYPE_FIXUP_1</a>;
</pre>
<p>First stage of fixup was done.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_GLOBAL">Macro </a>XML_SCHEMAS_TYPE_GLOBAL</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_GLOBAL">XML_SCHEMAS_TYPE_GLOBAL</a>;
</pre>
<p>the type is global</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_HAS_FACETS">Macro </a>XML_SCHEMAS_TYPE_HAS_FACETS</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_HAS_FACETS">XML_SCHEMAS_TYPE_HAS_FACETS</a>;
</pre>
<p>has facets</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_INTERNAL_INVALID">Macro </a>XML_SCHEMAS_TYPE_INTERNAL_INVALID</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_INTERNAL_INVALID">XML_SCHEMAS_TYPE_INTERNAL_INVALID</a>;
</pre>
<p>indicates that the type is invalid</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_INTERNAL_RESOLVED">Macro </a>XML_SCHEMAS_TYPE_INTERNAL_RESOLVED</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_INTERNAL_RESOLVED">XML_SCHEMAS_TYPE_INTERNAL_RESOLVED</a>;
</pre>
<p>indicates that the type was typefixed</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_MARKED">Macro </a>XML_SCHEMAS_TYPE_MARKED</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_MARKED">XML_SCHEMAS_TYPE_MARKED</a>;
</pre>
<p>Marks the item as marked; used for circular checks.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_MIXED">Macro </a>XML_SCHEMAS_TYPE_MIXED</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_MIXED">XML_SCHEMAS_TYPE_MIXED</a>;
</pre>
<p>the element content type is mixed</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_NORMVALUENEEDED">Macro </a>XML_SCHEMAS_TYPE_NORMVALUENEEDED</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_NORMVALUENEEDED">XML_SCHEMAS_TYPE_NORMVALUENEEDED</a>;
</pre>
<p>indicates if the facets (pattern) need a normalized value</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD">Macro </a>XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD">XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD</a>;
</pre>
<p>the complexType owns an <a href="libxml2-SAX.html#attribute">attribute</a> wildcard, i.e. it can be freed by the complexType</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_REDEFINED">Macro </a>XML_SCHEMAS_TYPE_REDEFINED</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_REDEFINED">XML_SCHEMAS_TYPE_REDEFINED</a>;
</pre>
<p>The type was redefined.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_VARIETY_ABSENT">Macro </a>XML_SCHEMAS_TYPE_VARIETY_ABSENT</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_VARIETY_ABSENT">XML_SCHEMAS_TYPE_VARIETY_ABSENT</a>;
</pre>
<p>the simpleType has a variety of "absent". TODO: Actually not necessary :-/, since if none of the variety flags occur then it's automatically absent.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_VARIETY_ATOMIC">Macro </a>XML_SCHEMAS_TYPE_VARIETY_ATOMIC</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_VARIETY_ATOMIC">XML_SCHEMAS_TYPE_VARIETY_ATOMIC</a>;
</pre>
<p>the simpleType has a variety of "union".</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_VARIETY_LIST">Macro </a>XML_SCHEMAS_TYPE_VARIETY_LIST</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_VARIETY_LIST">XML_SCHEMAS_TYPE_VARIETY_LIST</a>;
</pre>
<p>the simpleType has a variety of "list".</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_VARIETY_UNION">Macro </a>XML_SCHEMAS_TYPE_VARIETY_UNION</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_VARIETY_UNION">XML_SCHEMAS_TYPE_VARIETY_UNION</a>;
</pre>
<p>the simpleType has a variety of "union".</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE">Macro </a>XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE">XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE</a>;
</pre>
<p>a whitespace-facet value of "collapse"</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE">Macro </a>XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE">XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE</a>;
</pre>
<p>a whitespace-facet value of "preserve"</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_TYPE_WHITESPACE_REPLACE">Macro </a>XML_SCHEMAS_TYPE_WHITESPACE_REPLACE</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_TYPE_WHITESPACE_REPLACE">XML_SCHEMAS_TYPE_WHITESPACE_REPLACE</a>;
</pre>
<p>a whitespace-facet value of "replace"</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SCHEMAS_WILDCARD_COMPLETE">Macro </a>XML_SCHEMAS_WILDCARD_COMPLETE</h3>
<pre class="programlisting">#define <a href="#XML_SCHEMAS_WILDCARD_COMPLETE">XML_SCHEMAS_WILDCARD_COMPLETE</a>;
</pre>
<p>If the wildcard is complete.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaAnnot">Structure </a>xmlSchemaAnnot</h3>
<pre class="programlisting">struct _xmlSchemaAnnot {
struct _xmlSchemaAnnot * next
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> content : the annotation
} xmlSchemaAnnot;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaAnnotPtr">Typedef </a>xmlSchemaAnnotPtr</h3>
<pre class="programlisting"><a href="libxml2-schemasInternals.html#xmlSchemaAnnot">xmlSchemaAnnot</a> * xmlSchemaAnnotPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaAttribute">Structure </a>xmlSchemaAttribute</h3>
<pre class="programlisting">struct _xmlSchemaAttribute {
<a href="libxml2-schemasInternals.html#xmlSchemaTypeType">xmlSchemaTypeType</a> type
struct _xmlSchemaAttribute * next : the next <a href="libxml2-SAX.html#attribute">attribute</a> (not used?)
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name : the name of the declaration
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * id : Deprecated; not used
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ref : Deprecated; not used
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * refNs : Deprecated; not used
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * typeName : the local name of the type definition
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * typeNs : the ns URI of the type definition
<a href="libxml2-schemasInternals.html#xmlSchemaAnnotPtr">xmlSchemaAnnotPtr</a> annot
<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> base : Deprecated; not used
int occurs : Deprecated; not used
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * defValue : The initial value of the value constraint
<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> subtypes : the type definition
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * targetNamespace
int flags
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * refPrefix : Deprecated; not used
<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> defVal : The compiled value constraint
<a href="libxml2-schemasInternals.html#xmlSchemaAttributePtr">xmlSchemaAttributePtr</a> refDecl : Deprecated; not used
} xmlSchemaAttribute;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaAttributeGroup">Structure </a>xmlSchemaAttributeGroup</h3>
<pre class="programlisting">struct _xmlSchemaAttributeGroup {
<a href="libxml2-schemasInternals.html#xmlSchemaTypeType">xmlSchemaTypeType</a> type : The kind of type
struct _xmlSchemaAttribute * next : the next <a href="libxml2-SAX.html#attribute">attribute</a> if in a group ...
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * id
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ref : Deprecated; not used
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * refNs : Deprecated; not used
<a href="libxml2-schemasInternals.html#xmlSchemaAnnotPtr">xmlSchemaAnnotPtr</a> annot
<a href="libxml2-schemasInternals.html#xmlSchemaAttributePtr">xmlSchemaAttributePtr</a> attributes : Deprecated; not used
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node
int flags
<a href="libxml2-schemasInternals.html#xmlSchemaWildcardPtr">xmlSchemaWildcardPtr</a> attributeWildcard
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * refPrefix : Deprecated; not used
<a href="libxml2-schemasInternals.html#xmlSchemaAttributeGroupPtr">xmlSchemaAttributeGroupPtr</a> refItem : Deprecated; not used
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * targetNamespace
void * attrUses
} xmlSchemaAttributeGroup;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaAttributeGroupPtr">Typedef </a>xmlSchemaAttributeGroupPtr</h3>
<pre class="programlisting"><a href="libxml2-schemasInternals.html#xmlSchemaAttributeGroup">xmlSchemaAttributeGroup</a> * xmlSchemaAttributeGroupPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaAttributeLink">Structure </a>xmlSchemaAttributeLink</h3>
<pre class="programlisting">struct _xmlSchemaAttributeLink {
struct _xmlSchemaAttributeLink * next : the next <a href="libxml2-SAX.html#attribute">attribute</a> link ...
struct _xmlSchemaAttribute * attr : the linked <a href="libxml2-SAX.html#attribute">attribute</a>
} xmlSchemaAttributeLink;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaAttributeLinkPtr">Typedef </a>xmlSchemaAttributeLinkPtr</h3>
<pre class="programlisting"><a href="libxml2-schemasInternals.html#xmlSchemaAttributeLink">xmlSchemaAttributeLink</a> * xmlSchemaAttributeLinkPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaAttributePtr">Typedef </a>xmlSchemaAttributePtr</h3>
<pre class="programlisting"><a href="libxml2-schemasInternals.html#xmlSchemaAttribute">xmlSchemaAttribute</a> * xmlSchemaAttributePtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaContentType">Enum </a>xmlSchemaContentType</h3>
<pre class="programlisting">enum <a href="#xmlSchemaContentType">xmlSchemaContentType</a> {
<a name="XML_SCHEMA_CONTENT_UNKNOWN">XML_SCHEMA_CONTENT_UNKNOWN</a> = 0
<a name="XML_SCHEMA_CONTENT_EMPTY">XML_SCHEMA_CONTENT_EMPTY</a> = 1
<a name="XML_SCHEMA_CONTENT_ELEMENTS">XML_SCHEMA_CONTENT_ELEMENTS</a> = 2
<a name="XML_SCHEMA_CONTENT_MIXED">XML_SCHEMA_CONTENT_MIXED</a> = 3
<a name="XML_SCHEMA_CONTENT_SIMPLE">XML_SCHEMA_CONTENT_SIMPLE</a> = 4
<a name="XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS">XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS</a> = 5 /* Obsolete */
<a name="XML_SCHEMA_CONTENT_BASIC">XML_SCHEMA_CONTENT_BASIC</a> = 6
<a name="XML_SCHEMA_CONTENT_ANY">XML_SCHEMA_CONTENT_ANY</a> = 7
};
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaElement">Structure </a>xmlSchemaElement</h3>
<pre class="programlisting">struct _xmlSchemaElement {
<a href="libxml2-schemasInternals.html#xmlSchemaTypeType">xmlSchemaTypeType</a> type : The kind of type
struct _xmlSchemaType * next : Not used?
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * id : Deprecated; not used
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ref : Deprecated; not used
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * refNs : Deprecated; not used
<a href="libxml2-schemasInternals.html#xmlSchemaAnnotPtr">xmlSchemaAnnotPtr</a> annot
<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> subtypes : the type definition
<a href="libxml2-schemasInternals.html#xmlSchemaAttributePtr">xmlSchemaAttributePtr</a> attributes
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node
int minOccurs : Deprecated; not used
int maxOccurs : Deprecated; not used
int flags
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * targetNamespace
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * namedType
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * namedTypeNs
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * substGroup
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * substGroupNs
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * scope
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value : The original value of the value constraint.
struct _xmlSchemaElement * refDecl : This will now be used for the substitution group affiliation
<a href="libxml2-xmlregexp.html#xmlRegexpPtr">xmlRegexpPtr</a> contModel : Obsolete for WXS, maybe used for RelaxNG
<a href="libxml2-schemasInternals.html#xmlSchemaContentType">xmlSchemaContentType</a> contentType
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * refPrefix : Deprecated; not used
<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> defVal : The compiled value constraint.
void * idcs : The identity-constraint defs
} xmlSchemaElement;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaElementPtr">Typedef </a>xmlSchemaElementPtr</h3>
<pre class="programlisting"><a href="libxml2-schemasInternals.html#xmlSchemaElement">xmlSchemaElement</a> * xmlSchemaElementPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaFacet">Structure </a>xmlSchemaFacet</h3>
<pre class="programlisting">struct _xmlSchemaFacet {
<a href="libxml2-schemasInternals.html#xmlSchemaTypeType">xmlSchemaTypeType</a> type : The kind of type
struct _xmlSchemaFacet * next : the next type if in a sequence ...
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value : The original value
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * id : Obsolete
<a href="libxml2-schemasInternals.html#xmlSchemaAnnotPtr">xmlSchemaAnnotPtr</a> annot
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node
int fixed : XML_SCHEMAS_FACET_PRESERVE, etc.
int whitespace
<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> val : The compiled value
<a href="libxml2-xmlregexp.html#xmlRegexpPtr">xmlRegexpPtr</a> regexp : The regex for patterns
} xmlSchemaFacet;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaFacetLink">Structure </a>xmlSchemaFacetLink</h3>
<pre class="programlisting">struct _xmlSchemaFacetLink {
struct _xmlSchemaFacetLink * next : the next facet link ...
<a href="libxml2-schemasInternals.html#xmlSchemaFacetPtr">xmlSchemaFacetPtr</a> facet : the linked facet
} xmlSchemaFacetLink;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaFacetLinkPtr">Typedef </a>xmlSchemaFacetLinkPtr</h3>
<pre class="programlisting"><a href="libxml2-schemasInternals.html#xmlSchemaFacetLink">xmlSchemaFacetLink</a> * xmlSchemaFacetLinkPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaFacetPtr">Typedef </a>xmlSchemaFacetPtr</h3>
<pre class="programlisting"><a href="libxml2-schemasInternals.html#xmlSchemaFacet">xmlSchemaFacet</a> * xmlSchemaFacetPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaNotation">Structure </a>xmlSchemaNotation</h3>
<pre class="programlisting">struct _xmlSchemaNotation {
<a href="libxml2-schemasInternals.html#xmlSchemaTypeType">xmlSchemaTypeType</a> type : The kind of type
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name
<a href="libxml2-schemasInternals.html#xmlSchemaAnnotPtr">xmlSchemaAnnotPtr</a> annot
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * identifier
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * targetNamespace
} xmlSchemaNotation;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaNotationPtr">Typedef </a>xmlSchemaNotationPtr</h3>
<pre class="programlisting"><a href="libxml2-schemasInternals.html#xmlSchemaNotation">xmlSchemaNotation</a> * xmlSchemaNotationPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaType">Structure </a>xmlSchemaType</h3>
<pre class="programlisting">struct _xmlSchemaType {
<a href="libxml2-schemasInternals.html#xmlSchemaTypeType">xmlSchemaTypeType</a> type : The kind of type
struct _xmlSchemaType * next : the next type if in a sequence ...
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * id : Deprecated; not used
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ref : Deprecated; not used
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * refNs : Deprecated; not used
<a href="libxml2-schemasInternals.html#xmlSchemaAnnotPtr">xmlSchemaAnnotPtr</a> annot
<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> subtypes
<a href="libxml2-schemasInternals.html#xmlSchemaAttributePtr">xmlSchemaAttributePtr</a> attributes : Deprecated; not used
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node
int minOccurs : Deprecated; not used
int maxOccurs : Deprecated; not used
int flags
<a href="libxml2-schemasInternals.html#xmlSchemaContentType">xmlSchemaContentType</a> contentType
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * base : Base type's local name
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * baseNs : Base type's target namespace
<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> baseType : The base type component
<a href="libxml2-schemasInternals.html#xmlSchemaFacetPtr">xmlSchemaFacetPtr</a> facets : Local facets
struct _xmlSchemaType * redef : Deprecated; not used
int recurse : Obsolete
<a href="libxml2-schemasInternals.html#xmlSchemaAttributeLinkPtr">xmlSchemaAttributeLinkPtr</a> * attributeUses : Deprecated; not used
<a href="libxml2-schemasInternals.html#xmlSchemaWildcardPtr">xmlSchemaWildcardPtr</a> attributeWildcard
int builtInType : Type of built-in types.
<a href="libxml2-schemasInternals.html#xmlSchemaTypeLinkPtr">xmlSchemaTypeLinkPtr</a> memberTypes : member-types if a union type.
<a href="libxml2-schemasInternals.html#xmlSchemaFacetLinkPtr">xmlSchemaFacetLinkPtr</a> facetSet : All facets (incl. inherited)
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * refPrefix : Deprecated; not used
<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> contentTypeDef : Used for the simple content of complex types. Could we use @subtypes
<a href="libxml2-xmlregexp.html#xmlRegexpPtr">xmlRegexpPtr</a> contModel : Holds the automaton of the content model
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * targetNamespace
void * attrUses
} xmlSchemaType;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaTypeLink">Structure </a>xmlSchemaTypeLink</h3>
<pre class="programlisting">struct _xmlSchemaTypeLink {
struct _xmlSchemaTypeLink * next : the next type link ...
<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> type : the linked type
} xmlSchemaTypeLink;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaTypeLinkPtr">Typedef </a>xmlSchemaTypeLinkPtr</h3>
<pre class="programlisting"><a href="libxml2-schemasInternals.html#xmlSchemaTypeLink">xmlSchemaTypeLink</a> * xmlSchemaTypeLinkPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaTypePtr">Typedef </a>xmlSchemaTypePtr</h3>
<pre class="programlisting"><a href="libxml2-schemasInternals.html#xmlSchemaType">xmlSchemaType</a> * xmlSchemaTypePtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaTypeType">Enum </a>xmlSchemaTypeType</h3>
<pre class="programlisting">enum <a href="#xmlSchemaTypeType">xmlSchemaTypeType</a> {
<a name="XML_SCHEMA_TYPE_BASIC">XML_SCHEMA_TYPE_BASIC</a> = 1 /* A built-in datatype */
<a name="XML_SCHEMA_TYPE_ANY">XML_SCHEMA_TYPE_ANY</a> = 2
<a name="XML_SCHEMA_TYPE_FACET">XML_SCHEMA_TYPE_FACET</a> = 3
<a name="XML_SCHEMA_TYPE_SIMPLE">XML_SCHEMA_TYPE_SIMPLE</a> = 4
<a name="XML_SCHEMA_TYPE_COMPLEX">XML_SCHEMA_TYPE_COMPLEX</a> = 5
<a name="XML_SCHEMA_TYPE_SEQUENCE">XML_SCHEMA_TYPE_SEQUENCE</a> = 6
<a name="XML_SCHEMA_TYPE_CHOICE">XML_SCHEMA_TYPE_CHOICE</a> = 7
<a name="XML_SCHEMA_TYPE_ALL">XML_SCHEMA_TYPE_ALL</a> = 8
<a name="XML_SCHEMA_TYPE_SIMPLE_CONTENT">XML_SCHEMA_TYPE_SIMPLE_CONTENT</a> = 9
<a name="XML_SCHEMA_TYPE_COMPLEX_CONTENT">XML_SCHEMA_TYPE_COMPLEX_CONTENT</a> = 10
<a name="XML_SCHEMA_TYPE_UR">XML_SCHEMA_TYPE_UR</a> = 11
<a name="XML_SCHEMA_TYPE_RESTRICTION">XML_SCHEMA_TYPE_RESTRICTION</a> = 12
<a name="XML_SCHEMA_TYPE_EXTENSION">XML_SCHEMA_TYPE_EXTENSION</a> = 13
<a name="XML_SCHEMA_TYPE_ELEMENT">XML_SCHEMA_TYPE_ELEMENT</a> = 14
<a name="XML_SCHEMA_TYPE_ATTRIBUTE">XML_SCHEMA_TYPE_ATTRIBUTE</a> = 15
<a name="XML_SCHEMA_TYPE_ATTRIBUTEGROUP">XML_SCHEMA_TYPE_ATTRIBUTEGROUP</a> = 16
<a name="XML_SCHEMA_TYPE_GROUP">XML_SCHEMA_TYPE_GROUP</a> = 17
<a name="XML_SCHEMA_TYPE_NOTATION">XML_SCHEMA_TYPE_NOTATION</a> = 18
<a name="XML_SCHEMA_TYPE_LIST">XML_SCHEMA_TYPE_LIST</a> = 19
<a name="XML_SCHEMA_TYPE_UNION">XML_SCHEMA_TYPE_UNION</a> = 20
<a name="XML_SCHEMA_TYPE_ANY_ATTRIBUTE">XML_SCHEMA_TYPE_ANY_ATTRIBUTE</a> = 21
<a name="XML_SCHEMA_TYPE_IDC_UNIQUE">XML_SCHEMA_TYPE_IDC_UNIQUE</a> = 22
<a name="XML_SCHEMA_TYPE_IDC_KEY">XML_SCHEMA_TYPE_IDC_KEY</a> = 23
<a name="XML_SCHEMA_TYPE_IDC_KEYREF">XML_SCHEMA_TYPE_IDC_KEYREF</a> = 24
<a name="XML_SCHEMA_TYPE_PARTICLE">XML_SCHEMA_TYPE_PARTICLE</a> = 25
<a name="XML_SCHEMA_TYPE_ATTRIBUTE_USE">XML_SCHEMA_TYPE_ATTRIBUTE_USE</a> = 26
<a name="XML_SCHEMA_FACET_MININCLUSIVE">XML_SCHEMA_FACET_MININCLUSIVE</a> = 1000
<a name="XML_SCHEMA_FACET_MINEXCLUSIVE">XML_SCHEMA_FACET_MINEXCLUSIVE</a> = 1001
<a name="XML_SCHEMA_FACET_MAXINCLUSIVE">XML_SCHEMA_FACET_MAXINCLUSIVE</a> = 1002
<a name="XML_SCHEMA_FACET_MAXEXCLUSIVE">XML_SCHEMA_FACET_MAXEXCLUSIVE</a> = 1003
<a name="XML_SCHEMA_FACET_TOTALDIGITS">XML_SCHEMA_FACET_TOTALDIGITS</a> = 1004
<a name="XML_SCHEMA_FACET_FRACTIONDIGITS">XML_SCHEMA_FACET_FRACTIONDIGITS</a> = 1005
<a name="XML_SCHEMA_FACET_PATTERN">XML_SCHEMA_FACET_PATTERN</a> = 1006
<a name="XML_SCHEMA_FACET_ENUMERATION">XML_SCHEMA_FACET_ENUMERATION</a> = 1007
<a name="XML_SCHEMA_FACET_WHITESPACE">XML_SCHEMA_FACET_WHITESPACE</a> = 1008
<a name="XML_SCHEMA_FACET_LENGTH">XML_SCHEMA_FACET_LENGTH</a> = 1009
<a name="XML_SCHEMA_FACET_MAXLENGTH">XML_SCHEMA_FACET_MAXLENGTH</a> = 1010
<a name="XML_SCHEMA_FACET_MINLENGTH">XML_SCHEMA_FACET_MINLENGTH</a> = 1011
<a name="XML_SCHEMA_EXTRA_QNAMEREF">XML_SCHEMA_EXTRA_QNAMEREF</a> = 2000
<a name="XML_SCHEMA_EXTRA_ATTR_USE_PROHIB">XML_SCHEMA_EXTRA_ATTR_USE_PROHIB</a> = 2001
};
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaVal">Structure </a>xmlSchemaVal</h3>
<pre class="programlisting">struct _xmlSchemaVal {
The content of this structure is not made public by the API.
} xmlSchemaVal;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaValPtr">Typedef </a>xmlSchemaValPtr</h3>
<pre class="programlisting"><a href="libxml2-schemasInternals.html#xmlSchemaVal">xmlSchemaVal</a> * xmlSchemaValPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaValType">Enum </a>xmlSchemaValType</h3>
<pre class="programlisting">enum <a href="#xmlSchemaValType">xmlSchemaValType</a> {
<a name="XML_SCHEMAS_UNKNOWN">XML_SCHEMAS_UNKNOWN</a> = 0
<a name="XML_SCHEMAS_STRING">XML_SCHEMAS_STRING</a> = 1
<a name="XML_SCHEMAS_NORMSTRING">XML_SCHEMAS_NORMSTRING</a> = 2
<a name="XML_SCHEMAS_DECIMAL">XML_SCHEMAS_DECIMAL</a> = 3
<a name="XML_SCHEMAS_TIME">XML_SCHEMAS_TIME</a> = 4
<a name="XML_SCHEMAS_GDAY">XML_SCHEMAS_GDAY</a> = 5
<a name="XML_SCHEMAS_GMONTH">XML_SCHEMAS_GMONTH</a> = 6
<a name="XML_SCHEMAS_GMONTHDAY">XML_SCHEMAS_GMONTHDAY</a> = 7
<a name="XML_SCHEMAS_GYEAR">XML_SCHEMAS_GYEAR</a> = 8
<a name="XML_SCHEMAS_GYEARMONTH">XML_SCHEMAS_GYEARMONTH</a> = 9
<a name="XML_SCHEMAS_DATE">XML_SCHEMAS_DATE</a> = 10
<a name="XML_SCHEMAS_DATETIME">XML_SCHEMAS_DATETIME</a> = 11
<a name="XML_SCHEMAS_DURATION">XML_SCHEMAS_DURATION</a> = 12
<a name="XML_SCHEMAS_FLOAT">XML_SCHEMAS_FLOAT</a> = 13
<a name="XML_SCHEMAS_DOUBLE">XML_SCHEMAS_DOUBLE</a> = 14
<a name="XML_SCHEMAS_BOOLEAN">XML_SCHEMAS_BOOLEAN</a> = 15
<a name="XML_SCHEMAS_TOKEN">XML_SCHEMAS_TOKEN</a> = 16
<a name="XML_SCHEMAS_LANGUAGE">XML_SCHEMAS_LANGUAGE</a> = 17
<a name="XML_SCHEMAS_NMTOKEN">XML_SCHEMAS_NMTOKEN</a> = 18
<a name="XML_SCHEMAS_NMTOKENS">XML_SCHEMAS_NMTOKENS</a> = 19
<a name="XML_SCHEMAS_NAME">XML_SCHEMAS_NAME</a> = 20
<a name="XML_SCHEMAS_QNAME">XML_SCHEMAS_QNAME</a> = 21
<a name="XML_SCHEMAS_NCNAME">XML_SCHEMAS_NCNAME</a> = 22
<a name="XML_SCHEMAS_ID">XML_SCHEMAS_ID</a> = 23
<a name="XML_SCHEMAS_IDREF">XML_SCHEMAS_IDREF</a> = 24
<a name="XML_SCHEMAS_IDREFS">XML_SCHEMAS_IDREFS</a> = 25
<a name="XML_SCHEMAS_ENTITY">XML_SCHEMAS_ENTITY</a> = 26
<a name="XML_SCHEMAS_ENTITIES">XML_SCHEMAS_ENTITIES</a> = 27
<a name="XML_SCHEMAS_NOTATION">XML_SCHEMAS_NOTATION</a> = 28
<a name="XML_SCHEMAS_ANYURI">XML_SCHEMAS_ANYURI</a> = 29
<a name="XML_SCHEMAS_INTEGER">XML_SCHEMAS_INTEGER</a> = 30
<a name="XML_SCHEMAS_NPINTEGER">XML_SCHEMAS_NPINTEGER</a> = 31
<a name="XML_SCHEMAS_NINTEGER">XML_SCHEMAS_NINTEGER</a> = 32
<a name="XML_SCHEMAS_NNINTEGER">XML_SCHEMAS_NNINTEGER</a> = 33
<a name="XML_SCHEMAS_PINTEGER">XML_SCHEMAS_PINTEGER</a> = 34
<a name="XML_SCHEMAS_INT">XML_SCHEMAS_INT</a> = 35
<a name="XML_SCHEMAS_UINT">XML_SCHEMAS_UINT</a> = 36
<a name="XML_SCHEMAS_LONG">XML_SCHEMAS_LONG</a> = 37
<a name="XML_SCHEMAS_ULONG">XML_SCHEMAS_ULONG</a> = 38
<a name="XML_SCHEMAS_SHORT">XML_SCHEMAS_SHORT</a> = 39
<a name="XML_SCHEMAS_USHORT">XML_SCHEMAS_USHORT</a> = 40
<a name="XML_SCHEMAS_BYTE">XML_SCHEMAS_BYTE</a> = 41
<a name="XML_SCHEMAS_UBYTE">XML_SCHEMAS_UBYTE</a> = 42
<a name="XML_SCHEMAS_HEXBINARY">XML_SCHEMAS_HEXBINARY</a> = 43
<a name="XML_SCHEMAS_BASE64BINARY">XML_SCHEMAS_BASE64BINARY</a> = 44
<a name="XML_SCHEMAS_ANYTYPE">XML_SCHEMAS_ANYTYPE</a> = 45
<a name="XML_SCHEMAS_ANYSIMPLETYPE">XML_SCHEMAS_ANYSIMPLETYPE</a> = 46
};
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaWildcard">Structure </a>xmlSchemaWildcard</h3>
<pre class="programlisting">struct _xmlSchemaWildcard {
<a href="libxml2-schemasInternals.html#xmlSchemaTypeType">xmlSchemaTypeType</a> type : The kind of type
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * id : Deprecated; not used
<a href="libxml2-schemasInternals.html#xmlSchemaAnnotPtr">xmlSchemaAnnotPtr</a> annot
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node
int minOccurs : Deprecated; not used
int maxOccurs : Deprecated; not used
int processContents
int any : Indicates if the ns constraint is of ##any
<a href="libxml2-schemasInternals.html#xmlSchemaWildcardNsPtr">xmlSchemaWildcardNsPtr</a> nsSet : The list of allowed namespaces
<a href="libxml2-schemasInternals.html#xmlSchemaWildcardNsPtr">xmlSchemaWildcardNsPtr</a> negNsSet : The negated namespace
int flags
} xmlSchemaWildcard;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaWildcardNs">Structure </a>xmlSchemaWildcardNs</h3>
<pre class="programlisting">struct _xmlSchemaWildcardNs {
struct _xmlSchemaWildcardNs * next : the next constraint link ...
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value : the value
} xmlSchemaWildcardNs;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaWildcardNsPtr">Typedef </a>xmlSchemaWildcardNsPtr</h3>
<pre class="programlisting"><a href="libxml2-schemasInternals.html#xmlSchemaWildcardNs">xmlSchemaWildcardNs</a> * xmlSchemaWildcardNsPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaWildcardPtr">Typedef </a>xmlSchemaWildcardPtr</h3>
<pre class="programlisting"><a href="libxml2-schemasInternals.html#xmlSchemaWildcard">xmlSchemaWildcard</a> * xmlSchemaWildcardPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaFreeType"></a>xmlSchemaFreeType ()</h3>
<pre class="programlisting">void xmlSchemaFreeType (<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> type)<br>
</pre>
<p>Deallocate a Schema Type structure.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>type</tt></i>:</span></td>
<td>a schema type structure</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaFreeWildcard"></a>xmlSchemaFreeWildcard ()</h3>
<pre class="programlisting">void xmlSchemaFreeWildcard (<a href="libxml2-schemasInternals.html#xmlSchemaWildcardPtr">xmlSchemaWildcardPtr</a> wildcard)<br>
</pre>
<p>Deallocates a wildcard structure.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>wildcard</tt></i>:</span></td>
<td>a wildcard structure</td>
</tr></tbody>
</table></div>
</div>
<hr>
</div>
</div>
</body>
</html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>parserInternals: internals routines and limits exported by the parser.</title>
<meta name="generator" content="Libxml2 devhelp stylesheet">
<link rel="start" href="index.html" title="libxml2 Reference Manual">
<link rel="up" href="general.html" title="API">
<link rel="stylesheet" href="style.css" type="text/css">
<link rel="chapter" href="general.html" title="API">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table class="navigation" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"><tr valign="middle">
<td><a accesskey="p" href="libxml2-parser.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
<td><a accesskey="u" href="general.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
<td><a accesskey="n" href="libxml2-pattern.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
<th width="100%" align="center">libxml2 Reference Manual</th>
</tr></table>
<h2><span class="refentrytitle">parserInternals</span></h2>
<p>parserInternals - internals routines and limits exported by the parser.</p>
<p>this module exports a number of internal parsing routines they are not really all intended for applications but can prove useful doing low level processing. </p>
<p>Author(s): Daniel Veillard </p>
<div class="refsynopsisdiv">
<h2>Synopsis</h2>
<pre class="synopsis">#define <a href="#INPUT_CHUNK">INPUT_CHUNK</a>;
#define <a href="#IS_ASCII_DIGIT">IS_ASCII_DIGIT</a>(c);
#define <a href="#IS_ASCII_LETTER">IS_ASCII_LETTER</a>(c);
#define <a href="#IS_BASECHAR">IS_BASECHAR</a>(c);
#define <a href="#IS_BLANK">IS_BLANK</a>(c);
#define <a href="#IS_BLANK_CH">IS_BLANK_CH</a>(c);
#define <a href="#IS_BYTE_CHAR">IS_BYTE_CHAR</a>(c);
#define <a href="#IS_CHAR">IS_CHAR</a>(c);
#define <a href="#IS_CHAR_CH">IS_CHAR_CH</a>(c);
#define <a href="#IS_COMBINING">IS_COMBINING</a>(c);
#define <a href="#IS_COMBINING_CH">IS_COMBINING_CH</a>(c);
#define <a href="#IS_DIGIT">IS_DIGIT</a>(c);
#define <a href="#IS_DIGIT_CH">IS_DIGIT_CH</a>(c);
#define <a href="#IS_EXTENDER">IS_EXTENDER</a>(c);
#define <a href="#IS_EXTENDER_CH">IS_EXTENDER_CH</a>(c);
#define <a href="#IS_IDEOGRAPHIC">IS_IDEOGRAPHIC</a>(c);
#define <a href="#IS_LETTER">IS_LETTER</a>(c);
#define <a href="#IS_LETTER_CH">IS_LETTER_CH</a>(c);
#define <a href="#IS_PUBIDCHAR">IS_PUBIDCHAR</a>(c);
#define <a href="#IS_PUBIDCHAR_CH">IS_PUBIDCHAR_CH</a>(c);
#define <a href="#MOVETO_ENDTAG">MOVETO_ENDTAG</a>(p);
#define <a href="#MOVETO_STARTTAG">MOVETO_STARTTAG</a>(p);
#define <a href="#SKIP_EOL">SKIP_EOL</a>(p);
#define <a href="#XML_MAX_DICTIONARY_LIMIT">XML_MAX_DICTIONARY_LIMIT</a>;
#define <a href="#XML_MAX_LOOKUP_LIMIT">XML_MAX_LOOKUP_LIMIT</a>;
#define <a href="#XML_MAX_NAMELEN">XML_MAX_NAMELEN</a>;
#define <a href="#XML_MAX_NAME_LENGTH">XML_MAX_NAME_LENGTH</a>;
#define <a href="#XML_MAX_TEXT_LENGTH">XML_MAX_TEXT_LENGTH</a>;
#define <a href="#XML_SUBSTITUTE_BOTH">XML_SUBSTITUTE_BOTH</a>;
#define <a href="#XML_SUBSTITUTE_NONE">XML_SUBSTITUTE_NONE</a>;
#define <a href="#XML_SUBSTITUTE_PEREF">XML_SUBSTITUTE_PEREF</a>;
#define <a href="#XML_SUBSTITUTE_REF">XML_SUBSTITUTE_REF</a>;
<a href="libxml2-HTMLparser.html#htmlParserCtxtPtr">htmlParserCtxtPtr</a> <a href="#htmlCreateFileParserCtxt">htmlCreateFileParserCtxt</a> (const char * filename, <br> const char * encoding);
void <a href="#htmlInitAutoClose">htmlInitAutoClose</a> (void);
<a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a> <a href="#inputPop">inputPop</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
int <a href="#inputPush">inputPush</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a> value);
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#namePop">namePop</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
int <a href="#namePush">namePush</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#nodePop">nodePop</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
int <a href="#nodePush">nodePush</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> value);
int <a href="#xmlCheckLanguageID">xmlCheckLanguageID</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * lang);
int <a href="#xmlCopyChar">xmlCopyChar</a> (int len, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * out, <br> int val);
int <a href="#xmlCopyCharMultiByte">xmlCopyCharMultiByte</a> (<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * out, <br> int val);
<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> <a href="#xmlCreateEntityParserCtxt">xmlCreateEntityParserCtxt</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * URL, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ID, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * base);
<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> <a href="#xmlCreateFileParserCtxt">xmlCreateFileParserCtxt</a> (const char * filename);
<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> <a href="#xmlCreateMemoryParserCtxt">xmlCreateMemoryParserCtxt</a> (const char * buffer, <br> int size);
<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> <a href="#xmlCreateURLParserCtxt">xmlCreateURLParserCtxt</a> (const char * filename, <br> int options);
int <a href="#xmlCurrentChar">xmlCurrentChar</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> int * len);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlDecodeEntities">xmlDecodeEntities</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> int len, <br> int what, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> end, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> end2, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> end3);
typedef void <a href="#xmlEntityReferenceFunc">xmlEntityReferenceFunc</a> (<a href="libxml2-tree.html#xmlEntityPtr">xmlEntityPtr</a> ent, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> firstNode, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> lastNode);
void <a href="#xmlErrMemory">xmlErrMemory</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> const char * extra);
void <a href="#xmlFreeInputStream">xmlFreeInputStream</a> (<a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a> input);
void <a href="#xmlHandleEntity">xmlHandleEntity</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlEntityPtr">xmlEntityPtr</a> entity);
int <a href="#xmlIsLetter">xmlIsLetter</a> (int c);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlNamespaceParseNCName">xmlNamespaceParseNCName</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlNamespaceParseNSDef">xmlNamespaceParseNSDef</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlNamespaceParseQName">xmlNamespaceParseQName</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** prefix);
<a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a> <a href="#xmlNewEntityInputStream">xmlNewEntityInputStream</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlEntityPtr">xmlEntityPtr</a> entity);
<a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a> <a href="#xmlNewInputFromFile">xmlNewInputFromFile</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> const char * filename);
<a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a> <a href="#xmlNewInputStream">xmlNewInputStream</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
<a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a> <a href="#xmlNewStringInputStream">xmlNewStringInputStream</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * buffer);
void <a href="#xmlNextChar">xmlNextChar</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlParseAttValue">xmlParseAttValue</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlParseAttribute">xmlParseAttribute</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** value);
void <a href="#xmlParseAttributeListDecl">xmlParseAttributeListDecl</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
int <a href="#xmlParseAttributeType">xmlParseAttributeType</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlEnumerationPtr">xmlEnumerationPtr</a> * tree);
void <a href="#xmlParseCDSect">xmlParseCDSect</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
void <a href="#xmlParseCharData">xmlParseCharData</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> int cdata);
int <a href="#xmlParseCharRef">xmlParseCharRef</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
void <a href="#xmlParseComment">xmlParseComment</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
void <a href="#xmlParseContent">xmlParseContent</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
int <a href="#xmlParseDefaultDecl">xmlParseDefaultDecl</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** value);
void <a href="#xmlParseDocTypeDecl">xmlParseDocTypeDecl</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
void <a href="#xmlParseElement">xmlParseElement</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
<a href="libxml2-tree.html#xmlElementContentPtr">xmlElementContentPtr</a> <a href="#xmlParseElementChildrenContentDecl">xmlParseElementChildrenContentDecl</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> int inputchk);
int <a href="#xmlParseElementContentDecl">xmlParseElementContentDecl</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> <a href="libxml2-tree.html#xmlElementContentPtr">xmlElementContentPtr</a> * result);
int <a href="#xmlParseElementDecl">xmlParseElementDecl</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
<a href="libxml2-tree.html#xmlElementContentPtr">xmlElementContentPtr</a> <a href="#xmlParseElementMixedContentDecl">xmlParseElementMixedContentDecl</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> int inputchk);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlParseEncName">xmlParseEncName</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlParseEncodingDecl">xmlParseEncodingDecl</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
void <a href="#xmlParseEndTag">xmlParseEndTag</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
void <a href="#xmlParseEntityDecl">xmlParseEntityDecl</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
<a href="libxml2-tree.html#xmlEntityPtr">xmlEntityPtr</a> <a href="#xmlParseEntityRef">xmlParseEntityRef</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlParseEntityValue">xmlParseEntityValue</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** orig);
int <a href="#xmlParseEnumeratedType">xmlParseEnumeratedType</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlEnumerationPtr">xmlEnumerationPtr</a> * tree);
<a href="libxml2-tree.html#xmlEnumerationPtr">xmlEnumerationPtr</a> <a href="#xmlParseEnumerationType">xmlParseEnumerationType</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlParseExternalID">xmlParseExternalID</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** publicID, <br> int strict);
void <a href="#xmlParseExternalSubset">xmlParseExternalSubset</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ExternalID, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * SystemID);
void <a href="#xmlParseMarkupDecl">xmlParseMarkupDecl</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
void <a href="#xmlParseMisc">xmlParseMisc</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlParseName">xmlParseName</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
void <a href="#xmlParseNamespace">xmlParseNamespace</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlParseNmtoken">xmlParseNmtoken</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
void <a href="#xmlParseNotationDecl">xmlParseNotationDecl</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
<a href="libxml2-tree.html#xmlEnumerationPtr">xmlEnumerationPtr</a> <a href="#xmlParseNotationType">xmlParseNotationType</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
void <a href="#xmlParsePEReference">xmlParsePEReference</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
void <a href="#xmlParsePI">xmlParsePI</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlParsePITarget">xmlParsePITarget</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlParsePubidLiteral">xmlParsePubidLiteral</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlParseQuotedString">xmlParseQuotedString</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
void <a href="#xmlParseReference">xmlParseReference</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
int <a href="#xmlParseSDDecl">xmlParseSDDecl</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlParseStartTag">xmlParseStartTag</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlParseSystemLiteral">xmlParseSystemLiteral</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
void <a href="#xmlParseTextDecl">xmlParseTextDecl</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlParseVersionInfo">xmlParseVersionInfo</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlParseVersionNum">xmlParseVersionNum</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
void <a href="#xmlParseXMLDecl">xmlParseXMLDecl</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
void <a href="#xmlParserHandlePEReference">xmlParserHandlePEReference</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
void <a href="#xmlParserHandleReference">xmlParserHandleReference</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
void <a href="#xmlParserInputShrink">xmlParserInputShrink</a> (<a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a> in);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> <a href="#xmlPopInput">xmlPopInput</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
int <a href="#xmlPushInput">xmlPushInput</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a> input);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlScanName">xmlScanName</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
void <a href="#xmlSetEntityReferenceFunc">xmlSetEntityReferenceFunc</a> (<a href="libxml2-parserInternals.html#xmlEntityReferenceFunc">xmlEntityReferenceFunc</a> func);
int <a href="#xmlSkipBlankChars">xmlSkipBlankChars</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlSplitQName">xmlSplitQName</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** prefix);
int <a href="#xmlStringCurrentChar">xmlStringCurrentChar</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * cur, <br> int * len);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlStringDecodeEntities">xmlStringDecodeEntities</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * str, <br> int what, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> end, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> end2, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> end3);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlStringLenDecodeEntities">xmlStringLenDecodeEntities</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * str, <br> int len, <br> int what, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> end, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> end2, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> end3);
int <a href="#xmlSwitchEncoding">xmlSwitchEncoding</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-encoding.html#xmlCharEncoding">xmlCharEncoding</a> enc);
int <a href="#xmlSwitchInputEncoding">xmlSwitchInputEncoding</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a> input, <br> <a href="libxml2-encoding.html#xmlCharEncodingHandlerPtr">xmlCharEncodingHandlerPtr</a> handler);
int <a href="#xmlSwitchToEncoding">xmlSwitchToEncoding</a> (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-encoding.html#xmlCharEncodingHandlerPtr">xmlCharEncodingHandlerPtr</a> handler);
</pre>
</div>
<div class="refsect1" lang="en"><h2>Description</h2></div>
<div class="refsect1" lang="en">
<h2>Details</h2>
<div class="refsect2" lang="en">
<div class="refsect2" lang="en">
<h3>
<a name="INPUT_CHUNK">Macro </a>INPUT_CHUNK</h3>
<pre class="programlisting">#define <a href="#INPUT_CHUNK">INPUT_CHUNK</a>;
</pre>
<p>The parser tries to always have that amount of input ready. One of the point is providing context when reporting errors.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="IS_ASCII_DIGIT">Macro </a>IS_ASCII_DIGIT</h3>
<pre class="programlisting">#define <a href="#IS_ASCII_DIGIT">IS_ASCII_DIGIT</a>(c);
</pre>
<p>Macro to check [0-9]</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>c</tt></i>:</span></td>
<td>an <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> value</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="IS_ASCII_LETTER">Macro </a>IS_ASCII_LETTER</h3>
<pre class="programlisting">#define <a href="#IS_ASCII_LETTER">IS_ASCII_LETTER</a>(c);
</pre>
<p>Macro to check [a-zA-Z]</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>c</tt></i>:</span></td>
<td>an <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> value</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="IS_BASECHAR">Macro </a>IS_BASECHAR</h3>
<pre class="programlisting">#define <a href="#IS_BASECHAR">IS_BASECHAR</a>(c);
</pre>
<p>Macro to check the following production in the XML spec: [85] BaseChar ::= ... long list see REC ...</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>c</tt></i>:</span></td>
<td>an UNICODE value (int)</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="IS_BLANK">Macro </a>IS_BLANK</h3>
<pre class="programlisting">#define <a href="#IS_BLANK">IS_BLANK</a>(c);
</pre>
<p>Macro to check the following production in the XML spec: [3] S ::= (#x20 | #x9 | #xD | #xA)+</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>c</tt></i>:</span></td>
<td>an UNICODE value (int)</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="IS_BLANK_CH">Macro </a>IS_BLANK_CH</h3>
<pre class="programlisting">#define <a href="#IS_BLANK_CH">IS_BLANK_CH</a>(c);
</pre>
<p>Behaviour same as <a href="libxml2-parserInternals.html#IS_BLANK">IS_BLANK</a></p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>c</tt></i>:</span></td>
<td>an <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> value (normally unsigned char)</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="IS_BYTE_CHAR">Macro </a>IS_BYTE_CHAR</h3>
<pre class="programlisting">#define <a href="#IS_BYTE_CHAR">IS_BYTE_CHAR</a>(c);
</pre>
<p>Macro to check the following production in the XML spec: [2] Char ::= #x9 | #xA | #xD | [#x20...] any byte character in the accepted range</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>c</tt></i>:</span></td>
<td>an byte value (int)</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="IS_CHAR">Macro </a>IS_CHAR</h3>
<pre class="programlisting">#define <a href="#IS_CHAR">IS_CHAR</a>(c);
</pre>
<p>Macro to check the following production in the XML spec: [2] Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF] any Unicode character, excluding the surrogate blocks, FFFE, and FFFF.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>c</tt></i>:</span></td>
<td>an UNICODE value (int)</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="IS_CHAR_CH">Macro </a>IS_CHAR_CH</h3>
<pre class="programlisting">#define <a href="#IS_CHAR_CH">IS_CHAR_CH</a>(c);
</pre>
<p>Behaves like <a href="libxml2-parserInternals.html#IS_CHAR">IS_CHAR</a> on single-byte value</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>c</tt></i>:</span></td>
<td>an <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> (usually an unsigned char)</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="IS_COMBINING">Macro </a>IS_COMBINING</h3>
<pre class="programlisting">#define <a href="#IS_COMBINING">IS_COMBINING</a>(c);
</pre>
<p>Macro to check the following production in the XML spec: [87] CombiningChar ::= ... long list see REC ...</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>c</tt></i>:</span></td>
<td>an UNICODE value (int)</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="IS_COMBINING_CH">Macro </a>IS_COMBINING_CH</h3>
<pre class="programlisting">#define <a href="#IS_COMBINING_CH">IS_COMBINING_CH</a>(c);
</pre>
<p>Always false (all combining chars > 0xff)</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>c</tt></i>:</span></td>
<td>an <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> (usually an unsigned char)</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="IS_DIGIT">Macro </a>IS_DIGIT</h3>
<pre class="programlisting">#define <a href="#IS_DIGIT">IS_DIGIT</a>(c);
</pre>
<p>Macro to check the following production in the XML spec: [88] Digit ::= ... long list see REC ...</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>c</tt></i>:</span></td>
<td>an UNICODE value (int)</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="IS_DIGIT_CH">Macro </a>IS_DIGIT_CH</h3>
<pre class="programlisting">#define <a href="#IS_DIGIT_CH">IS_DIGIT_CH</a>(c);
</pre>
<p>Behaves like <a href="libxml2-parserInternals.html#IS_DIGIT">IS_DIGIT</a> but with a single byte argument</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>c</tt></i>:</span></td>
<td>an <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> value (usually an unsigned char)</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="IS_EXTENDER">Macro </a>IS_EXTENDER</h3>
<pre class="programlisting">#define <a href="#IS_EXTENDER">IS_EXTENDER</a>(c);
</pre>
<p>Macro to check the following production in the XML spec: [89] Extender ::= #x00B7 | #x02D0 | #x02D1 | #x0387 | #x0640 | #x0E46 | #x0EC6 | #x3005 | [#x3031-#x3035] | [#x309D-#x309E] | [#x30FC-#x30FE]</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>c</tt></i>:</span></td>
<td>an UNICODE value (int)</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="IS_EXTENDER_CH">Macro </a>IS_EXTENDER_CH</h3>
<pre class="programlisting">#define <a href="#IS_EXTENDER_CH">IS_EXTENDER_CH</a>(c);
</pre>
<p>Behaves like <a href="libxml2-parserInternals.html#IS_EXTENDER">IS_EXTENDER</a> but with a single-byte argument</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>c</tt></i>:</span></td>
<td>an <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> value (usually an unsigned char)</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="IS_IDEOGRAPHIC">Macro </a>IS_IDEOGRAPHIC</h3>
<pre class="programlisting">#define <a href="#IS_IDEOGRAPHIC">IS_IDEOGRAPHIC</a>(c);
</pre>
<p>Macro to check the following production in the XML spec: [86] Ideographic ::= [#x4E00-#x9FA5] | #x3007 | [#x3021-#x3029]</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>c</tt></i>:</span></td>
<td>an UNICODE value (int)</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="IS_LETTER">Macro </a>IS_LETTER</h3>
<pre class="programlisting">#define <a href="#IS_LETTER">IS_LETTER</a>(c);
</pre>
<p>Macro to check the following production in the XML spec: [84] Letter ::= BaseChar | Ideographic</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>c</tt></i>:</span></td>
<td>an UNICODE value (int)</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="IS_LETTER_CH">Macro </a>IS_LETTER_CH</h3>
<pre class="programlisting">#define <a href="#IS_LETTER_CH">IS_LETTER_CH</a>(c);
</pre>
<p>Macro behaves like IS_LETTER, but only check base chars</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>c</tt></i>:</span></td>
<td>an <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> value (normally unsigned char)</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="IS_PUBIDCHAR">Macro </a>IS_PUBIDCHAR</h3>
<pre class="programlisting">#define <a href="#IS_PUBIDCHAR">IS_PUBIDCHAR</a>(c);
</pre>
<p>Macro to check the following production in the XML spec: [13] PubidChar ::= #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%]</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>c</tt></i>:</span></td>
<td>an UNICODE value (int)</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="IS_PUBIDCHAR_CH">Macro </a>IS_PUBIDCHAR_CH</h3>
<pre class="programlisting">#define <a href="#IS_PUBIDCHAR_CH">IS_PUBIDCHAR_CH</a>(c);
</pre>
<p>Same as <a href="libxml2-parserInternals.html#IS_PUBIDCHAR">IS_PUBIDCHAR</a> but for single-byte value</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>c</tt></i>:</span></td>
<td>an <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> value (normally unsigned char)</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="MOVETO_ENDTAG">Macro </a>MOVETO_ENDTAG</h3>
<pre class="programlisting">#define <a href="#MOVETO_ENDTAG">MOVETO_ENDTAG</a>(p);
</pre>
<p>Skips to the next '>' char.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>p</tt></i>:</span></td>
<td>and UTF8 string pointer</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="MOVETO_STARTTAG">Macro </a>MOVETO_STARTTAG</h3>
<pre class="programlisting">#define <a href="#MOVETO_STARTTAG">MOVETO_STARTTAG</a>(p);
</pre>
<p>Skips to the next '<' char.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>p</tt></i>:</span></td>
<td>and UTF8 string pointer</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="SKIP_EOL">Macro </a>SKIP_EOL</h3>
<pre class="programlisting">#define <a href="#SKIP_EOL">SKIP_EOL</a>(p);
</pre>
<p>Skips the end of line chars.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>p</tt></i>:</span></td>
<td>and UTF8 string pointer</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_MAX_DICTIONARY_LIMIT">Macro </a>XML_MAX_DICTIONARY_LIMIT</h3>
<pre class="programlisting">#define <a href="#XML_MAX_DICTIONARY_LIMIT">XML_MAX_DICTIONARY_LIMIT</a>;
</pre>
<p>Maximum size allowed by the parser for a dictionary by default This is not a limitation of the parser but a safety boundary feature, use <a href="libxml2-parser.html#XML_PARSE_HUGE">XML_PARSE_HUGE</a> option to override it. Introduced in 2.9.0</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_MAX_LOOKUP_LIMIT">Macro </a>XML_MAX_LOOKUP_LIMIT</h3>
<pre class="programlisting">#define <a href="#XML_MAX_LOOKUP_LIMIT">XML_MAX_LOOKUP_LIMIT</a>;
</pre>
<p>Maximum size allowed by the parser for ahead lookup This is an upper boundary enforced by the parser to avoid bad behaviour on "unfriendly' content Introduced in 2.9.0</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_MAX_NAMELEN">Macro </a>XML_MAX_NAMELEN</h3>
<pre class="programlisting">#define <a href="#XML_MAX_NAMELEN">XML_MAX_NAMELEN</a>;
</pre>
<p>Identifiers can be longer, but this will be more costly at runtime.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_MAX_NAME_LENGTH">Macro </a>XML_MAX_NAME_LENGTH</h3>
<pre class="programlisting">#define <a href="#XML_MAX_NAME_LENGTH">XML_MAX_NAME_LENGTH</a>;
</pre>
<p>Maximum size allowed for a markup identifier. This is not a limitation of the parser but a safety boundary feature, use <a href="libxml2-parser.html#XML_PARSE_HUGE">XML_PARSE_HUGE</a> option to override it. Note that with the use of parsing dictionaries overriding the limit may result in more runtime memory usage in face of "unfriendly' content Introduced in 2.9.0</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_MAX_TEXT_LENGTH">Macro </a>XML_MAX_TEXT_LENGTH</h3>
<pre class="programlisting">#define <a href="#XML_MAX_TEXT_LENGTH">XML_MAX_TEXT_LENGTH</a>;
</pre>
<p>Maximum size allowed for a single text node when building a tree. This is not a limitation of the parser but a safety boundary feature, use <a href="libxml2-parser.html#XML_PARSE_HUGE">XML_PARSE_HUGE</a> option to override it. Introduced in 2.9.0</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SUBSTITUTE_BOTH">Macro </a>XML_SUBSTITUTE_BOTH</h3>
<pre class="programlisting">#define <a href="#XML_SUBSTITUTE_BOTH">XML_SUBSTITUTE_BOTH</a>;
</pre>
<p>Both general and parameter entities need to be substituted.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SUBSTITUTE_NONE">Macro </a>XML_SUBSTITUTE_NONE</h3>
<pre class="programlisting">#define <a href="#XML_SUBSTITUTE_NONE">XML_SUBSTITUTE_NONE</a>;
</pre>
<p>If no entities need to be substituted.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SUBSTITUTE_PEREF">Macro </a>XML_SUBSTITUTE_PEREF</h3>
<pre class="programlisting">#define <a href="#XML_SUBSTITUTE_PEREF">XML_SUBSTITUTE_PEREF</a>;
</pre>
<p>Whether parameter entities need to be substituted.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XML_SUBSTITUTE_REF">Macro </a>XML_SUBSTITUTE_REF</h3>
<pre class="programlisting">#define <a href="#XML_SUBSTITUTE_REF">XML_SUBSTITUTE_REF</a>;
</pre>
<p>Whether general entities need to be substituted.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlEntityReferenceFunc"></a>Function type xmlEntityReferenceFunc</h3>
<pre class="programlisting">void xmlEntityReferenceFunc (<a href="libxml2-tree.html#xmlEntityPtr">xmlEntityPtr</a> ent, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> firstNode, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> lastNode)<br>
</pre>
<p>Callback function used when one needs to be able to track back the provenance of a chunk of nodes inherited from an entity replacement.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ent</tt></i>:</span></td>
<td>the entity</td>
</tr>
<tr>
<td><span class="term"><i><tt>firstNode</tt></i>:</span></td>
<td>the fist node in the chunk</td>
</tr>
<tr>
<td><span class="term"><i><tt>lastNode</tt></i>:</span></td>
<td>the last nod in the chunk</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParserMaxDepth">Variable </a>xmlParserMaxDepth</h3>
<pre class="programlisting">unsigned int xmlParserMaxDepth;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlStringComment">Variable </a>xmlStringComment</h3>
<pre class="programlisting">const xmlCharxmlStringComment[] xmlStringComment;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlStringText">Variable </a>xmlStringText</h3>
<pre class="programlisting">const xmlCharxmlStringText[] xmlStringText;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlStringTextNoenc">Variable </a>xmlStringTextNoenc</h3>
<pre class="programlisting">const xmlCharxmlStringTextNoenc[] xmlStringTextNoenc;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="htmlCreateFileParserCtxt"></a>htmlCreateFileParserCtxt ()</h3>
<pre class="programlisting"><a href="libxml2-HTMLparser.html#htmlParserCtxtPtr">htmlParserCtxtPtr</a> htmlCreateFileParserCtxt (const char * filename, <br> const char * encoding)<br>
</pre>
<p>Create a parser context for a file content. Automatic support for ZLIB/Compress compressed document is provided by default if found at compile-time.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>filename</tt></i>:</span></td>
<td>the filename</td>
</tr>
<tr>
<td><span class="term"><i><tt>encoding</tt></i>:</span></td>
<td>a free form C string describing the HTML document encoding, or NULL</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the new parser context or NULL</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="htmlInitAutoClose"></a>htmlInitAutoClose ()</h3>
<pre class="programlisting">void htmlInitAutoClose (void)<br>
</pre>
<p>DEPRECATED: This function will be made private. Call <a href="libxml2-parser.html#xmlInitParser">xmlInitParser</a> to initialize the library. This is a no-op now.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="inputPop"></a>inputPop ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a> inputPop (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>Pops the top parser input from the input stack</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the input just removed</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="inputPush"></a>inputPush ()</h3>
<pre class="programlisting">int inputPush (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a> value)<br>
</pre>
<p>Pushes a new parser input on top of the input stack</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the parser input</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>-1 in case of error, the index in the stack otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="namePop"></a>namePop ()</h3>
<pre class="programlisting">const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * namePop (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>Pops the top element name from the name stack</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the name just removed</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="namePush"></a>namePush ()</h3>
<pre class="programlisting">int namePush (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value)<br>
</pre>
<p>Pushes a new element name on top of the name stack</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the element name</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>-1 in case of error, the index in the stack otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="nodePop"></a>nodePop ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> nodePop (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>Pops the top element node from the node stack</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the node just removed</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="nodePush"></a>nodePush ()</h3>
<pre class="programlisting">int nodePush (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> value)<br>
</pre>
<p>Pushes a new element node on top of the node stack</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the element node</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>-1 in case of error, the index in the stack otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlCheckLanguageID"></a>xmlCheckLanguageID ()</h3>
<pre class="programlisting">int xmlCheckLanguageID (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * lang)<br>
</pre>
<p>Checks that the value conforms to the LanguageID production: NOTE: this is somewhat deprecated, those productions were removed from the XML Second edition. [33] LanguageID ::= Langcode ('-' Subcode)* [34] Langcode ::= ISO639Code | IanaCode | UserCode [35] ISO639Code ::= ([a-z] | [A-Z]) ([a-z] | [A-Z]) [36] IanaCode ::= ('i' | 'I') '-' ([a-z] | [A-Z])+ [37] UserCode ::= ('x' | 'X') '-' ([a-z] | [A-Z])+ [38] Subcode ::= ([a-z] | [A-Z])+ The current REC <a href="libxml2-SAX.html#reference">reference</a> the successors of RFC 1766, currently 5646 http://www.rfc-editor.org/rfc/rfc5646.txt langtag = language ["-" script] ["-" region] *("-" variant) *("-" extension) ["-" privateuse] language = 2*3ALPHA ; shortest ISO 639 code ["-" extlang] ; sometimes followed by ; extended language subtags / 4ALPHA ; or reserved for future use / 5*8ALPHA ; or registered language subtag extlang = 3ALPHA ; selected ISO 639 codes *2("-" 3ALPHA) ; permanently reserved script = 4ALPHA ; ISO 15924 code region = 2ALPHA ; ISO 3166-1 code / 3DIGIT ; UN M.49 code variant = 5*8alphanum ; registered variants / (DIGIT 3alphanum) extension = singleton 1*("-" (2*8alphanum)) ; Single alphanumerics ; "x" reserved for private use singleton = DIGIT ; 0 - 9 / %x41-57 ; A - W / %x59-5A ; Y - Z / %x61-77 ; a - w / %x79-7A ; y - z it sounds right to still allow Irregular i-xxx IANA and user codes too The parser below doesn't try to cope with extension or privateuse that could be added but that's not interoperable anyway</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>lang</tt></i>:</span></td>
<td>pointer to the string value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if correct 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlCopyChar"></a>xmlCopyChar ()</h3>
<pre class="programlisting">int xmlCopyChar (int len, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * out, <br> int val)<br>
</pre>
<p>append the char value in the array</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>len</tt></i>:</span></td>
<td>Ignored, compatibility</td>
</tr>
<tr>
<td><span class="term"><i><tt>out</tt></i>:</span></td>
<td>pointer to an array of <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a>
</td>
</tr>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the char value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> written</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlCopyCharMultiByte"></a>xmlCopyCharMultiByte ()</h3>
<pre class="programlisting">int xmlCopyCharMultiByte (<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * out, <br> int val)<br>
</pre>
<p>append the char value in the array</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>out</tt></i>:</span></td>
<td>pointer to an array of <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a>
</td>
</tr>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the char value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> written</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlCreateEntityParserCtxt"></a>xmlCreateEntityParserCtxt ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> xmlCreateEntityParserCtxt (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * URL, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ID, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * base)<br>
</pre>
<p>Create a parser context for an external entity Automatic support for ZLIB/Compress compressed document is provided by default if found at compile-time.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>URL</tt></i>:</span></td>
<td>the entity URL</td>
</tr>
<tr>
<td><span class="term"><i><tt>ID</tt></i>:</span></td>
<td>the entity PUBLIC ID</td>
</tr>
<tr>
<td><span class="term"><i><tt>base</tt></i>:</span></td>
<td>a possible base for the target URI</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the new parser context or NULL</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlCreateFileParserCtxt"></a>xmlCreateFileParserCtxt ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> xmlCreateFileParserCtxt (const char * filename)<br>
</pre>
<p>Create a parser context for a file content. Automatic support for ZLIB/Compress compressed document is provided by default if found at compile-time.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>filename</tt></i>:</span></td>
<td>the filename</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the new parser context or NULL</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlCreateMemoryParserCtxt"></a>xmlCreateMemoryParserCtxt ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> xmlCreateMemoryParserCtxt (const char * buffer, <br> int size)<br>
</pre>
<p>Create a parser context for an XML in-memory document.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buffer</tt></i>:</span></td>
<td>a pointer to a char array</td>
</tr>
<tr>
<td><span class="term"><i><tt>size</tt></i>:</span></td>
<td>the size of the array</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the new parser context or NULL</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlCreateURLParserCtxt"></a>xmlCreateURLParserCtxt ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> xmlCreateURLParserCtxt (const char * filename, <br> int options)<br>
</pre>
<p>Create a parser context for a file or URL content. Automatic support for ZLIB/Compress compressed document is provided by default if found at compile-time and for file accesses</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>filename</tt></i>:</span></td>
<td>the filename or URL</td>
</tr>
<tr>
<td><span class="term"><i><tt>options</tt></i>:</span></td>
<td>a combination of <a href="libxml2-parser.html#xmlParserOption">xmlParserOption</a>
</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the new parser context or NULL</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlCurrentChar"></a>xmlCurrentChar ()</h3>
<pre class="programlisting">int xmlCurrentChar (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> int * len)<br>
</pre>
<p>The current char value, if using UTF-8 this may actually span multiple bytes in the input buffer. Implement the end of line normalization: 2.11 End-of-Line Handling Wherever an external parsed entity or the literal entity value of an internal parsed entity contains either the literal two-character sequence "#xD#xA" or a standalone literal #xD, an XML processor must pass to the application the single character #xA. This behavior can conveniently be produced by normalizing all line breaks to #xA on input, before parsing.)</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>len</tt></i>:</span></td>
<td>pointer to the length of the char read</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the current char value and its length</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDecodeEntities"></a>xmlDecodeEntities ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlDecodeEntities (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> int len, <br> int what, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> end, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> end2, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> end3)<br>
</pre>
<p>This function is deprecated, we now always process entities content through <a href="libxml2-parserInternals.html#xmlStringDecodeEntities">xmlStringDecodeEntities</a> TODO: remove it in next major release. [67] Reference ::= EntityRef | CharRef [69] PEReference ::= '%' Name ';'</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>len</tt></i>:</span></td>
<td>the len to decode (in bytes !), -1 for no size limit</td>
</tr>
<tr>
<td><span class="term"><i><tt>what</tt></i>:</span></td>
<td>combination of <a href="libxml2-parserInternals.html#XML_SUBSTITUTE_REF">XML_SUBSTITUTE_REF</a> and <a href="libxml2-parserInternals.html#XML_SUBSTITUTE_PEREF">XML_SUBSTITUTE_PEREF</a>
</td>
</tr>
<tr>
<td><span class="term"><i><tt>end</tt></i>:</span></td>
<td>an end marker xmlChar, 0 if none</td>
</tr>
<tr>
<td><span class="term"><i><tt>end2</tt></i>:</span></td>
<td>an end marker xmlChar, 0 if none</td>
</tr>
<tr>
<td><span class="term"><i><tt>end3</tt></i>:</span></td>
<td>an end marker xmlChar, 0 if none</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>A newly allocated string with the substitution done. The caller must deallocate it !</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlErrMemory"></a>xmlErrMemory ()</h3>
<pre class="programlisting">void xmlErrMemory (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> const char * extra)<br>
</pre>
<p>Handle a redefinition of <a href="libxml2-SAX.html#attribute">attribute</a> error</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>extra</tt></i>:</span></td>
<td>extra information</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlFreeInputStream"></a>xmlFreeInputStream ()</h3>
<pre class="programlisting">void xmlFreeInputStream (<a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a> input)<br>
</pre>
<p>Free up an input stream.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>input</tt></i>:</span></td>
<td>an <a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a>
</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlHandleEntity"></a>xmlHandleEntity ()</h3>
<pre class="programlisting">void xmlHandleEntity (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlEntityPtr">xmlEntityPtr</a> entity)<br>
</pre>
<p>Default handling of defined entities, when should we define a new input stream ? When do we just handle that as a set of chars ? OBSOLETE: to be removed at some point.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>entity</tt></i>:</span></td>
<td>an XML entity pointer.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlIsLetter"></a>xmlIsLetter ()</h3>
<pre class="programlisting">int xmlIsLetter (int c)<br>
</pre>
<p>Check whether the character is allowed by the production [84] Letter ::= BaseChar | Ideographic</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>c</tt></i>:</span></td>
<td>an unicode character (int)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if not, non-zero otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNamespaceParseNCName"></a>xmlNamespaceParseNCName ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlNamespaceParseNCName (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse an XML namespace name. TODO: this seems not in use anymore, the namespace handling is done on top of the SAX interfaces, i.e. not on raw input. [NS 3] NCName ::= (Letter | '_') (NCNameChar)* [NS 4] NCNameChar ::= Letter | Digit | '.' | '-' | '_' | CombiningChar | Extender</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the namespace name or NULL</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNamespaceParseNSDef"></a>xmlNamespaceParseNSDef ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlNamespaceParseNSDef (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse a namespace prefix declaration TODO: this seems not in use anymore, the namespace handling is done on top of the SAX interfaces, i.e. not on raw input. [NS 1] NSDef ::= PrefixDef Eq SystemLiteral [NS 2] PrefixDef ::= 'xmlns' (':' NCName)?</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the namespace name</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNamespaceParseQName"></a>xmlNamespaceParseQName ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlNamespaceParseQName (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** prefix)<br>
</pre>
<p>TODO: this seems not in use anymore, the namespace handling is done on top of the SAX interfaces, i.e. not on raw input. parse an XML qualified name [NS 5] QName ::= (Prefix ':')? LocalPart [NS 6] Prefix ::= NCName [NS 7] LocalPart ::= NCName</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>prefix</tt></i>:</span></td>
<td>a <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> **</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the local part, and prefix is updated to get the Prefix if any.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewEntityInputStream"></a>xmlNewEntityInputStream ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a> xmlNewEntityInputStream (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlEntityPtr">xmlEntityPtr</a> entity)<br>
</pre>
<p>Create a new input stream based on an <a href="libxml2-tree.html#xmlEntityPtr">xmlEntityPtr</a></p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>entity</tt></i>:</span></td>
<td>an Entity pointer</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the new input stream or NULL</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewInputFromFile"></a>xmlNewInputFromFile ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a> xmlNewInputFromFile (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> const char * filename)<br>
</pre>
<p>Create a new input stream based on a file or an URL.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>filename</tt></i>:</span></td>
<td>the filename to use as entity</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the new input stream or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewInputStream"></a>xmlNewInputStream ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a> xmlNewInputStream (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>Create a new input stream structure.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the new input stream or NULL</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewStringInputStream"></a>xmlNewStringInputStream ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a> xmlNewStringInputStream (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * buffer)<br>
</pre>
<p>Create a new input stream based on a memory buffer.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>buffer</tt></i>:</span></td>
<td>an memory buffer</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the new input stream</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNextChar"></a>xmlNextChar ()</h3>
<pre class="programlisting">void xmlNextChar (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>Skip to the next char input char.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XML parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseAttValue"></a>xmlParseAttValue ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlParseAttValue (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse a value for an <a href="libxml2-SAX.html#attribute">attribute</a> Note: the parser won't do substitution of entities here, this will be handled later in <a href="libxml2-tree.html#xmlStringGetNodeList">xmlStringGetNodeList</a> [10] AttValue ::= '"' ([^<&"] | Reference)* '"' | "'" ([^<&'] | Reference)* "'" 3.3.3 Attribute-Value Normalization: Before the value of an <a href="libxml2-SAX.html#attribute">attribute</a> is passed to the application or checked for validity, the XML processor must normalize it as follows: - a character <a href="libxml2-SAX.html#reference">reference</a> is processed by appending the referenced character to the <a href="libxml2-SAX.html#attribute">attribute</a> value - an entity <a href="libxml2-SAX.html#reference">reference</a> is processed by recursively processing the replacement text of the entity - a whitespace character (#x20, #xD, #xA, #x9) is processed by appending #x20 to the normalized value, except that only a single #x20 is appended for a "#xD#xA" sequence that is part of an external parsed entity or the literal entity value of an internal parsed entity - other <a href="libxml2-SAX.html#characters">characters</a> are processed by appending them to the normalized value If the declared value is not CDATA, then the XML processor must further process the normalized <a href="libxml2-SAX.html#attribute">attribute</a> value by discarding any leading and trailing space (#x20) characters, and by replacing sequences of space (#x20) <a href="libxml2-SAX.html#characters">characters</a> by a single space (#x20) character. All attributes for which no declaration has been read should be treated by a non-validating parser as if declared CDATA.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the AttValue parsed or NULL. The value has to be freed by the caller.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseAttribute"></a>xmlParseAttribute ()</h3>
<pre class="programlisting">const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlParseAttribute (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** value)<br>
</pre>
<p>parse an <a href="libxml2-SAX.html#attribute">attribute</a> [41] Attribute ::= Name Eq AttValue [ WFC: No External Entity References ] Attribute values cannot contain direct or indirect entity references to external entities. [ WFC: No < in Attribute Values ] The replacement text of any entity referred to directly or indirectly in an <a href="libxml2-SAX.html#attribute">attribute</a> value (other than "&lt;") must not contain a <. [ VC: Attribute Value Type ] The <a href="libxml2-SAX.html#attribute">attribute</a> must have been declared; the value must be of the type declared for it. [25] Eq ::= S? '=' S? With namespace: [NS 11] Attribute ::= QName Eq AttValue Also the case QName == xmlns:??? is handled independently as a namespace definition.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>a <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** used to store the value of the <a href="libxml2-SAX.html#attribute">attribute</a>
</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#attribute">attribute</a> name, and the value in *value.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseAttributeListDecl"></a>xmlParseAttributeListDecl ()</h3>
<pre class="programlisting">void xmlParseAttributeListDecl (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>: parse the Attribute list def for an element [52] AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>' [53] AttDef ::= S Name S AttType S DefaultDecl</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseAttributeType"></a>xmlParseAttributeType ()</h3>
<pre class="programlisting">int xmlParseAttributeType (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlEnumerationPtr">xmlEnumerationPtr</a> * tree)<br>
</pre>
<p>parse the Attribute list def for an element [54] AttType ::= StringType | TokenizedType | EnumeratedType [55] StringType ::= 'CDATA' [56] TokenizedType ::= 'ID' | 'IDREF' | 'IDREFS' | 'ENTITY' | 'ENTITIES' | 'NMTOKEN' | 'NMTOKENS' Validity constraints for <a href="libxml2-SAX.html#attribute">attribute</a> values syntax are checked in xmlValidateAttributeValue() [ VC: ID ] Values of type ID must match the Name production. A name must not appear more than once in an XML document as a value of this type; i.e., ID values must uniquely identify the elements which bear them. [ VC: One ID per Element Type ] No element type may have more than one ID <a href="libxml2-SAX.html#attribute">attribute</a> specified. [ VC: ID Attribute Default ] An ID <a href="libxml2-SAX.html#attribute">attribute</a> must have a declared default of #IMPLIED or #REQUIRED. [ VC: IDREF ] Values of type IDREF must match the Name production, and values of type IDREFS must match Names; each IDREF Name must match the value of an ID <a href="libxml2-SAX.html#attribute">attribute</a> on some element in the XML document; i.e. IDREF values must match the value of some ID attribute. [ VC: Entity Name ] Values of type ENTITY must match the Name production, values of type ENTITIES must match Names; each Entity Name must match the name of an unparsed entity declared in the DTD. [ VC: Name Token ] Values of type NMTOKEN must match the Nmtoken production; values of type NMTOKENS must match Nmtokens.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>tree</tt></i>:</span></td>
<td>the enumeration tree built while parsing</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the <a href="libxml2-SAX.html#attribute">attribute</a> type</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseCDSect"></a>xmlParseCDSect ()</h3>
<pre class="programlisting">void xmlParseCDSect (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>Parse escaped pure raw content. [18] CDSect ::= CDStart CData CDEnd [19] CDStart ::= '<![CDATA[' [20] Data ::= (Char* - (Char* ']]>' Char*)) [21] CDEnd ::= ']]>'</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseCharData"></a>xmlParseCharData ()</h3>
<pre class="programlisting">void xmlParseCharData (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> int cdata)<br>
</pre>
<p>parse a CharData section. if we are within a CDATA section ']]>' marks an end of section. The right angle bracket (>) may be represented using the string "&gt;", and must, for compatibility, be escaped using "&gt;" or a character <a href="libxml2-SAX.html#reference">reference</a> when it appears in the string "]]>" in content, when that string is not marking the end of a CDATA section. [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>cdata</tt></i>:</span></td>
<td>int indicating whether we are within a CDATA section</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseCharRef"></a>xmlParseCharRef ()</h3>
<pre class="programlisting">int xmlParseCharRef (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse Reference declarations [66] CharRef ::= '&#' [0-9]+ ';' | '&#x' [0-9a-fA-F]+ ';' [ WFC: Legal Character ] Characters referred to using character references must match the production for Char.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the value parsed (as an int), 0 in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseComment"></a>xmlParseComment ()</h3>
<pre class="programlisting">void xmlParseComment (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>Skip an XML (SGML) <a href="libxml2-SAX.html#comment">comment</a> <!-- .... --> The spec says that "For compatibility, the string "--" (double-hyphen) must not occur within comments. " [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseContent"></a>xmlParseContent ()</h3>
<pre class="programlisting">void xmlParseContent (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>Parse a content sequence. Stops at EOF or '</'. [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseDefaultDecl"></a>xmlParseDefaultDecl ()</h3>
<pre class="programlisting">int xmlParseDefaultDecl (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** value)<br>
</pre>
<p>Parse an <a href="libxml2-SAX.html#attribute">attribute</a> default declaration [60] DefaultDecl ::= '#REQUIRED' | '#IMPLIED' | (('#FIXED' S)? AttValue) [ VC: Required Attribute ] if the default declaration is the keyword #REQUIRED, then the <a href="libxml2-SAX.html#attribute">attribute</a> must be specified for all elements of the type in the attribute-list declaration. [ VC: Attribute Default Legal ] The declared default value must meet the lexical constraints of the declared <a href="libxml2-SAX.html#attribute">attribute</a> type c.f. xmlValidateAttributeDecl() [ VC: Fixed Attribute Default ] if an <a href="libxml2-SAX.html#attribute">attribute</a> has a default value declared with the #FIXED keyword, instances of that <a href="libxml2-SAX.html#attribute">attribute</a> must match the default value. [ WFC: No < in Attribute Values ] handled in xmlParseAttValue()</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>Receive a possible fixed default value for the <a href="libxml2-SAX.html#attribute">attribute</a>
</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>XML_ATTRIBUTE_NONE, XML_ATTRIBUTE_REQUIRED, <a href="libxml2-tree.html#XML_ATTRIBUTE_IMPLIED">XML_ATTRIBUTE_IMPLIED</a> or XML_ATTRIBUTE_FIXED.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseDocTypeDecl"></a>xmlParseDocTypeDecl ()</h3>
<pre class="programlisting">void xmlParseDocTypeDecl (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse a DOCTYPE declaration [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S? ('[' (markupdecl | PEReference | S)* ']' S?)? '>' [ VC: Root Element Type ] The Name in the document type declaration must match the element type of the root element.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseElement"></a>xmlParseElement ()</h3>
<pre class="programlisting">void xmlParseElement (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse an XML element [39] element ::= EmptyElemTag | STag content ETag [ WFC: Element Type Match ] The Name in an element's end-tag must match the element type in the start-tag.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseElementChildrenContentDecl"></a>xmlParseElementChildrenContentDecl ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlElementContentPtr">xmlElementContentPtr</a> xmlParseElementChildrenContentDecl (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> int inputchk)<br>
</pre>
<p>parse the declaration for a Mixed Element content The leading '(' and spaces have been skipped in <a href="libxml2-parserInternals.html#xmlParseElementContentDecl">xmlParseElementContentDecl</a> [47] children ::= (choice | seq) ('?' | '*' | '+')? [48] cp ::= (Name | choice | seq) ('?' | '*' | '+')? [49] choice ::= '(' S? cp ( S? '|' S? cp )* S? ')' [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')' [ VC: Proper Group/PE Nesting ] applies to [49] and [50] TODO Parameter-entity replacement text must be properly nested with parenthesized groups. That is to say, if either of the opening or closing parentheses in a choice, seq, or Mixed construct is contained in the replacement text for a parameter entity, both must be contained in the same replacement text. For interoperability, if a parameter-entity <a href="libxml2-SAX.html#reference">reference</a> appears in a choice, seq, or Mixed construct, its replacement text should not be empty, and neither the first nor last non-blank character of the replacement text should be a connector (| or ,).</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>inputchk</tt></i>:</span></td>
<td>the input used for the current entity, needed for boundary checks</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the tree of <a href="libxml2-tree.html#xmlElementContentPtr">xmlElementContentPtr</a> describing the element hierarchy.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseElementContentDecl"></a>xmlParseElementContentDecl ()</h3>
<pre class="programlisting">int xmlParseElementContentDecl (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> <a href="libxml2-tree.html#xmlElementContentPtr">xmlElementContentPtr</a> * result)<br>
</pre>
<p>parse the declaration for an Element content either Mixed or Children, the cases EMPTY and ANY are handled directly in <a href="libxml2-parserInternals.html#xmlParseElementDecl">xmlParseElementDecl</a> [46] contentspec ::= 'EMPTY' | 'ANY' | Mixed | children</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the name of the element being defined.</td>
</tr>
<tr>
<td><span class="term"><i><tt>result</tt></i>:</span></td>
<td>the Element Content pointer will be stored here if any</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the type of element content XML_ELEMENT_TYPE_xxx</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseElementDecl"></a>xmlParseElementDecl ()</h3>
<pre class="programlisting">int xmlParseElementDecl (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse an Element declaration. [45] elementdecl ::= '<!ELEMENT' S Name S contentspec S? '>' [ VC: Unique Element Type Declaration ] No element type may be declared more than once</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the type of the element, or -1 in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseElementMixedContentDecl"></a>xmlParseElementMixedContentDecl ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlElementContentPtr">xmlElementContentPtr</a> xmlParseElementMixedContentDecl (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> int inputchk)<br>
</pre>
<p>parse the declaration for a Mixed Element content The leading '(' and spaces have been skipped in <a href="libxml2-parserInternals.html#xmlParseElementContentDecl">xmlParseElementContentDecl</a> [51] Mixed ::= '(' S? '#PCDATA' (S? '|' S? Name)* S? ')*' | '(' S? '#PCDATA' S? ')' [ VC: Proper Group/PE Nesting ] applies to [51] too (see [49]) [ VC: No Duplicate Types ] The same name must not appear more than once in a single mixed-content declaration.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>inputchk</tt></i>:</span></td>
<td>the input used for the current entity, needed for boundary checks</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the list of the <a href="libxml2-tree.html#xmlElementContentPtr">xmlElementContentPtr</a> describing the element choices</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseEncName"></a>xmlParseEncName ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlParseEncName (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse the XML encoding name [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')*</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the encoding name value or NULL</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseEncodingDecl"></a>xmlParseEncodingDecl ()</h3>
<pre class="programlisting">const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlParseEncodingDecl (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse the XML encoding declaration [80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' | "'" EncName "'") this setups the conversion filters.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the encoding value or NULL</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseEndTag"></a>xmlParseEndTag ()</h3>
<pre class="programlisting">void xmlParseEndTag (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse an end of tag [42] ETag ::= '</' Name S? '>' With namespace [NS 9] ETag ::= '</' QName S? '>'</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseEntityDecl"></a>xmlParseEntityDecl ()</h3>
<pre class="programlisting">void xmlParseEntityDecl (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse <!ENTITY declarations [70] EntityDecl ::= GEDecl | PEDecl [71] GEDecl ::= '<!ENTITY' S Name S EntityDef S? '>' [72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>' [73] EntityDef ::= EntityValue | (ExternalID NDataDecl?) [74] PEDef ::= EntityValue | ExternalID [76] NDataDecl ::= S 'NDATA' S Name [ VC: Notation Declared ] The Name must match the declared name of a notation.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseEntityRef"></a>xmlParseEntityRef ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlEntityPtr">xmlEntityPtr</a> xmlParseEntityRef (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse ENTITY references declarations [68] EntityRef ::= '&' Name ';' [ WFC: Entity Declared ] In a document without any DTD, a document with only an internal DTD subset which contains no parameter entity references, or a document with "standalone='yes'", the Name given in the entity <a href="libxml2-SAX.html#reference">reference</a> must match that in an entity declaration, except that well-formed documents need not declare any of the following entities: amp, lt, gt, apos, quot. The declaration of a parameter entity must precede any <a href="libxml2-SAX.html#reference">reference</a> to it. Similarly, the declaration of a general entity must precede any <a href="libxml2-SAX.html#reference">reference</a> to it which appears in a default value in an attribute-list declaration. Note that if entities are declared in the external subset or in external parameter entities, a non-validating processor is not obligated to read and process their declarations; for such documents, the rule that an entity must be declared is a well-formedness constraint only if standalone='yes'. [ WFC: Parsed Entity ] An entity <a href="libxml2-SAX.html#reference">reference</a> must not contain the name of an unparsed entity</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the <a href="libxml2-tree.html#xmlEntityPtr">xmlEntityPtr</a> if found, or NULL otherwise.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseEntityValue"></a>xmlParseEntityValue ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlParseEntityValue (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** orig)<br>
</pre>
<p>parse a value for ENTITY declarations [9] EntityValue ::= '"' ([^%&"] | PEReference | Reference)* '"' | "'" ([^%&'] | PEReference | Reference)* "'"</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>orig</tt></i>:</span></td>
<td>if non-NULL store a copy of the original entity value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the EntityValue parsed with <a href="libxml2-SAX.html#reference">reference</a> substituted or NULL</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseEnumeratedType"></a>xmlParseEnumeratedType ()</h3>
<pre class="programlisting">int xmlParseEnumeratedType (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlEnumerationPtr">xmlEnumerationPtr</a> * tree)<br>
</pre>
<p>parse an Enumerated <a href="libxml2-SAX.html#attribute">attribute</a> type. [57] EnumeratedType ::= NotationType | Enumeration [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>tree</tt></i>:</span></td>
<td>the enumeration tree built while parsing</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>
<a href="libxml2-tree.html#XML_ATTRIBUTE_ENUMERATION">XML_ATTRIBUTE_ENUMERATION</a> or <a href="libxml2-tree.html#XML_ATTRIBUTE_NOTATION">XML_ATTRIBUTE_NOTATION</a>
</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseEnumerationType"></a>xmlParseEnumerationType ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlEnumerationPtr">xmlEnumerationPtr</a> xmlParseEnumerationType (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse an Enumeration <a href="libxml2-SAX.html#attribute">attribute</a> type. [59] Enumeration ::= '(' S? Nmtoken (S? '|' S? Nmtoken)* S? ')' [ VC: Enumeration ] Values of this type must match one of the Nmtoken tokens in the declaration</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the enumeration <a href="libxml2-SAX.html#attribute">attribute</a> tree built while parsing</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseExternalID"></a>xmlParseExternalID ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlParseExternalID (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** publicID, <br> int strict)<br>
</pre>
<p>Parse an External ID or a Public ID NOTE: Productions [75] and [83] interact badly since [75] can generate 'PUBLIC' S PubidLiteral S SystemLiteral [75] ExternalID ::= 'SYSTEM' S SystemLiteral | 'PUBLIC' S PubidLiteral S SystemLiteral [83] PublicID ::= 'PUBLIC' S PubidLiteral</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>publicID</tt></i>:</span></td>
<td>a xmlChar** receiving PubidLiteral</td>
</tr>
<tr>
<td><span class="term"><i><tt>strict</tt></i>:</span></td>
<td>indicate whether we should restrict parsing to only production [75], see NOTE below</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the function returns SystemLiteral and in the second case publicID receives PubidLiteral, is strict is off it is possible to return NULL and have publicID set.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseExternalSubset"></a>xmlParseExternalSubset ()</h3>
<pre class="programlisting">void xmlParseExternalSubset (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ExternalID, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * SystemID)<br>
</pre>
<p>parse Markup declarations from an external subset [30] extSubset ::= textDecl? extSubsetDecl [31] extSubsetDecl ::= (markupdecl | conditionalSect | PEReference | S) *</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>ExternalID</tt></i>:</span></td>
<td>the external identifier</td>
</tr>
<tr>
<td><span class="term"><i><tt>SystemID</tt></i>:</span></td>
<td>the system identifier (or URL)</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseMarkupDecl"></a>xmlParseMarkupDecl ()</h3>
<pre class="programlisting">void xmlParseMarkupDecl (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse Markup declarations [29] markupdecl ::= elementdecl | AttlistDecl | EntityDecl | NotationDecl | PI | Comment [ VC: Proper Declaration/PE Nesting ] Parameter-entity replacement text must be properly nested with markup declarations. That is to say, if either the first character or the last character of a markup declaration (markupdecl above) is contained in the replacement text for a parameter-entity reference, both must be contained in the same replacement text. [ WFC: PEs in Internal Subset ] In the internal DTD subset, parameter-entity references can occur only where markup declarations can occur, not within markup declarations. (This does not apply to references that occur in external parameter entities or to the external subset.)</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseMisc"></a>xmlParseMisc ()</h3>
<pre class="programlisting">void xmlParseMisc (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse an XML Misc* optional field. [27] Misc ::= Comment | PI | S</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseName"></a>xmlParseName ()</h3>
<pre class="programlisting">const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlParseName (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse an XML name. [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' | CombiningChar | Extender [5] Name ::= (Letter | '_' | ':') (NameChar)* [6] Names ::= Name (#x20 Name)*</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the Name parsed or NULL</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseNamespace"></a>xmlParseNamespace ()</h3>
<pre class="programlisting">void xmlParseNamespace (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>xmlParseNamespace: parse specific PI '<?namespace ...' constructs. This is what the older xml-name Working Draft specified, a bunch of other stuff may still rely on it, so support is still here as if it was declared on the root of the Tree:-( TODO: remove from library To be removed at next drop of binary compatibility</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseNmtoken"></a>xmlParseNmtoken ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlParseNmtoken (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse an XML Nmtoken. [7] Nmtoken ::= (NameChar)+ [8] Nmtokens ::= Nmtoken (#x20 Nmtoken)*</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the Nmtoken parsed or NULL</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseNotationDecl"></a>xmlParseNotationDecl ()</h3>
<pre class="programlisting">void xmlParseNotationDecl (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse a notation declaration [82] NotationDecl ::= '<!NOTATION' S Name S (ExternalID | PublicID) S? '>' Hence there is actually 3 choices: 'PUBLIC' S PubidLiteral 'PUBLIC' S PubidLiteral S SystemLiteral and 'SYSTEM' S SystemLiteral See the NOTE on xmlParseExternalID().</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseNotationType"></a>xmlParseNotationType ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlEnumerationPtr">xmlEnumerationPtr</a> xmlParseNotationType (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse an Notation <a href="libxml2-SAX.html#attribute">attribute</a> type. Note: the leading 'NOTATION' S part has already being parsed... [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')' [ VC: Notation Attributes ] Values of this type must match one of the notation names included in the declaration; all notation names in the declaration must be declared.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the notation <a href="libxml2-SAX.html#attribute">attribute</a> tree built while parsing</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParsePEReference"></a>xmlParsePEReference ()</h3>
<pre class="programlisting">void xmlParsePEReference (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse PEReference declarations The entity content is handled directly by pushing it's content as a new input stream. [69] PEReference ::= '%' Name ';' [ WFC: No Recursion ] A parsed entity must not contain a recursive <a href="libxml2-SAX.html#reference">reference</a> to itself, either directly or indirectly. [ WFC: Entity Declared ] In a document without any DTD, a document with only an internal DTD subset which contains no parameter entity references, or a document with "standalone='yes'", ... ... The declaration of a parameter entity must precede any <a href="libxml2-SAX.html#reference">reference</a> to it... [ VC: Entity Declared ] In a document with an external subset or external parameter entities with "standalone='no'", ... ... The declaration of a parameter entity must precede any <a href="libxml2-SAX.html#reference">reference</a> to it... [ WFC: In DTD ] Parameter-entity references may only appear in the DTD. NOTE: misleading but this is handled.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParsePI"></a>xmlParsePI ()</h3>
<pre class="programlisting">void xmlParsePI (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse an XML Processing Instruction. [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>' The processing is transferred to SAX once parsed.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParsePITarget"></a>xmlParsePITarget ()</h3>
<pre class="programlisting">const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlParsePITarget (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse the name of a PI [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l'))</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the PITarget name or NULL</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParsePubidLiteral"></a>xmlParsePubidLiteral ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlParsePubidLiteral (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse an XML public literal [12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'"</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the PubidLiteral parsed or NULL.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseQuotedString"></a>xmlParseQuotedString ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlParseQuotedString (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>Parse and return a string between quotes or doublequotes TODO: Deprecated, to be removed at next drop of binary compatibility</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the string parser or NULL.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseReference"></a>xmlParseReference ()</h3>
<pre class="programlisting">void xmlParseReference (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse and handle entity references in content, depending on the SAX interface, this may end-up in a call to character() if this is a CharRef, a predefined entity, if there is no reference() callback. or if the parser was asked to switch to that mode. [67] Reference ::= EntityRef | CharRef</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseSDDecl"></a>xmlParseSDDecl ()</h3>
<pre class="programlisting">int xmlParseSDDecl (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse the XML standalone declaration [32] SDDecl ::= S 'standalone' Eq (("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no')'"')) [ VC: Standalone Document Declaration ] TODO The standalone document declaration must have the value "no" if any external markup declarations contain declarations of: - attributes with default values, if elements to which these attributes apply appear in the document without specifications of values for these attributes, or - entities (other than amp, lt, gt, apos, quot), if references to those entities appear in the document, or - attributes with values subject to normalization, where the <a href="libxml2-SAX.html#attribute">attribute</a> appears in the document with a value which will change as a result of normalization, or - element types with element content, if white space occurs directly within any instance of those types.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if standalone="yes" 0 if standalone="no" -2 if standalone <a href="libxml2-SAX.html#attribute">attribute</a> is missing or invalid (A standalone value of -2 means that the XML declaration was found, but no value was specified for the standalone attribute).</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseStartTag"></a>xmlParseStartTag ()</h3>
<pre class="programlisting">const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlParseStartTag (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse a start of tag either for rule element or EmptyElement. In both case we don't parse the tag closing chars. [40] STag ::= '<' Name (S Attribute)* S? '>' [ WFC: Unique Att Spec ] No <a href="libxml2-SAX.html#attribute">attribute</a> name may appear more than once in the same start-tag or empty-element tag. [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>' [ WFC: Unique Att Spec ] No <a href="libxml2-SAX.html#attribute">attribute</a> name may appear more than once in the same start-tag or empty-element tag. With namespace: [NS 8] STag ::= '<' QName (S Attribute)* S? '>' [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the element name parsed</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseSystemLiteral"></a>xmlParseSystemLiteral ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlParseSystemLiteral (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse an XML Literal [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'")</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the SystemLiteral parsed or NULL</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseTextDecl"></a>xmlParseTextDecl ()</h3>
<pre class="programlisting">void xmlParseTextDecl (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse an XML declaration header for external entities [77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>'</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseVersionInfo"></a>xmlParseVersionInfo ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlParseVersionInfo (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse the XML version. [24] VersionInfo ::= S 'version' Eq (' VersionNum ' | " VersionNum ") [25] Eq ::= S? '=' S?</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the version string, e.g. "1.0"</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseVersionNum"></a>xmlParseVersionNum ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlParseVersionNum (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse the XML version value. [26] VersionNum ::= '1.' [0-9]+ In practice allow [0-9].[0-9]+ at that level</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the string giving the XML version number, or NULL</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseXMLDecl"></a>xmlParseXMLDecl ()</h3>
<pre class="programlisting">void xmlParseXMLDecl (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>parse an XML declaration header [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParserHandlePEReference"></a>xmlParserHandlePEReference ()</h3>
<pre class="programlisting">void xmlParserHandlePEReference (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>[69] PEReference ::= '%' Name ';' [ WFC: No Recursion ] A parsed entity must not contain a recursive <a href="libxml2-SAX.html#reference">reference</a> to itself, either directly or indirectly. [ WFC: Entity Declared ] In a document without any DTD, a document with only an internal DTD subset which contains no parameter entity references, or a document with "standalone='yes'", ... ... The declaration of a parameter entity must precede any <a href="libxml2-SAX.html#reference">reference</a> to it... [ VC: Entity Declared ] In a document with an external subset or external parameter entities with "standalone='no'", ... ... The declaration of a parameter entity must precede any <a href="libxml2-SAX.html#reference">reference</a> to it... [ WFC: In DTD ] Parameter-entity references may only appear in the DTD. NOTE: misleading but this is handled. A PEReference may have been detected in the current input stream the handling is done accordingly to http://www.w3.org/TR/REC-xml#entproc i.e. - Included in literal in entity values - Included as Parameter Entity <a href="libxml2-SAX.html#reference">reference</a> within DTDs</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParserHandleReference"></a>xmlParserHandleReference ()</h3>
<pre class="programlisting">void xmlParserHandleReference (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>TODO: Remove, now deprecated ... the test is done directly in the content parsing routines. [67] Reference ::= EntityRef | CharRef [68] EntityRef ::= '&' Name ';' [ WFC: Entity Declared ] the Name given in the entity <a href="libxml2-SAX.html#reference">reference</a> must match that in an entity declaration, except that well-formed documents need not declare any of the following entities: amp, lt, gt, apos, quot. [ WFC: Parsed Entity ] An entity <a href="libxml2-SAX.html#reference">reference</a> must not contain the name of an unparsed entity [66] CharRef ::= '&#' [0-9]+ ';' | '&#x' [0-9a-fA-F]+ ';' A PEReference may have been detected in the current input stream the handling is done accordingly to http://www.w3.org/TR/REC-xml#entproc</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParserInputShrink"></a>xmlParserInputShrink ()</h3>
<pre class="programlisting">void xmlParserInputShrink (<a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a> in)<br>
</pre>
<p>This function removes used input for the parser.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>in</tt></i>:</span></td>
<td>an XML parser input</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlPopInput"></a>xmlPopInput ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> xmlPopInput (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>xmlPopInput: the current input pointed by ctxt->input came to an end pop it and return the next char.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the current <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> in the parser context</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlPushInput"></a>xmlPushInput ()</h3>
<pre class="programlisting">int xmlPushInput (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a> input)<br>
</pre>
<p>xmlPushInput: switch to a new input stream which is stacked on top of the previous one(s).</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>input</tt></i>:</span></td>
<td>an XML parser input fragment (entity, XML fragment ...).</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>-1 in case of error or the index in the input stack</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlScanName"></a>xmlScanName ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlScanName (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>Trickery: parse an XML name but without consuming the input flow Needed for rollback cases. Used only when parsing entities references. TODO: seems deprecated now, only used in the default part of <a href="libxml2-parserInternals.html#xmlParserHandleReference">xmlParserHandleReference</a> [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' | CombiningChar | Extender [5] Name ::= (Letter | '_' | ':') (NameChar)* [6] Names ::= Name (S Name)*</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the Name parsed or NULL</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSetEntityReferenceFunc"></a>xmlSetEntityReferenceFunc ()</h3>
<pre class="programlisting">void xmlSetEntityReferenceFunc (<a href="libxml2-parserInternals.html#xmlEntityReferenceFunc">xmlEntityReferenceFunc</a> func)<br>
</pre>
<p>Set the function to call call back when a xml <a href="libxml2-SAX.html#reference">reference</a> has been made</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>func</tt></i>:</span></td>
<td>A valid function</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSkipBlankChars"></a>xmlSkipBlankChars ()</h3>
<pre class="programlisting">int xmlSkipBlankChars (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt)<br>
</pre>
<p>skip all blanks character found at that point in the input streams. It pops up finished entities in the process if allowable at that point.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of space chars skipped</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSplitQName"></a>xmlSplitQName ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlSplitQName (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** prefix)<br>
</pre>
<p>parse an UTF8 encoded XML qualified name string [NS 5] QName ::= (Prefix ':')? LocalPart [NS 6] Prefix ::= NCName [NS 7] LocalPart ::= NCName</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>an XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>prefix</tt></i>:</span></td>
<td>a <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> **</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the local part, and prefix is updated to get the Prefix if any.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlStringCurrentChar"></a>xmlStringCurrentChar ()</h3>
<pre class="programlisting">int xmlStringCurrentChar (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * cur, <br> int * len)<br>
</pre>
<p>The current char value, if using UTF-8 this may actually span multiple bytes in the input buffer.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XML parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>pointer to the beginning of the char</td>
</tr>
<tr>
<td><span class="term"><i><tt>len</tt></i>:</span></td>
<td>pointer to the length of the char read</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the current char value and its length</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlStringDecodeEntities"></a>xmlStringDecodeEntities ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlStringDecodeEntities (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * str, <br> int what, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> end, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> end2, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> end3)<br>
</pre>
<p>Takes a entity string content and process to do the adequate substitutions. [67] Reference ::= EntityRef | CharRef [69] PEReference ::= '%' Name ';'</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>str</tt></i>:</span></td>
<td>the input string</td>
</tr>
<tr>
<td><span class="term"><i><tt>what</tt></i>:</span></td>
<td>combination of <a href="libxml2-parserInternals.html#XML_SUBSTITUTE_REF">XML_SUBSTITUTE_REF</a> and <a href="libxml2-parserInternals.html#XML_SUBSTITUTE_PEREF">XML_SUBSTITUTE_PEREF</a>
</td>
</tr>
<tr>
<td><span class="term"><i><tt>end</tt></i>:</span></td>
<td>an end marker xmlChar, 0 if none</td>
</tr>
<tr>
<td><span class="term"><i><tt>end2</tt></i>:</span></td>
<td>an end marker xmlChar, 0 if none</td>
</tr>
<tr>
<td><span class="term"><i><tt>end3</tt></i>:</span></td>
<td>an end marker xmlChar, 0 if none</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>A newly allocated string with the substitution done. The caller must deallocate it !</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlStringLenDecodeEntities"></a>xmlStringLenDecodeEntities ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlStringLenDecodeEntities (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * str, <br> int len, <br> int what, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> end, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> end2, <br> <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> end3)<br>
</pre>
<p>Takes a entity string content and process to do the adequate substitutions. [67] Reference ::= EntityRef | CharRef [69] PEReference ::= '%' Name ';'</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>str</tt></i>:</span></td>
<td>the input string</td>
</tr>
<tr>
<td><span class="term"><i><tt>len</tt></i>:</span></td>
<td>the string length</td>
</tr>
<tr>
<td><span class="term"><i><tt>what</tt></i>:</span></td>
<td>combination of <a href="libxml2-parserInternals.html#XML_SUBSTITUTE_REF">XML_SUBSTITUTE_REF</a> and <a href="libxml2-parserInternals.html#XML_SUBSTITUTE_PEREF">XML_SUBSTITUTE_PEREF</a>
</td>
</tr>
<tr>
<td><span class="term"><i><tt>end</tt></i>:</span></td>
<td>an end marker xmlChar, 0 if none</td>
</tr>
<tr>
<td><span class="term"><i><tt>end2</tt></i>:</span></td>
<td>an end marker xmlChar, 0 if none</td>
</tr>
<tr>
<td><span class="term"><i><tt>end3</tt></i>:</span></td>
<td>an end marker xmlChar, 0 if none</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>A newly allocated string with the substitution done. The caller must deallocate it !</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSwitchEncoding"></a>xmlSwitchEncoding ()</h3>
<pre class="programlisting">int xmlSwitchEncoding (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-encoding.html#xmlCharEncoding">xmlCharEncoding</a> enc)<br>
</pre>
<p>change the input functions when discovering the character encoding of a given entity.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>enc</tt></i>:</span></td>
<td>the encoding value (number)</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 in case of success, -1 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSwitchInputEncoding"></a>xmlSwitchInputEncoding ()</h3>
<pre class="programlisting">int xmlSwitchInputEncoding (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlParserInputPtr">xmlParserInputPtr</a> input, <br> <a href="libxml2-encoding.html#xmlCharEncodingHandlerPtr">xmlCharEncodingHandlerPtr</a> handler)<br>
</pre>
<p>DEPRECATED: Use <a href="libxml2-parserInternals.html#xmlSwitchToEncoding">xmlSwitchToEncoding</a> change the input functions when discovering the character encoding of a given entity.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>input</tt></i>:</span></td>
<td>the input stream</td>
</tr>
<tr>
<td><span class="term"><i><tt>handler</tt></i>:</span></td>
<td>the encoding handler</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 in case of success, -1 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSwitchToEncoding"></a>xmlSwitchToEncoding ()</h3>
<pre class="programlisting">int xmlSwitchToEncoding (<a href="libxml2-tree.html#xmlParserCtxtPtr">xmlParserCtxtPtr</a> ctxt, <br> <a href="libxml2-encoding.html#xmlCharEncodingHandlerPtr">xmlCharEncodingHandlerPtr</a> handler)<br>
</pre>
<p>change the input functions when discovering the character encoding of a given entity.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>handler</tt></i>:</span></td>
<td>the encoding handler</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 in case of success, -1 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
</div>
</div>
</body>
</html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>xmlunicode: Unicode character APIs</title>
<meta name="generator" content="Libxml2 devhelp stylesheet">
<link rel="start" href="index.html" title="libxml2 Reference Manual">
<link rel="up" href="general.html" title="API">
<link rel="stylesheet" href="style.css" type="text/css">
<link rel="chapter" href="general.html" title="API">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table class="navigation" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"><tr valign="middle">
<td><a accesskey="p" href="libxml2-xmlstring.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
<td><a accesskey="u" href="general.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
<td><a accesskey="n" href="libxml2-xmlversion.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
<th width="100%" align="center">libxml2 Reference Manual</th>
</tr></table>
<h2><span class="refentrytitle">xmlunicode</span></h2>
<p>xmlunicode - Unicode character APIs</p>
<p>API for the Unicode character APIs This file is automatically generated from the UCS description files of the Unicode Character Database</p>
<p>Author(s): Daniel Veillard </p>
<div class="refsynopsisdiv">
<h2>Synopsis</h2>
<pre class="synopsis">int <a href="#xmlUCSIsAegeanNumbers">xmlUCSIsAegeanNumbers</a> (int code);
int <a href="#xmlUCSIsAlphabeticPresentationForms">xmlUCSIsAlphabeticPresentationForms</a> (int code);
int <a href="#xmlUCSIsArabic">xmlUCSIsArabic</a> (int code);
int <a href="#xmlUCSIsArabicPresentationFormsA">xmlUCSIsArabicPresentationFormsA</a> (int code);
int <a href="#xmlUCSIsArabicPresentationFormsB">xmlUCSIsArabicPresentationFormsB</a> (int code);
int <a href="#xmlUCSIsArmenian">xmlUCSIsArmenian</a> (int code);
int <a href="#xmlUCSIsArrows">xmlUCSIsArrows</a> (int code);
int <a href="#xmlUCSIsBasicLatin">xmlUCSIsBasicLatin</a> (int code);
int <a href="#xmlUCSIsBengali">xmlUCSIsBengali</a> (int code);
int <a href="#xmlUCSIsBlock">xmlUCSIsBlock</a> (int code, <br> const char * block);
int <a href="#xmlUCSIsBlockElements">xmlUCSIsBlockElements</a> (int code);
int <a href="#xmlUCSIsBopomofo">xmlUCSIsBopomofo</a> (int code);
int <a href="#xmlUCSIsBopomofoExtended">xmlUCSIsBopomofoExtended</a> (int code);
int <a href="#xmlUCSIsBoxDrawing">xmlUCSIsBoxDrawing</a> (int code);
int <a href="#xmlUCSIsBraillePatterns">xmlUCSIsBraillePatterns</a> (int code);
int <a href="#xmlUCSIsBuhid">xmlUCSIsBuhid</a> (int code);
int <a href="#xmlUCSIsByzantineMusicalSymbols">xmlUCSIsByzantineMusicalSymbols</a> (int code);
int <a href="#xmlUCSIsCJKCompatibility">xmlUCSIsCJKCompatibility</a> (int code);
int <a href="#xmlUCSIsCJKCompatibilityForms">xmlUCSIsCJKCompatibilityForms</a> (int code);
int <a href="#xmlUCSIsCJKCompatibilityIdeographs">xmlUCSIsCJKCompatibilityIdeographs</a> (int code);
int <a href="#xmlUCSIsCJKCompatibilityIdeographsSupplement">xmlUCSIsCJKCompatibilityIdeographsSupplement</a> (int code);
int <a href="#xmlUCSIsCJKRadicalsSupplement">xmlUCSIsCJKRadicalsSupplement</a> (int code);
int <a href="#xmlUCSIsCJKSymbolsandPunctuation">xmlUCSIsCJKSymbolsandPunctuation</a> (int code);
int <a href="#xmlUCSIsCJKUnifiedIdeographs">xmlUCSIsCJKUnifiedIdeographs</a> (int code);
int <a href="#xmlUCSIsCJKUnifiedIdeographsExtensionA">xmlUCSIsCJKUnifiedIdeographsExtensionA</a> (int code);
int <a href="#xmlUCSIsCJKUnifiedIdeographsExtensionB">xmlUCSIsCJKUnifiedIdeographsExtensionB</a> (int code);
int <a href="#xmlUCSIsCat">xmlUCSIsCat</a> (int code, <br> const char * cat);
int <a href="#xmlUCSIsCatC">xmlUCSIsCatC</a> (int code);
int <a href="#xmlUCSIsCatCc">xmlUCSIsCatCc</a> (int code);
int <a href="#xmlUCSIsCatCf">xmlUCSIsCatCf</a> (int code);
int <a href="#xmlUCSIsCatCo">xmlUCSIsCatCo</a> (int code);
int <a href="#xmlUCSIsCatCs">xmlUCSIsCatCs</a> (int code);
int <a href="#xmlUCSIsCatL">xmlUCSIsCatL</a> (int code);
int <a href="#xmlUCSIsCatLl">xmlUCSIsCatLl</a> (int code);
int <a href="#xmlUCSIsCatLm">xmlUCSIsCatLm</a> (int code);
int <a href="#xmlUCSIsCatLo">xmlUCSIsCatLo</a> (int code);
int <a href="#xmlUCSIsCatLt">xmlUCSIsCatLt</a> (int code);
int <a href="#xmlUCSIsCatLu">xmlUCSIsCatLu</a> (int code);
int <a href="#xmlUCSIsCatM">xmlUCSIsCatM</a> (int code);
int <a href="#xmlUCSIsCatMc">xmlUCSIsCatMc</a> (int code);
int <a href="#xmlUCSIsCatMe">xmlUCSIsCatMe</a> (int code);
int <a href="#xmlUCSIsCatMn">xmlUCSIsCatMn</a> (int code);
int <a href="#xmlUCSIsCatN">xmlUCSIsCatN</a> (int code);
int <a href="#xmlUCSIsCatNd">xmlUCSIsCatNd</a> (int code);
int <a href="#xmlUCSIsCatNl">xmlUCSIsCatNl</a> (int code);
int <a href="#xmlUCSIsCatNo">xmlUCSIsCatNo</a> (int code);
int <a href="#xmlUCSIsCatP">xmlUCSIsCatP</a> (int code);
int <a href="#xmlUCSIsCatPc">xmlUCSIsCatPc</a> (int code);
int <a href="#xmlUCSIsCatPd">xmlUCSIsCatPd</a> (int code);
int <a href="#xmlUCSIsCatPe">xmlUCSIsCatPe</a> (int code);
int <a href="#xmlUCSIsCatPf">xmlUCSIsCatPf</a> (int code);
int <a href="#xmlUCSIsCatPi">xmlUCSIsCatPi</a> (int code);
int <a href="#xmlUCSIsCatPo">xmlUCSIsCatPo</a> (int code);
int <a href="#xmlUCSIsCatPs">xmlUCSIsCatPs</a> (int code);
int <a href="#xmlUCSIsCatS">xmlUCSIsCatS</a> (int code);
int <a href="#xmlUCSIsCatSc">xmlUCSIsCatSc</a> (int code);
int <a href="#xmlUCSIsCatSk">xmlUCSIsCatSk</a> (int code);
int <a href="#xmlUCSIsCatSm">xmlUCSIsCatSm</a> (int code);
int <a href="#xmlUCSIsCatSo">xmlUCSIsCatSo</a> (int code);
int <a href="#xmlUCSIsCatZ">xmlUCSIsCatZ</a> (int code);
int <a href="#xmlUCSIsCatZl">xmlUCSIsCatZl</a> (int code);
int <a href="#xmlUCSIsCatZp">xmlUCSIsCatZp</a> (int code);
int <a href="#xmlUCSIsCatZs">xmlUCSIsCatZs</a> (int code);
int <a href="#xmlUCSIsCherokee">xmlUCSIsCherokee</a> (int code);
int <a href="#xmlUCSIsCombiningDiacriticalMarks">xmlUCSIsCombiningDiacriticalMarks</a> (int code);
int <a href="#xmlUCSIsCombiningDiacriticalMarksforSymbols">xmlUCSIsCombiningDiacriticalMarksforSymbols</a> (int code);
int <a href="#xmlUCSIsCombiningHalfMarks">xmlUCSIsCombiningHalfMarks</a> (int code);
int <a href="#xmlUCSIsCombiningMarksforSymbols">xmlUCSIsCombiningMarksforSymbols</a> (int code);
int <a href="#xmlUCSIsControlPictures">xmlUCSIsControlPictures</a> (int code);
int <a href="#xmlUCSIsCurrencySymbols">xmlUCSIsCurrencySymbols</a> (int code);
int <a href="#xmlUCSIsCypriotSyllabary">xmlUCSIsCypriotSyllabary</a> (int code);
int <a href="#xmlUCSIsCyrillic">xmlUCSIsCyrillic</a> (int code);
int <a href="#xmlUCSIsCyrillicSupplement">xmlUCSIsCyrillicSupplement</a> (int code);
int <a href="#xmlUCSIsDeseret">xmlUCSIsDeseret</a> (int code);
int <a href="#xmlUCSIsDevanagari">xmlUCSIsDevanagari</a> (int code);
int <a href="#xmlUCSIsDingbats">xmlUCSIsDingbats</a> (int code);
int <a href="#xmlUCSIsEnclosedAlphanumerics">xmlUCSIsEnclosedAlphanumerics</a> (int code);
int <a href="#xmlUCSIsEnclosedCJKLettersandMonths">xmlUCSIsEnclosedCJKLettersandMonths</a> (int code);
int <a href="#xmlUCSIsEthiopic">xmlUCSIsEthiopic</a> (int code);
int <a href="#xmlUCSIsGeneralPunctuation">xmlUCSIsGeneralPunctuation</a> (int code);
int <a href="#xmlUCSIsGeometricShapes">xmlUCSIsGeometricShapes</a> (int code);
int <a href="#xmlUCSIsGeorgian">xmlUCSIsGeorgian</a> (int code);
int <a href="#xmlUCSIsGothic">xmlUCSIsGothic</a> (int code);
int <a href="#xmlUCSIsGreek">xmlUCSIsGreek</a> (int code);
int <a href="#xmlUCSIsGreekExtended">xmlUCSIsGreekExtended</a> (int code);
int <a href="#xmlUCSIsGreekandCoptic">xmlUCSIsGreekandCoptic</a> (int code);
int <a href="#xmlUCSIsGujarati">xmlUCSIsGujarati</a> (int code);
int <a href="#xmlUCSIsGurmukhi">xmlUCSIsGurmukhi</a> (int code);
int <a href="#xmlUCSIsHalfwidthandFullwidthForms">xmlUCSIsHalfwidthandFullwidthForms</a> (int code);
int <a href="#xmlUCSIsHangulCompatibilityJamo">xmlUCSIsHangulCompatibilityJamo</a> (int code);
int <a href="#xmlUCSIsHangulJamo">xmlUCSIsHangulJamo</a> (int code);
int <a href="#xmlUCSIsHangulSyllables">xmlUCSIsHangulSyllables</a> (int code);
int <a href="#xmlUCSIsHanunoo">xmlUCSIsHanunoo</a> (int code);
int <a href="#xmlUCSIsHebrew">xmlUCSIsHebrew</a> (int code);
int <a href="#xmlUCSIsHighPrivateUseSurrogates">xmlUCSIsHighPrivateUseSurrogates</a> (int code);
int <a href="#xmlUCSIsHighSurrogates">xmlUCSIsHighSurrogates</a> (int code);
int <a href="#xmlUCSIsHiragana">xmlUCSIsHiragana</a> (int code);
int <a href="#xmlUCSIsIPAExtensions">xmlUCSIsIPAExtensions</a> (int code);
int <a href="#xmlUCSIsIdeographicDescriptionCharacters">xmlUCSIsIdeographicDescriptionCharacters</a> (int code);
int <a href="#xmlUCSIsKanbun">xmlUCSIsKanbun</a> (int code);
int <a href="#xmlUCSIsKangxiRadicals">xmlUCSIsKangxiRadicals</a> (int code);
int <a href="#xmlUCSIsKannada">xmlUCSIsKannada</a> (int code);
int <a href="#xmlUCSIsKatakana">xmlUCSIsKatakana</a> (int code);
int <a href="#xmlUCSIsKatakanaPhoneticExtensions">xmlUCSIsKatakanaPhoneticExtensions</a> (int code);
int <a href="#xmlUCSIsKhmer">xmlUCSIsKhmer</a> (int code);
int <a href="#xmlUCSIsKhmerSymbols">xmlUCSIsKhmerSymbols</a> (int code);
int <a href="#xmlUCSIsLao">xmlUCSIsLao</a> (int code);
int <a href="#xmlUCSIsLatin1Supplement">xmlUCSIsLatin1Supplement</a> (int code);
int <a href="#xmlUCSIsLatinExtendedA">xmlUCSIsLatinExtendedA</a> (int code);
int <a href="#xmlUCSIsLatinExtendedAdditional">xmlUCSIsLatinExtendedAdditional</a> (int code);
int <a href="#xmlUCSIsLatinExtendedB">xmlUCSIsLatinExtendedB</a> (int code);
int <a href="#xmlUCSIsLetterlikeSymbols">xmlUCSIsLetterlikeSymbols</a> (int code);
int <a href="#xmlUCSIsLimbu">xmlUCSIsLimbu</a> (int code);
int <a href="#xmlUCSIsLinearBIdeograms">xmlUCSIsLinearBIdeograms</a> (int code);
int <a href="#xmlUCSIsLinearBSyllabary">xmlUCSIsLinearBSyllabary</a> (int code);
int <a href="#xmlUCSIsLowSurrogates">xmlUCSIsLowSurrogates</a> (int code);
int <a href="#xmlUCSIsMalayalam">xmlUCSIsMalayalam</a> (int code);
int <a href="#xmlUCSIsMathematicalAlphanumericSymbols">xmlUCSIsMathematicalAlphanumericSymbols</a> (int code);
int <a href="#xmlUCSIsMathematicalOperators">xmlUCSIsMathematicalOperators</a> (int code);
int <a href="#xmlUCSIsMiscellaneousMathematicalSymbolsA">xmlUCSIsMiscellaneousMathematicalSymbolsA</a> (int code);
int <a href="#xmlUCSIsMiscellaneousMathematicalSymbolsB">xmlUCSIsMiscellaneousMathematicalSymbolsB</a> (int code);
int <a href="#xmlUCSIsMiscellaneousSymbols">xmlUCSIsMiscellaneousSymbols</a> (int code);
int <a href="#xmlUCSIsMiscellaneousSymbolsandArrows">xmlUCSIsMiscellaneousSymbolsandArrows</a> (int code);
int <a href="#xmlUCSIsMiscellaneousTechnical">xmlUCSIsMiscellaneousTechnical</a> (int code);
int <a href="#xmlUCSIsMongolian">xmlUCSIsMongolian</a> (int code);
int <a href="#xmlUCSIsMusicalSymbols">xmlUCSIsMusicalSymbols</a> (int code);
int <a href="#xmlUCSIsMyanmar">xmlUCSIsMyanmar</a> (int code);
int <a href="#xmlUCSIsNumberForms">xmlUCSIsNumberForms</a> (int code);
int <a href="#xmlUCSIsOgham">xmlUCSIsOgham</a> (int code);
int <a href="#xmlUCSIsOldItalic">xmlUCSIsOldItalic</a> (int code);
int <a href="#xmlUCSIsOpticalCharacterRecognition">xmlUCSIsOpticalCharacterRecognition</a> (int code);
int <a href="#xmlUCSIsOriya">xmlUCSIsOriya</a> (int code);
int <a href="#xmlUCSIsOsmanya">xmlUCSIsOsmanya</a> (int code);
int <a href="#xmlUCSIsPhoneticExtensions">xmlUCSIsPhoneticExtensions</a> (int code);
int <a href="#xmlUCSIsPrivateUse">xmlUCSIsPrivateUse</a> (int code);
int <a href="#xmlUCSIsPrivateUseArea">xmlUCSIsPrivateUseArea</a> (int code);
int <a href="#xmlUCSIsRunic">xmlUCSIsRunic</a> (int code);
int <a href="#xmlUCSIsShavian">xmlUCSIsShavian</a> (int code);
int <a href="#xmlUCSIsSinhala">xmlUCSIsSinhala</a> (int code);
int <a href="#xmlUCSIsSmallFormVariants">xmlUCSIsSmallFormVariants</a> (int code);
int <a href="#xmlUCSIsSpacingModifierLetters">xmlUCSIsSpacingModifierLetters</a> (int code);
int <a href="#xmlUCSIsSpecials">xmlUCSIsSpecials</a> (int code);
int <a href="#xmlUCSIsSuperscriptsandSubscripts">xmlUCSIsSuperscriptsandSubscripts</a> (int code);
int <a href="#xmlUCSIsSupplementalArrowsA">xmlUCSIsSupplementalArrowsA</a> (int code);
int <a href="#xmlUCSIsSupplementalArrowsB">xmlUCSIsSupplementalArrowsB</a> (int code);
int <a href="#xmlUCSIsSupplementalMathematicalOperators">xmlUCSIsSupplementalMathematicalOperators</a> (int code);
int <a href="#xmlUCSIsSupplementaryPrivateUseAreaA">xmlUCSIsSupplementaryPrivateUseAreaA</a> (int code);
int <a href="#xmlUCSIsSupplementaryPrivateUseAreaB">xmlUCSIsSupplementaryPrivateUseAreaB</a> (int code);
int <a href="#xmlUCSIsSyriac">xmlUCSIsSyriac</a> (int code);
int <a href="#xmlUCSIsTagalog">xmlUCSIsTagalog</a> (int code);
int <a href="#xmlUCSIsTagbanwa">xmlUCSIsTagbanwa</a> (int code);
int <a href="#xmlUCSIsTags">xmlUCSIsTags</a> (int code);
int <a href="#xmlUCSIsTaiLe">xmlUCSIsTaiLe</a> (int code);
int <a href="#xmlUCSIsTaiXuanJingSymbols">xmlUCSIsTaiXuanJingSymbols</a> (int code);
int <a href="#xmlUCSIsTamil">xmlUCSIsTamil</a> (int code);
int <a href="#xmlUCSIsTelugu">xmlUCSIsTelugu</a> (int code);
int <a href="#xmlUCSIsThaana">xmlUCSIsThaana</a> (int code);
int <a href="#xmlUCSIsThai">xmlUCSIsThai</a> (int code);
int <a href="#xmlUCSIsTibetan">xmlUCSIsTibetan</a> (int code);
int <a href="#xmlUCSIsUgaritic">xmlUCSIsUgaritic</a> (int code);
int <a href="#xmlUCSIsUnifiedCanadianAboriginalSyllabics">xmlUCSIsUnifiedCanadianAboriginalSyllabics</a> (int code);
int <a href="#xmlUCSIsVariationSelectors">xmlUCSIsVariationSelectors</a> (int code);
int <a href="#xmlUCSIsVariationSelectorsSupplement">xmlUCSIsVariationSelectorsSupplement</a> (int code);
int <a href="#xmlUCSIsYiRadicals">xmlUCSIsYiRadicals</a> (int code);
int <a href="#xmlUCSIsYiSyllables">xmlUCSIsYiSyllables</a> (int code);
int <a href="#xmlUCSIsYijingHexagramSymbols">xmlUCSIsYijingHexagramSymbols</a> (int code);
</pre>
</div>
<div class="refsect1" lang="en"><h2>Description</h2></div>
<div class="refsect1" lang="en">
<h2>Details</h2>
<div class="refsect2" lang="en">
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsAegeanNumbers"></a>xmlUCSIsAegeanNumbers ()</h3>
<pre class="programlisting">int xmlUCSIsAegeanNumbers (int code)<br>
</pre>
<p>Check whether the character is part of AegeanNumbers UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsAlphabeticPresentationForms"></a>xmlUCSIsAlphabeticPresentationForms ()</h3>
<pre class="programlisting">int xmlUCSIsAlphabeticPresentationForms (int code)<br>
</pre>
<p>Check whether the character is part of AlphabeticPresentationForms UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsArabic"></a>xmlUCSIsArabic ()</h3>
<pre class="programlisting">int xmlUCSIsArabic (int code)<br>
</pre>
<p>Check whether the character is part of Arabic UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsArabicPresentationFormsA"></a>xmlUCSIsArabicPresentationFormsA ()</h3>
<pre class="programlisting">int xmlUCSIsArabicPresentationFormsA (int code)<br>
</pre>
<p>Check whether the character is part of ArabicPresentationForms-A UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsArabicPresentationFormsB"></a>xmlUCSIsArabicPresentationFormsB ()</h3>
<pre class="programlisting">int xmlUCSIsArabicPresentationFormsB (int code)<br>
</pre>
<p>Check whether the character is part of ArabicPresentationForms-B UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsArmenian"></a>xmlUCSIsArmenian ()</h3>
<pre class="programlisting">int xmlUCSIsArmenian (int code)<br>
</pre>
<p>Check whether the character is part of Armenian UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsArrows"></a>xmlUCSIsArrows ()</h3>
<pre class="programlisting">int xmlUCSIsArrows (int code)<br>
</pre>
<p>Check whether the character is part of Arrows UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsBasicLatin"></a>xmlUCSIsBasicLatin ()</h3>
<pre class="programlisting">int xmlUCSIsBasicLatin (int code)<br>
</pre>
<p>Check whether the character is part of BasicLatin UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsBengali"></a>xmlUCSIsBengali ()</h3>
<pre class="programlisting">int xmlUCSIsBengali (int code)<br>
</pre>
<p>Check whether the character is part of Bengali UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsBlock"></a>xmlUCSIsBlock ()</h3>
<pre class="programlisting">int xmlUCSIsBlock (int code, <br> const char * block)<br>
</pre>
<p>Check whether the character is part of the UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>block</tt></i>:</span></td>
<td>UCS block name</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true, 0 if false and -1 on unknown block</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsBlockElements"></a>xmlUCSIsBlockElements ()</h3>
<pre class="programlisting">int xmlUCSIsBlockElements (int code)<br>
</pre>
<p>Check whether the character is part of BlockElements UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsBopomofo"></a>xmlUCSIsBopomofo ()</h3>
<pre class="programlisting">int xmlUCSIsBopomofo (int code)<br>
</pre>
<p>Check whether the character is part of Bopomofo UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsBopomofoExtended"></a>xmlUCSIsBopomofoExtended ()</h3>
<pre class="programlisting">int xmlUCSIsBopomofoExtended (int code)<br>
</pre>
<p>Check whether the character is part of BopomofoExtended UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsBoxDrawing"></a>xmlUCSIsBoxDrawing ()</h3>
<pre class="programlisting">int xmlUCSIsBoxDrawing (int code)<br>
</pre>
<p>Check whether the character is part of BoxDrawing UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsBraillePatterns"></a>xmlUCSIsBraillePatterns ()</h3>
<pre class="programlisting">int xmlUCSIsBraillePatterns (int code)<br>
</pre>
<p>Check whether the character is part of BraillePatterns UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsBuhid"></a>xmlUCSIsBuhid ()</h3>
<pre class="programlisting">int xmlUCSIsBuhid (int code)<br>
</pre>
<p>Check whether the character is part of Buhid UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsByzantineMusicalSymbols"></a>xmlUCSIsByzantineMusicalSymbols ()</h3>
<pre class="programlisting">int xmlUCSIsByzantineMusicalSymbols (int code)<br>
</pre>
<p>Check whether the character is part of ByzantineMusicalSymbols UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCJKCompatibility"></a>xmlUCSIsCJKCompatibility ()</h3>
<pre class="programlisting">int xmlUCSIsCJKCompatibility (int code)<br>
</pre>
<p>Check whether the character is part of CJKCompatibility UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCJKCompatibilityForms"></a>xmlUCSIsCJKCompatibilityForms ()</h3>
<pre class="programlisting">int xmlUCSIsCJKCompatibilityForms (int code)<br>
</pre>
<p>Check whether the character is part of CJKCompatibilityForms UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCJKCompatibilityIdeographs"></a>xmlUCSIsCJKCompatibilityIdeographs ()</h3>
<pre class="programlisting">int xmlUCSIsCJKCompatibilityIdeographs (int code)<br>
</pre>
<p>Check whether the character is part of CJKCompatibilityIdeographs UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCJKCompatibilityIdeographsSupplement"></a>xmlUCSIsCJKCompatibilityIdeographsSupplement ()</h3>
<pre class="programlisting">int xmlUCSIsCJKCompatibilityIdeographsSupplement (int code)<br>
</pre>
<p>Check whether the character is part of CJKCompatibilityIdeographsSupplement UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCJKRadicalsSupplement"></a>xmlUCSIsCJKRadicalsSupplement ()</h3>
<pre class="programlisting">int xmlUCSIsCJKRadicalsSupplement (int code)<br>
</pre>
<p>Check whether the character is part of CJKRadicalsSupplement UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCJKSymbolsandPunctuation"></a>xmlUCSIsCJKSymbolsandPunctuation ()</h3>
<pre class="programlisting">int xmlUCSIsCJKSymbolsandPunctuation (int code)<br>
</pre>
<p>Check whether the character is part of CJKSymbolsandPunctuation UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCJKUnifiedIdeographs"></a>xmlUCSIsCJKUnifiedIdeographs ()</h3>
<pre class="programlisting">int xmlUCSIsCJKUnifiedIdeographs (int code)<br>
</pre>
<p>Check whether the character is part of CJKUnifiedIdeographs UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCJKUnifiedIdeographsExtensionA"></a>xmlUCSIsCJKUnifiedIdeographsExtensionA ()</h3>
<pre class="programlisting">int xmlUCSIsCJKUnifiedIdeographsExtensionA (int code)<br>
</pre>
<p>Check whether the character is part of CJKUnifiedIdeographsExtensionA UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCJKUnifiedIdeographsExtensionB"></a>xmlUCSIsCJKUnifiedIdeographsExtensionB ()</h3>
<pre class="programlisting">int xmlUCSIsCJKUnifiedIdeographsExtensionB (int code)<br>
</pre>
<p>Check whether the character is part of CJKUnifiedIdeographsExtensionB UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCat"></a>xmlUCSIsCat ()</h3>
<pre class="programlisting">int xmlUCSIsCat (int code, <br> const char * cat)<br>
</pre>
<p>Check whether the character is part of the UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>cat</tt></i>:</span></td>
<td>UCS Category name</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true, 0 if false and -1 on unknown category</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatC"></a>xmlUCSIsCatC ()</h3>
<pre class="programlisting">int xmlUCSIsCatC (int code)<br>
</pre>
<p>Check whether the character is part of C UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatCc"></a>xmlUCSIsCatCc ()</h3>
<pre class="programlisting">int xmlUCSIsCatCc (int code)<br>
</pre>
<p>Check whether the character is part of Cc UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatCf"></a>xmlUCSIsCatCf ()</h3>
<pre class="programlisting">int xmlUCSIsCatCf (int code)<br>
</pre>
<p>Check whether the character is part of Cf UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatCo"></a>xmlUCSIsCatCo ()</h3>
<pre class="programlisting">int xmlUCSIsCatCo (int code)<br>
</pre>
<p>Check whether the character is part of Co UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatCs"></a>xmlUCSIsCatCs ()</h3>
<pre class="programlisting">int xmlUCSIsCatCs (int code)<br>
</pre>
<p>Check whether the character is part of Cs UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatL"></a>xmlUCSIsCatL ()</h3>
<pre class="programlisting">int xmlUCSIsCatL (int code)<br>
</pre>
<p>Check whether the character is part of L UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatLl"></a>xmlUCSIsCatLl ()</h3>
<pre class="programlisting">int xmlUCSIsCatLl (int code)<br>
</pre>
<p>Check whether the character is part of Ll UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatLm"></a>xmlUCSIsCatLm ()</h3>
<pre class="programlisting">int xmlUCSIsCatLm (int code)<br>
</pre>
<p>Check whether the character is part of Lm UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatLo"></a>xmlUCSIsCatLo ()</h3>
<pre class="programlisting">int xmlUCSIsCatLo (int code)<br>
</pre>
<p>Check whether the character is part of Lo UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatLt"></a>xmlUCSIsCatLt ()</h3>
<pre class="programlisting">int xmlUCSIsCatLt (int code)<br>
</pre>
<p>Check whether the character is part of Lt UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatLu"></a>xmlUCSIsCatLu ()</h3>
<pre class="programlisting">int xmlUCSIsCatLu (int code)<br>
</pre>
<p>Check whether the character is part of Lu UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatM"></a>xmlUCSIsCatM ()</h3>
<pre class="programlisting">int xmlUCSIsCatM (int code)<br>
</pre>
<p>Check whether the character is part of M UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatMc"></a>xmlUCSIsCatMc ()</h3>
<pre class="programlisting">int xmlUCSIsCatMc (int code)<br>
</pre>
<p>Check whether the character is part of Mc UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatMe"></a>xmlUCSIsCatMe ()</h3>
<pre class="programlisting">int xmlUCSIsCatMe (int code)<br>
</pre>
<p>Check whether the character is part of Me UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatMn"></a>xmlUCSIsCatMn ()</h3>
<pre class="programlisting">int xmlUCSIsCatMn (int code)<br>
</pre>
<p>Check whether the character is part of Mn UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatN"></a>xmlUCSIsCatN ()</h3>
<pre class="programlisting">int xmlUCSIsCatN (int code)<br>
</pre>
<p>Check whether the character is part of N UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatNd"></a>xmlUCSIsCatNd ()</h3>
<pre class="programlisting">int xmlUCSIsCatNd (int code)<br>
</pre>
<p>Check whether the character is part of Nd UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatNl"></a>xmlUCSIsCatNl ()</h3>
<pre class="programlisting">int xmlUCSIsCatNl (int code)<br>
</pre>
<p>Check whether the character is part of Nl UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatNo"></a>xmlUCSIsCatNo ()</h3>
<pre class="programlisting">int xmlUCSIsCatNo (int code)<br>
</pre>
<p>Check whether the character is part of No UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatP"></a>xmlUCSIsCatP ()</h3>
<pre class="programlisting">int xmlUCSIsCatP (int code)<br>
</pre>
<p>Check whether the character is part of P UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatPc"></a>xmlUCSIsCatPc ()</h3>
<pre class="programlisting">int xmlUCSIsCatPc (int code)<br>
</pre>
<p>Check whether the character is part of Pc UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatPd"></a>xmlUCSIsCatPd ()</h3>
<pre class="programlisting">int xmlUCSIsCatPd (int code)<br>
</pre>
<p>Check whether the character is part of Pd UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatPe"></a>xmlUCSIsCatPe ()</h3>
<pre class="programlisting">int xmlUCSIsCatPe (int code)<br>
</pre>
<p>Check whether the character is part of Pe UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatPf"></a>xmlUCSIsCatPf ()</h3>
<pre class="programlisting">int xmlUCSIsCatPf (int code)<br>
</pre>
<p>Check whether the character is part of Pf UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatPi"></a>xmlUCSIsCatPi ()</h3>
<pre class="programlisting">int xmlUCSIsCatPi (int code)<br>
</pre>
<p>Check whether the character is part of Pi UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatPo"></a>xmlUCSIsCatPo ()</h3>
<pre class="programlisting">int xmlUCSIsCatPo (int code)<br>
</pre>
<p>Check whether the character is part of Po UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatPs"></a>xmlUCSIsCatPs ()</h3>
<pre class="programlisting">int xmlUCSIsCatPs (int code)<br>
</pre>
<p>Check whether the character is part of Ps UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatS"></a>xmlUCSIsCatS ()</h3>
<pre class="programlisting">int xmlUCSIsCatS (int code)<br>
</pre>
<p>Check whether the character is part of S UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatSc"></a>xmlUCSIsCatSc ()</h3>
<pre class="programlisting">int xmlUCSIsCatSc (int code)<br>
</pre>
<p>Check whether the character is part of Sc UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatSk"></a>xmlUCSIsCatSk ()</h3>
<pre class="programlisting">int xmlUCSIsCatSk (int code)<br>
</pre>
<p>Check whether the character is part of Sk UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatSm"></a>xmlUCSIsCatSm ()</h3>
<pre class="programlisting">int xmlUCSIsCatSm (int code)<br>
</pre>
<p>Check whether the character is part of Sm UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatSo"></a>xmlUCSIsCatSo ()</h3>
<pre class="programlisting">int xmlUCSIsCatSo (int code)<br>
</pre>
<p>Check whether the character is part of So UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatZ"></a>xmlUCSIsCatZ ()</h3>
<pre class="programlisting">int xmlUCSIsCatZ (int code)<br>
</pre>
<p>Check whether the character is part of Z UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatZl"></a>xmlUCSIsCatZl ()</h3>
<pre class="programlisting">int xmlUCSIsCatZl (int code)<br>
</pre>
<p>Check whether the character is part of Zl UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatZp"></a>xmlUCSIsCatZp ()</h3>
<pre class="programlisting">int xmlUCSIsCatZp (int code)<br>
</pre>
<p>Check whether the character is part of Zp UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCatZs"></a>xmlUCSIsCatZs ()</h3>
<pre class="programlisting">int xmlUCSIsCatZs (int code)<br>
</pre>
<p>Check whether the character is part of Zs UCS Category</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCherokee"></a>xmlUCSIsCherokee ()</h3>
<pre class="programlisting">int xmlUCSIsCherokee (int code)<br>
</pre>
<p>Check whether the character is part of Cherokee UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCombiningDiacriticalMarks"></a>xmlUCSIsCombiningDiacriticalMarks ()</h3>
<pre class="programlisting">int xmlUCSIsCombiningDiacriticalMarks (int code)<br>
</pre>
<p>Check whether the character is part of CombiningDiacriticalMarks UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCombiningDiacriticalMarksforSymbols"></a>xmlUCSIsCombiningDiacriticalMarksforSymbols ()</h3>
<pre class="programlisting">int xmlUCSIsCombiningDiacriticalMarksforSymbols (int code)<br>
</pre>
<p>Check whether the character is part of CombiningDiacriticalMarksforSymbols UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCombiningHalfMarks"></a>xmlUCSIsCombiningHalfMarks ()</h3>
<pre class="programlisting">int xmlUCSIsCombiningHalfMarks (int code)<br>
</pre>
<p>Check whether the character is part of CombiningHalfMarks UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCombiningMarksforSymbols"></a>xmlUCSIsCombiningMarksforSymbols ()</h3>
<pre class="programlisting">int xmlUCSIsCombiningMarksforSymbols (int code)<br>
</pre>
<p>Check whether the character is part of CombiningMarksforSymbols UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsControlPictures"></a>xmlUCSIsControlPictures ()</h3>
<pre class="programlisting">int xmlUCSIsControlPictures (int code)<br>
</pre>
<p>Check whether the character is part of ControlPictures UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCurrencySymbols"></a>xmlUCSIsCurrencySymbols ()</h3>
<pre class="programlisting">int xmlUCSIsCurrencySymbols (int code)<br>
</pre>
<p>Check whether the character is part of CurrencySymbols UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCypriotSyllabary"></a>xmlUCSIsCypriotSyllabary ()</h3>
<pre class="programlisting">int xmlUCSIsCypriotSyllabary (int code)<br>
</pre>
<p>Check whether the character is part of CypriotSyllabary UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCyrillic"></a>xmlUCSIsCyrillic ()</h3>
<pre class="programlisting">int xmlUCSIsCyrillic (int code)<br>
</pre>
<p>Check whether the character is part of Cyrillic UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsCyrillicSupplement"></a>xmlUCSIsCyrillicSupplement ()</h3>
<pre class="programlisting">int xmlUCSIsCyrillicSupplement (int code)<br>
</pre>
<p>Check whether the character is part of CyrillicSupplement UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsDeseret"></a>xmlUCSIsDeseret ()</h3>
<pre class="programlisting">int xmlUCSIsDeseret (int code)<br>
</pre>
<p>Check whether the character is part of Deseret UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsDevanagari"></a>xmlUCSIsDevanagari ()</h3>
<pre class="programlisting">int xmlUCSIsDevanagari (int code)<br>
</pre>
<p>Check whether the character is part of Devanagari UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsDingbats"></a>xmlUCSIsDingbats ()</h3>
<pre class="programlisting">int xmlUCSIsDingbats (int code)<br>
</pre>
<p>Check whether the character is part of Dingbats UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsEnclosedAlphanumerics"></a>xmlUCSIsEnclosedAlphanumerics ()</h3>
<pre class="programlisting">int xmlUCSIsEnclosedAlphanumerics (int code)<br>
</pre>
<p>Check whether the character is part of EnclosedAlphanumerics UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsEnclosedCJKLettersandMonths"></a>xmlUCSIsEnclosedCJKLettersandMonths ()</h3>
<pre class="programlisting">int xmlUCSIsEnclosedCJKLettersandMonths (int code)<br>
</pre>
<p>Check whether the character is part of EnclosedCJKLettersandMonths UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsEthiopic"></a>xmlUCSIsEthiopic ()</h3>
<pre class="programlisting">int xmlUCSIsEthiopic (int code)<br>
</pre>
<p>Check whether the character is part of Ethiopic UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsGeneralPunctuation"></a>xmlUCSIsGeneralPunctuation ()</h3>
<pre class="programlisting">int xmlUCSIsGeneralPunctuation (int code)<br>
</pre>
<p>Check whether the character is part of GeneralPunctuation UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsGeometricShapes"></a>xmlUCSIsGeometricShapes ()</h3>
<pre class="programlisting">int xmlUCSIsGeometricShapes (int code)<br>
</pre>
<p>Check whether the character is part of GeometricShapes UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsGeorgian"></a>xmlUCSIsGeorgian ()</h3>
<pre class="programlisting">int xmlUCSIsGeorgian (int code)<br>
</pre>
<p>Check whether the character is part of Georgian UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsGothic"></a>xmlUCSIsGothic ()</h3>
<pre class="programlisting">int xmlUCSIsGothic (int code)<br>
</pre>
<p>Check whether the character is part of Gothic UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsGreek"></a>xmlUCSIsGreek ()</h3>
<pre class="programlisting">int xmlUCSIsGreek (int code)<br>
</pre>
<p>Check whether the character is part of Greek UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsGreekExtended"></a>xmlUCSIsGreekExtended ()</h3>
<pre class="programlisting">int xmlUCSIsGreekExtended (int code)<br>
</pre>
<p>Check whether the character is part of GreekExtended UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsGreekandCoptic"></a>xmlUCSIsGreekandCoptic ()</h3>
<pre class="programlisting">int xmlUCSIsGreekandCoptic (int code)<br>
</pre>
<p>Check whether the character is part of GreekandCoptic UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsGujarati"></a>xmlUCSIsGujarati ()</h3>
<pre class="programlisting">int xmlUCSIsGujarati (int code)<br>
</pre>
<p>Check whether the character is part of Gujarati UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsGurmukhi"></a>xmlUCSIsGurmukhi ()</h3>
<pre class="programlisting">int xmlUCSIsGurmukhi (int code)<br>
</pre>
<p>Check whether the character is part of Gurmukhi UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsHalfwidthandFullwidthForms"></a>xmlUCSIsHalfwidthandFullwidthForms ()</h3>
<pre class="programlisting">int xmlUCSIsHalfwidthandFullwidthForms (int code)<br>
</pre>
<p>Check whether the character is part of HalfwidthandFullwidthForms UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsHangulCompatibilityJamo"></a>xmlUCSIsHangulCompatibilityJamo ()</h3>
<pre class="programlisting">int xmlUCSIsHangulCompatibilityJamo (int code)<br>
</pre>
<p>Check whether the character is part of HangulCompatibilityJamo UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsHangulJamo"></a>xmlUCSIsHangulJamo ()</h3>
<pre class="programlisting">int xmlUCSIsHangulJamo (int code)<br>
</pre>
<p>Check whether the character is part of HangulJamo UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsHangulSyllables"></a>xmlUCSIsHangulSyllables ()</h3>
<pre class="programlisting">int xmlUCSIsHangulSyllables (int code)<br>
</pre>
<p>Check whether the character is part of HangulSyllables UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsHanunoo"></a>xmlUCSIsHanunoo ()</h3>
<pre class="programlisting">int xmlUCSIsHanunoo (int code)<br>
</pre>
<p>Check whether the character is part of Hanunoo UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsHebrew"></a>xmlUCSIsHebrew ()</h3>
<pre class="programlisting">int xmlUCSIsHebrew (int code)<br>
</pre>
<p>Check whether the character is part of Hebrew UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsHighPrivateUseSurrogates"></a>xmlUCSIsHighPrivateUseSurrogates ()</h3>
<pre class="programlisting">int xmlUCSIsHighPrivateUseSurrogates (int code)<br>
</pre>
<p>Check whether the character is part of HighPrivateUseSurrogates UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsHighSurrogates"></a>xmlUCSIsHighSurrogates ()</h3>
<pre class="programlisting">int xmlUCSIsHighSurrogates (int code)<br>
</pre>
<p>Check whether the character is part of HighSurrogates UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsHiragana"></a>xmlUCSIsHiragana ()</h3>
<pre class="programlisting">int xmlUCSIsHiragana (int code)<br>
</pre>
<p>Check whether the character is part of Hiragana UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsIPAExtensions"></a>xmlUCSIsIPAExtensions ()</h3>
<pre class="programlisting">int xmlUCSIsIPAExtensions (int code)<br>
</pre>
<p>Check whether the character is part of IPAExtensions UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsIdeographicDescriptionCharacters"></a>xmlUCSIsIdeographicDescriptionCharacters ()</h3>
<pre class="programlisting">int xmlUCSIsIdeographicDescriptionCharacters (int code)<br>
</pre>
<p>Check whether the character is part of IdeographicDescriptionCharacters UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsKanbun"></a>xmlUCSIsKanbun ()</h3>
<pre class="programlisting">int xmlUCSIsKanbun (int code)<br>
</pre>
<p>Check whether the character is part of Kanbun UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsKangxiRadicals"></a>xmlUCSIsKangxiRadicals ()</h3>
<pre class="programlisting">int xmlUCSIsKangxiRadicals (int code)<br>
</pre>
<p>Check whether the character is part of KangxiRadicals UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsKannada"></a>xmlUCSIsKannada ()</h3>
<pre class="programlisting">int xmlUCSIsKannada (int code)<br>
</pre>
<p>Check whether the character is part of Kannada UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsKatakana"></a>xmlUCSIsKatakana ()</h3>
<pre class="programlisting">int xmlUCSIsKatakana (int code)<br>
</pre>
<p>Check whether the character is part of Katakana UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsKatakanaPhoneticExtensions"></a>xmlUCSIsKatakanaPhoneticExtensions ()</h3>
<pre class="programlisting">int xmlUCSIsKatakanaPhoneticExtensions (int code)<br>
</pre>
<p>Check whether the character is part of KatakanaPhoneticExtensions UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsKhmer"></a>xmlUCSIsKhmer ()</h3>
<pre class="programlisting">int xmlUCSIsKhmer (int code)<br>
</pre>
<p>Check whether the character is part of Khmer UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsKhmerSymbols"></a>xmlUCSIsKhmerSymbols ()</h3>
<pre class="programlisting">int xmlUCSIsKhmerSymbols (int code)<br>
</pre>
<p>Check whether the character is part of KhmerSymbols UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsLao"></a>xmlUCSIsLao ()</h3>
<pre class="programlisting">int xmlUCSIsLao (int code)<br>
</pre>
<p>Check whether the character is part of Lao UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsLatin1Supplement"></a>xmlUCSIsLatin1Supplement ()</h3>
<pre class="programlisting">int xmlUCSIsLatin1Supplement (int code)<br>
</pre>
<p>Check whether the character is part of Latin-1Supplement UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsLatinExtendedA"></a>xmlUCSIsLatinExtendedA ()</h3>
<pre class="programlisting">int xmlUCSIsLatinExtendedA (int code)<br>
</pre>
<p>Check whether the character is part of LatinExtended-A UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsLatinExtendedAdditional"></a>xmlUCSIsLatinExtendedAdditional ()</h3>
<pre class="programlisting">int xmlUCSIsLatinExtendedAdditional (int code)<br>
</pre>
<p>Check whether the character is part of LatinExtendedAdditional UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsLatinExtendedB"></a>xmlUCSIsLatinExtendedB ()</h3>
<pre class="programlisting">int xmlUCSIsLatinExtendedB (int code)<br>
</pre>
<p>Check whether the character is part of LatinExtended-B UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsLetterlikeSymbols"></a>xmlUCSIsLetterlikeSymbols ()</h3>
<pre class="programlisting">int xmlUCSIsLetterlikeSymbols (int code)<br>
</pre>
<p>Check whether the character is part of LetterlikeSymbols UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsLimbu"></a>xmlUCSIsLimbu ()</h3>
<pre class="programlisting">int xmlUCSIsLimbu (int code)<br>
</pre>
<p>Check whether the character is part of Limbu UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsLinearBIdeograms"></a>xmlUCSIsLinearBIdeograms ()</h3>
<pre class="programlisting">int xmlUCSIsLinearBIdeograms (int code)<br>
</pre>
<p>Check whether the character is part of LinearBIdeograms UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsLinearBSyllabary"></a>xmlUCSIsLinearBSyllabary ()</h3>
<pre class="programlisting">int xmlUCSIsLinearBSyllabary (int code)<br>
</pre>
<p>Check whether the character is part of LinearBSyllabary UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsLowSurrogates"></a>xmlUCSIsLowSurrogates ()</h3>
<pre class="programlisting">int xmlUCSIsLowSurrogates (int code)<br>
</pre>
<p>Check whether the character is part of LowSurrogates UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsMalayalam"></a>xmlUCSIsMalayalam ()</h3>
<pre class="programlisting">int xmlUCSIsMalayalam (int code)<br>
</pre>
<p>Check whether the character is part of Malayalam UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsMathematicalAlphanumericSymbols"></a>xmlUCSIsMathematicalAlphanumericSymbols ()</h3>
<pre class="programlisting">int xmlUCSIsMathematicalAlphanumericSymbols (int code)<br>
</pre>
<p>Check whether the character is part of MathematicalAlphanumericSymbols UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsMathematicalOperators"></a>xmlUCSIsMathematicalOperators ()</h3>
<pre class="programlisting">int xmlUCSIsMathematicalOperators (int code)<br>
</pre>
<p>Check whether the character is part of MathematicalOperators UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsMiscellaneousMathematicalSymbolsA"></a>xmlUCSIsMiscellaneousMathematicalSymbolsA ()</h3>
<pre class="programlisting">int xmlUCSIsMiscellaneousMathematicalSymbolsA (int code)<br>
</pre>
<p>Check whether the character is part of MiscellaneousMathematicalSymbols-A UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsMiscellaneousMathematicalSymbolsB"></a>xmlUCSIsMiscellaneousMathematicalSymbolsB ()</h3>
<pre class="programlisting">int xmlUCSIsMiscellaneousMathematicalSymbolsB (int code)<br>
</pre>
<p>Check whether the character is part of MiscellaneousMathematicalSymbols-B UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsMiscellaneousSymbols"></a>xmlUCSIsMiscellaneousSymbols ()</h3>
<pre class="programlisting">int xmlUCSIsMiscellaneousSymbols (int code)<br>
</pre>
<p>Check whether the character is part of MiscellaneousSymbols UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsMiscellaneousSymbolsandArrows"></a>xmlUCSIsMiscellaneousSymbolsandArrows ()</h3>
<pre class="programlisting">int xmlUCSIsMiscellaneousSymbolsandArrows (int code)<br>
</pre>
<p>Check whether the character is part of MiscellaneousSymbolsandArrows UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsMiscellaneousTechnical"></a>xmlUCSIsMiscellaneousTechnical ()</h3>
<pre class="programlisting">int xmlUCSIsMiscellaneousTechnical (int code)<br>
</pre>
<p>Check whether the character is part of MiscellaneousTechnical UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsMongolian"></a>xmlUCSIsMongolian ()</h3>
<pre class="programlisting">int xmlUCSIsMongolian (int code)<br>
</pre>
<p>Check whether the character is part of Mongolian UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsMusicalSymbols"></a>xmlUCSIsMusicalSymbols ()</h3>
<pre class="programlisting">int xmlUCSIsMusicalSymbols (int code)<br>
</pre>
<p>Check whether the character is part of MusicalSymbols UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsMyanmar"></a>xmlUCSIsMyanmar ()</h3>
<pre class="programlisting">int xmlUCSIsMyanmar (int code)<br>
</pre>
<p>Check whether the character is part of Myanmar UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsNumberForms"></a>xmlUCSIsNumberForms ()</h3>
<pre class="programlisting">int xmlUCSIsNumberForms (int code)<br>
</pre>
<p>Check whether the character is part of NumberForms UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsOgham"></a>xmlUCSIsOgham ()</h3>
<pre class="programlisting">int xmlUCSIsOgham (int code)<br>
</pre>
<p>Check whether the character is part of Ogham UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsOldItalic"></a>xmlUCSIsOldItalic ()</h3>
<pre class="programlisting">int xmlUCSIsOldItalic (int code)<br>
</pre>
<p>Check whether the character is part of OldItalic UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsOpticalCharacterRecognition"></a>xmlUCSIsOpticalCharacterRecognition ()</h3>
<pre class="programlisting">int xmlUCSIsOpticalCharacterRecognition (int code)<br>
</pre>
<p>Check whether the character is part of OpticalCharacterRecognition UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsOriya"></a>xmlUCSIsOriya ()</h3>
<pre class="programlisting">int xmlUCSIsOriya (int code)<br>
</pre>
<p>Check whether the character is part of Oriya UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsOsmanya"></a>xmlUCSIsOsmanya ()</h3>
<pre class="programlisting">int xmlUCSIsOsmanya (int code)<br>
</pre>
<p>Check whether the character is part of Osmanya UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsPhoneticExtensions"></a>xmlUCSIsPhoneticExtensions ()</h3>
<pre class="programlisting">int xmlUCSIsPhoneticExtensions (int code)<br>
</pre>
<p>Check whether the character is part of PhoneticExtensions UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsPrivateUse"></a>xmlUCSIsPrivateUse ()</h3>
<pre class="programlisting">int xmlUCSIsPrivateUse (int code)<br>
</pre>
<p>Check whether the character is part of PrivateUse UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsPrivateUseArea"></a>xmlUCSIsPrivateUseArea ()</h3>
<pre class="programlisting">int xmlUCSIsPrivateUseArea (int code)<br>
</pre>
<p>Check whether the character is part of PrivateUseArea UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsRunic"></a>xmlUCSIsRunic ()</h3>
<pre class="programlisting">int xmlUCSIsRunic (int code)<br>
</pre>
<p>Check whether the character is part of Runic UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsShavian"></a>xmlUCSIsShavian ()</h3>
<pre class="programlisting">int xmlUCSIsShavian (int code)<br>
</pre>
<p>Check whether the character is part of Shavian UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsSinhala"></a>xmlUCSIsSinhala ()</h3>
<pre class="programlisting">int xmlUCSIsSinhala (int code)<br>
</pre>
<p>Check whether the character is part of Sinhala UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsSmallFormVariants"></a>xmlUCSIsSmallFormVariants ()</h3>
<pre class="programlisting">int xmlUCSIsSmallFormVariants (int code)<br>
</pre>
<p>Check whether the character is part of SmallFormVariants UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsSpacingModifierLetters"></a>xmlUCSIsSpacingModifierLetters ()</h3>
<pre class="programlisting">int xmlUCSIsSpacingModifierLetters (int code)<br>
</pre>
<p>Check whether the character is part of SpacingModifierLetters UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsSpecials"></a>xmlUCSIsSpecials ()</h3>
<pre class="programlisting">int xmlUCSIsSpecials (int code)<br>
</pre>
<p>Check whether the character is part of Specials UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsSuperscriptsandSubscripts"></a>xmlUCSIsSuperscriptsandSubscripts ()</h3>
<pre class="programlisting">int xmlUCSIsSuperscriptsandSubscripts (int code)<br>
</pre>
<p>Check whether the character is part of SuperscriptsandSubscripts UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsSupplementalArrowsA"></a>xmlUCSIsSupplementalArrowsA ()</h3>
<pre class="programlisting">int xmlUCSIsSupplementalArrowsA (int code)<br>
</pre>
<p>Check whether the character is part of SupplementalArrows-A UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsSupplementalArrowsB"></a>xmlUCSIsSupplementalArrowsB ()</h3>
<pre class="programlisting">int xmlUCSIsSupplementalArrowsB (int code)<br>
</pre>
<p>Check whether the character is part of SupplementalArrows-B UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsSupplementalMathematicalOperators"></a>xmlUCSIsSupplementalMathematicalOperators ()</h3>
<pre class="programlisting">int xmlUCSIsSupplementalMathematicalOperators (int code)<br>
</pre>
<p>Check whether the character is part of SupplementalMathematicalOperators UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsSupplementaryPrivateUseAreaA"></a>xmlUCSIsSupplementaryPrivateUseAreaA ()</h3>
<pre class="programlisting">int xmlUCSIsSupplementaryPrivateUseAreaA (int code)<br>
</pre>
<p>Check whether the character is part of SupplementaryPrivateUseArea-A UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsSupplementaryPrivateUseAreaB"></a>xmlUCSIsSupplementaryPrivateUseAreaB ()</h3>
<pre class="programlisting">int xmlUCSIsSupplementaryPrivateUseAreaB (int code)<br>
</pre>
<p>Check whether the character is part of SupplementaryPrivateUseArea-B UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsSyriac"></a>xmlUCSIsSyriac ()</h3>
<pre class="programlisting">int xmlUCSIsSyriac (int code)<br>
</pre>
<p>Check whether the character is part of Syriac UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsTagalog"></a>xmlUCSIsTagalog ()</h3>
<pre class="programlisting">int xmlUCSIsTagalog (int code)<br>
</pre>
<p>Check whether the character is part of Tagalog UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsTagbanwa"></a>xmlUCSIsTagbanwa ()</h3>
<pre class="programlisting">int xmlUCSIsTagbanwa (int code)<br>
</pre>
<p>Check whether the character is part of Tagbanwa UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsTags"></a>xmlUCSIsTags ()</h3>
<pre class="programlisting">int xmlUCSIsTags (int code)<br>
</pre>
<p>Check whether the character is part of Tags UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsTaiLe"></a>xmlUCSIsTaiLe ()</h3>
<pre class="programlisting">int xmlUCSIsTaiLe (int code)<br>
</pre>
<p>Check whether the character is part of TaiLe UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsTaiXuanJingSymbols"></a>xmlUCSIsTaiXuanJingSymbols ()</h3>
<pre class="programlisting">int xmlUCSIsTaiXuanJingSymbols (int code)<br>
</pre>
<p>Check whether the character is part of TaiXuanJingSymbols UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsTamil"></a>xmlUCSIsTamil ()</h3>
<pre class="programlisting">int xmlUCSIsTamil (int code)<br>
</pre>
<p>Check whether the character is part of Tamil UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsTelugu"></a>xmlUCSIsTelugu ()</h3>
<pre class="programlisting">int xmlUCSIsTelugu (int code)<br>
</pre>
<p>Check whether the character is part of Telugu UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsThaana"></a>xmlUCSIsThaana ()</h3>
<pre class="programlisting">int xmlUCSIsThaana (int code)<br>
</pre>
<p>Check whether the character is part of Thaana UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsThai"></a>xmlUCSIsThai ()</h3>
<pre class="programlisting">int xmlUCSIsThai (int code)<br>
</pre>
<p>Check whether the character is part of Thai UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsTibetan"></a>xmlUCSIsTibetan ()</h3>
<pre class="programlisting">int xmlUCSIsTibetan (int code)<br>
</pre>
<p>Check whether the character is part of Tibetan UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsUgaritic"></a>xmlUCSIsUgaritic ()</h3>
<pre class="programlisting">int xmlUCSIsUgaritic (int code)<br>
</pre>
<p>Check whether the character is part of Ugaritic UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsUnifiedCanadianAboriginalSyllabics"></a>xmlUCSIsUnifiedCanadianAboriginalSyllabics ()</h3>
<pre class="programlisting">int xmlUCSIsUnifiedCanadianAboriginalSyllabics (int code)<br>
</pre>
<p>Check whether the character is part of UnifiedCanadianAboriginalSyllabics UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsVariationSelectors"></a>xmlUCSIsVariationSelectors ()</h3>
<pre class="programlisting">int xmlUCSIsVariationSelectors (int code)<br>
</pre>
<p>Check whether the character is part of VariationSelectors UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsVariationSelectorsSupplement"></a>xmlUCSIsVariationSelectorsSupplement ()</h3>
<pre class="programlisting">int xmlUCSIsVariationSelectorsSupplement (int code)<br>
</pre>
<p>Check whether the character is part of VariationSelectorsSupplement UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsYiRadicals"></a>xmlUCSIsYiRadicals ()</h3>
<pre class="programlisting">int xmlUCSIsYiRadicals (int code)<br>
</pre>
<p>Check whether the character is part of YiRadicals UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsYiSyllables"></a>xmlUCSIsYiSyllables ()</h3>
<pre class="programlisting">int xmlUCSIsYiSyllables (int code)<br>
</pre>
<p>Check whether the character is part of YiSyllables UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUCSIsYijingHexagramSymbols"></a>xmlUCSIsYijingHexagramSymbols ()</h3>
<pre class="programlisting">int xmlUCSIsYijingHexagramSymbols (int code)<br>
</pre>
<p>Check whether the character is part of YijingHexagramSymbols UCS Block</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>code</tt></i>:</span></td>
<td>UCS code point</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
</div>
</div>
</body>
</html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>nanohttp: minimal HTTP implementation</title>
<meta name="generator" content="Libxml2 devhelp stylesheet">
<link rel="start" href="index.html" title="libxml2 Reference Manual">
<link rel="up" href="general.html" title="API">
<link rel="stylesheet" href="style.css" type="text/css">
<link rel="chapter" href="general.html" title="API">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table class="navigation" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"><tr valign="middle">
<td><a accesskey="p" href="libxml2-nanoftp.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
<td><a accesskey="u" href="general.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
<td><a accesskey="n" href="libxml2-parser.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
<th width="100%" align="center">libxml2 Reference Manual</th>
</tr></table>
<h2><span class="refentrytitle">nanohttp</span></h2>
<p>nanohttp - minimal HTTP implementation</p>
<p>minimal HTTP implementation allowing to fetch resources like external subset. </p>
<p>Author(s): Daniel Veillard </p>
<div class="refsynopsisdiv">
<h2>Synopsis</h2>
<pre class="synopsis">const char * <a href="#xmlNanoHTTPAuthHeader">xmlNanoHTTPAuthHeader</a> (void * ctx);
void <a href="#xmlNanoHTTPCleanup">xmlNanoHTTPCleanup</a> (void);
void <a href="#xmlNanoHTTPClose">xmlNanoHTTPClose</a> (void * ctx);
int <a href="#xmlNanoHTTPContentLength">xmlNanoHTTPContentLength</a> (void * ctx);
const char * <a href="#xmlNanoHTTPEncoding">xmlNanoHTTPEncoding</a> (void * ctx);
int <a href="#xmlNanoHTTPFetch">xmlNanoHTTPFetch</a> (const char * URL, <br> const char * filename, <br> char ** contentType);
void <a href="#xmlNanoHTTPInit">xmlNanoHTTPInit</a> (void);
void * <a href="#xmlNanoHTTPMethod">xmlNanoHTTPMethod</a> (const char * URL, <br> const char * method, <br> const char * input, <br> char ** contentType, <br> const char * headers, <br> int ilen);
void * <a href="#xmlNanoHTTPMethodRedir">xmlNanoHTTPMethodRedir</a> (const char * URL, <br> const char * method, <br> const char * input, <br> char ** contentType, <br> char ** redir, <br> const char * headers, <br> int ilen);
const char * <a href="#xmlNanoHTTPMimeType">xmlNanoHTTPMimeType</a> (void * ctx);
void * <a href="#xmlNanoHTTPOpen">xmlNanoHTTPOpen</a> (const char * URL, <br> char ** contentType);
void * <a href="#xmlNanoHTTPOpenRedir">xmlNanoHTTPOpenRedir</a> (const char * URL, <br> char ** contentType, <br> char ** redir);
int <a href="#xmlNanoHTTPRead">xmlNanoHTTPRead</a> (void * ctx, <br> void * dest, <br> int len);
const char * <a href="#xmlNanoHTTPRedir">xmlNanoHTTPRedir</a> (void * ctx);
int <a href="#xmlNanoHTTPReturnCode">xmlNanoHTTPReturnCode</a> (void * ctx);
int <a href="#xmlNanoHTTPSave">xmlNanoHTTPSave</a> (void * ctxt, <br> const char * filename);
void <a href="#xmlNanoHTTPScanProxy">xmlNanoHTTPScanProxy</a> (const char * URL);
</pre>
</div>
<div class="refsect1" lang="en"><h2>Description</h2></div>
<div class="refsect1" lang="en">
<h2>Details</h2>
<div class="refsect2" lang="en">
<div class="refsect2" lang="en">
<h3>
<a name="xmlNanoHTTPAuthHeader"></a>xmlNanoHTTPAuthHeader ()</h3>
<pre class="programlisting">const char * xmlNanoHTTPAuthHeader (void * ctx)<br>
</pre>
<p>Get the authentication header of an HTTP context</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctx</tt></i>:</span></td>
<td>the HTTP context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the stashed value of the WWW-Authenticate or Proxy-Authenticate header.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNanoHTTPCleanup"></a>xmlNanoHTTPCleanup ()</h3>
<pre class="programlisting">void xmlNanoHTTPCleanup (void)<br>
</pre>
<p>Cleanup the HTTP protocol layer.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNanoHTTPClose"></a>xmlNanoHTTPClose ()</h3>
<pre class="programlisting">void xmlNanoHTTPClose (void * ctx)<br>
</pre>
<p>This function closes an HTTP context, it ends up the connection and free all data related to it.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctx</tt></i>:</span></td>
<td>the HTTP context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNanoHTTPContentLength"></a>xmlNanoHTTPContentLength ()</h3>
<pre class="programlisting">int xmlNanoHTTPContentLength (void * ctx)<br>
</pre>
<p>Provides the specified content length from the HTTP header.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctx</tt></i>:</span></td>
<td>the HTTP context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the specified content length from the HTTP header. Note that a value of -1 indicates that the content length element was not included in the response header.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNanoHTTPEncoding"></a>xmlNanoHTTPEncoding ()</h3>
<pre class="programlisting">const char * xmlNanoHTTPEncoding (void * ctx)<br>
</pre>
<p>Provides the specified encoding if specified in the HTTP headers.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctx</tt></i>:</span></td>
<td>the HTTP context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the specified encoding or NULL if not available</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNanoHTTPFetch"></a>xmlNanoHTTPFetch ()</h3>
<pre class="programlisting">int xmlNanoHTTPFetch (const char * URL, <br> const char * filename, <br> char ** contentType)<br>
</pre>
<p>This function try to fetch the indicated resource via HTTP GET and save it's content in the file.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>URL</tt></i>:</span></td>
<td>The URL to load</td>
</tr>
<tr>
<td><span class="term"><i><tt>filename</tt></i>:</span></td>
<td>the filename where the content should be saved</td>
</tr>
<tr>
<td><span class="term"><i><tt>contentType</tt></i>:</span></td>
<td>if available the Content-Type information will be returned at that location</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>-1 in case of failure, 0 in case of success. The contentType, if provided must be freed by the caller</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNanoHTTPInit"></a>xmlNanoHTTPInit ()</h3>
<pre class="programlisting">void xmlNanoHTTPInit (void)<br>
</pre>
<p>Initialize the HTTP protocol layer. Currently it just checks for proxy information</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNanoHTTPMethod"></a>xmlNanoHTTPMethod ()</h3>
<pre class="programlisting">void * xmlNanoHTTPMethod (const char * URL, <br> const char * method, <br> const char * input, <br> char ** contentType, <br> const char * headers, <br> int ilen)<br>
</pre>
<p>This function try to open a connection to the indicated resource via HTTP using the given @method, adding the given extra headers and the input buffer for the request content.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>URL</tt></i>:</span></td>
<td>The URL to load</td>
</tr>
<tr>
<td><span class="term"><i><tt>method</tt></i>:</span></td>
<td>the HTTP method to use</td>
</tr>
<tr>
<td><span class="term"><i><tt>input</tt></i>:</span></td>
<td>the input string if any</td>
</tr>
<tr>
<td><span class="term"><i><tt>contentType</tt></i>:</span></td>
<td>the Content-Type information IN and OUT</td>
</tr>
<tr>
<td><span class="term"><i><tt>headers</tt></i>:</span></td>
<td>the extra headers</td>
</tr>
<tr>
<td><span class="term"><i><tt>ilen</tt></i>:</span></td>
<td>input length</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>NULL in case of failure, otherwise a request handler. The contentType, if provided must be freed by the caller</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNanoHTTPMethodRedir"></a>xmlNanoHTTPMethodRedir ()</h3>
<pre class="programlisting">void * xmlNanoHTTPMethodRedir (const char * URL, <br> const char * method, <br> const char * input, <br> char ** contentType, <br> char ** redir, <br> const char * headers, <br> int ilen)<br>
</pre>
<p>This function try to open a connection to the indicated resource via HTTP using the given @method, adding the given extra headers and the input buffer for the request content.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>URL</tt></i>:</span></td>
<td>The URL to load</td>
</tr>
<tr>
<td><span class="term"><i><tt>method</tt></i>:</span></td>
<td>the HTTP method to use</td>
</tr>
<tr>
<td><span class="term"><i><tt>input</tt></i>:</span></td>
<td>the input string if any</td>
</tr>
<tr>
<td><span class="term"><i><tt>contentType</tt></i>:</span></td>
<td>the Content-Type information IN and OUT</td>
</tr>
<tr>
<td><span class="term"><i><tt>redir</tt></i>:</span></td>
<td>the redirected URL OUT</td>
</tr>
<tr>
<td><span class="term"><i><tt>headers</tt></i>:</span></td>
<td>the extra headers</td>
</tr>
<tr>
<td><span class="term"><i><tt>ilen</tt></i>:</span></td>
<td>input length</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>NULL in case of failure, otherwise a request handler. The contentType, or redir, if provided must be freed by the caller</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNanoHTTPMimeType"></a>xmlNanoHTTPMimeType ()</h3>
<pre class="programlisting">const char * xmlNanoHTTPMimeType (void * ctx)<br>
</pre>
<p>Provides the specified Mime-Type if specified in the HTTP headers.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctx</tt></i>:</span></td>
<td>the HTTP context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the specified Mime-Type or NULL if not available</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNanoHTTPOpen"></a>xmlNanoHTTPOpen ()</h3>
<pre class="programlisting">void * xmlNanoHTTPOpen (const char * URL, <br> char ** contentType)<br>
</pre>
<p>This function try to open a connection to the indicated resource via HTTP GET.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>URL</tt></i>:</span></td>
<td>The URL to load</td>
</tr>
<tr>
<td><span class="term"><i><tt>contentType</tt></i>:</span></td>
<td>if available the Content-Type information will be returned at that location</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>NULL in case of failure, otherwise a request handler. The contentType, if provided must be freed by the caller</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNanoHTTPOpenRedir"></a>xmlNanoHTTPOpenRedir ()</h3>
<pre class="programlisting">void * xmlNanoHTTPOpenRedir (const char * URL, <br> char ** contentType, <br> char ** redir)<br>
</pre>
<p>This function try to open a connection to the indicated resource via HTTP GET.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>URL</tt></i>:</span></td>
<td>The URL to load</td>
</tr>
<tr>
<td><span class="term"><i><tt>contentType</tt></i>:</span></td>
<td>if available the Content-Type information will be returned at that location</td>
</tr>
<tr>
<td><span class="term"><i><tt>redir</tt></i>:</span></td>
<td>if available the redirected URL will be returned</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>NULL in case of failure, otherwise a request handler. The contentType, if provided must be freed by the caller</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNanoHTTPRead"></a>xmlNanoHTTPRead ()</h3>
<pre class="programlisting">int xmlNanoHTTPRead (void * ctx, <br> void * dest, <br> int len)<br>
</pre>
<p>This function tries to read @len bytes from the existing HTTP connection and saves them in @dest. This is a blocking call.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctx</tt></i>:</span></td>
<td>the HTTP context</td>
</tr>
<tr>
<td><span class="term"><i><tt>dest</tt></i>:</span></td>
<td>a buffer</td>
</tr>
<tr>
<td><span class="term"><i><tt>len</tt></i>:</span></td>
<td>the buffer length</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of byte read. 0 is an indication of an end of connection. -1 indicates a parameter error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNanoHTTPRedir"></a>xmlNanoHTTPRedir ()</h3>
<pre class="programlisting">const char * xmlNanoHTTPRedir (void * ctx)<br>
</pre>
<p>Provides the specified redirection URL if available from the HTTP header.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctx</tt></i>:</span></td>
<td>the HTTP context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the specified redirection URL or NULL if not redirected.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNanoHTTPReturnCode"></a>xmlNanoHTTPReturnCode ()</h3>
<pre class="programlisting">int xmlNanoHTTPReturnCode (void * ctx)<br>
</pre>
<p>Get the latest HTTP return code received</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctx</tt></i>:</span></td>
<td>the HTTP context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the HTTP return code for the request.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNanoHTTPSave"></a>xmlNanoHTTPSave ()</h3>
<pre class="programlisting">int xmlNanoHTTPSave (void * ctxt, <br> const char * filename)<br>
</pre>
<p>This function saves the output of the HTTP transaction to a file It closes and free the context at the end</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the HTTP context</td>
</tr>
<tr>
<td><span class="term"><i><tt>filename</tt></i>:</span></td>
<td>the filename where the content should be saved</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>-1 in case of failure, 0 in case of success.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNanoHTTPScanProxy"></a>xmlNanoHTTPScanProxy ()</h3>
<pre class="programlisting">void xmlNanoHTTPScanProxy (const char * URL)<br>
</pre>
<p>(Re)Initialize the HTTP Proxy context by parsing the URL and finding the protocol host port it indicates. Should be like http://myproxy/ or http://myproxy:3128/ A NULL URL cleans up proxy information.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>URL</tt></i>:</span></td>
<td>The proxy URL used to initialize the proxy context</td>
</tr></tbody>
</table></div>
</div>
<hr>
</div>
</div>
</body>
</html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>dict: string dictionary</title>
<meta name="generator" content="Libxml2 devhelp stylesheet">
<link rel="start" href="index.html" title="libxml2 Reference Manual">
<link rel="up" href="general.html" title="API">
<link rel="stylesheet" href="style.css" type="text/css">
<link rel="chapter" href="general.html" title="API">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table class="navigation" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"><tr valign="middle">
<td><a accesskey="p" href="libxml2-debugXML.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
<td><a accesskey="u" href="general.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
<td><a accesskey="n" href="libxml2-encoding.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
<th width="100%" align="center">libxml2 Reference Manual</th>
</tr></table>
<h2><span class="refentrytitle">dict</span></h2>
<p>dict - string dictionary</p>
<p>dictionary of reusable strings, just used to avoid allocation and freeing operations. </p>
<p>Author(s): Daniel Veillard </p>
<div class="refsynopsisdiv">
<h2>Synopsis</h2>
<pre class="synopsis">typedef struct _xmlDict <a href="#xmlDict">xmlDict</a>;
typedef <a href="libxml2-dict.html#xmlDict">xmlDict</a> * <a href="#xmlDictPtr">xmlDictPtr</a>;
void <a href="#xmlDictCleanup">xmlDictCleanup</a> (void);
<a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> <a href="#xmlDictCreate">xmlDictCreate</a> (void);
<a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> <a href="#xmlDictCreateSub">xmlDictCreateSub</a> (<a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> sub);
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlDictExists">xmlDictExists</a> (<a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> dict, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> int len);
void <a href="#xmlDictFree">xmlDictFree</a> (<a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> dict);
size_t <a href="#xmlDictGetUsage">xmlDictGetUsage</a> (<a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> dict);
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlDictLookup">xmlDictLookup</a> (<a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> dict, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> int len);
int <a href="#xmlDictOwns">xmlDictOwns</a> (<a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> dict, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * str);
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlDictQLookup">xmlDictQLookup</a> (<a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> dict, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * prefix, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name);
int <a href="#xmlDictReference">xmlDictReference</a> (<a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> dict);
size_t <a href="#xmlDictSetLimit">xmlDictSetLimit</a> (<a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> dict, <br> size_t limit);
int <a href="#xmlDictSize">xmlDictSize</a> (<a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> dict);
int <a href="#xmlInitializeDict">xmlInitializeDict</a> (void);
</pre>
</div>
<div class="refsect1" lang="en"><h2>Description</h2></div>
<div class="refsect1" lang="en">
<h2>Details</h2>
<div class="refsect2" lang="en">
<div class="refsect2" lang="en">
<h3>
<a name="xmlDict">Structure </a>xmlDict</h3>
<pre class="programlisting">struct _xmlDict {
The content of this structure is not made public by the API.
} xmlDict;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDictPtr">Typedef </a>xmlDictPtr</h3>
<pre class="programlisting"><a href="libxml2-dict.html#xmlDict">xmlDict</a> * xmlDictPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDictCleanup"></a>xmlDictCleanup ()</h3>
<pre class="programlisting">void xmlDictCleanup (void)<br>
</pre>
<p>DEPRECATED: This function will be made private. Call <a href="libxml2-parser.html#xmlCleanupParser">xmlCleanupParser</a> to free global state but see the warnings there. <a href="libxml2-parser.html#xmlCleanupParser">xmlCleanupParser</a> should be only called once at program exit. In most cases, you don't have call cleanup functions at all. Free the dictionary mutex. Do not call unless sure the library is not in use anymore !</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDictCreate"></a>xmlDictCreate ()</h3>
<pre class="programlisting"><a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> xmlDictCreate (void)<br>
</pre>
<p>Create a new dictionary</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the newly created dictionary, or NULL if an error occurred.</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDictCreateSub"></a>xmlDictCreateSub ()</h3>
<pre class="programlisting"><a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> xmlDictCreateSub (<a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> sub)<br>
</pre>
<p>Create a new dictionary, inheriting strings from the read-only dictionary @sub. On lookup, strings are first searched in the new dictionary, then in @sub, and if not found are created in the new dictionary.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>sub</tt></i>:</span></td>
<td>an existing dictionary</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the newly created dictionary, or NULL if an error occurred.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDictExists"></a>xmlDictExists ()</h3>
<pre class="programlisting">const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlDictExists (<a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> dict, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> int len)<br>
</pre>
<p>Check if the @name exists in the dictionary @dict.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>dict</tt></i>:</span></td>
<td>the dictionary</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the name of the userdata</td>
</tr>
<tr>
<td><span class="term"><i><tt>len</tt></i>:</span></td>
<td>the length of the name, if -1 it is recomputed</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the internal copy of the name or NULL if not found.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDictFree"></a>xmlDictFree ()</h3>
<pre class="programlisting">void xmlDictFree (<a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> dict)<br>
</pre>
<p>Free the hash @dict and its contents. The userdata is deallocated with @f if provided.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>dict</tt></i>:</span></td>
<td>the dictionary</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDictGetUsage"></a>xmlDictGetUsage ()</h3>
<pre class="programlisting">size_t xmlDictGetUsage (<a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> dict)<br>
</pre>
<p>Get how much memory is used by a dictionary for strings Added in 2.9.0</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>dict</tt></i>:</span></td>
<td>the dictionary</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the amount of strings allocated</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDictLookup"></a>xmlDictLookup ()</h3>
<pre class="programlisting">const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlDictLookup (<a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> dict, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> int len)<br>
</pre>
<p>Add the @name to the dictionary @dict if not present.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>dict</tt></i>:</span></td>
<td>the dictionary</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the name of the userdata</td>
</tr>
<tr>
<td><span class="term"><i><tt>len</tt></i>:</span></td>
<td>the length of the name, if -1 it is recomputed</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the internal copy of the name or NULL in case of internal error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDictOwns"></a>xmlDictOwns ()</h3>
<pre class="programlisting">int xmlDictOwns (<a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> dict, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * str)<br>
</pre>
<p>check if a string is owned by the dictionary</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>dict</tt></i>:</span></td>
<td>the dictionary</td>
</tr>
<tr>
<td><span class="term"><i><tt>str</tt></i>:</span></td>
<td>the string</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true, 0 if false and -1 in case of error -1 in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDictQLookup"></a>xmlDictQLookup ()</h3>
<pre class="programlisting">const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlDictQLookup (<a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> dict, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * prefix, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name)<br>
</pre>
<p>Add the QName @prefix:@name to the hash @dict if not present.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>dict</tt></i>:</span></td>
<td>the dictionary</td>
</tr>
<tr>
<td><span class="term"><i><tt>prefix</tt></i>:</span></td>
<td>the prefix</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the name</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the internal copy of the QName or NULL in case of internal error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDictReference"></a>xmlDictReference ()</h3>
<pre class="programlisting">int xmlDictReference (<a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> dict)<br>
</pre>
<p>Increment the <a href="libxml2-SAX.html#reference">reference</a> counter of a dictionary</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>dict</tt></i>:</span></td>
<td>the dictionary</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 in case of success and -1 in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDictSetLimit"></a>xmlDictSetLimit ()</h3>
<pre class="programlisting">size_t xmlDictSetLimit (<a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> dict, <br> size_t limit)<br>
</pre>
<p>Set a size limit for the dictionary Added in 2.9.0</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>dict</tt></i>:</span></td>
<td>the dictionary</td>
</tr>
<tr>
<td><span class="term"><i><tt>limit</tt></i>:</span></td>
<td>the limit in bytes</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the previous limit of the dictionary or 0</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDictSize"></a>xmlDictSize ()</h3>
<pre class="programlisting">int xmlDictSize (<a href="libxml2-dict.html#xmlDictPtr">xmlDictPtr</a> dict)<br>
</pre>
<p>Query the number of elements installed in the hash @dict.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>dict</tt></i>:</span></td>
<td>the dictionary</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of elements in the dictionary or -1 in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlInitializeDict"></a>xmlInitializeDict ()</h3>
<pre class="programlisting">int xmlInitializeDict (void)<br>
</pre>
<p>DEPRECATED: This function will be made private. Call <a href="libxml2-parser.html#xmlInitParser">xmlInitParser</a> to initialize the library. Do the dictionary mutex initialization.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if initialization was already done, and 1 if that call led to the initialization</td>
</tr></tbody>
</table></div>
</div>
<hr>
</div>
</div>
</body>
</html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>xmlexports: macros for marking symbols as exportable/importable.</title>
<meta name="generator" content="Libxml2 devhelp stylesheet">
<link rel="start" href="index.html" title="libxml2 Reference Manual">
<link rel="up" href="general.html" title="API">
<link rel="stylesheet" href="style.css" type="text/css">
<link rel="chapter" href="general.html" title="API">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table class="navigation" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"><tr valign="middle">
<td><a accesskey="p" href="libxml2-xmlerror.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
<td><a accesskey="u" href="general.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
<td><a accesskey="n" href="libxml2-xmlmemory.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
<th width="100%" align="center">libxml2 Reference Manual</th>
</tr></table>
<h2><span class="refentrytitle">xmlexports</span></h2>
<p>xmlexports - macros for marking symbols as exportable/importable.</p>
<p>macros for marking symbols as exportable/importable. </p>
<p>Author(s): </p>
<div class="refsynopsisdiv">
<h2>Synopsis</h2>
<pre class="synopsis">#define <a href="#LIBXML_DLL_IMPORT">LIBXML_DLL_IMPORT</a>;
#define <a href="#XMLCALL">XMLCALL</a>;
#define <a href="#XMLCDECL">XMLCDECL</a>;
#define <a href="#XMLPUBFUN">XMLPUBFUN</a>;
#define <a href="#XMLPUBLIC">XMLPUBLIC</a>;
#define <a href="#XMLPUBVAR">XMLPUBVAR</a>;
</pre>
</div>
<div class="refsect1" lang="en"><h2>Description</h2></div>
<div class="refsect1" lang="en">
<h2>Details</h2>
<div class="refsect2" lang="en">
<div class="refsect2" lang="en">
<h3>
<a name="LIBXML_DLL_IMPORT">Macro </a>LIBXML_DLL_IMPORT</h3>
<pre class="programlisting">#define <a href="#LIBXML_DLL_IMPORT">LIBXML_DLL_IMPORT</a>;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XMLCALL">Macro </a>XMLCALL</h3>
<pre class="programlisting">#define <a href="#XMLCALL">XMLCALL</a>;
</pre>
<p>Macro which declares the calling convention for exported functions</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XMLCDECL">Macro </a>XMLCDECL</h3>
<pre class="programlisting">#define <a href="#XMLCDECL">XMLCDECL</a>;
</pre>
<p>Macro which declares the calling convention for exported functions that use '...'.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XMLPUBFUN">Macro </a>XMLPUBFUN</h3>
<pre class="programlisting">#define <a href="#XMLPUBFUN">XMLPUBFUN</a>;
</pre>
<p>Macro which declares an exportable function</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XMLPUBLIC">Macro </a>XMLPUBLIC</h3>
<pre class="programlisting">#define <a href="#XMLPUBLIC">XMLPUBLIC</a>;
</pre>
<p>Macro which declares a public symbol</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XMLPUBVAR">Macro </a>XMLPUBVAR</h3>
<pre class="programlisting">#define <a href="#XMLPUBVAR">XMLPUBVAR</a>;
</pre>
<p>Macro which declares an exportable variable</p>
</div>
<hr>
</div>
</div>
</body>
</html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>xmlsave: the XML document serializer</title>
<meta name="generator" content="Libxml2 devhelp stylesheet">
<link rel="start" href="index.html" title="libxml2 Reference Manual">
<link rel="up" href="general.html" title="API">
<link rel="stylesheet" href="style.css" type="text/css">
<link rel="chapter" href="general.html" title="API">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table class="navigation" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"><tr valign="middle">
<td><a accesskey="p" href="libxml2-xmlregexp.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
<td><a accesskey="u" href="general.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
<td><a accesskey="n" href="libxml2-xmlschemas.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
<th width="100%" align="center">libxml2 Reference Manual</th>
</tr></table>
<h2><span class="refentrytitle">xmlsave</span></h2>
<p>xmlsave - the XML document serializer</p>
<p>API to save document or subtree of document </p>
<p>Author(s): Daniel Veillard </p>
<div class="refsynopsisdiv">
<h2>Synopsis</h2>
<pre class="synopsis">typedef struct _xmlSaveCtxt <a href="#xmlSaveCtxt">xmlSaveCtxt</a>;
typedef <a href="libxml2-xmlsave.html#xmlSaveCtxt">xmlSaveCtxt</a> * <a href="#xmlSaveCtxtPtr">xmlSaveCtxtPtr</a>;
typedef enum <a href="#xmlSaveOption">xmlSaveOption</a>;
int <a href="#xmlSaveClose">xmlSaveClose</a> (<a href="libxml2-xmlsave.html#xmlSaveCtxtPtr">xmlSaveCtxtPtr</a> ctxt);
long <a href="#xmlSaveDoc">xmlSaveDoc</a> (<a href="libxml2-xmlsave.html#xmlSaveCtxtPtr">xmlSaveCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc);
int <a href="#xmlSaveFlush">xmlSaveFlush</a> (<a href="libxml2-xmlsave.html#xmlSaveCtxtPtr">xmlSaveCtxtPtr</a> ctxt);
int <a href="#xmlSaveSetAttrEscape">xmlSaveSetAttrEscape</a> (<a href="libxml2-xmlsave.html#xmlSaveCtxtPtr">xmlSaveCtxtPtr</a> ctxt, <br> <a href="libxml2-encoding.html#xmlCharEncodingOutputFunc">xmlCharEncodingOutputFunc</a> escape);
int <a href="#xmlSaveSetEscape">xmlSaveSetEscape</a> (<a href="libxml2-xmlsave.html#xmlSaveCtxtPtr">xmlSaveCtxtPtr</a> ctxt, <br> <a href="libxml2-encoding.html#xmlCharEncodingOutputFunc">xmlCharEncodingOutputFunc</a> escape);
<a href="libxml2-xmlsave.html#xmlSaveCtxtPtr">xmlSaveCtxtPtr</a> <a href="#xmlSaveToBuffer">xmlSaveToBuffer</a> (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buffer, <br> const char * encoding, <br> int options);
<a href="libxml2-xmlsave.html#xmlSaveCtxtPtr">xmlSaveCtxtPtr</a> <a href="#xmlSaveToFd">xmlSaveToFd</a> (int fd, <br> const char * encoding, <br> int options);
<a href="libxml2-xmlsave.html#xmlSaveCtxtPtr">xmlSaveCtxtPtr</a> <a href="#xmlSaveToFilename">xmlSaveToFilename</a> (const char * filename, <br> const char * encoding, <br> int options);
<a href="libxml2-xmlsave.html#xmlSaveCtxtPtr">xmlSaveCtxtPtr</a> <a href="#xmlSaveToIO">xmlSaveToIO</a> (<a href="libxml2-xmlIO.html#xmlOutputWriteCallback">xmlOutputWriteCallback</a> iowrite, <br> <a href="libxml2-xmlIO.html#xmlOutputCloseCallback">xmlOutputCloseCallback</a> ioclose, <br> void * ioctx, <br> const char * encoding, <br> int options);
long <a href="#xmlSaveTree">xmlSaveTree</a> (<a href="libxml2-xmlsave.html#xmlSaveCtxtPtr">xmlSaveCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
</pre>
</div>
<div class="refsect1" lang="en"><h2>Description</h2></div>
<div class="refsect1" lang="en">
<h2>Details</h2>
<div class="refsect2" lang="en">
<div class="refsect2" lang="en">
<h3>
<a name="xmlSaveCtxt">Structure </a>xmlSaveCtxt</h3>
<pre class="programlisting">struct _xmlSaveCtxt {
The content of this structure is not made public by the API.
} xmlSaveCtxt;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSaveCtxtPtr">Typedef </a>xmlSaveCtxtPtr</h3>
<pre class="programlisting"><a href="libxml2-xmlsave.html#xmlSaveCtxt">xmlSaveCtxt</a> * xmlSaveCtxtPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSaveOption">Enum </a>xmlSaveOption</h3>
<pre class="programlisting">enum <a href="#xmlSaveOption">xmlSaveOption</a> {
<a name="XML_SAVE_FORMAT">XML_SAVE_FORMAT</a> = 1 /* format save output */
<a name="XML_SAVE_NO_DECL">XML_SAVE_NO_DECL</a> = 2 /* drop the xml declaration */
<a name="XML_SAVE_NO_EMPTY">XML_SAVE_NO_EMPTY</a> = 4 /* no empty tags */
<a name="XML_SAVE_NO_XHTML">XML_SAVE_NO_XHTML</a> = 8 /* disable XHTML1 specific rules */
<a name="XML_SAVE_XHTML">XML_SAVE_XHTML</a> = 16 /* force XHTML1 specific rules */
<a name="XML_SAVE_AS_XML">XML_SAVE_AS_XML</a> = 32 /* force XML serialization on HTML doc */
<a name="XML_SAVE_AS_HTML">XML_SAVE_AS_HTML</a> = 64 /* force HTML serialization on XML doc */
<a name="XML_SAVE_WSNONSIG">XML_SAVE_WSNONSIG</a> = 128 /* format with non-significant whitespace */
};
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSaveClose"></a>xmlSaveClose ()</h3>
<pre class="programlisting">int xmlSaveClose (<a href="libxml2-xmlsave.html#xmlSaveCtxtPtr">xmlSaveCtxtPtr</a> ctxt)<br>
</pre>
<p>Close a document saving context, i.e. make sure that all bytes have been output and free the associated data.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>a document saving context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of byte written or -1 in case of error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSaveDoc"></a>xmlSaveDoc ()</h3>
<pre class="programlisting">long xmlSaveDoc (<a href="libxml2-xmlsave.html#xmlSaveCtxtPtr">xmlSaveCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlDocPtr">xmlDocPtr</a> doc)<br>
</pre>
<p>Save a full document to a saving context TODO: The function is not fully implemented yet as it does not return the byte count but 0 instead</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>a document saving context</td>
</tr>
<tr>
<td><span class="term"><i><tt>doc</tt></i>:</span></td>
<td>a document</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of byte written or -1 in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSaveFlush"></a>xmlSaveFlush ()</h3>
<pre class="programlisting">int xmlSaveFlush (<a href="libxml2-xmlsave.html#xmlSaveCtxtPtr">xmlSaveCtxtPtr</a> ctxt)<br>
</pre>
<p>Flush a document saving context, i.e. make sure that all bytes have been output.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>a document saving context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of byte written or -1 in case of error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSaveSetAttrEscape"></a>xmlSaveSetAttrEscape ()</h3>
<pre class="programlisting">int xmlSaveSetAttrEscape (<a href="libxml2-xmlsave.html#xmlSaveCtxtPtr">xmlSaveCtxtPtr</a> ctxt, <br> <a href="libxml2-encoding.html#xmlCharEncodingOutputFunc">xmlCharEncodingOutputFunc</a> escape)<br>
</pre>
<p>Set a custom escaping function to be used for text in <a href="libxml2-SAX.html#attribute">attribute</a> content</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>a document saving context</td>
</tr>
<tr>
<td><span class="term"><i><tt>escape</tt></i>:</span></td>
<td>the escaping function</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if successful or -1 in case of error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSaveSetEscape"></a>xmlSaveSetEscape ()</h3>
<pre class="programlisting">int xmlSaveSetEscape (<a href="libxml2-xmlsave.html#xmlSaveCtxtPtr">xmlSaveCtxtPtr</a> ctxt, <br> <a href="libxml2-encoding.html#xmlCharEncodingOutputFunc">xmlCharEncodingOutputFunc</a> escape)<br>
</pre>
<p>Set a custom escaping function to be used for text in element content</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>a document saving context</td>
</tr>
<tr>
<td><span class="term"><i><tt>escape</tt></i>:</span></td>
<td>the escaping function</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if successful or -1 in case of error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSaveToBuffer"></a>xmlSaveToBuffer ()</h3>
<pre class="programlisting"><a href="libxml2-xmlsave.html#xmlSaveCtxtPtr">xmlSaveCtxtPtr</a> xmlSaveToBuffer (<a href="libxml2-tree.html#xmlBufferPtr">xmlBufferPtr</a> buffer, <br> const char * encoding, <br> int options)<br>
</pre>
<p>Create a document saving context serializing to a buffer with the encoding and the options given</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>buffer</tt></i>:</span></td>
<td>a buffer</td>
</tr>
<tr>
<td><span class="term"><i><tt>encoding</tt></i>:</span></td>
<td>the encoding name to use or NULL</td>
</tr>
<tr>
<td><span class="term"><i><tt>options</tt></i>:</span></td>
<td>a set of xmlSaveOptions</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a new serialization context or NULL in case of error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSaveToFd"></a>xmlSaveToFd ()</h3>
<pre class="programlisting"><a href="libxml2-xmlsave.html#xmlSaveCtxtPtr">xmlSaveCtxtPtr</a> xmlSaveToFd (int fd, <br> const char * encoding, <br> int options)<br>
</pre>
<p>Create a document saving context serializing to a file descriptor with the encoding and the options given.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>fd</tt></i>:</span></td>
<td>a file descriptor number</td>
</tr>
<tr>
<td><span class="term"><i><tt>encoding</tt></i>:</span></td>
<td>the encoding name to use or NULL</td>
</tr>
<tr>
<td><span class="term"><i><tt>options</tt></i>:</span></td>
<td>a set of xmlSaveOptions</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a new serialization context or NULL in case of error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSaveToFilename"></a>xmlSaveToFilename ()</h3>
<pre class="programlisting"><a href="libxml2-xmlsave.html#xmlSaveCtxtPtr">xmlSaveCtxtPtr</a> xmlSaveToFilename (const char * filename, <br> const char * encoding, <br> int options)<br>
</pre>
<p>Create a document saving context serializing to a filename or possibly to an URL (but this is less reliable) with the encoding and the options given.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>filename</tt></i>:</span></td>
<td>a file name or an URL</td>
</tr>
<tr>
<td><span class="term"><i><tt>encoding</tt></i>:</span></td>
<td>the encoding name to use or NULL</td>
</tr>
<tr>
<td><span class="term"><i><tt>options</tt></i>:</span></td>
<td>a set of xmlSaveOptions</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a new serialization context or NULL in case of error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSaveToIO"></a>xmlSaveToIO ()</h3>
<pre class="programlisting"><a href="libxml2-xmlsave.html#xmlSaveCtxtPtr">xmlSaveCtxtPtr</a> xmlSaveToIO (<a href="libxml2-xmlIO.html#xmlOutputWriteCallback">xmlOutputWriteCallback</a> iowrite, <br> <a href="libxml2-xmlIO.html#xmlOutputCloseCallback">xmlOutputCloseCallback</a> ioclose, <br> void * ioctx, <br> const char * encoding, <br> int options)<br>
</pre>
<p>Create a document saving context serializing to a file descriptor with the encoding and the options given</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>iowrite</tt></i>:</span></td>
<td>an I/O write function</td>
</tr>
<tr>
<td><span class="term"><i><tt>ioclose</tt></i>:</span></td>
<td>an I/O close function</td>
</tr>
<tr>
<td><span class="term"><i><tt>ioctx</tt></i>:</span></td>
<td>an I/O handler</td>
</tr>
<tr>
<td><span class="term"><i><tt>encoding</tt></i>:</span></td>
<td>the encoding name to use or NULL</td>
</tr>
<tr>
<td><span class="term"><i><tt>options</tt></i>:</span></td>
<td>a set of xmlSaveOptions</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a new serialization context or NULL in case of error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSaveTree"></a>xmlSaveTree ()</h3>
<pre class="programlisting">long xmlSaveTree (<a href="libxml2-xmlsave.html#xmlSaveCtxtPtr">xmlSaveCtxtPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Save a subtree starting at the node parameter to a saving context TODO: The function is not fully implemented yet as it does not return the byte count but 0 instead</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>a document saving context</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td></td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of byte written or -1 in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
</div>
</div>
</body>
</html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>xmlmodule: dynamic module loading</title>
<meta name="generator" content="Libxml2 devhelp stylesheet">
<link rel="start" href="index.html" title="libxml2 Reference Manual">
<link rel="up" href="general.html" title="API">
<link rel="stylesheet" href="style.css" type="text/css">
<link rel="chapter" href="general.html" title="API">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table class="navigation" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"><tr valign="middle">
<td><a accesskey="p" href="libxml2-xmlmemory.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
<td><a accesskey="u" href="general.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
<td><a accesskey="n" href="libxml2-xmlreader.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
<th width="100%" align="center">libxml2 Reference Manual</th>
</tr></table>
<h2><span class="refentrytitle">xmlmodule</span></h2>
<p>xmlmodule - dynamic module loading</p>
<p>basic API for dynamic module loading, used by libexslt added in 2.6.17 </p>
<p>Author(s): Joel W. Reed </p>
<div class="refsynopsisdiv">
<h2>Synopsis</h2>
<pre class="synopsis">typedef struct _xmlModule <a href="#xmlModule">xmlModule</a>;
typedef enum <a href="#xmlModuleOption">xmlModuleOption</a>;
typedef <a href="libxml2-xmlmodule.html#xmlModule">xmlModule</a> * <a href="#xmlModulePtr">xmlModulePtr</a>;
int <a href="#xmlModuleClose">xmlModuleClose</a> (<a href="libxml2-xmlmodule.html#xmlModulePtr">xmlModulePtr</a> module);
int <a href="#xmlModuleFree">xmlModuleFree</a> (<a href="libxml2-xmlmodule.html#xmlModulePtr">xmlModulePtr</a> module);
<a href="libxml2-xmlmodule.html#xmlModulePtr">xmlModulePtr</a> <a href="#xmlModuleOpen">xmlModuleOpen</a> (const char * name, <br> int options);
int <a href="#xmlModuleSymbol">xmlModuleSymbol</a> (<a href="libxml2-xmlmodule.html#xmlModulePtr">xmlModulePtr</a> module, <br> const char * name, <br> void ** symbol);
</pre>
</div>
<div class="refsect1" lang="en"><h2>Description</h2></div>
<div class="refsect1" lang="en">
<h2>Details</h2>
<div class="refsect2" lang="en">
<div class="refsect2" lang="en">
<h3>
<a name="xmlModule">Structure </a>xmlModule</h3>
<pre class="programlisting">struct _xmlModule {
The content of this structure is not made public by the API.
} xmlModule;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlModuleOption">Enum </a>xmlModuleOption</h3>
<pre class="programlisting">enum <a href="#xmlModuleOption">xmlModuleOption</a> {
<a name="XML_MODULE_LAZY">XML_MODULE_LAZY</a> = 1 /* lazy binding */
<a name="XML_MODULE_LOCAL">XML_MODULE_LOCAL</a> = 2 /* local binding */
};
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlModulePtr">Typedef </a>xmlModulePtr</h3>
<pre class="programlisting"><a href="libxml2-xmlmodule.html#xmlModule">xmlModule</a> * xmlModulePtr;
</pre>
<p>A handle to a dynamically loaded module</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlModuleClose"></a>xmlModuleClose ()</h3>
<pre class="programlisting">int xmlModuleClose (<a href="libxml2-xmlmodule.html#xmlModulePtr">xmlModulePtr</a> module)<br>
</pre>
<p>The close operations unload the associated module and free the data associated to the module.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>module</tt></i>:</span></td>
<td>the module handle</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 in case of success, -1 in case of argument error and -2 if the module could not be closed/unloaded.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlModuleFree"></a>xmlModuleFree ()</h3>
<pre class="programlisting">int xmlModuleFree (<a href="libxml2-xmlmodule.html#xmlModulePtr">xmlModulePtr</a> module)<br>
</pre>
<p>The free operations free the data associated to the module but does not unload the associated shared library which may still be in use.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>module</tt></i>:</span></td>
<td>the module handle</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 in case of success, -1 in case of argument error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlModuleOpen"></a>xmlModuleOpen ()</h3>
<pre class="programlisting"><a href="libxml2-xmlmodule.html#xmlModulePtr">xmlModulePtr</a> xmlModuleOpen (const char * name, <br> int options)<br>
</pre>
<p>Opens a module/shared library given its name or path NOTE: that due to portability issues, behaviour can only be guaranteed with @name using ASCII. We cannot guarantee that an UTF-8 string would work, which is why name is a const char * and not a const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * . TODO: options are not yet implemented.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the module name</td>
</tr>
<tr>
<td><span class="term"><i><tt>options</tt></i>:</span></td>
<td>a set of <a href="libxml2-xmlmodule.html#xmlModuleOption">xmlModuleOption</a>
</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a handle for the module or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlModuleSymbol"></a>xmlModuleSymbol ()</h3>
<pre class="programlisting">int xmlModuleSymbol (<a href="libxml2-xmlmodule.html#xmlModulePtr">xmlModulePtr</a> module, <br> const char * name, <br> void ** symbol)<br>
</pre>
<p>Lookup for a symbol address in the given module NOTE: that due to portability issues, behaviour can only be guaranteed with @name using ASCII. We cannot guarantee that an UTF-8 string would work, which is why name is a const char * and not a const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * .</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>module</tt></i>:</span></td>
<td>the module</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the name of the symbol</td>
</tr>
<tr>
<td><span class="term"><i><tt>symbol</tt></i>:</span></td>
<td>the resulting symbol address</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if the symbol was found, or -1 in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
</div>
</div>
</body>
</html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>xpathInternals: internal interfaces for XML Path Language implementation</title>
<meta name="generator" content="Libxml2 devhelp stylesheet">
<link rel="start" href="index.html" title="libxml2 Reference Manual">
<link rel="up" href="general.html" title="API">
<link rel="stylesheet" href="style.css" type="text/css">
<link rel="chapter" href="general.html" title="API">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table class="navigation" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"><tr valign="middle">
<td><a accesskey="p" href="libxml2-xpath.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
<td><a accesskey="u" href="general.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
<td><a accesskey="n" href="libxml2-xpointer.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
<th width="100%" align="center">libxml2 Reference Manual</th>
</tr></table>
<h2><span class="refentrytitle">xpathInternals</span></h2>
<p>xpathInternals - internal interfaces for XML Path Language implementation</p>
<p>internal interfaces for XML Path Language implementation used to build new modules on top of XPath like XPointer and XSLT </p>
<p>Author(s): Daniel Veillard </p>
<div class="refsynopsisdiv">
<h2>Synopsis</h2>
<pre class="synopsis">#define <a href="#CAST_TO_BOOLEAN">CAST_TO_BOOLEAN</a>;
#define <a href="#CAST_TO_NUMBER">CAST_TO_NUMBER</a>;
#define <a href="#CAST_TO_STRING">CAST_TO_STRING</a>;
#define <a href="#CHECK_ARITY">CHECK_ARITY</a>(x);
#define <a href="#CHECK_ERROR">CHECK_ERROR</a>;
#define <a href="#CHECK_ERROR0">CHECK_ERROR0</a>;
#define <a href="#CHECK_TYPE">CHECK_TYPE</a>(typeval);
#define <a href="#CHECK_TYPE0">CHECK_TYPE0</a>(typeval);
#define <a href="#XP_ERROR">XP_ERROR</a>(X);
#define <a href="#XP_ERROR0">XP_ERROR0</a>(X);
#define <a href="#xmlXPathCheckError">xmlXPathCheckError</a>(ctxt);
#define <a href="#xmlXPathEmptyNodeSet">xmlXPathEmptyNodeSet</a>(ns);
#define <a href="#xmlXPathGetContextNode">xmlXPathGetContextNode</a>(ctxt);
#define <a href="#xmlXPathGetDocument">xmlXPathGetDocument</a>(ctxt);
#define <a href="#xmlXPathGetError">xmlXPathGetError</a>(ctxt);
#define <a href="#xmlXPathReturnBoolean">xmlXPathReturnBoolean</a>(ctxt, val);
#define <a href="#xmlXPathReturnEmptyNodeSet">xmlXPathReturnEmptyNodeSet</a>(ctxt);
#define <a href="#xmlXPathReturnEmptyString">xmlXPathReturnEmptyString</a>(ctxt);
#define <a href="#xmlXPathReturnExternal">xmlXPathReturnExternal</a>(ctxt, val);
#define <a href="#xmlXPathReturnFalse">xmlXPathReturnFalse</a>(ctxt);
#define <a href="#xmlXPathReturnNodeSet">xmlXPathReturnNodeSet</a>(ctxt, ns);
#define <a href="#xmlXPathReturnNumber">xmlXPathReturnNumber</a>(ctxt, val);
#define <a href="#xmlXPathReturnString">xmlXPathReturnString</a>(ctxt, str);
#define <a href="#xmlXPathReturnTrue">xmlXPathReturnTrue</a>(ctxt);
#define <a href="#xmlXPathSetArityError">xmlXPathSetArityError</a>(ctxt);
#define <a href="#xmlXPathSetError">xmlXPathSetError</a>(ctxt, err);
#define <a href="#xmlXPathSetTypeError">xmlXPathSetTypeError</a>(ctxt);
#define <a href="#xmlXPathStackIsExternal">xmlXPathStackIsExternal</a>(ctxt);
#define <a href="#xmlXPathStackIsNodeSet">xmlXPathStackIsNodeSet</a>(ctxt);
<a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> <a href="#valuePop">valuePop</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt);
int <a href="#valuePush">valuePush</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> value);
void <a href="#xmlXPathAddValues">xmlXPathAddValues</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt);
void <a href="#xmlXPathBooleanFunction">xmlXPathBooleanFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
void <a href="#xmlXPathCeilingFunction">xmlXPathCeilingFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
int <a href="#xmlXPathCompareValues">xmlXPathCompareValues</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int inf, <br> int strict);
void <a href="#xmlXPathConcatFunction">xmlXPathConcatFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
void <a href="#xmlXPathContainsFunction">xmlXPathContainsFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
void <a href="#xmlXPathCountFunction">xmlXPathCountFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
void <a href="#xmlXPathDebugDumpCompExpr">xmlXPathDebugDumpCompExpr</a> (FILE * output, <br> <a href="libxml2-xpath.html#xmlXPathCompExprPtr">xmlXPathCompExprPtr</a> comp, <br> int depth);
void <a href="#xmlXPathDebugDumpObject">xmlXPathDebugDumpObject</a> (FILE * output, <br> <a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> cur, <br> int depth);
<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> <a href="#xmlXPathDifference">xmlXPathDifference</a> (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes1, <br> <a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes2);
<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> <a href="#xmlXPathDistinct">xmlXPathDistinct</a> (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes);
<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> <a href="#xmlXPathDistinctSorted">xmlXPathDistinctSorted</a> (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes);
void <a href="#xmlXPathDivValues">xmlXPathDivValues</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt);
int <a href="#xmlXPathEqualValues">xmlXPathEqualValues</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt);
void <a href="#xmlXPathErr">xmlXPathErr</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int error);
void <a href="#xmlXPathEvalExpr">xmlXPathEvalExpr</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt);
int <a href="#xmlXPathEvaluatePredicateResult">xmlXPathEvaluatePredicateResult</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> res);
void <a href="#xmlXPathFalseFunction">xmlXPathFalseFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
void <a href="#xmlXPathFloorFunction">xmlXPathFloorFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
void <a href="#xmlXPathFreeParserContext">xmlXPathFreeParserContext</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt);
<a href="libxml2-xpath.html#xmlXPathFunction">xmlXPathFunction</a> <a href="#xmlXPathFunctionLookup">xmlXPathFunctionLookup</a> (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name);
<a href="libxml2-xpath.html#xmlXPathFunction">xmlXPathFunction</a> <a href="#xmlXPathFunctionLookupNS">xmlXPathFunctionLookupNS</a> (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ns_uri);
int <a href="#xmlXPathHasSameNodes">xmlXPathHasSameNodes</a> (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes1, <br> <a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes2);
void <a href="#xmlXPathIdFunction">xmlXPathIdFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> <a href="#xmlXPathIntersection">xmlXPathIntersection</a> (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes1, <br> <a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes2);
int <a href="#xmlXPathIsNodeType">xmlXPathIsNodeType</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name);
void <a href="#xmlXPathLangFunction">xmlXPathLangFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
void <a href="#xmlXPathLastFunction">xmlXPathLastFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> <a href="#xmlXPathLeading">xmlXPathLeading</a> (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes1, <br> <a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes2);
<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> <a href="#xmlXPathLeadingSorted">xmlXPathLeadingSorted</a> (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes1, <br> <a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes2);
void <a href="#xmlXPathLocalNameFunction">xmlXPathLocalNameFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
void <a href="#xmlXPathModValues">xmlXPathModValues</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt);
void <a href="#xmlXPathMultValues">xmlXPathMultValues</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt);
void <a href="#xmlXPathNamespaceURIFunction">xmlXPathNamespaceURIFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
<a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> <a href="#xmlXPathNewBoolean">xmlXPathNewBoolean</a> (int val);
<a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> <a href="#xmlXPathNewCString">xmlXPathNewCString</a> (const char * val);
<a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> <a href="#xmlXPathNewFloat">xmlXPathNewFloat</a> (double val);
<a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> <a href="#xmlXPathNewNodeSet">xmlXPathNewNodeSet</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> val);
<a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> <a href="#xmlXPathNewNodeSetList">xmlXPathNewNodeSetList</a> (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> val);
<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> <a href="#xmlXPathNewParserContext">xmlXPathNewParserContext</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * str, <br> <a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt);
<a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> <a href="#xmlXPathNewString">xmlXPathNewString</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * val);
<a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> <a href="#xmlXPathNewValueTree">xmlXPathNewValueTree</a> (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> val);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlXPathNextAncestor">xmlXPathNextAncestor</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlXPathNextAncestorOrSelf">xmlXPathNextAncestorOrSelf</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlXPathNextAttribute">xmlXPathNextAttribute</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlXPathNextChild">xmlXPathNextChild</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlXPathNextDescendant">xmlXPathNextDescendant</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlXPathNextDescendantOrSelf">xmlXPathNextDescendantOrSelf</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlXPathNextFollowing">xmlXPathNextFollowing</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlXPathNextFollowingSibling">xmlXPathNextFollowingSibling</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlXPathNextNamespace">xmlXPathNextNamespace</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlXPathNextParent">xmlXPathNextParent</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlXPathNextPreceding">xmlXPathNextPreceding</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlXPathNextPrecedingSibling">xmlXPathNextPrecedingSibling</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> <a href="#xmlXPathNextSelf">xmlXPathNextSelf</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur);
<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> <a href="#xmlXPathNodeLeading">xmlXPathNodeLeading</a> (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node);
<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> <a href="#xmlXPathNodeLeadingSorted">xmlXPathNodeLeadingSorted</a> (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node);
int <a href="#xmlXPathNodeSetAdd">xmlXPathNodeSetAdd</a> (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> cur, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> val);
int <a href="#xmlXPathNodeSetAddNs">xmlXPathNodeSetAddNs</a> (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> cur, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns);
int <a href="#xmlXPathNodeSetAddUnique">xmlXPathNodeSetAddUnique</a> (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> cur, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> val);
int <a href="#xmlXPathNodeSetContains">xmlXPathNodeSetContains</a> (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> cur, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> val);
void <a href="#xmlXPathNodeSetDel">xmlXPathNodeSetDel</a> (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> cur, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> val);
void <a href="#xmlXPathNodeSetFreeNs">xmlXPathNodeSetFreeNs</a> (<a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns);
<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> <a href="#xmlXPathNodeSetMerge">xmlXPathNodeSetMerge</a> (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> val1, <br> <a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> val2);
void <a href="#xmlXPathNodeSetRemove">xmlXPathNodeSetRemove</a> (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> cur, <br> int val);
void <a href="#xmlXPathNodeSetSort">xmlXPathNodeSetSort</a> (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> set);
<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> <a href="#xmlXPathNodeTrailing">xmlXPathNodeTrailing</a> (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node);
<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> <a href="#xmlXPathNodeTrailingSorted">xmlXPathNodeTrailingSorted</a> (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node);
void <a href="#xmlXPathNormalizeFunction">xmlXPathNormalizeFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
int <a href="#xmlXPathNotEqualValues">xmlXPathNotEqualValues</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt);
void <a href="#xmlXPathNotFunction">xmlXPathNotFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlXPathNsLookup">xmlXPathNsLookup</a> (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * prefix);
void <a href="#xmlXPathNumberFunction">xmlXPathNumberFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlXPathParseNCName">xmlXPathParseNCName</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlXPathParseName">xmlXPathParseName</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt);
int <a href="#xmlXPathPopBoolean">xmlXPathPopBoolean</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt);
void * <a href="#xmlXPathPopExternal">xmlXPathPopExternal</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt);
<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> <a href="#xmlXPathPopNodeSet">xmlXPathPopNodeSet</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt);
double <a href="#xmlXPathPopNumber">xmlXPathPopNumber</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlXPathPopString">xmlXPathPopString</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt);
void <a href="#xmlXPathPositionFunction">xmlXPathPositionFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
void <a href="#xmlXPathRegisterAllFunctions">xmlXPathRegisterAllFunctions</a> (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt);
int <a href="#xmlXPathRegisterFunc">xmlXPathRegisterFunc</a> (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> <a href="libxml2-xpath.html#xmlXPathFunction">xmlXPathFunction</a> f);
void <a href="#xmlXPathRegisterFuncLookup">xmlXPathRegisterFuncLookup</a> (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> <a href="libxml2-xpath.html#xmlXPathFuncLookupFunc">xmlXPathFuncLookupFunc</a> f, <br> void * funcCtxt);
int <a href="#xmlXPathRegisterFuncNS">xmlXPathRegisterFuncNS</a> (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ns_uri, <br> <a href="libxml2-xpath.html#xmlXPathFunction">xmlXPathFunction</a> f);
int <a href="#xmlXPathRegisterNs">xmlXPathRegisterNs</a> (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * prefix, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ns_uri);
int <a href="#xmlXPathRegisterVariable">xmlXPathRegisterVariable</a> (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> <a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> value);
void <a href="#xmlXPathRegisterVariableLookup">xmlXPathRegisterVariableLookup</a> (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> <a href="libxml2-xpath.html#xmlXPathVariableLookupFunc">xmlXPathVariableLookupFunc</a> f, <br> void * data);
int <a href="#xmlXPathRegisterVariableNS">xmlXPathRegisterVariableNS</a> (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ns_uri, <br> <a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> value);
void <a href="#xmlXPathRegisteredFuncsCleanup">xmlXPathRegisteredFuncsCleanup</a> (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt);
void <a href="#xmlXPathRegisteredNsCleanup">xmlXPathRegisteredNsCleanup</a> (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt);
void <a href="#xmlXPathRegisteredVariablesCleanup">xmlXPathRegisteredVariablesCleanup</a> (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt);
void <a href="#xmlXPathRoot">xmlXPathRoot</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt);
void <a href="#xmlXPathRoundFunction">xmlXPathRoundFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
void <a href="#xmlXPathStartsWithFunction">xmlXPathStartsWithFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
double <a href="#xmlXPathStringEvalNumber">xmlXPathStringEvalNumber</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * str);
void <a href="#xmlXPathStringFunction">xmlXPathStringFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
void <a href="#xmlXPathStringLengthFunction">xmlXPathStringLengthFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
void <a href="#xmlXPathSubValues">xmlXPathSubValues</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt);
void <a href="#xmlXPathSubstringAfterFunction">xmlXPathSubstringAfterFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
void <a href="#xmlXPathSubstringBeforeFunction">xmlXPathSubstringBeforeFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
void <a href="#xmlXPathSubstringFunction">xmlXPathSubstringFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
void <a href="#xmlXPathSumFunction">xmlXPathSumFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> <a href="#xmlXPathTrailing">xmlXPathTrailing</a> (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes1, <br> <a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes2);
<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> <a href="#xmlXPathTrailingSorted">xmlXPathTrailingSorted</a> (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes1, <br> <a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes2);
void <a href="#xmlXPathTranslateFunction">xmlXPathTranslateFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
void <a href="#xmlXPathTrueFunction">xmlXPathTrueFunction</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs);
void <a href="#xmlXPathValueFlipSign">xmlXPathValueFlipSign</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt);
<a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> <a href="#xmlXPathVariableLookup">xmlXPathVariableLookup</a> (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name);
<a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> <a href="#xmlXPathVariableLookupNS">xmlXPathVariableLookupNS</a> (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ns_uri);
<a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> <a href="#xmlXPathWrapCString">xmlXPathWrapCString</a> (char * val);
<a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> <a href="#xmlXPathWrapExternal">xmlXPathWrapExternal</a> (void * val);
<a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> <a href="#xmlXPathWrapNodeSet">xmlXPathWrapNodeSet</a> (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> val);
<a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> <a href="#xmlXPathWrapString">xmlXPathWrapString</a> (<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * val);
void <a href="#xmlXPatherror">xmlXPatherror</a> (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> const char * file, <br> int line, <br> int no);
</pre>
</div>
<div class="refsect1" lang="en"><h2>Description</h2></div>
<div class="refsect1" lang="en">
<h2>Details</h2>
<div class="refsect2" lang="en">
<div class="refsect2" lang="en">
<h3>
<a name="CAST_TO_BOOLEAN">Macro </a>CAST_TO_BOOLEAN</h3>
<pre class="programlisting">#define <a href="#CAST_TO_BOOLEAN">CAST_TO_BOOLEAN</a>;
</pre>
<p>Macro to try to cast the value on the top of the XPath stack to a boolean.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="CAST_TO_NUMBER">Macro </a>CAST_TO_NUMBER</h3>
<pre class="programlisting">#define <a href="#CAST_TO_NUMBER">CAST_TO_NUMBER</a>;
</pre>
<p>Macro to try to cast the value on the top of the XPath stack to a number.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="CAST_TO_STRING">Macro </a>CAST_TO_STRING</h3>
<pre class="programlisting">#define <a href="#CAST_TO_STRING">CAST_TO_STRING</a>;
</pre>
<p>Macro to try to cast the value on the top of the XPath stack to a string.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="CHECK_ARITY">Macro </a>CHECK_ARITY</h3>
<pre class="programlisting">#define <a href="#CHECK_ARITY">CHECK_ARITY</a>(x);
</pre>
<p>Macro to check that the number of args passed to an XPath function matches.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>x</tt></i>:</span></td>
<td>the number of expected args</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="CHECK_ERROR">Macro </a>CHECK_ERROR</h3>
<pre class="programlisting">#define <a href="#CHECK_ERROR">CHECK_ERROR</a>;
</pre>
<p>Macro to return from the function if an XPath error was detected.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="CHECK_ERROR0">Macro </a>CHECK_ERROR0</h3>
<pre class="programlisting">#define <a href="#CHECK_ERROR0">CHECK_ERROR0</a>;
</pre>
<p>Macro to return 0 from the function if an XPath error was detected.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="CHECK_TYPE">Macro </a>CHECK_TYPE</h3>
<pre class="programlisting">#define <a href="#CHECK_TYPE">CHECK_TYPE</a>(typeval);
</pre>
<p>Macro to check that the value on top of the XPath stack is of a given type.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>typeval</tt></i>:</span></td>
<td>the XPath type</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="CHECK_TYPE0">Macro </a>CHECK_TYPE0</h3>
<pre class="programlisting">#define <a href="#CHECK_TYPE0">CHECK_TYPE0</a>(typeval);
</pre>
<p>Macro to check that the value on top of the XPath stack is of a given type. Return(0) in case of failure</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>typeval</tt></i>:</span></td>
<td>the XPath type</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XP_ERROR">Macro </a>XP_ERROR</h3>
<pre class="programlisting">#define <a href="#XP_ERROR">XP_ERROR</a>(X);
</pre>
<p>Macro to raise an XPath error and return.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>X</tt></i>:</span></td>
<td>the error code</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="XP_ERROR0">Macro </a>XP_ERROR0</h3>
<pre class="programlisting">#define <a href="#XP_ERROR0">XP_ERROR0</a>(X);
</pre>
<p>Macro to raise an XPath error and return 0.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>X</tt></i>:</span></td>
<td>the error code</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathCheckError">Macro </a>xmlXPathCheckError</h3>
<pre class="programlisting">#define <a href="#xmlXPathCheckError">xmlXPathCheckError</a>(ctxt);
</pre>
<p>Check if an XPath error was raised. Returns true if an error has been raised, false otherwise.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathEmptyNodeSet">Macro </a>xmlXPathEmptyNodeSet</h3>
<pre class="programlisting">#define <a href="#xmlXPathEmptyNodeSet">xmlXPathEmptyNodeSet</a>(ns);
</pre>
<p>Empties a node-set.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ns</tt></i>:</span></td>
<td>a node-set</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathGetContextNode">Macro </a>xmlXPathGetContextNode</h3>
<pre class="programlisting">#define <a href="#xmlXPathGetContextNode">xmlXPathGetContextNode</a>(ctxt);
</pre>
<p>Get the context node of an XPath context. Returns the context node.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathGetDocument">Macro </a>xmlXPathGetDocument</h3>
<pre class="programlisting">#define <a href="#xmlXPathGetDocument">xmlXPathGetDocument</a>(ctxt);
</pre>
<p>Get the document of an XPath context. Returns the context document.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathGetError">Macro </a>xmlXPathGetError</h3>
<pre class="programlisting">#define <a href="#xmlXPathGetError">xmlXPathGetError</a>(ctxt);
</pre>
<p>Get the error code of an XPath context. Returns the context error.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathReturnBoolean">Macro </a>xmlXPathReturnBoolean</h3>
<pre class="programlisting">#define <a href="#xmlXPathReturnBoolean">xmlXPathReturnBoolean</a>(ctxt, val);
</pre>
<p>Pushes the boolean @val on the context stack.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>a boolean</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathReturnEmptyNodeSet">Macro </a>xmlXPathReturnEmptyNodeSet</h3>
<pre class="programlisting">#define <a href="#xmlXPathReturnEmptyNodeSet">xmlXPathReturnEmptyNodeSet</a>(ctxt);
</pre>
<p>Pushes an empty node-set on the context stack.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathReturnEmptyString">Macro </a>xmlXPathReturnEmptyString</h3>
<pre class="programlisting">#define <a href="#xmlXPathReturnEmptyString">xmlXPathReturnEmptyString</a>(ctxt);
</pre>
<p>Pushes an empty string on the stack.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathReturnExternal">Macro </a>xmlXPathReturnExternal</h3>
<pre class="programlisting">#define <a href="#xmlXPathReturnExternal">xmlXPathReturnExternal</a>(ctxt, val);
</pre>
<p>Pushes user data on the context stack.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>user data</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathReturnFalse">Macro </a>xmlXPathReturnFalse</h3>
<pre class="programlisting">#define <a href="#xmlXPathReturnFalse">xmlXPathReturnFalse</a>(ctxt);
</pre>
<p>Pushes false on the context stack.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathReturnNodeSet">Macro </a>xmlXPathReturnNodeSet</h3>
<pre class="programlisting">#define <a href="#xmlXPathReturnNodeSet">xmlXPathReturnNodeSet</a>(ctxt, ns);
</pre>
<p>Pushes the node-set @ns on the context stack.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>ns</tt></i>:</span></td>
<td>a node-set</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathReturnNumber">Macro </a>xmlXPathReturnNumber</h3>
<pre class="programlisting">#define <a href="#xmlXPathReturnNumber">xmlXPathReturnNumber</a>(ctxt, val);
</pre>
<p>Pushes the double @val on the context stack.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>a double</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathReturnString">Macro </a>xmlXPathReturnString</h3>
<pre class="programlisting">#define <a href="#xmlXPathReturnString">xmlXPathReturnString</a>(ctxt, str);
</pre>
<p>Pushes the string @str on the context stack.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>str</tt></i>:</span></td>
<td>a string</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathReturnTrue">Macro </a>xmlXPathReturnTrue</h3>
<pre class="programlisting">#define <a href="#xmlXPathReturnTrue">xmlXPathReturnTrue</a>(ctxt);
</pre>
<p>Pushes true on the context stack.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathSetArityError">Macro </a>xmlXPathSetArityError</h3>
<pre class="programlisting">#define <a href="#xmlXPathSetArityError">xmlXPathSetArityError</a>(ctxt);
</pre>
<p>Raises an <a href="libxml2-xpath.html#XPATH_INVALID_ARITY">XPATH_INVALID_ARITY</a> error.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathSetError">Macro </a>xmlXPathSetError</h3>
<pre class="programlisting">#define <a href="#xmlXPathSetError">xmlXPathSetError</a>(ctxt, err);
</pre>
<p>Raises an error.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>err</tt></i>:</span></td>
<td>an <a href="libxml2-xpath.html#xmlXPathError">xmlXPathError</a> code</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathSetTypeError">Macro </a>xmlXPathSetTypeError</h3>
<pre class="programlisting">#define <a href="#xmlXPathSetTypeError">xmlXPathSetTypeError</a>(ctxt);
</pre>
<p>Raises an <a href="libxml2-xpath.html#XPATH_INVALID_TYPE">XPATH_INVALID_TYPE</a> error.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathStackIsExternal">Macro </a>xmlXPathStackIsExternal</h3>
<pre class="programlisting">#define <a href="#xmlXPathStackIsExternal">xmlXPathStackIsExternal</a>(ctxt);
</pre>
<p>Checks if the current value on the XPath stack is an external object. Returns true if the current object on the stack is an external object.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathStackIsNodeSet">Macro </a>xmlXPathStackIsNodeSet</h3>
<pre class="programlisting">#define <a href="#xmlXPathStackIsNodeSet">xmlXPathStackIsNodeSet</a>(ctxt);
</pre>
<p>Check if the current value on the XPath stack is a node set or an XSLT value tree. Returns true if the current object on the stack is a node-set.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="valuePop"></a>valuePop ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> valuePop (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt)<br>
</pre>
<p>Pops the top XPath object from the value stack</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath evaluation context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the XPath object just removed</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="valuePush"></a>valuePush ()</h3>
<pre class="programlisting">int valuePush (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> value)<br>
</pre>
<p>Pushes a new XPath object on top of the value stack. If value is NULL, a memory error is recorded in the parser context.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath evaluation context</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the XPath object</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number of items on the value stack, or -1 in case of error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathAddValues"></a>xmlXPathAddValues ()</h3>
<pre class="programlisting">void xmlXPathAddValues (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt)<br>
</pre>
<p>Implement the add operation on XPath objects: The numeric operators convert their operands to numbers as if by calling the number function.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathBooleanFunction"></a>xmlXPathBooleanFunction ()</h3>
<pre class="programlisting">void xmlXPathBooleanFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the boolean() XPath function boolean boolean(object) The boolean function converts its argument to a boolean as follows: - a number is true if and only if it is neither positive or negative zero nor NaN - a node-set is true if and only if it is non-empty - a string is true if and only if its length is non-zero</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathCeilingFunction"></a>xmlXPathCeilingFunction ()</h3>
<pre class="programlisting">void xmlXPathCeilingFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the ceiling() XPath function number ceiling(number) The ceiling function returns the smallest (closest to negative infinity) number that is not less than the argument and that is an integer.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathCompareValues"></a>xmlXPathCompareValues ()</h3>
<pre class="programlisting">int xmlXPathCompareValues (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int inf, <br> int strict)<br>
</pre>
<p>Implement the compare operation on XPath objects: @arg1 < @arg2 (1, 1, ... @arg1 <= @arg2 (1, 0, ... @arg1 > @arg2 (0, 1, ... @arg1 >= @arg2 (0, 0, ... When neither object to be compared is a node-set and the operator is <=, <, >=, >, then the objects are compared by converted both objects to numbers and comparing the numbers according to IEEE 754. The < comparison will be true if and only if the first number is less than the second number. The <= comparison will be true if and only if the first number is less than or equal to the second number. The > comparison will be true if and only if the first number is greater than the second number. The >= comparison will be true if and only if the first number is greater than or equal to the second number.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>inf</tt></i>:</span></td>
<td>less than (1) or greater than (0)</td>
</tr>
<tr>
<td><span class="term"><i><tt>strict</tt></i>:</span></td>
<td>is the comparison strict</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if the comparison succeeded, 0 if it failed</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathConcatFunction"></a>xmlXPathConcatFunction ()</h3>
<pre class="programlisting">void xmlXPathConcatFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the concat() XPath function string concat(string, string, string*) The concat function returns the concatenation of its arguments.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathContainsFunction"></a>xmlXPathContainsFunction ()</h3>
<pre class="programlisting">void xmlXPathContainsFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the contains() XPath function boolean contains(string, string) The contains function returns true if the first argument string contains the second argument string, and otherwise returns false.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathCountFunction"></a>xmlXPathCountFunction ()</h3>
<pre class="programlisting">void xmlXPathCountFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the count() XPath function number count(node-set)</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathDebugDumpCompExpr"></a>xmlXPathDebugDumpCompExpr ()</h3>
<pre class="programlisting">void xmlXPathDebugDumpCompExpr (FILE * output, <br> <a href="libxml2-xpath.html#xmlXPathCompExprPtr">xmlXPathCompExprPtr</a> comp, <br> int depth)<br>
</pre>
<p>Dumps the tree of the compiled XPath expression.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>output</tt></i>:</span></td>
<td>the FILE * for the output</td>
</tr>
<tr>
<td><span class="term"><i><tt>comp</tt></i>:</span></td>
<td>the precompiled XPath expression</td>
</tr>
<tr>
<td><span class="term"><i><tt>depth</tt></i>:</span></td>
<td>the indentation level.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathDebugDumpObject"></a>xmlXPathDebugDumpObject ()</h3>
<pre class="programlisting">void xmlXPathDebugDumpObject (FILE * output, <br> <a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> cur, <br> int depth)<br>
</pre>
<p>Dump the content of the object for debugging purposes</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>output</tt></i>:</span></td>
<td>the FILE * to dump the output</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the object to inspect</td>
</tr>
<tr>
<td><span class="term"><i><tt>depth</tt></i>:</span></td>
<td>indentation level</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathDifference"></a>xmlXPathDifference ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> xmlXPathDifference (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes1, <br> <a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes2)<br>
</pre>
<p>Implements the EXSLT - Sets difference() function: node-set set:difference (node-set, node-set)</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>nodes1</tt></i>:</span></td>
<td>a node-set</td>
</tr>
<tr>
<td><span class="term"><i><tt>nodes2</tt></i>:</span></td>
<td>a node-set</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the difference between the two node sets, or nodes1 if nodes2 is empty</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathDistinct"></a>xmlXPathDistinct ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> xmlXPathDistinct (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes)<br>
</pre>
<p>Implements the EXSLT - Sets distinct() function: node-set set:distinct (node-set) @nodes is sorted by document order, then #exslSetsDistinctSorted is called with the sorted node-set</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>nodes</tt></i>:</span></td>
<td>a node-set</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a subset of the nodes contained in @nodes, or @nodes if it is empty</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathDistinctSorted"></a>xmlXPathDistinctSorted ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> xmlXPathDistinctSorted (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes)<br>
</pre>
<p>Implements the EXSLT - Sets distinct() function: node-set set:distinct (node-set)</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>nodes</tt></i>:</span></td>
<td>a node-set, sorted by document order</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a subset of the nodes contained in @nodes, or @nodes if it is empty</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathDivValues"></a>xmlXPathDivValues ()</h3>
<pre class="programlisting">void xmlXPathDivValues (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt)<br>
</pre>
<p>Implement the div operation on XPath objects @arg1 / @arg2: The numeric operators convert their operands to numbers as if by calling the number function.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathEqualValues"></a>xmlXPathEqualValues ()</h3>
<pre class="programlisting">int xmlXPathEqualValues (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt)<br>
</pre>
<p>Implement the equal operation on XPath objects content: @arg1 == @arg2</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 or 1 depending on the results of the test.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathErr"></a>xmlXPathErr ()</h3>
<pre class="programlisting">void xmlXPathErr (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int error)<br>
</pre>
<p>Handle an XPath error</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>a XPath parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>error</tt></i>:</span></td>
<td>the error code</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathEvalExpr"></a>xmlXPathEvalExpr ()</h3>
<pre class="programlisting">void xmlXPathEvalExpr (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt)<br>
</pre>
<p>Parse and evaluate an XPath expression in the given context, then push the result on the context stack</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathEvaluatePredicateResult"></a>xmlXPathEvaluatePredicateResult ()</h3>
<pre class="programlisting">int xmlXPathEvaluatePredicateResult (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> res)<br>
</pre>
<p>Evaluate a predicate result for the current node. A PredicateExpr is evaluated by evaluating the Expr and converting the result to a boolean. If the result is a number, the result will be converted to true if the number is equal to the position of the context node in the context node list (as returned by the position function) and will be converted to false otherwise; if the result is not a number, then the result will be converted as if by a call to the boolean function.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>res</tt></i>:</span></td>
<td>the Predicate Expression evaluation result</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if predicate is true, 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathFalseFunction"></a>xmlXPathFalseFunction ()</h3>
<pre class="programlisting">void xmlXPathFalseFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the false() XPath function boolean false()</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathFloorFunction"></a>xmlXPathFloorFunction ()</h3>
<pre class="programlisting">void xmlXPathFloorFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the floor() XPath function number floor(number) The floor function returns the largest (closest to positive infinity) number that is not greater than the argument and that is an integer.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathFreeParserContext"></a>xmlXPathFreeParserContext ()</h3>
<pre class="programlisting">void xmlXPathFreeParserContext (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt)<br>
</pre>
<p>Free up an <a href="libxml2-xpath.html#xmlXPathParserContext">xmlXPathParserContext</a></p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the context to free</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathFunctionLookup"></a>xmlXPathFunctionLookup ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlXPathFunction">xmlXPathFunction</a> xmlXPathFunctionLookup (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name)<br>
</pre>
<p>Search in the Function array of the context for the given function.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath context</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the function name</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the <a href="libxml2-xpath.html#xmlXPathFunction">xmlXPathFunction</a> or NULL if not found</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathFunctionLookupNS"></a>xmlXPathFunctionLookupNS ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlXPathFunction">xmlXPathFunction</a> xmlXPathFunctionLookupNS (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ns_uri)<br>
</pre>
<p>Search in the Function array of the context for the given function.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath context</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the function name</td>
</tr>
<tr>
<td><span class="term"><i><tt>ns_uri</tt></i>:</span></td>
<td>the function namespace URI</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the <a href="libxml2-xpath.html#xmlXPathFunction">xmlXPathFunction</a> or NULL if not found</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathHasSameNodes"></a>xmlXPathHasSameNodes ()</h3>
<pre class="programlisting">int xmlXPathHasSameNodes (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes1, <br> <a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes2)<br>
</pre>
<p>Implements the EXSLT - Sets has-same-nodes function: boolean set:has-same-node(node-set, node-set)</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>nodes1</tt></i>:</span></td>
<td>a node-set</td>
</tr>
<tr>
<td><span class="term"><i><tt>nodes2</tt></i>:</span></td>
<td>a node-set</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>true (1) if @nodes1 shares any node with @nodes2, false (0) otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathIdFunction"></a>xmlXPathIdFunction ()</h3>
<pre class="programlisting">void xmlXPathIdFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the id() XPath function node-set id(object) The id function selects elements by their unique ID (see [5.2.1 Unique IDs]). When the argument to id is of type node-set, then the result is the union of the result of applying id to the string value of each of the nodes in the argument node-set. When the argument to id is of any other type, the argument is converted to a string as if by a call to the string function; the string is split into a whitespace-separated list of tokens (whitespace is any sequence of <a href="libxml2-SAX.html#characters">characters</a> matching the production S); the result is a node-set containing the elements in the same document as the context node that have a unique ID equal to any of the tokens in the list.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathIntersection"></a>xmlXPathIntersection ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> xmlXPathIntersection (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes1, <br> <a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes2)<br>
</pre>
<p>Implements the EXSLT - Sets intersection() function: node-set set:intersection (node-set, node-set)</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>nodes1</tt></i>:</span></td>
<td>a node-set</td>
</tr>
<tr>
<td><span class="term"><i><tt>nodes2</tt></i>:</span></td>
<td>a node-set</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a node set comprising the nodes that are within both the node sets passed as arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathIsNodeType"></a>xmlXPathIsNodeType ()</h3>
<pre class="programlisting">int xmlXPathIsNodeType (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name)<br>
</pre>
<p>Is the name given a NodeType one. [38] NodeType ::= 'comment' | 'text' | 'processing-instruction' | 'node'</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>a name string</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true 0 otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathLangFunction"></a>xmlXPathLangFunction ()</h3>
<pre class="programlisting">void xmlXPathLangFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the lang() XPath function boolean lang(string) The lang function returns true or false depending on whether the language of the context node as specified by xml:lang attributes is the same as or is a sublanguage of the language specified by the argument string. The language of the context node is determined by the value of the xml:lang <a href="libxml2-SAX.html#attribute">attribute</a> on the context node, or, if the context node has no xml:lang attribute, by the value of the xml:lang <a href="libxml2-SAX.html#attribute">attribute</a> on the nearest ancestor of the context node that has an xml:lang attribute. If there is no such attribute, then lang</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathLastFunction"></a>xmlXPathLastFunction ()</h3>
<pre class="programlisting">void xmlXPathLastFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the last() XPath function number last() The last function returns the number of nodes in the context node list.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathLeading"></a>xmlXPathLeading ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> xmlXPathLeading (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes1, <br> <a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes2)<br>
</pre>
<p>Implements the EXSLT - Sets leading() function: node-set set:leading (node-set, node-set) @nodes1 and @nodes2 are sorted by document order, then #exslSetsLeadingSorted is called.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>nodes1</tt></i>:</span></td>
<td>a node-set</td>
</tr>
<tr>
<td><span class="term"><i><tt>nodes2</tt></i>:</span></td>
<td>a node-set</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the nodes in @nodes1 that precede the first node in @nodes2 in document order, @nodes1 if @nodes2 is NULL or empty or an empty node-set if @nodes1 doesn't contain @nodes2</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathLeadingSorted"></a>xmlXPathLeadingSorted ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> xmlXPathLeadingSorted (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes1, <br> <a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes2)<br>
</pre>
<p>Implements the EXSLT - Sets leading() function: node-set set:leading (node-set, node-set)</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>nodes1</tt></i>:</span></td>
<td>a node-set, sorted by document order</td>
</tr>
<tr>
<td><span class="term"><i><tt>nodes2</tt></i>:</span></td>
<td>a node-set, sorted by document order</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the nodes in @nodes1 that precede the first node in @nodes2 in document order, @nodes1 if @nodes2 is NULL or empty or an empty node-set if @nodes1 doesn't contain @nodes2</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathLocalNameFunction"></a>xmlXPathLocalNameFunction ()</h3>
<pre class="programlisting">void xmlXPathLocalNameFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the local-name() XPath function string local-name(node-set?) The local-name function returns a string containing the local part of the name of the node in the argument node-set that is first in document order. If the node-set is empty or the first node has no name, an empty string is returned. If the argument is omitted it defaults to the context node.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathModValues"></a>xmlXPathModValues ()</h3>
<pre class="programlisting">void xmlXPathModValues (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt)<br>
</pre>
<p>Implement the mod operation on XPath objects: @arg1 / @arg2 The numeric operators convert their operands to numbers as if by calling the number function.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathMultValues"></a>xmlXPathMultValues ()</h3>
<pre class="programlisting">void xmlXPathMultValues (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt)<br>
</pre>
<p>Implement the multiply operation on XPath objects: The numeric operators convert their operands to numbers as if by calling the number function.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNamespaceURIFunction"></a>xmlXPathNamespaceURIFunction ()</h3>
<pre class="programlisting">void xmlXPathNamespaceURIFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the namespace-uri() XPath function string namespace-uri(node-set?) The namespace-uri function returns a string containing the namespace URI of the expanded name of the node in the argument node-set that is first in document order. If the node-set is empty, the first node has no name, or the expanded name has no namespace URI, an empty string is returned. If the argument is omitted it defaults to the context node.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNewBoolean"></a>xmlXPathNewBoolean ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> xmlXPathNewBoolean (int val)<br>
</pre>
<p>Create a new <a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> of type boolean and of value @val</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the boolean value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the newly created object.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNewCString"></a>xmlXPathNewCString ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> xmlXPathNewCString (const char * val)<br>
</pre>
<p>Create a new <a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> of type string and of value @val</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the char * value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the newly created object.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNewFloat"></a>xmlXPathNewFloat ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> xmlXPathNewFloat (double val)<br>
</pre>
<p>Create a new <a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> of type double and of value @val</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the double value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the newly created object.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNewNodeSet"></a>xmlXPathNewNodeSet ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> xmlXPathNewNodeSet (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> val)<br>
</pre>
<p>Create a new <a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> of type NodeSet and initialize it with the single Node @val</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the NodePtr value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the newly created object.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNewNodeSetList"></a>xmlXPathNewNodeSetList ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> xmlXPathNewNodeSetList (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> val)<br>
</pre>
<p>Create a new <a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> of type NodeSet and initialize it with the Nodeset @val</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>an existing NodeSet</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the newly created object.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNewParserContext"></a>xmlXPathNewParserContext ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> xmlXPathNewParserContext (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * str, <br> <a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt)<br>
</pre>
<p>Create a new <a href="libxml2-xpath.html#xmlXPathParserContext">xmlXPathParserContext</a></p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>str</tt></i>:</span></td>
<td>the XPath expression</td>
</tr>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the <a href="libxml2-xpath.html#xmlXPathParserContext">xmlXPathParserContext</a> just allocated.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNewString"></a>xmlXPathNewString ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> xmlXPathNewString (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * val)<br>
</pre>
<p>Create a new <a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> of type string and of value @val</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the newly created object.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNewValueTree"></a>xmlXPathNewValueTree ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> xmlXPathNewValueTree (<a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> val)<br>
</pre>
<p>Create a new <a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> of type Value Tree (XSLT) and initialize it with the tree root @val</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the NodePtr value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the newly created object.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNextAncestor"></a>xmlXPathNextAncestor ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlXPathNextAncestor (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Traversal function for the "ancestor" direction the ancestor axis contains the ancestors of the context node; the ancestors of the context node consist of the parent of context node and the parent's parent and so on; the nodes are ordered in reverse document order; thus the parent is the first node on the axis, and the parent's parent is the second node on the axis</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the current node in the traversal</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the next element following that axis</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNextAncestorOrSelf"></a>xmlXPathNextAncestorOrSelf ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlXPathNextAncestorOrSelf (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Traversal function for the "ancestor-or-self" direction he ancestor-or-self axis contains the context node and ancestors of the context node in reverse document order; thus the context node is the first node on the axis, and the context node's parent the second; parent here is defined the same as with the parent axis.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the current node in the traversal</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the next element following that axis</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNextAttribute"></a>xmlXPathNextAttribute ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlXPathNextAttribute (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Traversal function for the "attribute" direction TODO: support DTD inherited default attributes</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the current <a href="libxml2-SAX.html#attribute">attribute</a> in the traversal</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the next element following that axis</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNextChild"></a>xmlXPathNextChild ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlXPathNextChild (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Traversal function for the "child" direction The child axis contains the children of the context node in document order.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the current node in the traversal</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the next element following that axis</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNextDescendant"></a>xmlXPathNextDescendant ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlXPathNextDescendant (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Traversal function for the "descendant" direction the descendant axis contains the descendants of the context node in document order; a descendant is a child or a child of a child and so on.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the current node in the traversal</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the next element following that axis</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNextDescendantOrSelf"></a>xmlXPathNextDescendantOrSelf ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlXPathNextDescendantOrSelf (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Traversal function for the "descendant-or-self" direction the descendant-or-self axis contains the context node and the descendants of the context node in document order; thus the context node is the first node on the axis, and the first child of the context node is the second node on the axis</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the current node in the traversal</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the next element following that axis</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNextFollowing"></a>xmlXPathNextFollowing ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlXPathNextFollowing (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Traversal function for the "following" direction The following axis contains all nodes in the same document as the context node that are after the context node in document order, excluding any descendants and excluding <a href="libxml2-SAX.html#attribute">attribute</a> nodes and namespace nodes; the nodes are ordered in document order</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the current node in the traversal</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the next element following that axis</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNextFollowingSibling"></a>xmlXPathNextFollowingSibling ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlXPathNextFollowingSibling (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Traversal function for the "following-sibling" direction The following-sibling axis contains the following siblings of the context node in document order.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the current node in the traversal</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the next element following that axis</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNextNamespace"></a>xmlXPathNextNamespace ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlXPathNextNamespace (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Traversal function for the "namespace" direction the namespace axis contains the namespace nodes of the context node; the order of nodes on this axis is implementation-defined; the axis will be empty unless the context node is an element We keep the XML namespace node at the end of the list.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the current <a href="libxml2-SAX.html#attribute">attribute</a> in the traversal</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the next element following that axis</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNextParent"></a>xmlXPathNextParent ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlXPathNextParent (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Traversal function for the "parent" direction The parent axis contains the parent of the context node, if there is one.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the current node in the traversal</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the next element following that axis</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNextPreceding"></a>xmlXPathNextPreceding ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlXPathNextPreceding (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Traversal function for the "preceding" direction the preceding axis contains all nodes in the same document as the context node that are before the context node in document order, excluding any ancestors and excluding <a href="libxml2-SAX.html#attribute">attribute</a> nodes and namespace nodes; the nodes are ordered in reverse document order</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the current node in the traversal</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the next element following that axis</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNextPrecedingSibling"></a>xmlXPathNextPrecedingSibling ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlXPathNextPrecedingSibling (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Traversal function for the "preceding-sibling" direction The preceding-sibling axis contains the preceding siblings of the context node in reverse document order; the first preceding sibling is first on the axis; the sibling preceding that node is the second on the axis and so on.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the current node in the traversal</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the next element following that axis</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNextSelf"></a>xmlXPathNextSelf ()</h3>
<pre class="programlisting"><a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> xmlXPathNextSelf (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> cur)<br>
</pre>
<p>Traversal function for the "self" direction The self axis contains just the context node itself</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the current node in the traversal</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the next element following that axis</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNodeLeading"></a>xmlXPathNodeLeading ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> xmlXPathNodeLeading (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node)<br>
</pre>
<p>Implements the EXSLT - Sets leading() function: node-set set:leading (node-set, node-set) @nodes is sorted by document order, then #exslSetsNodeLeadingSorted is called.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>nodes</tt></i>:</span></td>
<td>a node-set</td>
</tr>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>a node</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the nodes in @nodes that precede @node in document order, @nodes if @node is NULL or an empty node-set if @nodes doesn't contain @node</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNodeLeadingSorted"></a>xmlXPathNodeLeadingSorted ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> xmlXPathNodeLeadingSorted (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node)<br>
</pre>
<p>Implements the EXSLT - Sets leading() function: node-set set:leading (node-set, node-set)</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>nodes</tt></i>:</span></td>
<td>a node-set, sorted by document order</td>
</tr>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>a node</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the nodes in @nodes that precede @node in document order, @nodes if @node is NULL or an empty node-set if @nodes doesn't contain @node</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNodeSetAdd"></a>xmlXPathNodeSetAdd ()</h3>
<pre class="programlisting">int xmlXPathNodeSetAdd (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> cur, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> val)<br>
</pre>
<p>add a new <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> to an existing NodeSet</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the initial node set</td>
</tr>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>a new <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a>
</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 in case of success, and -1 in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNodeSetAddNs"></a>xmlXPathNodeSetAddNs ()</h3>
<pre class="programlisting">int xmlXPathNodeSetAddNs (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> cur, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node, <br> <a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns)<br>
</pre>
<p>add a new namespace node to an existing NodeSet</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the initial node set</td>
</tr>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the hosting node</td>
</tr>
<tr>
<td><span class="term"><i><tt>ns</tt></i>:</span></td>
<td>a the namespace node</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 in case of success and -1 in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNodeSetAddUnique"></a>xmlXPathNodeSetAddUnique ()</h3>
<pre class="programlisting">int xmlXPathNodeSetAddUnique (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> cur, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> val)<br>
</pre>
<p>add a new <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> to an existing NodeSet, optimized version when we are sure the node is not already in the set.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the initial node set</td>
</tr>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>a new <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a>
</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 in case of success and -1 in case of failure</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNodeSetContains"></a>xmlXPathNodeSetContains ()</h3>
<pre class="programlisting">int xmlXPathNodeSetContains (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> cur, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> val)<br>
</pre>
<p>checks whether @cur contains @val</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the node-set</td>
</tr>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the node</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>true (1) if @cur contains @val, false (0) otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNodeSetDel"></a>xmlXPathNodeSetDel ()</h3>
<pre class="programlisting">void xmlXPathNodeSetDel (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> cur, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> val)<br>
</pre>
<p>Removes an <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> from an existing NodeSet</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the initial node set</td>
</tr>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>an <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a>
</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNodeSetFreeNs"></a>xmlXPathNodeSetFreeNs ()</h3>
<pre class="programlisting">void xmlXPathNodeSetFreeNs (<a href="libxml2-tree.html#xmlNsPtr">xmlNsPtr</a> ns)<br>
</pre>
<p>Namespace nodes in libxml don't match the XPath semantic. In a node set the namespace nodes are duplicated and the next pointer is set to the parent node in the XPath semantic. Check if such a node needs to be freed</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ns</tt></i>:</span></td>
<td>the XPath namespace node found in a nodeset.</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNodeSetMerge"></a>xmlXPathNodeSetMerge ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> xmlXPathNodeSetMerge (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> val1, <br> <a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> val2)<br>
</pre>
<p>Merges two nodesets, all nodes from @val2 are added to @val1 if @val1 is NULL, a new set is created and copied from @val2</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>val1</tt></i>:</span></td>
<td>the first NodeSet or NULL</td>
</tr>
<tr>
<td><span class="term"><i><tt>val2</tt></i>:</span></td>
<td>the second NodeSet</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>@val1 once extended or NULL in case of error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNodeSetRemove"></a>xmlXPathNodeSetRemove ()</h3>
<pre class="programlisting">void xmlXPathNodeSetRemove (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> cur, <br> int val)<br>
</pre>
<p>Removes an entry from an existing NodeSet list.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the initial node set</td>
</tr>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the index to remove</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNodeSetSort"></a>xmlXPathNodeSetSort ()</h3>
<pre class="programlisting">void xmlXPathNodeSetSort (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> set)<br>
</pre>
<p>Sort the node set in document order</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>set</tt></i>:</span></td>
<td>the node set</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNodeTrailing"></a>xmlXPathNodeTrailing ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> xmlXPathNodeTrailing (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node)<br>
</pre>
<p>Implements the EXSLT - Sets trailing() function: node-set set:trailing (node-set, node-set) @nodes is sorted by document order, then #xmlXPathNodeTrailingSorted is called.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>nodes</tt></i>:</span></td>
<td>a node-set</td>
</tr>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>a node</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the nodes in @nodes that follow @node in document order, @nodes if @node is NULL or an empty node-set if @nodes doesn't contain @node</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNodeTrailingSorted"></a>xmlXPathNodeTrailingSorted ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> xmlXPathNodeTrailingSorted (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node)<br>
</pre>
<p>Implements the EXSLT - Sets trailing() function: node-set set:trailing (node-set, node-set)</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>nodes</tt></i>:</span></td>
<td>a node-set, sorted by document order</td>
</tr>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>a node</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the nodes in @nodes that follow @node in document order, @nodes if @node is NULL or an empty node-set if @nodes doesn't contain @node</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNormalizeFunction"></a>xmlXPathNormalizeFunction ()</h3>
<pre class="programlisting">void xmlXPathNormalizeFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the normalize-space() XPath function string normalize-space(string?) The normalize-space function returns the argument string with white space normalized by stripping leading and trailing whitespace and replacing sequences of whitespace <a href="libxml2-SAX.html#characters">characters</a> by a single space. Whitespace <a href="libxml2-SAX.html#characters">characters</a> are the same allowed by the S production in XML. If the argument is omitted, it defaults to the context node converted to a string, in other words the value of the context node.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNotEqualValues"></a>xmlXPathNotEqualValues ()</h3>
<pre class="programlisting">int xmlXPathNotEqualValues (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt)<br>
</pre>
<p>Implement the equal operation on XPath objects content: @arg1 == @arg2</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 or 1 depending on the results of the test.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNotFunction"></a>xmlXPathNotFunction ()</h3>
<pre class="programlisting">void xmlXPathNotFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the not() XPath function boolean not(boolean) The not function returns true if its argument is false, and false otherwise.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNsLookup"></a>xmlXPathNsLookup ()</h3>
<pre class="programlisting">const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlXPathNsLookup (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * prefix)<br>
</pre>
<p>Search in the namespace declaration array of the context for the given namespace name associated to the given prefix</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath context</td>
</tr>
<tr>
<td><span class="term"><i><tt>prefix</tt></i>:</span></td>
<td>the namespace prefix value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the value or NULL if not found</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathNumberFunction"></a>xmlXPathNumberFunction ()</h3>
<pre class="programlisting">void xmlXPathNumberFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the number() XPath function number number(object?)</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathParseNCName"></a>xmlXPathParseNCName ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlXPathParseNCName (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt)<br>
</pre>
<p>parse an XML namespace non qualified name. [NS 3] NCName ::= (Letter | '_') (NCNameChar)* [NS 4] NCNameChar ::= Letter | Digit | '.' | '-' | '_' | CombiningChar | Extender</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the namespace name or NULL</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathParseName"></a>xmlXPathParseName ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlXPathParseName (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt)<br>
</pre>
<p>parse an XML name [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' | CombiningChar | Extender [5] Name ::= (Letter | '_' | ':') (NameChar)*</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the namespace name or NULL</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathPopBoolean"></a>xmlXPathPopBoolean ()</h3>
<pre class="programlisting">int xmlXPathPopBoolean (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt)<br>
</pre>
<p>Pops a boolean from the stack, handling conversion if needed. Check error with #xmlXPathCheckError.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the boolean</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathPopExternal"></a>xmlXPathPopExternal ()</h3>
<pre class="programlisting">void * xmlXPathPopExternal (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt)<br>
</pre>
<p>Pops an external object from the stack, handling conversion if needed. Check error with #xmlXPathCheckError.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the object</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathPopNodeSet"></a>xmlXPathPopNodeSet ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> xmlXPathPopNodeSet (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt)<br>
</pre>
<p>Pops a node-set from the stack, handling conversion if needed. Check error with #xmlXPathCheckError.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the node-set</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathPopNumber"></a>xmlXPathPopNumber ()</h3>
<pre class="programlisting">double xmlXPathPopNumber (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt)<br>
</pre>
<p>Pops a number from the stack, handling conversion if needed. Check error with #xmlXPathCheckError.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the number</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathPopString"></a>xmlXPathPopString ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlXPathPopString (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt)<br>
</pre>
<p>Pops a string from the stack, handling conversion if needed. Check error with #xmlXPathCheckError.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>an XPath parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the string</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathPositionFunction"></a>xmlXPathPositionFunction ()</h3>
<pre class="programlisting">void xmlXPathPositionFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the position() XPath function number position() The position function returns the position of the context node in the context node list. The first position is 1, and so the last position will be equal to last().</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathRegisterAllFunctions"></a>xmlXPathRegisterAllFunctions ()</h3>
<pre class="programlisting">void xmlXPathRegisterAllFunctions (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt)<br>
</pre>
<p>Registers all default XPath functions in this context</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathRegisterFunc"></a>xmlXPathRegisterFunc ()</h3>
<pre class="programlisting">int xmlXPathRegisterFunc (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> <a href="libxml2-xpath.html#xmlXPathFunction">xmlXPathFunction</a> f)<br>
</pre>
<p>Register a new function. If @f is NULL it unregisters the function</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath context</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the function name</td>
</tr>
<tr>
<td><span class="term"><i><tt>f</tt></i>:</span></td>
<td>the function implementation or NULL</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 in case of success, -1 in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathRegisterFuncLookup"></a>xmlXPathRegisterFuncLookup ()</h3>
<pre class="programlisting">void xmlXPathRegisterFuncLookup (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> <a href="libxml2-xpath.html#xmlXPathFuncLookupFunc">xmlXPathFuncLookupFunc</a> f, <br> void * funcCtxt)<br>
</pre>
<p>Registers an external mechanism to do function lookup.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath context</td>
</tr>
<tr>
<td><span class="term"><i><tt>f</tt></i>:</span></td>
<td>the lookup function</td>
</tr>
<tr>
<td><span class="term"><i><tt>funcCtxt</tt></i>:</span></td>
<td>the lookup data</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathRegisterFuncNS"></a>xmlXPathRegisterFuncNS ()</h3>
<pre class="programlisting">int xmlXPathRegisterFuncNS (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ns_uri, <br> <a href="libxml2-xpath.html#xmlXPathFunction">xmlXPathFunction</a> f)<br>
</pre>
<p>Register a new function. If @f is NULL it unregisters the function</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath context</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the function name</td>
</tr>
<tr>
<td><span class="term"><i><tt>ns_uri</tt></i>:</span></td>
<td>the function namespace URI</td>
</tr>
<tr>
<td><span class="term"><i><tt>f</tt></i>:</span></td>
<td>the function implementation or NULL</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 in case of success, -1 in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathRegisterNs"></a>xmlXPathRegisterNs ()</h3>
<pre class="programlisting">int xmlXPathRegisterNs (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * prefix, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ns_uri)<br>
</pre>
<p>Register a new namespace. If @ns_uri is NULL it unregisters the namespace</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath context</td>
</tr>
<tr>
<td><span class="term"><i><tt>prefix</tt></i>:</span></td>
<td>the namespace prefix cannot be NULL or empty string</td>
</tr>
<tr>
<td><span class="term"><i><tt>ns_uri</tt></i>:</span></td>
<td>the namespace name</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 in case of success, -1 in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathRegisterVariable"></a>xmlXPathRegisterVariable ()</h3>
<pre class="programlisting">int xmlXPathRegisterVariable (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> <a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> value)<br>
</pre>
<p>Register a new variable value. If @value is NULL it unregisters the variable</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath context</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the variable name</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the variable value or NULL</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 in case of success, -1 in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathRegisterVariableLookup"></a>xmlXPathRegisterVariableLookup ()</h3>
<pre class="programlisting">void xmlXPathRegisterVariableLookup (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> <a href="libxml2-xpath.html#xmlXPathVariableLookupFunc">xmlXPathVariableLookupFunc</a> f, <br> void * data)<br>
</pre>
<p>register an external mechanism to do variable lookup</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath context</td>
</tr>
<tr>
<td><span class="term"><i><tt>f</tt></i>:</span></td>
<td>the lookup function</td>
</tr>
<tr>
<td><span class="term"><i><tt>data</tt></i>:</span></td>
<td>the lookup data</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathRegisterVariableNS"></a>xmlXPathRegisterVariableNS ()</h3>
<pre class="programlisting">int xmlXPathRegisterVariableNS (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ns_uri, <br> <a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> value)<br>
</pre>
<p>Register a new variable value. If @value is NULL it unregisters the variable</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath context</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the variable name</td>
</tr>
<tr>
<td><span class="term"><i><tt>ns_uri</tt></i>:</span></td>
<td>the variable namespace URI</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the variable value or NULL</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 in case of success, -1 in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathRegisteredFuncsCleanup"></a>xmlXPathRegisteredFuncsCleanup ()</h3>
<pre class="programlisting">void xmlXPathRegisteredFuncsCleanup (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt)<br>
</pre>
<p>Cleanup the XPath context data associated to registered functions</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathRegisteredNsCleanup"></a>xmlXPathRegisteredNsCleanup ()</h3>
<pre class="programlisting">void xmlXPathRegisteredNsCleanup (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt)<br>
</pre>
<p>Cleanup the XPath context data associated to registered variables</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathRegisteredVariablesCleanup"></a>xmlXPathRegisteredVariablesCleanup ()</h3>
<pre class="programlisting">void xmlXPathRegisteredVariablesCleanup (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt)<br>
</pre>
<p>Cleanup the XPath context data associated to registered variables</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathRoot"></a>xmlXPathRoot ()</h3>
<pre class="programlisting">void xmlXPathRoot (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt)<br>
</pre>
<p>Initialize the context to the root of the document</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathRoundFunction"></a>xmlXPathRoundFunction ()</h3>
<pre class="programlisting">void xmlXPathRoundFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the round() XPath function number round(number) The round function returns the number that is closest to the argument and that is an integer. If there are two such numbers, then the one that is closest to positive infinity is returned.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathStartsWithFunction"></a>xmlXPathStartsWithFunction ()</h3>
<pre class="programlisting">void xmlXPathStartsWithFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the starts-with() XPath function boolean starts-with(string, string) The starts-with function returns true if the first argument string starts with the second argument string, and otherwise returns false.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathStringEvalNumber"></a>xmlXPathStringEvalNumber ()</h3>
<pre class="programlisting">double xmlXPathStringEvalNumber (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * str)<br>
</pre>
<p>[30a] Float ::= Number ('e' Digits?)? [30] Number ::= Digits ('.' Digits?)? | '.' Digits [31] Digits ::= [0-9]+ Compile a Number in the string In complement of the Number expression, this function also handles negative values : '-' Number.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>str</tt></i>:</span></td>
<td>A string to scan</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the double value.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathStringFunction"></a>xmlXPathStringFunction ()</h3>
<pre class="programlisting">void xmlXPathStringFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the string() XPath function string string(object?) The string function converts an object to a string as follows: - A node-set is converted to a string by returning the value of the node in the node-set that is first in document order. If the node-set is empty, an empty string is returned. - A number is converted to a string as follows + NaN is converted to the string NaN + positive zero is converted to the string 0 + negative zero is converted to the string 0 + positive infinity is converted to the string Infinity + negative infinity is converted to the string -Infinity + if the number is an integer, the number is represented in decimal form as a Number with no decimal point and no leading zeros, preceded by a minus sign (-) if the number is negative + otherwise, the number is represented in decimal form as a Number including a decimal point with at least one digit before the decimal point and at least one digit after the decimal point, preceded by a minus sign (-) if the number is negative; there must be no leading zeros before the decimal point apart possibly from the one required digit immediately before the decimal point; beyond the one required digit after the decimal point there must be as many, but only as many, more digits as are needed to uniquely distinguish the number from all other IEEE 754 numeric values. - The boolean false value is converted to the string false. The boolean true value is converted to the string true. If the argument is omitted, it defaults to a node-set with the context node as its only member.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathStringLengthFunction"></a>xmlXPathStringLengthFunction ()</h3>
<pre class="programlisting">void xmlXPathStringLengthFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the string-length() XPath function number string-length(string?) The string-length returns the number of <a href="libxml2-SAX.html#characters">characters</a> in the string (see [3.6 Strings]). If the argument is omitted, it defaults to the context node converted to a string, in other words the value of the context node.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathSubValues"></a>xmlXPathSubValues ()</h3>
<pre class="programlisting">void xmlXPathSubValues (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt)<br>
</pre>
<p>Implement the subtraction operation on XPath objects: The numeric operators convert their operands to numbers as if by calling the number function.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathSubstringAfterFunction"></a>xmlXPathSubstringAfterFunction ()</h3>
<pre class="programlisting">void xmlXPathSubstringAfterFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the substring-after() XPath function string substring-after(string, string) The substring-after function returns the substring of the first argument string that follows the first occurrence of the second argument string in the first argument string, or the empty stringi if the first argument string does not contain the second argument string. For example, substring-after("1999/04/01","/") returns 04/01, and substring-after("1999/04/01","19") returns 99/04/01.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathSubstringBeforeFunction"></a>xmlXPathSubstringBeforeFunction ()</h3>
<pre class="programlisting">void xmlXPathSubstringBeforeFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the substring-before() XPath function string substring-before(string, string) The substring-before function returns the substring of the first argument string that precedes the first occurrence of the second argument string in the first argument string, or the empty string if the first argument string does not contain the second argument string. For example, substring-before("1999/04/01","/") returns 1999.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathSubstringFunction"></a>xmlXPathSubstringFunction ()</h3>
<pre class="programlisting">void xmlXPathSubstringFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the substring() XPath function string substring(string, number, number?) The substring function returns the substring of the first argument starting at the position specified in the second argument with length specified in the third argument. For example, substring("12345",2,3) returns "234". If the third argument is not specified, it returns the substring starting at the position specified in the second argument and continuing to the end of the string. For example, substring("12345",2) returns "2345". More precisely, each character in the string (see [3.6 Strings]) is considered to have a numeric position: the position of the first character is 1, the position of the second character is 2 and so on. The returned substring contains those <a href="libxml2-SAX.html#characters">characters</a> for which the position of the character is greater than or equal to the second argument and, if the third argument is specified, less than the sum of the second and third arguments; the comparisons and addition used for the above follow the standard IEEE 754 rules. Thus: - substring("12345", 1.5, 2.6) returns "234" - substring("12345", 0, 3) returns "12" - substring("12345", 0 div 0, 3) returns "" - substring("12345", 1, 0 div 0) returns "" - substring("12345", -42, 1 div 0) returns "12345" - substring("12345", -1 div 0, 1 div 0) returns ""</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathSumFunction"></a>xmlXPathSumFunction ()</h3>
<pre class="programlisting">void xmlXPathSumFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the sum() XPath function number sum(node-set) The sum function returns the sum of the values of the nodes in the argument node-set.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathTrailing"></a>xmlXPathTrailing ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> xmlXPathTrailing (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes1, <br> <a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes2)<br>
</pre>
<p>Implements the EXSLT - Sets trailing() function: node-set set:trailing (node-set, node-set) @nodes1 and @nodes2 are sorted by document order, then #xmlXPathTrailingSorted is called.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>nodes1</tt></i>:</span></td>
<td>a node-set</td>
</tr>
<tr>
<td><span class="term"><i><tt>nodes2</tt></i>:</span></td>
<td>a node-set</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the nodes in @nodes1 that follow the first node in @nodes2 in document order, @nodes1 if @nodes2 is NULL or empty or an empty node-set if @nodes1 doesn't contain @nodes2</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathTrailingSorted"></a>xmlXPathTrailingSorted ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> xmlXPathTrailingSorted (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes1, <br> <a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> nodes2)<br>
</pre>
<p>Implements the EXSLT - Sets trailing() function: node-set set:trailing (node-set, node-set)</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>nodes1</tt></i>:</span></td>
<td>a node-set, sorted by document order</td>
</tr>
<tr>
<td><span class="term"><i><tt>nodes2</tt></i>:</span></td>
<td>a node-set, sorted by document order</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the nodes in @nodes1 that follow the first node in @nodes2 in document order, @nodes1 if @nodes2 is NULL or empty or an empty node-set if @nodes1 doesn't contain @nodes2</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathTranslateFunction"></a>xmlXPathTranslateFunction ()</h3>
<pre class="programlisting">void xmlXPathTranslateFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the translate() XPath function string translate(string, string, string) The translate function returns the first argument string with occurrences of <a href="libxml2-SAX.html#characters">characters</a> in the second argument string replaced by the character at the corresponding position in the third argument string. For example, translate("bar","abc","ABC") returns the string BAr. If there is a character in the second argument string with no character at a corresponding position in the third argument string (because the second argument string is longer than the third argument string), then occurrences of that character in the first argument string are removed. For example, translate("--aaa--","abc-","ABC")</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathTrueFunction"></a>xmlXPathTrueFunction ()</h3>
<pre class="programlisting">void xmlXPathTrueFunction (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> int nargs)<br>
</pre>
<p>Implement the true() XPath function boolean true()</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>nargs</tt></i>:</span></td>
<td>the number of arguments</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathValueFlipSign"></a>xmlXPathValueFlipSign ()</h3>
<pre class="programlisting">void xmlXPathValueFlipSign (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt)<br>
</pre>
<p>Implement the unary - operation on an XPath object The numeric operators convert their operands to numbers as if by calling the number function.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathVariableLookup"></a>xmlXPathVariableLookup ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> xmlXPathVariableLookup (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name)<br>
</pre>
<p>Search in the Variable array of the context for the given variable value.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath context</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the variable name</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a copy of the value or NULL if not found</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathVariableLookupNS"></a>xmlXPathVariableLookupNS ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> xmlXPathVariableLookupNS (<a href="libxml2-xpath.html#xmlXPathContextPtr">xmlXPathContextPtr</a> ctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ns_uri)<br>
</pre>
<p>Search in the Variable array of the context for the given variable value.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath context</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the variable name</td>
</tr>
<tr>
<td><span class="term"><i><tt>ns_uri</tt></i>:</span></td>
<td>the variable namespace URI</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the a copy of the value or NULL if not found</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathWrapCString"></a>xmlXPathWrapCString ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> xmlXPathWrapCString (char * val)<br>
</pre>
<p>Wraps a string into an XPath object.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the char * value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the newly created object.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathWrapExternal"></a>xmlXPathWrapExternal ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> xmlXPathWrapExternal (void * val)<br>
</pre>
<p>Wraps the @val data into an XPath object.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the user data</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the newly created object.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathWrapNodeSet"></a>xmlXPathWrapNodeSet ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> xmlXPathWrapNodeSet (<a href="libxml2-xpath.html#xmlNodeSetPtr">xmlNodeSetPtr</a> val)<br>
</pre>
<p>Wrap the Nodeset @val in a new <a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a></p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the NodePtr value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the newly created object.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPathWrapString"></a>xmlXPathWrapString ()</h3>
<pre class="programlisting"><a href="libxml2-xpath.html#xmlXPathObjectPtr">xmlXPathObjectPtr</a> xmlXPathWrapString (<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * val)<br>
</pre>
<p>Wraps the @val string into an XPath object.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the newly created object.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlXPatherror"></a>xmlXPatherror ()</h3>
<pre class="programlisting">void xmlXPatherror (<a href="libxml2-xpath.html#xmlXPathParserContextPtr">xmlXPathParserContextPtr</a> ctxt, <br> const char * file, <br> int line, <br> int no)<br>
</pre>
<p>Formats an error message.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>ctxt</tt></i>:</span></td>
<td>the XPath Parser context</td>
</tr>
<tr>
<td><span class="term"><i><tt>file</tt></i>:</span></td>
<td>the file name</td>
</tr>
<tr>
<td><span class="term"><i><tt>line</tt></i>:</span></td>
<td>the line number</td>
</tr>
<tr>
<td><span class="term"><i><tt>no</tt></i>:</span></td>
<td>the error number</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
</div>
</div>
</body>
</html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>libxml2: </title>
<meta name="generator" content="Libxml2 devhelp stylesheet">
<link rel="start" href="index.html" title="libxml2 Reference Manual">
<link rel="up" href="index.html" title="libxml2 Reference Manual">
<link rel="stylesheet" href="style.css" type="text/css">
<link rel="chapter" href="index.html" title="libxml2 Reference Manual">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table class="navigation" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"><tr valign="middle">
<td><a accesskey="u" href="index.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
<td><a accesskey="n" href="libxml2-HTMLparser.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
<th width="100%" align="center">libxml2 Reference Manual</th>
</tr></table>
<h2><span class="refentrytitle">libxml2 API Modules</span></h2>
<p><a href="libxml2-HTMLparser.html">HTMLparser</a> - interface for an HTML 4.0 non-verifying parser<br><a href="libxml2-HTMLtree.html">HTMLtree</a> - specific APIs to process HTML tree, especially serialization<br><a href="libxml2-SAX.html">SAX</a> - Old SAX version 1 handler, deprecated<br><a href="libxml2-SAX2.html">SAX2</a> - SAX2 parser interface used to build the DOM tree<br><a href="libxml2-c14n.html">c14n</a> - Provide Canonical XML and Exclusive XML Canonicalization<br><a href="libxml2-catalog.html">catalog</a> - interfaces to the Catalog handling system<br><a href="libxml2-chvalid.html">chvalid</a> - Unicode character range checking<br><a href="libxml2-debugXML.html">debugXML</a> - Tree debugging APIs<br><a href="libxml2-dict.html">dict</a> - string dictionary<br><a href="libxml2-encoding.html">encoding</a> - interface for the encoding conversion functions<br><a href="libxml2-entities.html">entities</a> - interface for the XML entities handling<br><a href="libxml2-globals.html">globals</a> - interface for all global variables of the library<br><a href="libxml2-hash.html">hash</a> - Chained hash tables<br><a href="libxml2-list.html">list</a> - lists interfaces<br><a href="libxml2-nanoftp.html">nanoftp</a> - minimal FTP implementation<br><a href="libxml2-nanohttp.html">nanohttp</a> - minimal HTTP implementation<br><a href="libxml2-parser.html">parser</a> - the core parser module<br><a href="libxml2-parserInternals.html">parserInternals</a> - internals routines and limits exported by the parser.<br><a href="libxml2-pattern.html">pattern</a> - pattern expression handling<br><a href="libxml2-relaxng.html">relaxng</a> - implementation of the Relax-NG validation<br><a href="libxml2-schemasInternals.html">schemasInternals</a> - internal interfaces for XML Schemas<br><a href="libxml2-schematron.html">schematron</a> - XML Schematron implementation<br><a href="libxml2-threads.html">threads</a> - interfaces for thread handling<br><a href="libxml2-tree.html">tree</a> - interfaces for tree manipulation<br><a href="libxml2-uri.html">uri</a> - library of generic URI related routines<br><a href="libxml2-valid.html">valid</a> - The DTD validation<br><a href="libxml2-xinclude.html">xinclude</a> - implementation of XInclude<br><a href="libxml2-xlink.html">xlink</a> - unfinished XLink detection module<br><a href="libxml2-xmlIO.html">xmlIO</a> - interface for the I/O interfaces used by the parser<br><a href="libxml2-xmlautomata.html">xmlautomata</a> - API to build regexp automata<br><a href="libxml2-xmlerror.html">xmlerror</a> - error handling<br><a href="libxml2-xmlexports.html">xmlexports</a> - macros for marking symbols as exportable/importable.<br><a href="libxml2-xmlmemory.html">xmlmemory</a> - interface for the memory allocator<br><a href="libxml2-xmlmodule.html">xmlmodule</a> - dynamic module loading<br><a href="libxml2-xmlreader.html">xmlreader</a> - the XMLReader implementation<br><a href="libxml2-xmlregexp.html">xmlregexp</a> - regular expressions handling<br><a href="libxml2-xmlsave.html">xmlsave</a> - the XML document serializer<br><a href="libxml2-xmlschemas.html">xmlschemas</a> - incomplete XML Schemas structure implementation<br><a href="libxml2-xmlschemastypes.html">xmlschemastypes</a> - implementation of XML Schema Datatypes<br><a href="libxml2-xmlstring.html">xmlstring</a> - set of routines to process strings<br><a href="libxml2-xmlunicode.html">xmlunicode</a> - Unicode character APIs<br><a href="libxml2-xmlversion.html">xmlversion</a> - compile-time version information<br><a href="libxml2-xmlwriter.html">xmlwriter</a> - text writing API for XML<br><a href="libxml2-xpath.html">xpath</a> - XML Path Language implementation<br><a href="libxml2-xpathInternals.html">xpathInternals</a> - internal interfaces for XML Path Language implementation<br><a href="libxml2-xpointer.html">xpointer</a> - API to handle XML Pointers<br></p>
</body>
</html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>xmlschemastypes: implementation of XML Schema Datatypes</title>
<meta name="generator" content="Libxml2 devhelp stylesheet">
<link rel="start" href="index.html" title="libxml2 Reference Manual">
<link rel="up" href="general.html" title="API">
<link rel="stylesheet" href="style.css" type="text/css">
<link rel="chapter" href="general.html" title="API">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table class="navigation" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"><tr valign="middle">
<td><a accesskey="p" href="libxml2-xmlschemas.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
<td><a accesskey="u" href="general.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
<td><a accesskey="n" href="libxml2-xmlstring.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
<th width="100%" align="center">libxml2 Reference Manual</th>
</tr></table>
<h2><span class="refentrytitle">xmlschemastypes</span></h2>
<p>xmlschemastypes - implementation of XML Schema Datatypes</p>
<p>module providing the XML Schema Datatypes implementation both definition and validity checking </p>
<p>Author(s): Daniel Veillard </p>
<div class="refsynopsisdiv">
<h2>Synopsis</h2>
<pre class="synopsis">typedef enum <a href="#xmlSchemaWhitespaceValueType">xmlSchemaWhitespaceValueType</a>;
int <a href="#xmlSchemaCheckFacet">xmlSchemaCheckFacet</a> (<a href="libxml2-schemasInternals.html#xmlSchemaFacetPtr">xmlSchemaFacetPtr</a> facet, <br> <a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> typeDecl, <br> <a href="libxml2-xmlschemas.html#xmlSchemaParserCtxtPtr">xmlSchemaParserCtxtPtr</a> pctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name);
void <a href="#xmlSchemaCleanupTypes">xmlSchemaCleanupTypes</a> (void);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlSchemaCollapseString">xmlSchemaCollapseString</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value);
int <a href="#xmlSchemaCompareValues">xmlSchemaCompareValues</a> (<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> x, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> y);
int <a href="#xmlSchemaCompareValuesWhtsp">xmlSchemaCompareValuesWhtsp</a> (<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> x, <br> <a href="libxml2-xmlschemastypes.html#xmlSchemaWhitespaceValueType">xmlSchemaWhitespaceValueType</a> xws, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> y, <br> <a href="libxml2-xmlschemastypes.html#xmlSchemaWhitespaceValueType">xmlSchemaWhitespaceValueType</a> yws);
<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> <a href="#xmlSchemaCopyValue">xmlSchemaCopyValue</a> (<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> val);
void <a href="#xmlSchemaFreeFacet">xmlSchemaFreeFacet</a> (<a href="libxml2-schemasInternals.html#xmlSchemaFacetPtr">xmlSchemaFacetPtr</a> facet);
void <a href="#xmlSchemaFreeValue">xmlSchemaFreeValue</a> (<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> value);
<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> <a href="#xmlSchemaGetBuiltInListSimpleTypeItemType">xmlSchemaGetBuiltInListSimpleTypeItemType</a> (<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> type);
<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> <a href="#xmlSchemaGetBuiltInType">xmlSchemaGetBuiltInType</a> (<a href="libxml2-schemasInternals.html#xmlSchemaValType">xmlSchemaValType</a> type);
int <a href="#xmlSchemaGetCanonValue">xmlSchemaGetCanonValue</a> (<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> val, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** retValue);
int <a href="#xmlSchemaGetCanonValueWhtsp">xmlSchemaGetCanonValueWhtsp</a> (<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> val, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** retValue, <br> <a href="libxml2-xmlschemastypes.html#xmlSchemaWhitespaceValueType">xmlSchemaWhitespaceValueType</a> ws);
unsigned long <a href="#xmlSchemaGetFacetValueAsULong">xmlSchemaGetFacetValueAsULong</a> (<a href="libxml2-schemasInternals.html#xmlSchemaFacetPtr">xmlSchemaFacetPtr</a> facet);
<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> <a href="#xmlSchemaGetPredefinedType">xmlSchemaGetPredefinedType</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ns);
<a href="libxml2-schemasInternals.html#xmlSchemaValType">xmlSchemaValType</a> <a href="#xmlSchemaGetValType">xmlSchemaGetValType</a> (<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> val);
void <a href="#xmlSchemaInitTypes">xmlSchemaInitTypes</a> (void);
int <a href="#xmlSchemaIsBuiltInTypeFacet">xmlSchemaIsBuiltInTypeFacet</a> (<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> type, <br> int facetType);
<a href="libxml2-schemasInternals.html#xmlSchemaFacetPtr">xmlSchemaFacetPtr</a> <a href="#xmlSchemaNewFacet">xmlSchemaNewFacet</a> (void);
<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> <a href="#xmlSchemaNewNOTATIONValue">xmlSchemaNewNOTATIONValue</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ns);
<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> <a href="#xmlSchemaNewQNameValue">xmlSchemaNewQNameValue</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * namespaceName, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * localName);
<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> <a href="#xmlSchemaNewStringValue">xmlSchemaNewStringValue</a> (<a href="libxml2-schemasInternals.html#xmlSchemaValType">xmlSchemaValType</a> type, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value);
int <a href="#xmlSchemaValPredefTypeNode">xmlSchemaValPredefTypeNode</a> (<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> type, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> * val, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node);
int <a href="#xmlSchemaValPredefTypeNodeNoNorm">xmlSchemaValPredefTypeNodeNoNorm</a> (<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> type, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> * val, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node);
int <a href="#xmlSchemaValidateFacet">xmlSchemaValidateFacet</a> (<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> base, <br> <a href="libxml2-schemasInternals.html#xmlSchemaFacetPtr">xmlSchemaFacetPtr</a> facet, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> val);
int <a href="#xmlSchemaValidateFacetWhtsp">xmlSchemaValidateFacetWhtsp</a> (<a href="libxml2-schemasInternals.html#xmlSchemaFacetPtr">xmlSchemaFacetPtr</a> facet, <br> <a href="libxml2-xmlschemastypes.html#xmlSchemaWhitespaceValueType">xmlSchemaWhitespaceValueType</a> fws, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValType">xmlSchemaValType</a> valType, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> val, <br> <a href="libxml2-xmlschemastypes.html#xmlSchemaWhitespaceValueType">xmlSchemaWhitespaceValueType</a> ws);
int <a href="#xmlSchemaValidateLengthFacet">xmlSchemaValidateLengthFacet</a> (<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> type, <br> <a href="libxml2-schemasInternals.html#xmlSchemaFacetPtr">xmlSchemaFacetPtr</a> facet, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> val, <br> unsigned long * length);
int <a href="#xmlSchemaValidateLengthFacetWhtsp">xmlSchemaValidateLengthFacetWhtsp</a> (<a href="libxml2-schemasInternals.html#xmlSchemaFacetPtr">xmlSchemaFacetPtr</a> facet, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValType">xmlSchemaValType</a> valType, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> val, <br> unsigned long * length, <br> <a href="libxml2-xmlschemastypes.html#xmlSchemaWhitespaceValueType">xmlSchemaWhitespaceValueType</a> ws);
int <a href="#xmlSchemaValidateListSimpleTypeFacet">xmlSchemaValidateListSimpleTypeFacet</a> (<a href="libxml2-schemasInternals.html#xmlSchemaFacetPtr">xmlSchemaFacetPtr</a> facet, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> unsigned long actualLen, <br> unsigned long * expectedLen);
int <a href="#xmlSchemaValidatePredefinedType">xmlSchemaValidatePredefinedType</a> (<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> type, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> * val);
int <a href="#xmlSchemaValueAppend">xmlSchemaValueAppend</a> (<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> prev, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> cur);
int <a href="#xmlSchemaValueGetAsBoolean">xmlSchemaValueGetAsBoolean</a> (<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> val);
const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlSchemaValueGetAsString">xmlSchemaValueGetAsString</a> (<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> val);
<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> <a href="#xmlSchemaValueGetNext">xmlSchemaValueGetNext</a> (<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> cur);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlSchemaWhiteSpaceReplace">xmlSchemaWhiteSpaceReplace</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value);
</pre>
</div>
<div class="refsect1" lang="en"><h2>Description</h2></div>
<div class="refsect1" lang="en">
<h2>Details</h2>
<div class="refsect2" lang="en">
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaWhitespaceValueType">Enum </a>xmlSchemaWhitespaceValueType</h3>
<pre class="programlisting">enum <a href="#xmlSchemaWhitespaceValueType">xmlSchemaWhitespaceValueType</a> {
<a name="XML_SCHEMA_WHITESPACE_UNKNOWN">XML_SCHEMA_WHITESPACE_UNKNOWN</a> = 0
<a name="XML_SCHEMA_WHITESPACE_PRESERVE">XML_SCHEMA_WHITESPACE_PRESERVE</a> = 1
<a name="XML_SCHEMA_WHITESPACE_REPLACE">XML_SCHEMA_WHITESPACE_REPLACE</a> = 2
<a name="XML_SCHEMA_WHITESPACE_COLLAPSE">XML_SCHEMA_WHITESPACE_COLLAPSE</a> = 3
};
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaCheckFacet"></a>xmlSchemaCheckFacet ()</h3>
<pre class="programlisting">int xmlSchemaCheckFacet (<a href="libxml2-schemasInternals.html#xmlSchemaFacetPtr">xmlSchemaFacetPtr</a> facet, <br> <a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> typeDecl, <br> <a href="libxml2-xmlschemas.html#xmlSchemaParserCtxtPtr">xmlSchemaParserCtxtPtr</a> pctxt, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name)<br>
</pre>
<p>Checks and computes the values of facets.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>facet</tt></i>:</span></td>
<td>the facet</td>
</tr>
<tr>
<td><span class="term"><i><tt>typeDecl</tt></i>:</span></td>
<td>the schema type definition</td>
</tr>
<tr>
<td><span class="term"><i><tt>pctxt</tt></i>:</span></td>
<td>the schema parser context or NULL</td>
</tr>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the optional name of the type</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if valid, a positive error code if not valid and -1 in case of an internal or API error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaCleanupTypes"></a>xmlSchemaCleanupTypes ()</h3>
<pre class="programlisting">void xmlSchemaCleanupTypes (void)<br>
</pre>
<p>DEPRECATED: This function will be made private. Call <a href="libxml2-parser.html#xmlCleanupParser">xmlCleanupParser</a> to free global state but see the warnings there. <a href="libxml2-parser.html#xmlCleanupParser">xmlCleanupParser</a> should be only called once at program exit. In most cases, you don't have call cleanup functions at all. Cleanup the default XML Schemas type library</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaCollapseString"></a>xmlSchemaCollapseString ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlSchemaCollapseString (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value)<br>
</pre>
<p>Removes and normalize white spaces in the string</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>a value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the new string or NULL if no change was required.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaCompareValues"></a>xmlSchemaCompareValues ()</h3>
<pre class="programlisting">int xmlSchemaCompareValues (<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> x, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> y)<br>
</pre>
<p>Compare 2 values</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>x</tt></i>:</span></td>
<td>a first value</td>
</tr>
<tr>
<td><span class="term"><i><tt>y</tt></i>:</span></td>
<td>a second value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>-1 if x < y, 0 if x == y, 1 if x > y, 2 if x <> y, and -2 in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaCompareValuesWhtsp"></a>xmlSchemaCompareValuesWhtsp ()</h3>
<pre class="programlisting">int xmlSchemaCompareValuesWhtsp (<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> x, <br> <a href="libxml2-xmlschemastypes.html#xmlSchemaWhitespaceValueType">xmlSchemaWhitespaceValueType</a> xws, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> y, <br> <a href="libxml2-xmlschemastypes.html#xmlSchemaWhitespaceValueType">xmlSchemaWhitespaceValueType</a> yws)<br>
</pre>
<p>Compare 2 values</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>x</tt></i>:</span></td>
<td>a first value</td>
</tr>
<tr>
<td><span class="term"><i><tt>xws</tt></i>:</span></td>
<td>the whitespace value of x</td>
</tr>
<tr>
<td><span class="term"><i><tt>y</tt></i>:</span></td>
<td>a second value</td>
</tr>
<tr>
<td><span class="term"><i><tt>yws</tt></i>:</span></td>
<td>the whitespace value of y</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>-1 if x < y, 0 if x == y, 1 if x > y, 2 if x <> y, and -2 in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaCopyValue"></a>xmlSchemaCopyValue ()</h3>
<pre class="programlisting"><a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> xmlSchemaCopyValue (<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> val)<br>
</pre>
<p>Copies the precomputed value. This duplicates any string within.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the precomputed value to be copied</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the copy or NULL if a copy for a data-type is not implemented.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaFreeFacet"></a>xmlSchemaFreeFacet ()</h3>
<pre class="programlisting">void xmlSchemaFreeFacet (<a href="libxml2-schemasInternals.html#xmlSchemaFacetPtr">xmlSchemaFacetPtr</a> facet)<br>
</pre>
<p>Deallocate a Schema Facet structure.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>facet</tt></i>:</span></td>
<td>a schema facet structure</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaFreeValue"></a>xmlSchemaFreeValue ()</h3>
<pre class="programlisting">void xmlSchemaFreeValue (<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> value)<br>
</pre>
<p>Cleanup the default XML Schemas type library</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the value to free</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaGetBuiltInListSimpleTypeItemType"></a>xmlSchemaGetBuiltInListSimpleTypeItemType ()</h3>
<pre class="programlisting"><a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> xmlSchemaGetBuiltInListSimpleTypeItemType (<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> type)<br>
</pre>
<p>Lookup function</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>type</tt></i>:</span></td>
<td>the built-in simple type.</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the item type of @type as defined by the built-in datatype hierarchy of XML Schema Part 2: Datatypes, or NULL in case of an error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaGetBuiltInType"></a>xmlSchemaGetBuiltInType ()</h3>
<pre class="programlisting"><a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> xmlSchemaGetBuiltInType (<a href="libxml2-schemasInternals.html#xmlSchemaValType">xmlSchemaValType</a> type)<br>
</pre>
<p>Gives you the type struct for a built-in type by its type id.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>type</tt></i>:</span></td>
<td>the type of the built in type</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the type if found, NULL otherwise.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaGetCanonValue"></a>xmlSchemaGetCanonValue ()</h3>
<pre class="programlisting">int xmlSchemaGetCanonValue (<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> val, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** retValue)<br>
</pre>
<p>Get the canonical lexical representation of the value. The caller has to FREE the returned retValue. WARNING: Some value types are not supported yet, resulting in a @retValue of "???". TODO: XML Schema 1.0 does not define canonical representations for: duration, gYearMonth, gYear, gMonthDay, gMonth, gDay, anyURI, QName, NOTATION. This will be fixed in XML Schema 1.1.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the precomputed value</td>
</tr>
<tr>
<td><span class="term"><i><tt>retValue</tt></i>:</span></td>
<td>the returned value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if the value could be built, 1 if the value type is not supported yet and -1 in case of API errors.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaGetCanonValueWhtsp"></a>xmlSchemaGetCanonValueWhtsp ()</h3>
<pre class="programlisting">int xmlSchemaGetCanonValueWhtsp (<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> val, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> ** retValue, <br> <a href="libxml2-xmlschemastypes.html#xmlSchemaWhitespaceValueType">xmlSchemaWhitespaceValueType</a> ws)<br>
</pre>
<p>Get the canonical representation of the value. The caller has to free the returned @retValue.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the precomputed value</td>
</tr>
<tr>
<td><span class="term"><i><tt>retValue</tt></i>:</span></td>
<td>the returned value</td>
</tr>
<tr>
<td><span class="term"><i><tt>ws</tt></i>:</span></td>
<td>the whitespace type of the value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if the value could be built, 1 if the value type is not supported yet and -1 in case of API errors.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaGetFacetValueAsULong"></a>xmlSchemaGetFacetValueAsULong ()</h3>
<pre class="programlisting">unsigned long xmlSchemaGetFacetValueAsULong (<a href="libxml2-schemasInternals.html#xmlSchemaFacetPtr">xmlSchemaFacetPtr</a> facet)<br>
</pre>
<p>Extract the value of a facet</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>facet</tt></i>:</span></td>
<td>an schemas type facet</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the value as a long</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaGetPredefinedType"></a>xmlSchemaGetPredefinedType ()</h3>
<pre class="programlisting"><a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> xmlSchemaGetPredefinedType (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ns)<br>
</pre>
<p>Lookup a type in the default XML Schemas type library</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the type name</td>
</tr>
<tr>
<td><span class="term"><i><tt>ns</tt></i>:</span></td>
<td>the URI of the namespace usually "http://www.w3.org/2001/XMLSchema"</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the type if found, NULL otherwise</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaGetValType"></a>xmlSchemaGetValType ()</h3>
<pre class="programlisting"><a href="libxml2-schemasInternals.html#xmlSchemaValType">xmlSchemaValType</a> xmlSchemaGetValType (<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> val)<br>
</pre>
<p>Accessor for the type of a value</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>a schemas value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the <a href="libxml2-schemasInternals.html#xmlSchemaValType">xmlSchemaValType</a> of the value</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaInitTypes"></a>xmlSchemaInitTypes ()</h3>
<pre class="programlisting">void xmlSchemaInitTypes (void)<br>
</pre>
<p>Initialize the default XML Schemas type library</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaIsBuiltInTypeFacet"></a>xmlSchemaIsBuiltInTypeFacet ()</h3>
<pre class="programlisting">int xmlSchemaIsBuiltInTypeFacet (<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> type, <br> int facetType)<br>
</pre>
<p>Evaluates if a specific facet can be used in conjunction with a type.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>type</tt></i>:</span></td>
<td>the built-in type</td>
</tr>
<tr>
<td><span class="term"><i><tt>facetType</tt></i>:</span></td>
<td>the facet type</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if the facet can be used with the given built-in type, 0 otherwise and -1 in case the type is not a built-in type.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaNewFacet"></a>xmlSchemaNewFacet ()</h3>
<pre class="programlisting"><a href="libxml2-schemasInternals.html#xmlSchemaFacetPtr">xmlSchemaFacetPtr</a> xmlSchemaNewFacet (void)<br>
</pre>
<p>Allocate a new Facet structure.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the newly allocated structure or NULL in case or error</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaNewNOTATIONValue"></a>xmlSchemaNewNOTATIONValue ()</h3>
<pre class="programlisting"><a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> xmlSchemaNewNOTATIONValue (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * name, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * ns)<br>
</pre>
<p>Allocate a new NOTATION value. The given values are consumed and freed with the struct.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>name</tt></i>:</span></td>
<td>the notation name</td>
</tr>
<tr>
<td><span class="term"><i><tt>ns</tt></i>:</span></td>
<td>the notation namespace name or NULL</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new value or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaNewQNameValue"></a>xmlSchemaNewQNameValue ()</h3>
<pre class="programlisting"><a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> xmlSchemaNewQNameValue (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * namespaceName, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * localName)<br>
</pre>
<p>Allocate a new QName value. The given values are consumed and freed with the struct.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>namespaceName</tt></i>:</span></td>
<td>the namespace name</td>
</tr>
<tr>
<td><span class="term"><i><tt>localName</tt></i>:</span></td>
<td>the local name</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new value or NULL in case of an error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaNewStringValue"></a>xmlSchemaNewStringValue ()</h3>
<pre class="programlisting"><a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> xmlSchemaNewStringValue (<a href="libxml2-schemasInternals.html#xmlSchemaValType">xmlSchemaValType</a> type, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value)<br>
</pre>
<p>Allocate a new simple type value. The type can be of XML_SCHEMAS_STRING. WARNING: This one is intended to be expanded for other string based types. We need this for anySimpleType as well. The given value is consumed and freed with the struct.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>type</tt></i>:</span></td>
<td>the value type</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a pointer to the new value or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaValPredefTypeNode"></a>xmlSchemaValPredefTypeNode ()</h3>
<pre class="programlisting">int xmlSchemaValPredefTypeNode (<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> type, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> * val, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node)<br>
</pre>
<p>Check that a value conforms to the lexical space of the predefined type. if true a value is computed and returned in @val.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>type</tt></i>:</span></td>
<td>the predefined type</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the value to check</td>
</tr>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the return computed value</td>
</tr>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the node containing the value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if this validates, a positive error code number otherwise and -1 in case of internal or API error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaValPredefTypeNodeNoNorm"></a>xmlSchemaValPredefTypeNodeNoNorm ()</h3>
<pre class="programlisting">int xmlSchemaValPredefTypeNodeNoNorm (<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> type, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> * val, <br> <a href="libxml2-tree.html#xmlNodePtr">xmlNodePtr</a> node)<br>
</pre>
<p>Check that a value conforms to the lexical space of the predefined type. if true a value is computed and returned in @val. This one does apply any normalization to the value.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>type</tt></i>:</span></td>
<td>the predefined type</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the value to check</td>
</tr>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the return computed value</td>
</tr>
<tr>
<td><span class="term"><i><tt>node</tt></i>:</span></td>
<td>the node containing the value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if this validates, a positive error code number otherwise and -1 in case of internal or API error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaValidateFacet"></a>xmlSchemaValidateFacet ()</h3>
<pre class="programlisting">int xmlSchemaValidateFacet (<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> base, <br> <a href="libxml2-schemasInternals.html#xmlSchemaFacetPtr">xmlSchemaFacetPtr</a> facet, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> val)<br>
</pre>
<p>Check a value against a facet condition</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>base</tt></i>:</span></td>
<td>the base type</td>
</tr>
<tr>
<td><span class="term"><i><tt>facet</tt></i>:</span></td>
<td>the facet to check</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the lexical repr of the value to validate</td>
</tr>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the precomputed value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if the element is schemas valid, a positive error code number otherwise and -1 in case of internal or API error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaValidateFacetWhtsp"></a>xmlSchemaValidateFacetWhtsp ()</h3>
<pre class="programlisting">int xmlSchemaValidateFacetWhtsp (<a href="libxml2-schemasInternals.html#xmlSchemaFacetPtr">xmlSchemaFacetPtr</a> facet, <br> <a href="libxml2-xmlschemastypes.html#xmlSchemaWhitespaceValueType">xmlSchemaWhitespaceValueType</a> fws, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValType">xmlSchemaValType</a> valType, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> val, <br> <a href="libxml2-xmlschemastypes.html#xmlSchemaWhitespaceValueType">xmlSchemaWhitespaceValueType</a> ws)<br>
</pre>
<p>Check a value against a facet condition. This takes value normalization according to the specified whitespace types into account. Note that @value needs to be the *normalized* value if the facet is of type "pattern".</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>facet</tt></i>:</span></td>
<td>the facet to check</td>
</tr>
<tr>
<td><span class="term"><i><tt>fws</tt></i>:</span></td>
<td>the whitespace type of the facet's value</td>
</tr>
<tr>
<td><span class="term"><i><tt>valType</tt></i>:</span></td>
<td>the built-in type of the value</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the lexical (or normalized for pattern) repr of the value to validate</td>
</tr>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the precomputed value</td>
</tr>
<tr>
<td><span class="term"><i><tt>ws</tt></i>:</span></td>
<td>the whitespace type of the value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if the element is schemas valid, a positive error code number otherwise and -1 in case of internal or API error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaValidateLengthFacet"></a>xmlSchemaValidateLengthFacet ()</h3>
<pre class="programlisting">int xmlSchemaValidateLengthFacet (<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> type, <br> <a href="libxml2-schemasInternals.html#xmlSchemaFacetPtr">xmlSchemaFacetPtr</a> facet, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> val, <br> unsigned long * length)<br>
</pre>
<p>Checka a value against a "length", "minLength" and "maxLength" facet; sets @length to the computed length of @value.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>type</tt></i>:</span></td>
<td>the built-in type</td>
</tr>
<tr>
<td><span class="term"><i><tt>facet</tt></i>:</span></td>
<td>the facet to check</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the lexical repr. of the value to be validated</td>
</tr>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the precomputed value</td>
</tr>
<tr>
<td><span class="term"><i><tt>length</tt></i>:</span></td>
<td>the actual length of the value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if the value is valid, a positive error code otherwise and -1 in case of an internal or API error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaValidateLengthFacetWhtsp"></a>xmlSchemaValidateLengthFacetWhtsp ()</h3>
<pre class="programlisting">int xmlSchemaValidateLengthFacetWhtsp (<a href="libxml2-schemasInternals.html#xmlSchemaFacetPtr">xmlSchemaFacetPtr</a> facet, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValType">xmlSchemaValType</a> valType, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> val, <br> unsigned long * length, <br> <a href="libxml2-xmlschemastypes.html#xmlSchemaWhitespaceValueType">xmlSchemaWhitespaceValueType</a> ws)<br>
</pre>
<p>Checka a value against a "length", "minLength" and "maxLength" facet; sets @length to the computed length of @value.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>facet</tt></i>:</span></td>
<td>the facet to check</td>
</tr>
<tr>
<td><span class="term"><i><tt>valType</tt></i>:</span></td>
<td>the built-in type</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the lexical repr. of the value to be validated</td>
</tr>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the precomputed value</td>
</tr>
<tr>
<td><span class="term"><i><tt>length</tt></i>:</span></td>
<td>the actual length of the value</td>
</tr>
<tr>
<td><span class="term"><i><tt>ws</tt></i>:</span></td>
<td>the whitespace type of the value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if the value is valid, a positive error code otherwise and -1 in case of an internal or API error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaValidateListSimpleTypeFacet"></a>xmlSchemaValidateListSimpleTypeFacet ()</h3>
<pre class="programlisting">int xmlSchemaValidateListSimpleTypeFacet (<a href="libxml2-schemasInternals.html#xmlSchemaFacetPtr">xmlSchemaFacetPtr</a> facet, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> unsigned long actualLen, <br> unsigned long * expectedLen)<br>
</pre>
<p>Checks the value of a list simple type against a facet.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>facet</tt></i>:</span></td>
<td>the facet to check</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the lexical repr of the value to validate</td>
</tr>
<tr>
<td><span class="term"><i><tt>actualLen</tt></i>:</span></td>
<td>the number of list items</td>
</tr>
<tr>
<td><span class="term"><i><tt>expectedLen</tt></i>:</span></td>
<td>the resulting expected number of list items</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if the value is valid, a positive error code number otherwise and -1 in case of an internal error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaValidatePredefinedType"></a>xmlSchemaValidatePredefinedType ()</h3>
<pre class="programlisting">int xmlSchemaValidatePredefinedType (<a href="libxml2-schemasInternals.html#xmlSchemaTypePtr">xmlSchemaTypePtr</a> type, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> * val)<br>
</pre>
<p>Check that a value conforms to the lexical space of the predefined type. if true a value is computed and returned in @val.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>type</tt></i>:</span></td>
<td>the predefined type</td>
</tr>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>the value to check</td>
</tr>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the return computed value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if this validates, a positive error code number otherwise and -1 in case of internal or API error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaValueAppend"></a>xmlSchemaValueAppend ()</h3>
<pre class="programlisting">int xmlSchemaValueAppend (<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> prev, <br> <a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> cur)<br>
</pre>
<p>Appends a next sibling to a list of computed values.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>prev</tt></i>:</span></td>
<td>the value</td>
</tr>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the value to be appended</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 if succeeded and -1 on API errors.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaValueGetAsBoolean"></a>xmlSchemaValueGetAsBoolean ()</h3>
<pre class="programlisting">int xmlSchemaValueGetAsBoolean (<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> val)<br>
</pre>
<p>Accessor for the boolean value of a computed value.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true and 0 if false, or in case of an error. Hmm.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaValueGetAsString"></a>xmlSchemaValueGetAsString ()</h3>
<pre class="programlisting">const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlSchemaValueGetAsString (<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> val)<br>
</pre>
<p>Accessor for the string value of a computed value.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>val</tt></i>:</span></td>
<td>the value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the string value or NULL if there was none, or on API errors.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaValueGetNext"></a>xmlSchemaValueGetNext ()</h3>
<pre class="programlisting"><a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> xmlSchemaValueGetNext (<a href="libxml2-schemasInternals.html#xmlSchemaValPtr">xmlSchemaValPtr</a> cur)<br>
</pre>
<p>Accessor for the next sibling of a list of computed values.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>cur</tt></i>:</span></td>
<td>the value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the next value or NULL if there was none, or on API errors.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSchemaWhiteSpaceReplace"></a>xmlSchemaWhiteSpaceReplace ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlSchemaWhiteSpaceReplace (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * value)<br>
</pre>
<p>Replaces 0xd, 0x9 and 0xa with a space.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>value</tt></i>:</span></td>
<td>a value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the new string or NULL if no change was required.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
</div>
</div>
</body>
</html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>threads: interfaces for thread handling</title>
<meta name="generator" content="Libxml2 devhelp stylesheet">
<link rel="start" href="index.html" title="libxml2 Reference Manual">
<link rel="up" href="general.html" title="API">
<link rel="stylesheet" href="style.css" type="text/css">
<link rel="chapter" href="general.html" title="API">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table class="navigation" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"><tr valign="middle">
<td><a accesskey="p" href="libxml2-schematron.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
<td><a accesskey="u" href="general.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
<td><a accesskey="n" href="libxml2-tree.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
<th width="100%" align="center">libxml2 Reference Manual</th>
</tr></table>
<h2><span class="refentrytitle">threads</span></h2>
<p>threads - interfaces for thread handling</p>
<p>set of generic threading related routines should work with pthreads, Windows native or TLS threads </p>
<p>Author(s): Daniel Veillard </p>
<div class="refsynopsisdiv">
<h2>Synopsis</h2>
<pre class="synopsis">typedef struct _xmlMutex <a href="#xmlMutex">xmlMutex</a>;
typedef <a href="libxml2-threads.html#xmlMutex">xmlMutex</a> * <a href="#xmlMutexPtr">xmlMutexPtr</a>;
typedef struct _xmlRMutex <a href="#xmlRMutex">xmlRMutex</a>;
typedef <a href="libxml2-threads.html#xmlRMutex">xmlRMutex</a> * <a href="#xmlRMutexPtr">xmlRMutexPtr</a>;
void <a href="#xmlCleanupThreads">xmlCleanupThreads</a> (void);
int <a href="#xmlDllMain">xmlDllMain</a> (void * hinstDLL, <br> unsigned long fdwReason, <br> void * lpvReserved);
void <a href="#xmlFreeMutex">xmlFreeMutex</a> (<a href="libxml2-threads.html#xmlMutexPtr">xmlMutexPtr</a> tok);
void <a href="#xmlFreeRMutex">xmlFreeRMutex</a> (<a href="libxml2-threads.html#xmlRMutexPtr">xmlRMutexPtr</a> tok);
<a href="libxml2-globals.html#xmlGlobalStatePtr">xmlGlobalStatePtr</a> <a href="#xmlGetGlobalState">xmlGetGlobalState</a> (void);
int <a href="#xmlGetThreadId">xmlGetThreadId</a> (void);
void <a href="#xmlInitThreads">xmlInitThreads</a> (void);
int <a href="#xmlIsMainThread">xmlIsMainThread</a> (void);
void <a href="#xmlLockLibrary">xmlLockLibrary</a> (void);
void <a href="#xmlMutexLock">xmlMutexLock</a> (<a href="libxml2-threads.html#xmlMutexPtr">xmlMutexPtr</a> tok);
void <a href="#xmlMutexUnlock">xmlMutexUnlock</a> (<a href="libxml2-threads.html#xmlMutexPtr">xmlMutexPtr</a> tok);
<a href="libxml2-threads.html#xmlMutexPtr">xmlMutexPtr</a> <a href="#xmlNewMutex">xmlNewMutex</a> (void);
<a href="libxml2-threads.html#xmlRMutexPtr">xmlRMutexPtr</a> <a href="#xmlNewRMutex">xmlNewRMutex</a> (void);
void <a href="#xmlRMutexLock">xmlRMutexLock</a> (<a href="libxml2-threads.html#xmlRMutexPtr">xmlRMutexPtr</a> tok);
void <a href="#xmlRMutexUnlock">xmlRMutexUnlock</a> (<a href="libxml2-threads.html#xmlRMutexPtr">xmlRMutexPtr</a> tok);
void <a href="#xmlUnlockLibrary">xmlUnlockLibrary</a> (void);
</pre>
</div>
<div class="refsect1" lang="en"><h2>Description</h2></div>
<div class="refsect1" lang="en">
<h2>Details</h2>
<div class="refsect2" lang="en">
<div class="refsect2" lang="en">
<h3>
<a name="xmlMutex">Structure </a>xmlMutex</h3>
<pre class="programlisting">struct _xmlMutex {
The content of this structure is not made public by the API.
} xmlMutex;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlMutexPtr">Typedef </a>xmlMutexPtr</h3>
<pre class="programlisting"><a href="libxml2-threads.html#xmlMutex">xmlMutex</a> * xmlMutexPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlRMutex">Structure </a>xmlRMutex</h3>
<pre class="programlisting">struct _xmlRMutex {
The content of this structure is not made public by the API.
} xmlRMutex;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlRMutexPtr">Typedef </a>xmlRMutexPtr</h3>
<pre class="programlisting"><a href="libxml2-threads.html#xmlRMutex">xmlRMutex</a> * xmlRMutexPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlCleanupThreads"></a>xmlCleanupThreads ()</h3>
<pre class="programlisting">void xmlCleanupThreads (void)<br>
</pre>
<p>DEPRECATED: This function will be made private. Call <a href="libxml2-parser.html#xmlCleanupParser">xmlCleanupParser</a> to free global state but see the warnings there. <a href="libxml2-parser.html#xmlCleanupParser">xmlCleanupParser</a> should be only called once at program exit. In most cases, you don't have call cleanup functions at all. xmlCleanupThreads() is used to to cleanup all the thread related data of the libxml2 library once processing has ended. WARNING: if your application is multithreaded or has plugin support calling this may crash the application if another thread or a plugin is still using libxml2. It's sometimes very hard to guess if libxml2 is in use in the application, some libraries or plugins may use it without notice. In case of doubt abstain from calling this function or do it just before calling exit() to avoid leak reports from valgrind !</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlDllMain"></a>xmlDllMain ()</h3>
<pre class="programlisting">int xmlDllMain (void * hinstDLL, <br> unsigned long fdwReason, <br> void * lpvReserved)<br>
</pre>
<p></p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>hinstDLL</tt></i>:</span></td>
<td></td>
</tr>
<tr>
<td><span class="term"><i><tt>fdwReason</tt></i>:</span></td>
<td></td>
</tr>
<tr>
<td><span class="term"><i><tt>lpvReserved</tt></i>:</span></td>
<td></td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td></td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlFreeMutex"></a>xmlFreeMutex ()</h3>
<pre class="programlisting">void xmlFreeMutex (<a href="libxml2-threads.html#xmlMutexPtr">xmlMutexPtr</a> tok)<br>
</pre>
<p>xmlFreeMutex() is used to reclaim resources associated with a libxml2 token struct.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>tok</tt></i>:</span></td>
<td>the simple mutex</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlFreeRMutex"></a>xmlFreeRMutex ()</h3>
<pre class="programlisting">void xmlFreeRMutex (<a href="libxml2-threads.html#xmlRMutexPtr">xmlRMutexPtr</a> tok)<br>
</pre>
<p>xmlRFreeMutex() is used to reclaim resources associated with a reentrant mutex.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>tok</tt></i>:</span></td>
<td>the reentrant mutex</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlGetGlobalState"></a>xmlGetGlobalState ()</h3>
<pre class="programlisting"><a href="libxml2-globals.html#xmlGlobalStatePtr">xmlGlobalStatePtr</a> xmlGetGlobalState (void)<br>
</pre>
<p>xmlGetGlobalState() is called to retrieve the global state for a thread.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the thread global state or NULL in case of error</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlGetThreadId"></a>xmlGetThreadId ()</h3>
<pre class="programlisting">int xmlGetThreadId (void)<br>
</pre>
<p>xmlGetThreadId() find the current thread ID number Note that this is likely to be broken on some platforms using pthreads as the specification doesn't mandate pthread_t to be an integer type</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the current thread ID number</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlInitThreads"></a>xmlInitThreads ()</h3>
<pre class="programlisting">void xmlInitThreads (void)<br>
</pre>
<p>DEPRECATED: This function will be made private. Call <a href="libxml2-parser.html#xmlInitParser">xmlInitParser</a> to initialize the library. xmlInitThreads() is used to to initialize all the thread related data of the libxml2 library.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlIsMainThread"></a>xmlIsMainThread ()</h3>
<pre class="programlisting">int xmlIsMainThread (void)<br>
</pre>
<p>xmlIsMainThread() check whether the current thread is the main thread.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if the current thread is the main thread, 0 otherwise</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlLockLibrary"></a>xmlLockLibrary ()</h3>
<pre class="programlisting">void xmlLockLibrary (void)<br>
</pre>
<p>xmlLockLibrary() is used to take out a re-entrant lock on the libxml2 library.</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlMutexLock"></a>xmlMutexLock ()</h3>
<pre class="programlisting">void xmlMutexLock (<a href="libxml2-threads.html#xmlMutexPtr">xmlMutexPtr</a> tok)<br>
</pre>
<p>xmlMutexLock() is used to lock a libxml2 token.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>tok</tt></i>:</span></td>
<td>the simple mutex</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlMutexUnlock"></a>xmlMutexUnlock ()</h3>
<pre class="programlisting">void xmlMutexUnlock (<a href="libxml2-threads.html#xmlMutexPtr">xmlMutexPtr</a> tok)<br>
</pre>
<p>xmlMutexUnlock() is used to unlock a libxml2 token.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>tok</tt></i>:</span></td>
<td>the simple mutex</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewMutex"></a>xmlNewMutex ()</h3>
<pre class="programlisting"><a href="libxml2-threads.html#xmlMutexPtr">xmlMutexPtr</a> xmlNewMutex (void)<br>
</pre>
<p>xmlNewMutex() is used to allocate a libxml2 token struct for use in synchronizing access to data.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a new simple mutex pointer or NULL in case of error</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewRMutex"></a>xmlNewRMutex ()</h3>
<pre class="programlisting"><a href="libxml2-threads.html#xmlRMutexPtr">xmlRMutexPtr</a> xmlNewRMutex (void)<br>
</pre>
<p>xmlRNewMutex() is used to allocate a reentrant mutex for use in synchronizing access to data. token_r is a re-entrant lock and thus useful for synchronizing access to data structures that may be manipulated in a recursive fashion.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the new reentrant mutex pointer or NULL in case of error</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlRMutexLock"></a>xmlRMutexLock ()</h3>
<pre class="programlisting">void xmlRMutexLock (<a href="libxml2-threads.html#xmlRMutexPtr">xmlRMutexPtr</a> tok)<br>
</pre>
<p>xmlRMutexLock() is used to lock a libxml2 token_r.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>tok</tt></i>:</span></td>
<td>the reentrant mutex</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlRMutexUnlock"></a>xmlRMutexUnlock ()</h3>
<pre class="programlisting">void xmlRMutexUnlock (<a href="libxml2-threads.html#xmlRMutexPtr">xmlRMutexPtr</a> tok)<br>
</pre>
<p>xmlRMutexUnlock() is used to unlock a libxml2 token_r.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>tok</tt></i>:</span></td>
<td>the reentrant mutex</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlUnlockLibrary"></a>xmlUnlockLibrary ()</h3>
<pre class="programlisting">void xmlUnlockLibrary (void)<br>
</pre>
<p>xmlUnlockLibrary() is used to release a re-entrant lock on the libxml2 library.</p>
</div>
<hr>
</div>
</div>
</body>
</html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>uri: library of generic URI related routines</title>
<meta name="generator" content="Libxml2 devhelp stylesheet">
<link rel="start" href="index.html" title="libxml2 Reference Manual">
<link rel="up" href="general.html" title="API">
<link rel="stylesheet" href="style.css" type="text/css">
<link rel="chapter" href="general.html" title="API">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table class="navigation" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"><tr valign="middle">
<td><a accesskey="p" href="libxml2-tree.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
<td><a accesskey="u" href="general.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
<td><a accesskey="n" href="libxml2-valid.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
<th width="100%" align="center">libxml2 Reference Manual</th>
</tr></table>
<h2><span class="refentrytitle">uri</span></h2>
<p>uri - library of generic URI related routines</p>
<p>library of generic URI related routines Implements RFC 2396 </p>
<p>Author(s): Daniel Veillard </p>
<div class="refsynopsisdiv">
<h2>Synopsis</h2>
<pre class="synopsis">typedef struct _xmlURI <a href="#xmlURI">xmlURI</a>;
typedef <a href="libxml2-uri.html#xmlURI">xmlURI</a> * <a href="#xmlURIPtr">xmlURIPtr</a>;
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlBuildRelativeURI">xmlBuildRelativeURI</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * URI, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * base);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlBuildURI">xmlBuildURI</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * URI, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * base);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlCanonicPath">xmlCanonicPath</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * path);
<a href="libxml2-uri.html#xmlURIPtr">xmlURIPtr</a> <a href="#xmlCreateURI">xmlCreateURI</a> (void);
void <a href="#xmlFreeURI">xmlFreeURI</a> (<a href="libxml2-uri.html#xmlURIPtr">xmlURIPtr</a> uri);
int <a href="#xmlNormalizeURIPath">xmlNormalizeURIPath</a> (char * path);
<a href="libxml2-uri.html#xmlURIPtr">xmlURIPtr</a> <a href="#xmlParseURI">xmlParseURI</a> (const char * str);
<a href="libxml2-uri.html#xmlURIPtr">xmlURIPtr</a> <a href="#xmlParseURIRaw">xmlParseURIRaw</a> (const char * str, <br> int raw);
int <a href="#xmlParseURIReference">xmlParseURIReference</a> (<a href="libxml2-uri.html#xmlURIPtr">xmlURIPtr</a> uri, <br> const char * str);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlPathToURI">xmlPathToURI</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * path);
void <a href="#xmlPrintURI">xmlPrintURI</a> (FILE * stream, <br> <a href="libxml2-uri.html#xmlURIPtr">xmlURIPtr</a> uri);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlSaveUri">xmlSaveUri</a> (<a href="libxml2-uri.html#xmlURIPtr">xmlURIPtr</a> uri);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlURIEscape">xmlURIEscape</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * str);
<a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlURIEscapeStr">xmlURIEscapeStr</a> (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * str, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * list);
char * <a href="#xmlURIUnescapeString">xmlURIUnescapeString</a> (const char * str, <br> int len, <br> char * target);
</pre>
</div>
<div class="refsect1" lang="en"><h2>Description</h2></div>
<div class="refsect1" lang="en">
<h2>Details</h2>
<div class="refsect2" lang="en">
<div class="refsect2" lang="en">
<h3>
<a name="xmlURI">Structure </a>xmlURI</h3>
<pre class="programlisting">struct _xmlURI {
char * scheme : the URI scheme
char * opaque : opaque part
char * authority : the authority part
char * server : the server part
char * user : the user part
int port : the port number
char * path : the path string
char * query : the query string (deprecated - use with caution)
char * fragment : the fragment identifier
int cleanup : parsing potentially unclean URI
char * query_raw : the query string (as it appears in the URI)
} xmlURI;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlURIPtr">Typedef </a>xmlURIPtr</h3>
<pre class="programlisting"><a href="libxml2-uri.html#xmlURI">xmlURI</a> * xmlURIPtr;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBuildRelativeURI"></a>xmlBuildRelativeURI ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlBuildRelativeURI (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * URI, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * base)<br>
</pre>
<p>Expresses the URI of the <a href="libxml2-SAX.html#reference">reference</a> in terms relative to the base. Some examples of this operation include: base = "http://site1.com/docs/book1.html" URI input URI returned docs/pic1.gif pic1.gif docs/img/pic1.gif img/pic1.gif img/pic1.gif ../img/pic1.gif http://site1.com/docs/pic1.gif pic1.gif http://site2.com/docs/pic1.gif http://site2.com/docs/pic1.gif base = "docs/book1.html" URI input URI returned docs/pic1.gif pic1.gif docs/img/pic1.gif img/pic1.gif img/pic1.gif ../img/pic1.gif http://site1.com/docs/pic1.gif http://site1.com/docs/pic1.gif Note: if the URI <a href="libxml2-SAX.html#reference">reference</a> is really weird or complicated, it may be worthwhile to first convert it into a "nice" one by calling <a href="libxml2-uri.html#xmlBuildURI">xmlBuildURI</a> (using 'base') before calling this routine, since this routine (for reasonable efficiency) assumes URI has already been through some validation.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>URI</tt></i>:</span></td>
<td>the URI <a href="libxml2-SAX.html#reference">reference</a> under consideration</td>
</tr>
<tr>
<td><span class="term"><i><tt>base</tt></i>:</span></td>
<td>the base value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a new URI string (to be freed by the caller) or NULL in case error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlBuildURI"></a>xmlBuildURI ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlBuildURI (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * URI, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * base)<br>
</pre>
<p>Computes he final URI of the <a href="libxml2-SAX.html#reference">reference</a> done by checking that the given URI is valid, and building the final URI using the base URI. This is processed according to section 5.2 of the RFC 2396 5.2. Resolving Relative References to Absolute Form</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>URI</tt></i>:</span></td>
<td>the URI instance found in the document</td>
</tr>
<tr>
<td><span class="term"><i><tt>base</tt></i>:</span></td>
<td>the base value</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a new URI string (to be freed by the caller) or NULL in case of error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlCanonicPath"></a>xmlCanonicPath ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlCanonicPath (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * path)<br>
</pre>
<p>Constructs a canonic path from the specified path.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>path</tt></i>:</span></td>
<td>the resource locator in a filesystem notation</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a new canonic path, or a duplicate of the path parameter if the construction fails. The caller is responsible for freeing the memory occupied by the returned string. If there is insufficient memory available, or the argument is NULL, the function returns NULL.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlCreateURI"></a>xmlCreateURI ()</h3>
<pre class="programlisting"><a href="libxml2-uri.html#xmlURIPtr">xmlURIPtr</a> xmlCreateURI (void)<br>
</pre>
<p>Simply creates an empty <a href="libxml2-uri.html#xmlURI">xmlURI</a></p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the new structure or NULL in case of error</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlFreeURI"></a>xmlFreeURI ()</h3>
<pre class="programlisting">void xmlFreeURI (<a href="libxml2-uri.html#xmlURIPtr">xmlURIPtr</a> uri)<br>
</pre>
<p>Free up the <a href="libxml2-uri.html#xmlURI">xmlURI</a> struct</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>uri</tt></i>:</span></td>
<td>pointer to an <a href="libxml2-uri.html#xmlURI">xmlURI</a>
</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNormalizeURIPath"></a>xmlNormalizeURIPath ()</h3>
<pre class="programlisting">int xmlNormalizeURIPath (char * path)<br>
</pre>
<p>Applies the 5 normalization steps to a path string--that is, RFC 2396 Section 5.2, steps 6.c through 6.g. Normalization occurs directly on the string, no new allocation is done</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>path</tt></i>:</span></td>
<td>pointer to the path string</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 or an error code</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseURI"></a>xmlParseURI ()</h3>
<pre class="programlisting"><a href="libxml2-uri.html#xmlURIPtr">xmlURIPtr</a> xmlParseURI (const char * str)<br>
</pre>
<p>Parse an URI based on RFC 3986 URI-reference = [ absoluteURI | relativeURI ] [ "#" fragment ]</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>str</tt></i>:</span></td>
<td>the URI string to analyze</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a newly built <a href="libxml2-uri.html#xmlURIPtr">xmlURIPtr</a> or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseURIRaw"></a>xmlParseURIRaw ()</h3>
<pre class="programlisting"><a href="libxml2-uri.html#xmlURIPtr">xmlURIPtr</a> xmlParseURIRaw (const char * str, <br> int raw)<br>
</pre>
<p>Parse an URI but allows to keep intact the original fragments. URI-reference = URI / relative-ref</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>str</tt></i>:</span></td>
<td>the URI string to analyze</td>
</tr>
<tr>
<td><span class="term"><i><tt>raw</tt></i>:</span></td>
<td>if 1 unescaping of URI pieces are disabled</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a newly built <a href="libxml2-uri.html#xmlURIPtr">xmlURIPtr</a> or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlParseURIReference"></a>xmlParseURIReference ()</h3>
<pre class="programlisting">int xmlParseURIReference (<a href="libxml2-uri.html#xmlURIPtr">xmlURIPtr</a> uri, <br> const char * str)<br>
</pre>
<p>Parse an URI <a href="libxml2-SAX.html#reference">reference</a> string based on RFC 3986 and fills in the appropriate fields of the @uri structure URI-reference = URI / relative-ref</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>uri</tt></i>:</span></td>
<td>pointer to an URI structure</td>
</tr>
<tr>
<td><span class="term"><i><tt>str</tt></i>:</span></td>
<td>the string to analyze</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 or the error code</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlPathToURI"></a>xmlPathToURI ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlPathToURI (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * path)<br>
</pre>
<p>Constructs an URI expressing the existing path</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>path</tt></i>:</span></td>
<td>the resource locator in a filesystem notation</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a new URI, or a duplicate of the path parameter if the construction fails. The caller is responsible for freeing the memory occupied by the returned string. If there is insufficient memory available, or the argument is NULL, the function returns NULL.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlPrintURI"></a>xmlPrintURI ()</h3>
<pre class="programlisting">void xmlPrintURI (FILE * stream, <br> <a href="libxml2-uri.html#xmlURIPtr">xmlURIPtr</a> uri)<br>
</pre>
<p>Prints the URI in the stream @stream.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>stream</tt></i>:</span></td>
<td>a FILE* for the output</td>
</tr>
<tr>
<td><span class="term"><i><tt>uri</tt></i>:</span></td>
<td>pointer to an <a href="libxml2-uri.html#xmlURI">xmlURI</a>
</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlSaveUri"></a>xmlSaveUri ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlSaveUri (<a href="libxml2-uri.html#xmlURIPtr">xmlURIPtr</a> uri)<br>
</pre>
<p>Save the URI as an escaped string</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>uri</tt></i>:</span></td>
<td>pointer to an <a href="libxml2-uri.html#xmlURI">xmlURI</a>
</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a new string (to be deallocated by caller)</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlURIEscape"></a>xmlURIEscape ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlURIEscape (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * str)<br>
</pre>
<p>Escaping routine, does not do validity checks ! It will try to escape the chars needing this, but this is heuristic based it's impossible to be sure.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>str</tt></i>:</span></td>
<td>the string of the URI to escape</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>an copy of the string, but escaped 25 May 2001 Uses <a href="libxml2-uri.html#xmlParseURI">xmlParseURI</a> and <a href="libxml2-uri.html#xmlURIEscapeStr">xmlURIEscapeStr</a> to try to escape correctly according to RFC2396. - Carl Douglas</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlURIEscapeStr"></a>xmlURIEscapeStr ()</h3>
<pre class="programlisting"><a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * xmlURIEscapeStr (const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * str, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * list)<br>
</pre>
<p>This routine escapes a string to hex, ignoring reserved <a href="libxml2-SAX.html#characters">characters</a> (a-z) and the <a href="libxml2-SAX.html#characters">characters</a> in the exception list.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>str</tt></i>:</span></td>
<td>string to escape</td>
</tr>
<tr>
<td><span class="term"><i><tt>list</tt></i>:</span></td>
<td>exception list string of chars not to escape</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a new escaped string or NULL in case of error.</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlURIUnescapeString"></a>xmlURIUnescapeString ()</h3>
<pre class="programlisting">char * xmlURIUnescapeString (const char * str, <br> int len, <br> char * target)<br>
</pre>
<p>Unescaping routine, but does not check that the string is an URI. The output is a direct unsigned char translation of %XX values (no encoding) Note that the length of the result can only be smaller or same size as the input string.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>str</tt></i>:</span></td>
<td>the string to unescape</td>
</tr>
<tr>
<td><span class="term"><i><tt>len</tt></i>:</span></td>
<td>the length in bytes to unescape (or <= 0 to indicate full string)</td>
</tr>
<tr>
<td><span class="term"><i><tt>target</tt></i>:</span></td>
<td>optional destination buffer</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>a copy of the string, but unescaped, will return NULL only in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
</div>
</div>
</body>
</html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>xmlautomata: API to build regexp automata</title>
<meta name="generator" content="Libxml2 devhelp stylesheet">
<link rel="start" href="index.html" title="libxml2 Reference Manual">
<link rel="up" href="general.html" title="API">
<link rel="stylesheet" href="style.css" type="text/css">
<link rel="chapter" href="general.html" title="API">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table class="navigation" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"><tr valign="middle">
<td><a accesskey="p" href="libxml2-xmlIO.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
<td><a accesskey="u" href="general.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
<td><a accesskey="n" href="libxml2-xmlerror.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
<th width="100%" align="center">libxml2 Reference Manual</th>
</tr></table>
<h2><span class="refentrytitle">xmlautomata</span></h2>
<p>xmlautomata - API to build regexp automata</p>
<p>the API to build regexp automata </p>
<p>Author(s): Daniel Veillard </p>
<div class="refsynopsisdiv">
<h2>Synopsis</h2>
<pre class="synopsis">typedef struct _xmlAutomata <a href="#xmlAutomata">xmlAutomata</a>;
typedef <a href="libxml2-xmlautomata.html#xmlAutomata">xmlAutomata</a> * <a href="#xmlAutomataPtr">xmlAutomataPtr</a>;
typedef struct _xmlAutomataState <a href="#xmlAutomataState">xmlAutomataState</a>;
typedef <a href="libxml2-xmlautomata.html#xmlAutomataState">xmlAutomataState</a> * <a href="#xmlAutomataStatePtr">xmlAutomataStatePtr</a>;
<a href="libxml2-xmlregexp.html#xmlRegexpPtr">xmlRegexpPtr</a> <a href="#xmlAutomataCompile">xmlAutomataCompile</a> (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am);
<a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> <a href="#xmlAutomataGetInitState">xmlAutomataGetInitState</a> (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am);
int <a href="#xmlAutomataIsDeterminist">xmlAutomataIsDeterminist</a> (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am);
<a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> <a href="#xmlAutomataNewAllTrans">xmlAutomataNewAllTrans</a> (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> from, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> to, <br> int lax);
<a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> <a href="#xmlAutomataNewCountTrans">xmlAutomataNewCountTrans</a> (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> from, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> to, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * token, <br> int min, <br> int max, <br> void * data);
<a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> <a href="#xmlAutomataNewCountTrans2">xmlAutomataNewCountTrans2</a> (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> from, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> to, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * token, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * token2, <br> int min, <br> int max, <br> void * data);
<a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> <a href="#xmlAutomataNewCountedTrans">xmlAutomataNewCountedTrans</a> (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> from, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> to, <br> int counter);
int <a href="#xmlAutomataNewCounter">xmlAutomataNewCounter</a> (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> int min, <br> int max);
<a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> <a href="#xmlAutomataNewCounterTrans">xmlAutomataNewCounterTrans</a> (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> from, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> to, <br> int counter);
<a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> <a href="#xmlAutomataNewEpsilon">xmlAutomataNewEpsilon</a> (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> from, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> to);
<a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> <a href="#xmlAutomataNewNegTrans">xmlAutomataNewNegTrans</a> (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> from, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> to, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * token, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * token2, <br> void * data);
<a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> <a href="#xmlAutomataNewOnceTrans">xmlAutomataNewOnceTrans</a> (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> from, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> to, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * token, <br> int min, <br> int max, <br> void * data);
<a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> <a href="#xmlAutomataNewOnceTrans2">xmlAutomataNewOnceTrans2</a> (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> from, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> to, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * token, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * token2, <br> int min, <br> int max, <br> void * data);
<a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> <a href="#xmlAutomataNewState">xmlAutomataNewState</a> (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am);
<a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> <a href="#xmlAutomataNewTransition">xmlAutomataNewTransition</a> (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> from, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> to, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * token, <br> void * data);
<a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> <a href="#xmlAutomataNewTransition2">xmlAutomataNewTransition2</a> (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> from, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> to, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * token, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * token2, <br> void * data);
int <a href="#xmlAutomataSetFinalState">xmlAutomataSetFinalState</a> (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> state);
void <a href="#xmlFreeAutomata">xmlFreeAutomata</a> (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am);
<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> <a href="#xmlNewAutomata">xmlNewAutomata</a> (void);
</pre>
</div>
<div class="refsect1" lang="en"><h2>Description</h2></div>
<div class="refsect1" lang="en">
<h2>Details</h2>
<div class="refsect2" lang="en">
<div class="refsect2" lang="en">
<h3>
<a name="xmlAutomata">Structure </a>xmlAutomata</h3>
<pre class="programlisting">struct _xmlAutomata {
The content of this structure is not made public by the API.
} xmlAutomata;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAutomataPtr">Typedef </a>xmlAutomataPtr</h3>
<pre class="programlisting"><a href="libxml2-xmlautomata.html#xmlAutomata">xmlAutomata</a> * xmlAutomataPtr;
</pre>
<p>A libxml automata description, It can be compiled into a regexp</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAutomataState">Structure </a>xmlAutomataState</h3>
<pre class="programlisting">struct _xmlAutomataState {
The content of this structure is not made public by the API.
} xmlAutomataState;
</pre>
<p></p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAutomataStatePtr">Typedef </a>xmlAutomataStatePtr</h3>
<pre class="programlisting"><a href="libxml2-xmlautomata.html#xmlAutomataState">xmlAutomataState</a> * xmlAutomataStatePtr;
</pre>
<p>A state int the automata description,</p>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAutomataCompile"></a>xmlAutomataCompile ()</h3>
<pre class="programlisting"><a href="libxml2-xmlregexp.html#xmlRegexpPtr">xmlRegexpPtr</a> xmlAutomataCompile (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am)<br>
</pre>
<p>Compile the automata into a Reg Exp ready for being executed. The automata should be free after this point.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>am</tt></i>:</span></td>
<td>an automata</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the compiled regexp or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAutomataGetInitState"></a>xmlAutomataGetInitState ()</h3>
<pre class="programlisting"><a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> xmlAutomataGetInitState (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am)<br>
</pre>
<p>Initial state lookup</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>am</tt></i>:</span></td>
<td>an automata</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the initial state of the automata</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAutomataIsDeterminist"></a>xmlAutomataIsDeterminist ()</h3>
<pre class="programlisting">int xmlAutomataIsDeterminist (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am)<br>
</pre>
<p>Checks if an automata is determinist.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>am</tt></i>:</span></td>
<td>an automata</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>1 if true, 0 if not, and -1 in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAutomataNewAllTrans"></a>xmlAutomataNewAllTrans ()</h3>
<pre class="programlisting"><a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> xmlAutomataNewAllTrans (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> from, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> to, <br> int lax)<br>
</pre>
<p>If @to is NULL, this creates first a new target state in the automata and then adds a an ALL transition from the @from state to the target state. That transition is an epsilon transition allowed only when all transitions from the @from node have been activated.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>am</tt></i>:</span></td>
<td>an automata</td>
</tr>
<tr>
<td><span class="term"><i><tt>from</tt></i>:</span></td>
<td>the starting point of the transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>to</tt></i>:</span></td>
<td>the target point of the transition or NULL</td>
</tr>
<tr>
<td><span class="term"><i><tt>lax</tt></i>:</span></td>
<td>allow to transition if not all all transitions have been activated</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the target state or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAutomataNewCountTrans"></a>xmlAutomataNewCountTrans ()</h3>
<pre class="programlisting"><a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> xmlAutomataNewCountTrans (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> from, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> to, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * token, <br> int min, <br> int max, <br> void * data)<br>
</pre>
<p>If @to is NULL, this creates first a new target state in the automata and then adds a transition from the @from state to the target state activated by a succession of input of value @token and whose number is between @min and @max</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>am</tt></i>:</span></td>
<td>an automata</td>
</tr>
<tr>
<td><span class="term"><i><tt>from</tt></i>:</span></td>
<td>the starting point of the transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>to</tt></i>:</span></td>
<td>the target point of the transition or NULL</td>
</tr>
<tr>
<td><span class="term"><i><tt>token</tt></i>:</span></td>
<td>the input string associated to that transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>min</tt></i>:</span></td>
<td>the minimum successive occurrences of token</td>
</tr>
<tr>
<td><span class="term"><i><tt>max</tt></i>:</span></td>
<td>the maximum successive occurrences of token</td>
</tr>
<tr>
<td><span class="term"><i><tt>data</tt></i>:</span></td>
<td>data associated to the transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the target state or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAutomataNewCountTrans2"></a>xmlAutomataNewCountTrans2 ()</h3>
<pre class="programlisting"><a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> xmlAutomataNewCountTrans2 (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> from, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> to, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * token, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * token2, <br> int min, <br> int max, <br> void * data)<br>
</pre>
<p>If @to is NULL, this creates first a new target state in the automata and then adds a transition from the @from state to the target state activated by a succession of input of value @token and @token2 and whose number is between @min and @max</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>am</tt></i>:</span></td>
<td>an automata</td>
</tr>
<tr>
<td><span class="term"><i><tt>from</tt></i>:</span></td>
<td>the starting point of the transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>to</tt></i>:</span></td>
<td>the target point of the transition or NULL</td>
</tr>
<tr>
<td><span class="term"><i><tt>token</tt></i>:</span></td>
<td>the input string associated to that transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>token2</tt></i>:</span></td>
<td>the second input string associated to that transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>min</tt></i>:</span></td>
<td>the minimum successive occurrences of token</td>
</tr>
<tr>
<td><span class="term"><i><tt>max</tt></i>:</span></td>
<td>the maximum successive occurrences of token</td>
</tr>
<tr>
<td><span class="term"><i><tt>data</tt></i>:</span></td>
<td>data associated to the transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the target state or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAutomataNewCountedTrans"></a>xmlAutomataNewCountedTrans ()</h3>
<pre class="programlisting"><a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> xmlAutomataNewCountedTrans (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> from, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> to, <br> int counter)<br>
</pre>
<p>If @to is NULL, this creates first a new target state in the automata and then adds an epsilon transition from the @from state to the target state which will increment the counter provided</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>am</tt></i>:</span></td>
<td>an automata</td>
</tr>
<tr>
<td><span class="term"><i><tt>from</tt></i>:</span></td>
<td>the starting point of the transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>to</tt></i>:</span></td>
<td>the target point of the transition or NULL</td>
</tr>
<tr>
<td><span class="term"><i><tt>counter</tt></i>:</span></td>
<td>the counter associated to that transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the target state or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAutomataNewCounter"></a>xmlAutomataNewCounter ()</h3>
<pre class="programlisting">int xmlAutomataNewCounter (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> int min, <br> int max)<br>
</pre>
<p>Create a new counter</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>am</tt></i>:</span></td>
<td>an automata</td>
</tr>
<tr>
<td><span class="term"><i><tt>min</tt></i>:</span></td>
<td>the minimal value on the counter</td>
</tr>
<tr>
<td><span class="term"><i><tt>max</tt></i>:</span></td>
<td>the maximal value on the counter</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the counter number or -1 in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAutomataNewCounterTrans"></a>xmlAutomataNewCounterTrans ()</h3>
<pre class="programlisting"><a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> xmlAutomataNewCounterTrans (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> from, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> to, <br> int counter)<br>
</pre>
<p>If @to is NULL, this creates first a new target state in the automata and then adds an epsilon transition from the @from state to the target state which will be allowed only if the counter is within the right range.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>am</tt></i>:</span></td>
<td>an automata</td>
</tr>
<tr>
<td><span class="term"><i><tt>from</tt></i>:</span></td>
<td>the starting point of the transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>to</tt></i>:</span></td>
<td>the target point of the transition or NULL</td>
</tr>
<tr>
<td><span class="term"><i><tt>counter</tt></i>:</span></td>
<td>the counter associated to that transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the target state or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAutomataNewEpsilon"></a>xmlAutomataNewEpsilon ()</h3>
<pre class="programlisting"><a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> xmlAutomataNewEpsilon (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> from, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> to)<br>
</pre>
<p>If @to is NULL, this creates first a new target state in the automata and then adds an epsilon transition from the @from state to the target state</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>am</tt></i>:</span></td>
<td>an automata</td>
</tr>
<tr>
<td><span class="term"><i><tt>from</tt></i>:</span></td>
<td>the starting point of the transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>to</tt></i>:</span></td>
<td>the target point of the transition or NULL</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the target state or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAutomataNewNegTrans"></a>xmlAutomataNewNegTrans ()</h3>
<pre class="programlisting"><a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> xmlAutomataNewNegTrans (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> from, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> to, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * token, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * token2, <br> void * data)<br>
</pre>
<p>If @to is NULL, this creates first a new target state in the automata and then adds a transition from the @from state to the target state activated by any value except (@token,@token2) Note that if @token2 is not NULL, then (X, NULL) won't match to follow # the semantic of XSD ##other</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>am</tt></i>:</span></td>
<td>an automata</td>
</tr>
<tr>
<td><span class="term"><i><tt>from</tt></i>:</span></td>
<td>the starting point of the transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>to</tt></i>:</span></td>
<td>the target point of the transition or NULL</td>
</tr>
<tr>
<td><span class="term"><i><tt>token</tt></i>:</span></td>
<td>the first input string associated to that transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>token2</tt></i>:</span></td>
<td>the second input string associated to that transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>data</tt></i>:</span></td>
<td>data passed to the callback function if the transition is activated</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the target state or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAutomataNewOnceTrans"></a>xmlAutomataNewOnceTrans ()</h3>
<pre class="programlisting"><a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> xmlAutomataNewOnceTrans (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> from, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> to, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * token, <br> int min, <br> int max, <br> void * data)<br>
</pre>
<p>If @to is NULL, this creates first a new target state in the automata and then adds a transition from the @from state to the target state activated by a succession of input of value @token and whose number is between @min and @max, moreover that transition can only be crossed once.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>am</tt></i>:</span></td>
<td>an automata</td>
</tr>
<tr>
<td><span class="term"><i><tt>from</tt></i>:</span></td>
<td>the starting point of the transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>to</tt></i>:</span></td>
<td>the target point of the transition or NULL</td>
</tr>
<tr>
<td><span class="term"><i><tt>token</tt></i>:</span></td>
<td>the input string associated to that transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>min</tt></i>:</span></td>
<td>the minimum successive occurrences of token</td>
</tr>
<tr>
<td><span class="term"><i><tt>max</tt></i>:</span></td>
<td>the maximum successive occurrences of token</td>
</tr>
<tr>
<td><span class="term"><i><tt>data</tt></i>:</span></td>
<td>data associated to the transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the target state or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAutomataNewOnceTrans2"></a>xmlAutomataNewOnceTrans2 ()</h3>
<pre class="programlisting"><a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> xmlAutomataNewOnceTrans2 (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> from, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> to, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * token, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * token2, <br> int min, <br> int max, <br> void * data)<br>
</pre>
<p>If @to is NULL, this creates first a new target state in the automata and then adds a transition from the @from state to the target state activated by a succession of input of value @token and @token2 and whose number is between @min and @max, moreover that transition can only be crossed once.</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>am</tt></i>:</span></td>
<td>an automata</td>
</tr>
<tr>
<td><span class="term"><i><tt>from</tt></i>:</span></td>
<td>the starting point of the transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>to</tt></i>:</span></td>
<td>the target point of the transition or NULL</td>
</tr>
<tr>
<td><span class="term"><i><tt>token</tt></i>:</span></td>
<td>the input string associated to that transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>token2</tt></i>:</span></td>
<td>the second input string associated to that transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>min</tt></i>:</span></td>
<td>the minimum successive occurrences of token</td>
</tr>
<tr>
<td><span class="term"><i><tt>max</tt></i>:</span></td>
<td>the maximum successive occurrences of token</td>
</tr>
<tr>
<td><span class="term"><i><tt>data</tt></i>:</span></td>
<td>data associated to the transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the target state or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAutomataNewState"></a>xmlAutomataNewState ()</h3>
<pre class="programlisting"><a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> xmlAutomataNewState (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am)<br>
</pre>
<p>Create a new disconnected state in the automata</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>am</tt></i>:</span></td>
<td>an automata</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the new state or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAutomataNewTransition"></a>xmlAutomataNewTransition ()</h3>
<pre class="programlisting"><a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> xmlAutomataNewTransition (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> from, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> to, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * token, <br> void * data)<br>
</pre>
<p>If @to is NULL, this creates first a new target state in the automata and then adds a transition from the @from state to the target state activated by the value of @token</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>am</tt></i>:</span></td>
<td>an automata</td>
</tr>
<tr>
<td><span class="term"><i><tt>from</tt></i>:</span></td>
<td>the starting point of the transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>to</tt></i>:</span></td>
<td>the target point of the transition or NULL</td>
</tr>
<tr>
<td><span class="term"><i><tt>token</tt></i>:</span></td>
<td>the input string associated to that transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>data</tt></i>:</span></td>
<td>data passed to the callback function if the transition is activated</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the target state or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAutomataNewTransition2"></a>xmlAutomataNewTransition2 ()</h3>
<pre class="programlisting"><a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> xmlAutomataNewTransition2 (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> from, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> to, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * token, <br> const <a href="libxml2-xmlstring.html#xmlChar">xmlChar</a> * token2, <br> void * data)<br>
</pre>
<p>If @to is NULL, this creates first a new target state in the automata and then adds a transition from the @from state to the target state activated by the value of @token</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>am</tt></i>:</span></td>
<td>an automata</td>
</tr>
<tr>
<td><span class="term"><i><tt>from</tt></i>:</span></td>
<td>the starting point of the transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>to</tt></i>:</span></td>
<td>the target point of the transition or NULL</td>
</tr>
<tr>
<td><span class="term"><i><tt>token</tt></i>:</span></td>
<td>the first input string associated to that transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>token2</tt></i>:</span></td>
<td>the second input string associated to that transition</td>
</tr>
<tr>
<td><span class="term"><i><tt>data</tt></i>:</span></td>
<td>data passed to the callback function if the transition is activated</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the target state or NULL in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlAutomataSetFinalState"></a>xmlAutomataSetFinalState ()</h3>
<pre class="programlisting">int xmlAutomataSetFinalState (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am, <br> <a href="libxml2-xmlautomata.html#xmlAutomataStatePtr">xmlAutomataStatePtr</a> state)<br>
</pre>
<p>Makes that state a final state</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody>
<tr>
<td><span class="term"><i><tt>am</tt></i>:</span></td>
<td>an automata</td>
</tr>
<tr>
<td><span class="term"><i><tt>state</tt></i>:</span></td>
<td>a state in this automata</td>
</tr>
<tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>0 or -1 in case of error</td>
</tr>
</tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlFreeAutomata"></a>xmlFreeAutomata ()</h3>
<pre class="programlisting">void xmlFreeAutomata (<a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> am)<br>
</pre>
<p>Free an automata</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>am</tt></i>:</span></td>
<td>an automata</td>
</tr></tbody>
</table></div>
</div>
<hr>
<div class="refsect2" lang="en">
<h3>
<a name="xmlNewAutomata"></a>xmlNewAutomata ()</h3>
<pre class="programlisting"><a href="libxml2-xmlautomata.html#xmlAutomataPtr">xmlAutomataPtr</a> xmlNewAutomata (void)<br>
</pre>
<p>Create a new automata</p>
<div class="variablelist"><table border="0">
<col align="left">
<tbody><tr>
<td><span class="term"><i><tt>Returns</tt></i>:</span></td>
<td>the new object or NULL in case of failure</td>
</tr></tbody>
</table></div>
</div>
<hr>
</div>
</div>
</body>
</html>
�PNG
IHDR �w=� bKGD � � ����� pHYs ��~� tIME�2.�E�� #IDATx��=J�@ F�o�]
!+��2��[Z�<@/�<����X�
ڭ�2�0v����
�j0�l�vV��A`��� �t*i��Hҭ~x�R~'IUU�9�#O��my�eJ�TeY�Gv�@x�O#�;2E>9��|t$D�9nnB���j��BRIsI��:H�8�U�����P��N�1fc�sN�95M㧖ɵ� � 束��1~�pE�e $�I���� �7nrD� f!;�`����'