attribute ()

void	attribute			(void * ctx, 
					 const xmlChar * fullname, 
					 const xmlChar * 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. DEPRECATED: use xmlSAX2Attribute()

attributeDecl ()

void	attributeDecl			(void * ctx, 
					 const xmlChar * elem, 
					 const xmlChar * fullname, 
					 int type, 
					 int def, 
					 const xmlChar * defaultValue, 
					 xmlEnumerationPtr tree)

An attribute definition has been parsed DEPRECATED: use xmlSAX2AttributeDecl()

cdataBlock ()

void	cdataBlock			(void * ctx, 
					 const xmlChar * value, 
					 int len)

called when a pcdata block has been parsed DEPRECATED: use xmlSAX2CDataBlock()

characters ()

void	characters			(void * ctx, 
					 const xmlChar * ch, 
					 int len)

receiving some chars from the parser. DEPRECATED: use xmlSAX2Characters()

checkNamespace ()

int	checkNamespace			(void * ctx, 
					 xmlChar * namespace)

Check that the current element namespace is the same as the one read upon parsing. DEPRECATED

comment ()

void	comment			(void * ctx, 
					 const xmlChar * value)

A comment has been parsed. DEPRECATED: use xmlSAX2Comment()

elementDecl ()

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

An element definition has been parsed DEPRECATED: use xmlSAX2ElementDecl()

endDocument ()

void	endDocument			(void * ctx)

called when the document end has been detected. DEPRECATED: use xmlSAX2EndDocument()

endElement ()

void	endElement			(void * ctx, 
					 const xmlChar * name)

called when the end of an element has been detected. DEPRECATED: use xmlSAX2EndElement()

entityDecl ()

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

An entity definition has been parsed DEPRECATED: use xmlSAX2EntityDecl()

externalSubset ()

void	externalSubset			(void * ctx, 
					 const xmlChar * name, 
					 const xmlChar * ExternalID, 
					 const xmlChar * SystemID)

Callback on external subset declaration. DEPRECATED: use xmlSAX2ExternalSubset()

getColumnNumber ()

int	getColumnNumber			(void * ctx)

Provide the column number of the current parsing point. DEPRECATED: use xmlSAX2GetColumnNumber()

getEntity ()

xmlEntityPtr	getEntity		(void * ctx, 
					 const xmlChar * name)

Get an entity by name DEPRECATED: use xmlSAX2GetEntity()

getLineNumber ()

int	getLineNumber			(void * ctx)

Provide the line number of the current parsing point. DEPRECATED: use xmlSAX2GetLineNumber()

getNamespace ()

xmlNsPtr	getNamespace		(void * ctx)

Get the current element namespace. DEPRECATED

getParameterEntity ()

xmlEntityPtr	getParameterEntity	(void * ctx, 
					 const xmlChar * name)

Get a parameter entity by name DEPRECATED: use xmlSAX2GetParameterEntity()

getPublicId ()

const xmlChar *	getPublicId		(void * ctx)

Provides the public ID e.g. "-//SGMLSOURCE//DTD DEMO//EN" DEPRECATED: use xmlSAX2GetPublicId()

getSystemId ()

const xmlChar *	getSystemId		(void * ctx)

Provides the system ID, basically URL or filename e.g. http://www.sgmlsource.com/dtds/memo.dtd DEPRECATED: use xmlSAX2GetSystemId()

globalNamespace ()

void	globalNamespace			(void * ctx, 
					 const xmlChar * href, 
					 const xmlChar * prefix)

An old global namespace has been parsed. DEPRECATED

hasExternalSubset ()

int	hasExternalSubset		(void * ctx)

Does this document has an external subset DEPRECATED: use xmlSAX2HasExternalSubset()

hasInternalSubset ()

int	hasInternalSubset		(void * ctx)

Does this document has an internal subset DEPRECATED: use xmlSAX2HasInternalSubset()

ignorableWhitespace ()

void	ignorableWhitespace		(void * ctx, 
					 const xmlChar * ch, 
					 int len)

receiving some ignorable whitespaces from the parser. UNUSED: by default the DOM building will use characters DEPRECATED: use xmlSAX2IgnorableWhitespace()

inithtmlDefaultSAXHandler ()

void	inithtmlDefaultSAXHandler	(xmlSAXHandlerV1 * hdlr)

Initialize the default HTML SAX version 1 handler DEPRECATED: use xmlSAX2InitHtmlDefaultSAXHandler() for the new SAX2 blocks

initxmlDefaultSAXHandler ()

void	initxmlDefaultSAXHandler	(xmlSAXHandlerV1 * hdlr, 
					 int warning)

Initialize the default XML SAX version 1 handler DEPRECATED: use xmlSAX2InitDefaultSAXHandler() for the new SAX2 blocks

internalSubset ()

void	internalSubset			(void * ctx, 
					 const xmlChar * name, 
					 const xmlChar * ExternalID, 
					 const xmlChar * SystemID)

Callback on internal subset declaration. DEPRECATED: use xmlSAX2InternalSubset()

isStandalone ()

int	isStandalone			(void * ctx)

Is this document tagged standalone ? DEPRECATED: use xmlSAX2IsStandalone()

namespaceDecl ()

void	namespaceDecl			(void * ctx, 
					 const xmlChar * href, 
					 const xmlChar * prefix)

A namespace has been parsed. DEPRECATED

notationDecl ()

void	notationDecl			(void * ctx, 
					 const xmlChar * name, 
					 const xmlChar * publicId, 
					 const xmlChar * systemId)

What to do when a notation declaration has been parsed. DEPRECATED: use xmlSAX2NotationDecl()

processingInstruction ()

void	processingInstruction		(void * ctx, 
					 const xmlChar * target, 
					 const xmlChar * data)

A processing instruction has been parsed. DEPRECATED: use xmlSAX2ProcessingInstruction()

reference ()

void	reference			(void * ctx, 
					 const xmlChar * name)

called when an entity reference is detected. DEPRECATED: use xmlSAX2Reference()

resolveEntity ()

xmlParserInputPtr	resolveEntity	(void * ctx, 
					 const xmlChar * publicId, 
					 const xmlChar * systemId)

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 DEPRECATED: use xmlSAX2ResolveEntity()

setDocumentLocator ()

void	setDocumentLocator		(void * ctx, 
					 xmlSAXLocatorPtr loc)

Receive the document locator at startup, actually xmlDefaultSAXLocator Everything is available on the context, so this is useless in our case. DEPRECATED

setNamespace ()

void	setNamespace			(void * ctx, 
					 const xmlChar * name)

Set the current element namespace. DEPRECATED

startDocument ()

void	startDocument			(void * ctx)

called when the document start being processed. DEPRECATED: use xmlSAX2StartDocument()

startElement ()

void	startElement			(void * ctx, 
					 const xmlChar * fullname, 
					 const xmlChar ** atts)

called when an opening tag has been processed. DEPRECATED: use xmlSAX2StartElement()

unparsedEntityDecl ()

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

What to do when an unparsed entity declaration is parsed DEPRECATED: use xmlSAX2UnparsedEntityDecl()

Macro HTML_COMMENT_NODE

#define HTML_COMMENT_NODE;

Macro. A comment in a HTML document is really implemented the same way as a comment in an XML document.

Macro HTML_ENTITY_REF_NODE

#define 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.

Macro HTML_PI_NODE

#define 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.

Macro HTML_PRESERVE_NODE

#define 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.

Macro HTML_TEXT_NODE

#define 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.

htmlDocContentDumpFormatOutput ()

void	htmlDocContentDumpFormatOutput	(xmlOutputBufferPtr buf, 
					 xmlDocPtr cur, 
					 const char * encoding, 
					 int format)

Dump an HTML document.

htmlDocContentDumpOutput ()

void	htmlDocContentDumpOutput	(xmlOutputBufferPtr buf, 
					 xmlDocPtr cur, 
					 const char * encoding)

Dump an HTML document. Formatting return/spaces are added.

htmlDocDump ()

int	htmlDocDump			(FILE * f, 
					 xmlDocPtr cur)

Dump an HTML document to an open FILE.

htmlDocDumpMemory ()

void	htmlDocDumpMemory		(xmlDocPtr cur, 
					 xmlChar ** mem, 
					 int * size)

Dump an HTML document in memory and return the xmlChar * and it's size. It's up to the caller to free the memory.

htmlDocDumpMemoryFormat ()

void	htmlDocDumpMemoryFormat		(xmlDocPtr cur, 
					 xmlChar ** mem, 
					 int * size, 
					 int format)

Dump an HTML document in memory and return the xmlChar * and it's size. It's up to the caller to free the memory.

htmlGetMetaEncoding ()

const xmlChar *	htmlGetMetaEncoding	(htmlDocPtr doc)

Encoding definition lookup in the Meta tags

htmlIsBooleanAttr ()

int	htmlIsBooleanAttr		(const xmlChar * name)

Determine if a given attribute is a boolean attribute.

htmlNewDoc ()

htmlDocPtr	htmlNewDoc		(const xmlChar * URI, 
					 const xmlChar * ExternalID)

Creates a new HTML document

htmlNewDocNoDtD ()

htmlDocPtr	htmlNewDocNoDtD		(const xmlChar * URI, 
					 const xmlChar * ExternalID)

Creates a new HTML document without a DTD node if @URI and @ExternalID are NULL

htmlNodeDump ()

int	htmlNodeDump			(xmlBufferPtr buf, 
					 xmlDocPtr doc, 
					 xmlNodePtr cur)

Dump an HTML node, recursive behaviour,children are printed too, and formatting returns are added.

htmlNodeDumpFile ()

void	htmlNodeDumpFile		(FILE * out, 
					 xmlDocPtr doc, 
					 xmlNodePtr cur)

Dump an HTML node, recursive behaviour,children are printed too, and formatting returns are added.

htmlNodeDumpFileFormat ()

int	htmlNodeDumpFileFormat		(FILE * out, 
					 xmlDocPtr doc, 
					 xmlNodePtr cur, 
					 const char * encoding, 
					 int format)

Dump an HTML node, recursive behaviour,children are printed too. TODO: if encoding == NULL try to save in the doc encoding

htmlNodeDumpFormatOutput ()

void	htmlNodeDumpFormatOutput	(xmlOutputBufferPtr buf, 
					 xmlDocPtr doc, 
					 xmlNodePtr cur, 
					 const char * encoding, 
					 int format)

Dump an HTML node, recursive behaviour,children are printed too.

htmlNodeDumpOutput ()

void	htmlNodeDumpOutput		(xmlOutputBufferPtr buf, 
					 xmlDocPtr doc, 
					 xmlNodePtr cur, 
					 const char * encoding)

Dump an HTML node, recursive behaviour,children are printed too, and formatting returns/spaces are added.

htmlSaveFile ()

int	htmlSaveFile			(const char * filename, 
					 xmlDocPtr cur)

Dump an HTML document to a file. If @filename is "-" the stdout file is used.

htmlSaveFileEnc ()

int	htmlSaveFileEnc			(const char * filename, 
					 xmlDocPtr cur, 
					 const char * encoding)

Dump an HTML document to a file using a given encoding and formatting returns/spaces are added.

htmlSaveFileFormat ()

int	htmlSaveFileFormat		(const char * filename, 
					 xmlDocPtr cur, 
					 const char * encoding, 
					 int format)

Dump an HTML document to a file using a given encoding.

htmlSetMetaEncoding ()

int	htmlSetMetaEncoding		(htmlDocPtr doc, 
					 const xmlChar * encoding)

Sets the current encoding in the Meta tags NOTE: this will not change the document content encoding, just the META flag associated.

Structure xmlAutomata

struct _xmlAutomata {
The content of this structure is not made public by the API.
} xmlAutomata;

Typedef xmlAutomataPtr

xmlAutomata * xmlAutomataPtr;

A libxml automata description, It can be compiled into a regexp

Structure xmlAutomataState

struct _xmlAutomataState {
The content of this structure is not made public by the API.
} xmlAutomataState;

Typedef xmlAutomataStatePtr

xmlAutomataState * xmlAutomataStatePtr;

A state int the automata description,

xmlAutomataCompile ()

xmlRegexpPtr	xmlAutomataCompile	(xmlAutomataPtr am)

Compile the automata into a Reg Exp ready for being executed. The automata should be free after this point.

xmlAutomataGetInitState ()

xmlAutomataStatePtr	xmlAutomataGetInitState	(xmlAutomataPtr am)

Initial state lookup

xmlAutomataIsDeterminist ()

int	xmlAutomataIsDeterminist	(xmlAutomataPtr am)

Checks if an automata is determinist.

xmlAutomataNewAllTrans ()

xmlAutomataStatePtr	xmlAutomataNewAllTrans	(xmlAutomataPtr am, 
						 xmlAutomataStatePtr from, 
						 xmlAutomataStatePtr to, 
						 int lax)

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.

xmlAutomataNewCountTrans ()

xmlAutomataStatePtr	xmlAutomataNewCountTrans	(xmlAutomataPtr am, 
							 xmlAutomataStatePtr from, 
							 xmlAutomataStatePtr to, 
							 const xmlChar * token, 
							 int min, 
							 int max, 
							 void * data)

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

xmlAutomataNewCountTrans2 ()

xmlAutomataStatePtr	xmlAutomataNewCountTrans2	(xmlAutomataPtr am, 
							 xmlAutomataStatePtr from, 
							 xmlAutomataStatePtr to, 
							 const xmlChar * token, 
							 const xmlChar * token2, 
							 int min, 
							 int max, 
							 void * data)

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

xmlAutomataNewCountedTrans ()

xmlAutomataStatePtr	xmlAutomataNewCountedTrans	(xmlAutomataPtr am, 
							 xmlAutomataStatePtr from, 
							 xmlAutomataStatePtr to, 
							 int counter)

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

xmlAutomataNewCounter ()

int	xmlAutomataNewCounter		(xmlAutomataPtr am, 
					 int min, 
					 int max)

Create a new counter

xmlAutomataNewCounterTrans ()

xmlAutomataStatePtr	xmlAutomataNewCounterTrans	(xmlAutomataPtr am, 
							 xmlAutomataStatePtr from, 
							 xmlAutomataStatePtr to, 
							 int counter)

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.

xmlAutomataNewEpsilon ()

xmlAutomataStatePtr	xmlAutomataNewEpsilon	(xmlAutomataPtr am, 
						 xmlAutomataStatePtr from, 
						 xmlAutomataStatePtr to)

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

xmlAutomataNewNegTrans ()

xmlAutomataStatePtr	xmlAutomataNewNegTrans	(xmlAutomataPtr am, 
						 xmlAutomataStatePtr from, 
						 xmlAutomataStatePtr to, 
						 const xmlChar * token, 
						 const xmlChar * token2, 
						 void * data)

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

xmlAutomataNewOnceTrans ()

xmlAutomataStatePtr	xmlAutomataNewOnceTrans	(xmlAutomataPtr am, 
						 xmlAutomataStatePtr from, 
						 xmlAutomataStatePtr to, 
						 const xmlChar * token, 
						 int min, 
						 int max, 
						 void * data)

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.

xmlAutomataNewOnceTrans2 ()

xmlAutomataStatePtr	xmlAutomataNewOnceTrans2	(xmlAutomataPtr am, 
							 xmlAutomataStatePtr from, 
							 xmlAutomataStatePtr to, 
							 const xmlChar * token, 
							 const xmlChar * token2, 
							 int min, 
							 int max, 
							 void * data)

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.

xmlAutomataNewState ()

xmlAutomataStatePtr	xmlAutomataNewState	(xmlAutomataPtr am)

Create a new disconnected state in the automata

xmlAutomataNewTransition ()

xmlAutomataStatePtr	xmlAutomataNewTransition	(xmlAutomataPtr am, 
							 xmlAutomataStatePtr from, 
							 xmlAutomataStatePtr to, 
							 const xmlChar * token, 
							 void * data)

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

xmlAutomataNewTransition2 ()

xmlAutomataStatePtr	xmlAutomataNewTransition2	(xmlAutomataPtr am, 
							 xmlAutomataStatePtr from, 
							 xmlAutomataStatePtr to, 
							 const xmlChar * token, 
							 const xmlChar * token2, 
							 void * data)

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

xmlAutomataSetFinalState ()

int	xmlAutomataSetFinalState	(xmlAutomataPtr am, 
					 xmlAutomataStatePtr state)

Makes that state a final state

xmlFreeAutomata ()

void	xmlFreeAutomata			(xmlAutomataPtr am)

Free an automata

xmlNewAutomata ()

xmlAutomataPtr	xmlNewAutomata		(void)

Create a new automata

Structure xmlModule

struct _xmlModule {
The content of this structure is not made public by the API.
} xmlModule;

Enum xmlModuleOption

enum xmlModuleOption {
    XML_MODULE_LAZY = 1 /* lazy binding */
    XML_MODULE_LOCAL = 2 /*  local binding */
};

Typedef xmlModulePtr

xmlModule * xmlModulePtr;

A handle to a dynamically loaded module

xmlModuleClose ()

int	xmlModuleClose			(xmlModulePtr module)

The close operations unload the associated module and free the data associated to the module.

xmlModuleFree ()

int	xmlModuleFree			(xmlModulePtr module)

The free operations free the data associated to the module but does not unload the associated shared library which may still be in use.

xmlModuleOpen ()

xmlModulePtr	xmlModuleOpen		(const char * name, 
					 int options)

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 xmlChar * . TODO: options are not yet implemented.

xmlModuleSymbol ()

int	xmlModuleSymbol			(xmlModulePtr module, 
					 const char * name, 
					 void ** symbol)

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 xmlChar * .

Enum xmlCharEncoding

enum xmlCharEncoding {
    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 */
};

Structure xmlCharEncodingHandler

struct _xmlCharEncodingHandler {
    char *	name
    xmlCharEncodingInputFunc	input
    xmlCharEncodingOutputFunc	output
    iconv_t	iconv_in
    iconv_t	iconv_out
    struct _uconv_t *	uconv_in
    struct _uconv_t *	uconv_out
} xmlCharEncodingHandler;

Typedef xmlCharEncodingHandlerPtr

xmlCharEncodingHandler * xmlCharEncodingHandlerPtr;

Function type xmlCharEncodingInputFunc

int	xmlCharEncodingInputFunc	(unsigned char * out, 
					 int * outlen, 
					 const unsigned char * in, 
					 int * inlen)

Take a block of chars in the original encoding and try to convert it to an UTF-8 block of chars out.

Function type xmlCharEncodingOutputFunc

int	xmlCharEncodingOutputFunc	(unsigned char * out, 
					 int * outlen, 
					 const unsigned char * in, 
					 int * inlen)

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.

UTF8Toisolat1 ()

int	UTF8Toisolat1			(unsigned char * out, 
					 int * outlen, 
					 const unsigned char * in, 
					 int * inlen)

Take a block of UTF-8 chars in and try to convert it to an ISO Latin 1 block of chars out.

isolat1ToUTF8 ()

int	isolat1ToUTF8			(unsigned char * out, 
					 int * outlen, 
					 const unsigned char * in, 
					 int * inlen)

Take a block of ISO Latin 1 chars in and try to convert it to an UTF-8 block of chars out.

xmlAddEncodingAlias ()

int	xmlAddEncodingAlias		(const char * name, 
					 const char * alias)

Registers an alias @alias for an encoding named @name. Existing alias will be overwritten.

xmlCharEncCloseFunc ()

int	xmlCharEncCloseFunc		(xmlCharEncodingHandler * handler)

Generic front-end for encoding handler close function

xmlCharEncFirstLine ()

int	xmlCharEncFirstLine		(xmlCharEncodingHandler * handler, 
					 xmlBufferPtr out, 
					 xmlBufferPtr in)

Front-end for the encoding handler input function, but handle only the very first line, i.e. limit itself to 45 chars.

xmlCharEncInFunc ()

int	xmlCharEncInFunc		(xmlCharEncodingHandler * handler, 
					 xmlBufferPtr out, 
					 xmlBufferPtr in)

Generic front-end for the encoding handler input function

xmlCharEncOutFunc ()

int	xmlCharEncOutFunc		(xmlCharEncodingHandler * handler, 
					 xmlBufferPtr out, 
					 xmlBufferPtr in)

Generic front-end for the encoding handler output function a first call with @in == NULL has to be made firs to initiate the output in case of non-stateless encoding needing to initiate their state or the output (like the BOM in UTF16). In case of UTF8 sequence conversion errors for the given encoder, the content will be automatically remapped to a CharRef sequence.

xmlCleanupCharEncodingHandlers ()

void	xmlCleanupCharEncodingHandlers	(void)

DEPRECATED: This function will be made private. Call xmlCleanupParser to free global state but see the warnings there. xmlCleanupParser should be only called once at program exit. In most cases, you don't have call cleanup functions at all. Cleanup the memory allocated for the char encoding support, it unregisters all the encoding handlers and the aliases.

xmlCleanupEncodingAliases ()

void	xmlCleanupEncodingAliases	(void)

Unregisters all aliases

xmlDelEncodingAlias ()

int	xmlDelEncodingAlias		(const char * alias)

Unregisters an encoding alias @alias

xmlDetectCharEncoding ()

xmlCharEncoding	xmlDetectCharEncoding	(const unsigned char * in, 
					 int len)

Guess the encoding of the entity using the first bytes of the entity content according to the non-normative appendix F of the XML-1.0 recommendation.

xmlFindCharEncodingHandler ()

xmlCharEncodingHandlerPtr	xmlFindCharEncodingHandler	(const char * name)

Search in the registered set the handler able to read/write that encoding.

xmlGetCharEncodingHandler ()

xmlCharEncodingHandlerPtr	xmlGetCharEncodingHandler	(xmlCharEncoding enc)

Search in the registered set the handler able to read/write that encoding.

xmlGetCharEncodingName ()

const char *	xmlGetCharEncodingName	(xmlCharEncoding enc)

The "canonical" name for XML encoding. C.f. http://www.w3.org/TR/REC-xml#charencoding Section 4.3.3 Character Encoding in Entities

xmlGetEncodingAlias ()

const char *	xmlGetEncodingAlias	(const char * alias)

Lookup an encoding name for the given alias.

xmlInitCharEncodingHandlers ()

void	xmlInitCharEncodingHandlers	(void)

DEPRECATED: This function will be made private. Call xmlInitParser to initialize the library. Initialize the char encoding support, it registers the default encoding supported. NOTE: while public, this function usually doesn't need to be called in normal processing.

xmlNewCharEncodingHandler ()

xmlCharEncodingHandlerPtr	xmlNewCharEncodingHandler	(const char * name, 
							 xmlCharEncodingInputFunc input, 
							 xmlCharEncodingOutputFunc output)

Create and registers an xmlCharEncodingHandler.

xmlParseCharEncoding ()

xmlCharEncoding	xmlParseCharEncoding	(const char * name)

Compare the string to the encoding schemes already known. Note that the comparison is case insensitive accordingly to the section [XML] 4.3.3 Character Encoding in Entities.

xmlRegisterCharEncodingHandler ()

void	xmlRegisterCharEncodingHandler	(xmlCharEncodingHandlerPtr handler)

Register the char encoding handler, surprising, isn't it ?

Structure xmlGlobalState

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
} xmlGlobalState;

Typedef xmlGlobalStatePtr

xmlGlobalState * xmlGlobalStatePtr;

Function type xmlDeregisterNodeFunc

void	xmlDeregisterNodeFunc		(xmlNodePtr node)

Signature for the deregistration callback of a discarded node

Function type xmlOutputBufferCreateFilenameFunc

xmlOutputBufferPtr	xmlOutputBufferCreateFilenameFunc	(const char * URI, 
							 xmlCharEncodingHandlerPtr encoder, 
							 int compression)

Signature for the function doing the lookup for a suitable output method corresponding to an URI.

Function type xmlParserInputBufferCreateFilenameFunc

xmlParserInputBufferPtr	xmlParserInputBufferCreateFilenameFunc	(const char * URI, 
							 xmlCharEncoding enc)

Signature for the function doing the lookup for a suitable input method corresponding to an URI.

Function type xmlRegisterNodeFunc

void	xmlRegisterNodeFunc		(xmlNodePtr node)

Signature for the registration callback of a created node

Variable htmlDefaultSAXHandler

xmlSAXHandlerV1 htmlDefaultSAXHandler;

Variable oldXMLWDcompatibility

int oldXMLWDcompatibility;

Variable xmlBufferAllocScheme

xmlBufferAllocationScheme xmlBufferAllocScheme;

Variable xmlDefaultBufferSize

int xmlDefaultBufferSize;

Variable xmlDefaultSAXHandler

xmlSAXHandlerV1 xmlDefaultSAXHandler;

Variable xmlDefaultSAXLocator

xmlSAXLocator xmlDefaultSAXLocator;

Variable xmlDeregisterNodeDefaultValue

xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValue;

Variable xmlDoValidityCheckingDefaultValue

int xmlDoValidityCheckingDefaultValue;

Variable xmlFree

xmlFreeFunc xmlFree;

Variable xmlGenericError

xmlGenericErrorFunc xmlGenericError;

Variable xmlGenericErrorContext

void * xmlGenericErrorContext;

Variable xmlGetWarningsDefaultValue

int xmlGetWarningsDefaultValue;

Variable xmlIndentTreeOutput

int xmlIndentTreeOutput;

Variable xmlKeepBlanksDefaultValue

int xmlKeepBlanksDefaultValue;

Variable xmlLastError

xmlError xmlLastError;

Variable xmlLineNumbersDefaultValue

int xmlLineNumbersDefaultValue;

Variable xmlLoadExtDtdDefaultValue

int xmlLoadExtDtdDefaultValue;

Variable xmlMalloc

xmlMallocFunc xmlMalloc;

Variable xmlMallocAtomic

xmlMallocFunc xmlMallocAtomic;

Variable xmlMemStrdup

xmlStrdupFunc xmlMemStrdup;

Variable xmlOutputBufferCreateFilenameValue

xmlOutputBufferCreateFilenameFunc xmlOutputBufferCreateFilenameValue;

Variable xmlParserDebugEntities

int xmlParserDebugEntities;

Variable xmlParserInputBufferCreateFilenameValue

xmlParserInputBufferCreateFilenameFunc xmlParserInputBufferCreateFilenameValue;

Variable xmlParserVersion

const char * xmlParserVersion;

Variable xmlPedanticParserDefaultValue

int xmlPedanticParserDefaultValue;

Variable xmlRealloc

xmlReallocFunc xmlRealloc;

Variable xmlRegisterNodeDefaultValue

xmlRegisterNodeFunc xmlRegisterNodeDefaultValue;

Variable xmlSaveNoEmptyTags

int xmlSaveNoEmptyTags;

Variable xmlStructuredError

xmlStructuredErrorFunc xmlStructuredError;

Variable xmlStructuredErrorContext

void * xmlStructuredErrorContext;

Variable xmlSubstituteEntitiesDefaultValue

int xmlSubstituteEntitiesDefaultValue;

Variable xmlTreeIndentString

const char * xmlTreeIndentString;

xmlCleanupGlobals ()

void	xmlCleanupGlobals		(void)

DEPRECATED: This function will be made private. Call xmlCleanupParser to free global state but see the warnings there. xmlCleanupParser should be only called once at program exit. In most cases, you don't have call cleanup functions at all. Additional cleanup for multi-threading

xmlDeregisterNodeDefault ()

xmlDeregisterNodeFunc	xmlDeregisterNodeDefault	(xmlDeregisterNodeFunc func)

Registers a callback for node destruction

xmlInitGlobals ()

void	xmlInitGlobals			(void)

DEPRECATED: This function will be made private. Call xmlInitParser to initialize the library. Additional initialisation for multi-threading

xmlInitializeGlobalState ()

void	xmlInitializeGlobalState	(xmlGlobalStatePtr gs)

xmlInitializeGlobalState() initialize a global state with all the default values of the library.

xmlOutputBufferCreateFilenameDefault ()

xmlOutputBufferCreateFilenameFunc	xmlOutputBufferCreateFilenameDefault	(xmlOutputBufferCreateFilenameFunc func)

Registers a callback for URI output file handling

xmlParserInputBufferCreateFilenameDefault ()

xmlParserInputBufferCreateFilenameFunc	xmlParserInputBufferCreateFilenameDefault	(xmlParserInputBufferCreateFilenameFunc func)

Registers a callback for URI input file handling

xmlRegisterNodeDefault ()

xmlRegisterNodeFunc	xmlRegisterNodeDefault	(xmlRegisterNodeFunc func)

Registers a callback for node creation

xmlThrDefBufferAllocScheme ()

xmlBufferAllocationScheme	xmlThrDefBufferAllocScheme	(xmlBufferAllocationScheme v)

xmlThrDefDefaultBufferSize ()

int	xmlThrDefDefaultBufferSize	(int v)

xmlThrDefDeregisterNodeDefault ()

xmlDeregisterNodeFunc	xmlThrDefDeregisterNodeDefault	(xmlDeregisterNodeFunc func)

xmlThrDefDoValidityCheckingDefaultValue ()

int	xmlThrDefDoValidityCheckingDefaultValue	(int v)

xmlThrDefGetWarningsDefaultValue ()

int	xmlThrDefGetWarningsDefaultValue	(int v)

xmlThrDefIndentTreeOutput ()

int	xmlThrDefIndentTreeOutput	(int v)

xmlThrDefKeepBlanksDefaultValue ()

int	xmlThrDefKeepBlanksDefaultValue	(int v)

xmlThrDefLineNumbersDefaultValue ()

int	xmlThrDefLineNumbersDefaultValue	(int v)

xmlThrDefLoadExtDtdDefaultValue ()

int	xmlThrDefLoadExtDtdDefaultValue	(int v)

xmlThrDefOutputBufferCreateFilenameDefault ()

xmlOutputBufferCreateFilenameFunc	xmlThrDefOutputBufferCreateFilenameDefault	(xmlOutputBufferCreateFilenameFunc func)

xmlThrDefParserDebugEntities ()

int	xmlThrDefParserDebugEntities	(int v)

xmlThrDefParserInputBufferCreateFilenameDefault ()

xmlParserInputBufferCreateFilenameFunc	xmlThrDefParserInputBufferCreateFilenameDefault	(xmlParserInputBufferCreateFilenameFunc func)

xmlThrDefPedanticParserDefaultValue ()

int	xmlThrDefPedanticParserDefaultValue	(int v)

xmlThrDefRegisterNodeDefault ()

xmlRegisterNodeFunc	xmlThrDefRegisterNodeDefault	(xmlRegisterNodeFunc func)

xmlThrDefSaveNoEmptyTags ()

int	xmlThrDefSaveNoEmptyTags	(int v)

xmlThrDefSetGenericErrorFunc ()

void	xmlThrDefSetGenericErrorFunc	(void * ctx, 
					 xmlGenericErrorFunc handler)

xmlThrDefSetStructuredErrorFunc ()

void	xmlThrDefSetStructuredErrorFunc	(void * ctx, 
					 xmlStructuredErrorFunc handler)

xmlThrDefSubstituteEntitiesDefaultValue ()

int	xmlThrDefSubstituteEntitiesDefaultValue	(int v)

xmlThrDefTreeIndentString ()

const char *	xmlThrDefTreeIndentString	(const char * v)

Macro XML_XPATH_CHECKNS

#define XML_XPATH_CHECKNS;

check namespaces at compilation

Macro XML_XPATH_NOVAR

#define XML_XPATH_NOVAR;

forbid variables in expression

Macro XPATH_LOCATIONSET

#define XPATH_LOCATIONSET;

Macro XPATH_POINT

#define XPATH_POINT;

Macro XPATH_RANGE

#define XPATH_RANGE;

Macro xmlXPathNodeSetGetLength

#define xmlXPathNodeSetGetLength(ns);

Implement a functionality similar to the DOM NodeList.length. Returns the number of nodes in the node-set.

Macro xmlXPathNodeSetIsEmpty

#define xmlXPathNodeSetIsEmpty(ns);

Checks whether @ns is empty or not. Returns %TRUE if @ns is an empty node-set.

Macro xmlXPathNodeSetItem

#define xmlXPathNodeSetItem(ns, index);

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)

Structure xmlNodeSet

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 nam
} xmlNodeSet;

Typedef xmlNodeSetPtr

xmlNodeSet * xmlNodeSetPtr;

Structure xmlXPathAxis

struct _xmlXPathAxis {
    const xmlChar *	name	: the axis name
    xmlXPathAxisFunc	func	: the search function
} xmlXPathAxis;

Typedef xmlXPathAxisPtr

xmlXPathAxis * xmlXPathAxisPtr;

Structure xmlXPathCompExpr

struct _xmlXPathCompExpr {
The content of this structure is not made public by the API.
} xmlXPathCompExpr;

Typedef xmlXPathCompExprPtr

xmlXPathCompExpr * xmlXPathCompExprPtr;

Structure xmlXPathContext

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 expre
    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 n
    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
} xmlXPathContext;

Typedef xmlXPathContextPtr

xmlXPathContext * xmlXPathContextPtr;

Enum xmlXPathError

enum xmlXPathError {
    XPATH_EXPRESSION_OK = 0
    XPATH_NUMBER_ERROR = 1
    XPATH_UNFINISHED_LITERAL_ERROR = 2
    XPATH_START_LITERAL_ERROR = 3
    XPATH_VARIABLE_REF_ERROR = 4
    XPATH_UNDEF_VARIABLE_ERROR = 5
    XPATH_INVALID_PREDICATE_ERROR = 6
    XPATH_EXPR_ERROR = 7
    XPATH_UNCLOSED_ERROR = 8
    XPATH_UNKNOWN_FUNC_ERROR = 9
    XPATH_INVALID_OPERAND = 10
    XPATH_INVALID_TYPE = 11
    XPATH_INVALID_ARITY = 12
    XPATH_INVALID_CTXT_SIZE = 13
    XPATH_INVALID_CTXT_POSITION = 14
    XPATH_MEMORY_ERROR = 15
    XPTR_SYNTAX_ERROR = 16
    XPTR_RESOURCE_ERROR = 17
    XPTR_SUB_RESOURCE_ERROR = 18
    XPATH_UNDEF_PREFIX_ERROR = 19
    XPATH_ENCODING_ERROR = 20
    XPATH_INVALID_CHAR_ERROR = 21
    XPATH_INVALID_CTXT = 22
    XPATH_STACK_ERROR = 23
    XPATH_FORBID_VARIABLE_ERROR = 24
    XPATH_OP_LIMIT_EXCEEDED = 25
    XPATH_RECURSION_LIMIT_EXCEEDED = 26
};

Typedef xmlXPathFuncPtr

xmlXPathFunct * xmlXPathFuncPtr;

Structure xmlXPathFunct

struct _xmlXPathFunct {
    const xmlChar *	name	: the function name
    xmlXPathEvalFunc	func	: the evaluation function
} xmlXPathFunct;

Structure xmlXPathObject

struct _xmlXPathObject {
    xmlXPathObjectType	type
    xmlNodeSetPtr	nodesetval
    int	boolval
    double	floatval
    xmlChar *	stringval
    void *	user
    int	index
    void *	user2
    int	index2
} xmlXPathObject;

Typedef xmlXPathObjectPtr

xmlXPathObject * xmlXPathObjectPtr;

Enum xmlXPathObjectType

enum xmlXPathObjectType {
    XPATH_UNDEFINED = 0
    XPATH_NODESET = 1
    XPATH_BOOLEAN = 2
    XPATH_NUMBER = 3
    XPATH_STRING = 4
    XPATH_POINT = 5
    XPATH_RANGE = 6
    XPATH_LOCATIONSET = 7
    XPATH_USERS = 8
    XPATH_XSLT_TREE = 9 /*  An XSLT value tree, non modifiable */
};

Structure xmlXPathParserContext

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
} xmlXPathParserContext;

Typedef xmlXPathParserContextPtr

xmlXPathParserContext * xmlXPathParserContextPtr;

Structure xmlXPathType

struct _xmlXPathType {
    const xmlChar *	name	: the type name
    xmlXPathConvertFunc	func	: the conversion function
} xmlXPathType;

Typedef xmlXPathTypePtr

xmlXPathType * xmlXPathTypePtr;

Structure xmlXPathVariable

struct _xmlXPathVariable {
    const xmlChar *	name	: the variable name
    xmlXPathObjectPtr	value	: the value
} xmlXPathVariable;

Typedef xmlXPathVariablePtr

xmlXPathVariable * xmlXPathVariablePtr;

Function type xmlXPathAxisFunc

xmlXPathObjectPtr	xmlXPathAxisFunc	(xmlXPathParserContextPtr ctxt, 
						 xmlXPathObjectPtr cur)

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.

Function type xmlXPathConvertFunc

int	xmlXPathConvertFunc		(xmlXPathObjectPtr obj, 
					 int type)

A conversion function is associated to a type and used to cast the new type to primitive values.

Function type xmlXPathEvalFunc

void	xmlXPathEvalFunc		(xmlXPathParserContextPtr ctxt, 
					 int nargs)

An XPath evaluation function, the parameters are on the XPath context stack.

Function type xmlXPathFuncLookupFunc

xmlXPathFunction	xmlXPathFuncLookupFunc	(void * ctxt, 
						 const xmlChar * name, 
						 const xmlChar * ns_uri)

Prototype for callbacks used to plug function lookup in the XPath engine.

Function type xmlXPathFunction

void	xmlXPathFunction		(xmlXPathParserContextPtr ctxt, 
					 int nargs)

An XPath function. The arguments (if any) are popped out from the context stack and the result is pushed on the stack.

Function type xmlXPathVariableLookupFunc

xmlXPathObjectPtr	xmlXPathVariableLookupFunc	(void * ctxt, 
							 const xmlChar * name, 
							 const xmlChar * ns_uri)

Prototype for callbacks used to plug variable lookup in the XPath engine.

Variable xmlXPathNAN

double xmlXPathNAN;

Variable xmlXPathNINF

double xmlXPathNINF;

Variable xmlXPathPINF

double xmlXPathPINF;

xmlXPathCastBooleanToNumber ()

double	xmlXPathCastBooleanToNumber	(int val)

Converts a boolean to its number value

xmlXPathCastBooleanToString ()

xmlChar *	xmlXPathCastBooleanToString	(int val)

Converts a boolean to its string value.

xmlXPathCastNodeSetToBoolean ()

int	xmlXPathCastNodeSetToBoolean	(xmlNodeSetPtr ns)

Converts a node-set to its boolean value

xmlXPathCastNodeSetToNumber ()

double	xmlXPathCastNodeSetToNumber	(xmlNodeSetPtr ns)

Converts a node-set to its number value

xmlXPathCastNodeSetToString ()

xmlChar *	xmlXPathCastNodeSetToString	(xmlNodeSetPtr ns)

Converts a node-set to its string value.

xmlXPathCastNodeToNumber ()

double	xmlXPathCastNodeToNumber	(xmlNodePtr node)

Converts a node to its number value

xmlXPathCastNodeToString ()

xmlChar *	xmlXPathCastNodeToString	(xmlNodePtr node)

Converts a node to its string value.

xmlXPathCastNumberToBoolean ()

int	xmlXPathCastNumberToBoolean	(double val)

Converts a number to its boolean value

xmlXPathCastNumberToString ()

xmlChar *	xmlXPathCastNumberToString	(double val)

Converts a number to its string value.

xmlXPathCastStringToBoolean ()

int	xmlXPathCastStringToBoolean	(const xmlChar * val)

Converts a string to its boolean value

xmlXPathCastStringToNumber ()

double	xmlXPathCastStringToNumber	(const xmlChar * val)

Converts a string to its number value

xmlXPathCastToBoolean ()

int	xmlXPathCastToBoolean		(xmlXPathObjectPtr val)

Converts an XPath object to its boolean value

xmlXPathCastToNumber ()

double	xmlXPathCastToNumber		(xmlXPathObjectPtr val)

Converts an XPath object to its number value

xmlXPathCastToString ()

xmlChar *	xmlXPathCastToString	(xmlXPathObjectPtr val)

Converts an existing object to its string() equivalent

xmlXPathCmpNodes ()

int	xmlXPathCmpNodes		(xmlNodePtr node1, 
					 xmlNodePtr node2)

Compare two nodes w.r.t document order

xmlXPathCompile ()

xmlXPathCompExprPtr	xmlXPathCompile	(const xmlChar * str)

Compile an XPath expression

xmlXPathCompiledEval ()

xmlXPathObjectPtr	xmlXPathCompiledEval	(xmlXPathCompExprPtr comp, 
						 xmlXPathContextPtr ctx)

Evaluate the Precompiled XPath expression in the given context.

xmlXPathCompiledEvalToBoolean ()

int	xmlXPathCompiledEvalToBoolean	(xmlXPathCompExprPtr comp, 
					 xmlXPathContextPtr ctxt)

Applies the XPath boolean() function on the result of the given compiled expression.

xmlXPathContextSetCache ()

int	xmlXPathContextSetCache		(xmlXPathContextPtr ctxt, 
					 int active, 
					 int value, 
					 int options)

Creates/frees an object cache on the XPath context. If activates XPath objects (xmlXPathObject) will be cached internally to be reused. @options: 0: This will set the XPath object caching: @value: This will set the maximum number of XPath objects to be cached per slot There are 5 slots for: node-set, string, number, boolean, and misc objects. Use <0 for the default number (100). Other values for @options have currently no effect.

xmlXPathConvertBoolean ()

xmlXPathObjectPtr	xmlXPathConvertBoolean	(xmlXPathObjectPtr val)

Converts an existing object to its boolean() equivalent

xmlXPathConvertNumber ()

xmlXPathObjectPtr	xmlXPathConvertNumber	(xmlXPathObjectPtr val)

Converts an existing object to its number() equivalent

xmlXPathConvertString ()

xmlXPathObjectPtr	xmlXPathConvertString	(xmlXPathObjectPtr val)

Converts an existing object to its string() equivalent

xmlXPathCtxtCompile ()

xmlXPathCompExprPtr	xmlXPathCtxtCompile	(xmlXPathContextPtr ctxt, 
						 const xmlChar * str)

Compile an XPath expression

xmlXPathEval ()

xmlXPathObjectPtr	xmlXPathEval	(const xmlChar * str, 
					 xmlXPathContextPtr ctx)

Evaluate the XPath Location Path in the given context.

xmlXPathEvalExpression ()

xmlXPathObjectPtr	xmlXPathEvalExpression	(const xmlChar * str, 
						 xmlXPathContextPtr ctxt)

Alias for xmlXPathEval().

xmlXPathEvalPredicate ()

int	xmlXPathEvalPredicate		(xmlXPathContextPtr ctxt, 
					 xmlXPathObjectPtr res)

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.

xmlXPathFreeCompExpr ()

void	xmlXPathFreeCompExpr		(xmlXPathCompExprPtr comp)

Free up the memory allocated by @comp

xmlXPathFreeContext ()

void	xmlXPathFreeContext		(xmlXPathContextPtr ctxt)

Free up an xmlXPathContext

xmlXPathFreeNodeSet ()

void	xmlXPathFreeNodeSet		(xmlNodeSetPtr obj)

Free the NodeSet compound (not the actual nodes !).

xmlXPathFreeNodeSetList ()

void	xmlXPathFreeNodeSetList		(xmlXPathObjectPtr obj)

Free up the xmlXPathObjectPtr @obj but don't deallocate the objects in the list contrary to xmlXPathFreeObject().

xmlXPathFreeObject ()

void	xmlXPathFreeObject		(xmlXPathObjectPtr obj)

Free up an xmlXPathObjectPtr object.

xmlXPathInit ()

void	xmlXPathInit			(void)

DEPRECATED: This function will be made private. Call xmlInitParser to initialize the library. Initialize the XPath environment

xmlXPathIsInf ()

int	xmlXPathIsInf			(double val)

xmlXPathIsNaN ()

int	xmlXPathIsNaN			(double val)

xmlXPathNewContext ()

xmlXPathContextPtr	xmlXPathNewContext	(xmlDocPtr doc)

Create a new xmlXPathContext

xmlXPathNodeEval ()

xmlXPathObjectPtr	xmlXPathNodeEval	(xmlNodePtr node, 
						 const xmlChar * str, 
						 xmlXPathContextPtr ctx)

Evaluate the XPath Location Path in the given context. The node 'node' is set as the context node. The context node is not restored.

xmlXPathNodeSetCreate ()

xmlNodeSetPtr	xmlXPathNodeSetCreate	(xmlNodePtr val)

Create a new xmlNodeSetPtr of type double and of value @val

xmlXPathObjectCopy ()

xmlXPathObjectPtr	xmlXPathObjectCopy	(xmlXPathObjectPtr val)

allocate a new copy of a given object

xmlXPathOrderDocElems ()

long	xmlXPathOrderDocElems		(xmlDocPtr doc)

Call this routine to speed up XPath computation on static documents. This stamps all the element nodes with the document order Like for line information, the order is kept in the element->content field, the value stored is actually - the node number (starting at -1) to be able to differentiate from line numbers.

xmlXPathSetContextNode ()

int	xmlXPathSetContextNode		(xmlNodePtr node, 
					 xmlXPathContextPtr ctx)

Sets 'node' as the context node. The node must be in the same document as that associated with the context.

Structure xmlSchematron

struct _xmlSchematron {
The content of this structure is not made public by the API.
} xmlSchematron;

Structure xmlSchematronParserCtxt

struct _xmlSchematronParserCtxt {
The content of this structure is not made public by the API.
} xmlSchematronParserCtxt;

Typedef xmlSchematronParserCtxtPtr

xmlSchematronParserCtxt * xmlSchematronParserCtxtPtr;

Typedef xmlSchematronPtr

xmlSchematron * xmlSchematronPtr;

Structure xmlSchematronValidCtxt

struct _xmlSchematronValidCtxt {
The content of this structure is not made public by the API.
} xmlSchematronValidCtxt;

Typedef xmlSchematronValidCtxtPtr

xmlSchematronValidCtxt * xmlSchematronValidCtxtPtr;

Enum xmlSchematronValidOptions

enum xmlSchematronValidOptions {
    XML_SCHEMATRON_OUT_QUIET = 1 /* quiet no report */
    XML_SCHEMATRON_OUT_TEXT = 2 /* build a textual report */
    XML_SCHEMATRON_OUT_XML = 4 /* output SVRL */
    XML_SCHEMATRON_OUT_ERROR = 8 /* output via xmlStructuredErrorFunc */
    XML_SCHEMATRON_OUT_FILE = 256 /* output to a file descriptor */
    XML_SCHEMATRON_OUT_BUFFER = 512 /* output to a buffer */
    XML_SCHEMATRON_OUT_IO = 1024 /*  output to I/O mechanism */
};

Function type xmlSchematronValidityErrorFunc

void	xmlSchematronValidityErrorFunc	(void * ctx, 
					 const char * msg, 
					 ... ...)

Signature of an error callback from a Schematron validation

Function type xmlSchematronValidityWarningFunc

void	xmlSchematronValidityWarningFunc	(void * ctx, 
						 const char * msg, 
						 ... ...)

Signature of a warning callback from a Schematron validation

xmlSchematronFree ()

void	xmlSchematronFree		(xmlSchematronPtr schema)

Deallocate a Schematron structure.

xmlSchematronFreeParserCtxt ()

void	xmlSchematronFreeParserCtxt	(xmlSchematronParserCtxtPtr ctxt)

Free the resources associated to the schema parser context

xmlSchematronFreeValidCtxt ()

void	xmlSchematronFreeValidCtxt	(xmlSchematronValidCtxtPtr ctxt)

Free the resources associated to the schema validation context

xmlSchematronNewDocParserCtxt ()

xmlSchematronParserCtxtPtr	xmlSchematronNewDocParserCtxt	(xmlDocPtr doc)

Create an XML Schematrons parse context for that document. NB. The document may be modified during the parsing process.

xmlSchematronNewMemParserCtxt ()

xmlSchematronParserCtxtPtr	xmlSchematronNewMemParserCtxt	(const char * buffer, 
							 int size)

Create an XML Schematrons parse context for that memory buffer expected to contain an XML Schematrons file.

xmlSchematronNewParserCtxt ()

xmlSchematronParserCtxtPtr	xmlSchematronNewParserCtxt	(const char * URL)

Create an XML Schematrons parse context for that file/resource expected to contain an XML Schematrons file.

xmlSchematronNewValidCtxt ()

xmlSchematronValidCtxtPtr	xmlSchematronNewValidCtxt	(xmlSchematronPtr schema, 
							 int options)

Create an XML Schematrons validation context based on the given schema.

xmlSchematronParse ()

xmlSchematronPtr	xmlSchematronParse	(xmlSchematronParserCtxtPtr ctxt)

parse a schema definition resource and build an internal XML Schema structure which can be used to validate instances.

xmlSchematronSetValidStructuredErrors ()

void	xmlSchematronSetValidStructuredErrors	(xmlSchematronValidCtxtPtr ctxt, 
						 xmlStructuredErrorFunc serror, 
						 void * ctx)

Set the structured error callback

xmlSchematronValidateDoc ()

int	xmlSchematronValidateDoc	(xmlSchematronValidCtxtPtr ctxt, 
					 xmlDocPtr instance)

Validate a tree instance against the schematron