shaba/libxml2
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/libxml2.git synced 2025-03-27 18:50:07 +03:00
Code

Exportability taint of the headers

Browse Source
This commit is contained in:
Igor Zlatkovic 2003-08-25 09:05:12 +00:00
parent 9ce224a234
commit 76874e4516
42 changed files with 1759 additions and 1352 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
genUnicode.py
View File

@ -146,6 +146,8 @@ header.write(
#ifndef __XML_UNICODE_H__
#define __XML_UNICODE_H__
#include <libxml/xmlversion.h>
#ifdef __cplusplus
extern "C" {
#endif
@ -181,7 +183,7 @@ keys.sort()
for block in keys:
(start, end) = BlockNames[block]
name = string.replace(block, '-', '')
header.write("int\txmlUCSIs%s\t(int code);\n" % name)
header.write("XMLPUBFUN int XMLCALL xmlUCSIs%s\t(int code);\n" % name)
output.write("/**\n * xmlUCSIs%s:\n * @code: UCS code point\n" % (name))
output.write(" *\n * Check whether the character is part of %s UCS Block\n"%
(block))
@ -190,7 +192,7 @@ for block in keys:
output.write(" return((code >= %s) && (code <= %s));\n" % (start, end))
output.write("}\n\n")
header.write("\nint\txmlUCSIsBlock\t(int code,\n\t\t\t const char *block);\n\n")
header.write("\nXMLPUBFUN int XMLCALL xmlUCSIsBlock\t(int code,\n\t\t\t const char *block);\n\n")
output.write("/**\n * xmlUCSIsBlock:\n * @code: UCS code point\n")
output.write(" * @block: UCS block name\n")
output.write(" *\n * Check whether the caracter is part of the UCS Block\n")
@ -209,7 +211,7 @@ keys = Categories.keys()
keys.sort()
for name in keys:
ranges = Categories[name]
header.write("int\txmlUCSIsCat%s\t(int code);\n" % name)
header.write("XMLPUBFUN int XMLCALL xmlUCSIsCat%s\t(int code);\n" % name)
output.write("/**\n * xmlUCSIsCat%s:\n * @code: UCS code point\n" % (name))
output.write(" *\n * Check whether the character is part of %s UCS Category\n"%
(name))
@ -230,7 +232,7 @@ for name in keys:
hex(begin), hex(end)))
output.write(");\n}\n\n")
header.write("\nint\txmlUCSIsCat\t(int code,\n\t\t\t const char *cat);\n")
header.write("\nXMLPUBFUN int XMLCALL xmlUCSIsCat\t(int code,\n\t\t\t const char *cat);\n")
output.write("/**\n * xmlUCSIsCat:\n * @code: UCS code point\n")
output.write(" * @cat: UCS Category name\n")
output.write(" *\n * Check whether the caracter is part of the UCS Category\n")

49
include/libxml/DOCBparser.h
View File

@ -8,6 +8,7 @@
#ifndef __DOCB_PARSER_H__
#define __DOCB_PARSER_H__
#include <libxml/xmlversion.h>
#include <libxml/parser.h>
#ifdef __cplusplus
@ -30,41 +31,51 @@ typedef xmlNodePtr docbNodePtr;
/*
* There is only few public functions.
*/
int docbEncodeEntities(unsigned char *out,
XMLPUBFUN int XMLCALL
docbEncodeEntities(unsigned char *out,
int *outlen,
const unsigned char *in,
int *inlen, int quoteChar);
docbDocPtr docbSAXParseDoc (xmlChar *cur,
XMLPUBFUN docbDocPtr XMLCALL
docbSAXParseDoc (xmlChar *cur,
const char *encoding,
docbSAXHandlerPtr sax,
void *userData);
docbDocPtr docbParseDoc (xmlChar *cur,
XMLPUBFUN docbDocPtr XMLCALL
docbParseDoc (xmlChar *cur,
const char *encoding);
docbDocPtr docbSAXParseFile(const char *filename,
XMLPUBFUN docbDocPtr XMLCALL
docbSAXParseFile (const char *filename,
const char *encoding,
docbSAXHandlerPtr sax,
void *userData);
docbDocPtr docbParseFile (const char *filename,
XMLPUBFUN docbDocPtr XMLCALL
docbParseFile (const char *filename,
const char *encoding);
/**
* Interfaces for the Push mode.
*/
void docbFreeParserCtxt (docbParserCtxtPtr ctxt);
docbParserCtxtPtr docbCreatePushParserCtxt(docbSAXHandlerPtr sax,
void *user_data,
const char *chunk,
int size,
const char *filename,
xmlCharEncoding enc);
int docbParseChunk (docbParserCtxtPtr ctxt,
const char *chunk,
int size,
int terminate);
docbParserCtxtPtr docbCreateFileParserCtxt(const char *filename,
const char *encoding);
int docbParseDocument (docbParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
docbFreeParserCtxt (docbParserCtxtPtr ctxt);
XMLPUBFUN docbParserCtxtPtr XMLCALL
docbCreatePushParserCtxt(docbSAXHandlerPtr sax,
void *user_data,
const char *chunk,
int size,
const char *filename,
xmlCharEncoding enc);
XMLPUBFUN int XMLCALL
docbParseChunk (docbParserCtxtPtr ctxt,
const char *chunk,
int size,
int terminate);
XMLPUBFUN docbParserCtxtPtr XMLCALL
docbCreateFileParserCtxt(const char *filename,
const char *encoding);
XMLPUBFUN int XMLCALL
docbParseDocument (docbParserCtxtPtr ctxt);
#ifdef __cplusplus
}

72
include/libxml/HTMLparser.h
View File

@ -8,6 +8,7 @@
#ifndef __HTML_PARSER_H__
#define __HTML_PARSER_H__
#include <libxml/xmlversion.h>
#include <libxml/parser.h>
#ifdef __cplusplus
@ -76,58 +77,79 @@ struct _htmlEntityDesc {
/*
* There is only few public functions.
*/
const htmlElemDesc * htmlTagLookup (const xmlChar *tag);
const htmlEntityDesc * htmlEntityLookup(const xmlChar *name);
const htmlEntityDesc * htmlEntityValueLookup(unsigned int value);
XMLPUBFUN const htmlElemDesc * XMLCALL
htmlTagLookup (const xmlChar *tag);
XMLPUBFUN const htmlEntityDesc * XMLCALL
htmlEntityLookup(const xmlChar *name);
XMLPUBFUN const htmlEntityDesc * XMLCALL
htmlEntityValueLookup(unsigned int value);
int htmlIsAutoClosed(htmlDocPtr doc,
XMLPUBFUN int XMLCALL
htmlIsAutoClosed(htmlDocPtr doc,
htmlNodePtr elem);
int htmlAutoCloseTag(htmlDocPtr doc,
XMLPUBFUN int XMLCALL
htmlAutoCloseTag(htmlDocPtr doc,
const xmlChar *name,
htmlNodePtr elem);
const htmlEntityDesc * htmlParseEntityRef(htmlParserCtxtPtr ctxt,
XMLPUBFUN const htmlEntityDesc * XMLCALL
htmlParseEntityRef(htmlParserCtxtPtr ctxt,
const xmlChar **str);
int htmlParseCharRef(htmlParserCtxtPtr ctxt);
void htmlParseElement(htmlParserCtxtPtr ctxt);
XMLPUBFUN int XMLCALL
htmlParseCharRef(htmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
htmlParseElement(htmlParserCtxtPtr ctxt);
htmlParserCtxtPtr htmlCreateMemoryParserCtxt(const char *buffer,
XMLPUBFUN htmlParserCtxtPtr XMLCALL
htmlCreateMemoryParserCtxt(const char *buffer,
int size);
int htmlParseDocument(htmlParserCtxtPtr ctxt);
htmlDocPtr htmlSAXParseDoc (xmlChar *cur,
XMLPUBFUN int XMLCALL
htmlParseDocument(htmlParserCtxtPtr ctxt);
XMLPUBFUN htmlDocPtr XMLCALL
htmlSAXParseDoc (xmlChar *cur,
const char *encoding,
htmlSAXHandlerPtr sax,
void *userData);
htmlDocPtr htmlParseDoc (xmlChar *cur,
XMLPUBFUN htmlDocPtr XMLCALL
htmlParseDoc (xmlChar *cur,
const char *encoding);
htmlDocPtr htmlSAXParseFile(const char *filename,
XMLPUBFUN htmlDocPtr XMLCALL
htmlSAXParseFile(const char *filename,
const char *encoding,
htmlSAXHandlerPtr sax,
void *userData);
htmlDocPtr htmlParseFile (const char *filename,
XMLPUBFUN htmlDocPtr XMLCALL
htmlParseFile (const char *filename,
const char *encoding);
int UTF8ToHtml (unsigned char *out,
XMLPUBFUN int XMLCALL
UTF8ToHtml (unsigned char *out,
int *outlen,
const unsigned char *in,
int *inlen);
int htmlEncodeEntities(unsigned char *out,
XMLPUBFUN int XMLCALL
htmlEncodeEntities(unsigned char *out,
int *outlen,
const unsigned char *in,
int *inlen, int quoteChar);
int htmlIsScriptAttribute(const xmlChar *name);
int htmlHandleOmittedElem(int val);
XMLPUBFUN int XMLCALL
htmlIsScriptAttribute(const xmlChar *name);
XMLPUBFUN int XMLCALL
htmlHandleOmittedElem(int val);
/**
* Interfaces for the Push mode.
*/
void htmlFreeParserCtxt (htmlParserCtxtPtr ctxt);
htmlParserCtxtPtr htmlCreatePushParserCtxt(htmlSAXHandlerPtr sax,
XMLPUBFUN void XMLCALL
htmlFreeParserCtxt (htmlParserCtxtPtr ctxt);
XMLPUBFUN htmlParserCtxtPtr XMLCALL
htmlCreatePushParserCtxt(htmlSAXHandlerPtr sax,
void *user_data,
const char *chunk,
int size,
const char *filename,
xmlCharEncoding enc);
int htmlParseChunk (htmlParserCtxtPtr ctxt,
XMLPUBFUN int XMLCALL
htmlParseChunk (htmlParserCtxtPtr ctxt,
const char *chunk,
int size,
int terminate);
@ -145,10 +167,10 @@ typedef enum {
/* Using htmlElemDesc rather than name here, to emphasise the fact
that otherwise there's a lookup overhead
*/
htmlStatus htmlAttrAllowed(const htmlElemDesc*, const xmlChar*, int) ;
int htmlElementAllowedHere(const htmlElemDesc*, const xmlChar*) ;
htmlStatus htmlElementStatusHere(const htmlElemDesc*, const htmlElemDesc*) ;
htmlStatus htmlNodeStatus(const htmlNodePtr, int) ;
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

56
include/libxml/HTMLtree.h
View File

@ -11,6 +11,7 @@
#define __HTML_TREE_H__
#include <stdio.h>
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#include <libxml/HTMLparser.h>
@ -56,55 +57,74 @@ extern "C" {
*/
#define HTML_PI_NODE XML_PI_NODE
htmlDocPtr htmlNewDoc (const xmlChar *URI,
XMLPUBFUN htmlDocPtr XMLCALL
htmlNewDoc (const xmlChar *URI,
const xmlChar *ExternalID);
htmlDocPtr htmlNewDocNoDtD (const xmlChar *URI,
XMLPUBFUN htmlDocPtr XMLCALL
htmlNewDocNoDtD (const xmlChar *URI,
const xmlChar *ExternalID);
const xmlChar * htmlGetMetaEncoding (htmlDocPtr doc);
int htmlSetMetaEncoding (htmlDocPtr doc,
XMLPUBFUN const xmlChar * XMLCALL
htmlGetMetaEncoding (htmlDocPtr doc);
XMLPUBFUN int XMLCALL
htmlSetMetaEncoding (htmlDocPtr doc,
const xmlChar *encoding);
void htmlDocDumpMemory (xmlDocPtr cur,
XMLPUBFUN void XMLCALL
htmlDocDumpMemory (xmlDocPtr cur,
xmlChar **mem,
int *size);
int htmlDocDump (FILE *f,
XMLPUBFUN int XMLCALL
htmlDocDump (FILE *f,
xmlDocPtr cur);
int htmlSaveFile (const char *filename,
XMLPUBFUN int XMLCALL
htmlSaveFile (const char *filename,
xmlDocPtr cur);
int htmlNodeDump (xmlBufferPtr buf,
XMLPUBFUN int XMLCALL
htmlNodeDump (xmlBufferPtr buf,
xmlDocPtr doc,
xmlNodePtr cur);
void htmlNodeDumpFile (FILE *out,
XMLPUBFUN void XMLCALL
htmlNodeDumpFile (FILE *out,
xmlDocPtr doc,
xmlNodePtr cur);
int htmlNodeDumpFileFormat (FILE *out,
XMLPUBFUN int XMLCALL
htmlNodeDumpFileFormat (FILE *out,
xmlDocPtr doc,
xmlNodePtr cur,
const char *encoding,
int format);
int htmlSaveFileEnc (const char *filename,
XMLPUBFUN int XMLCALL
htmlSaveFileEnc (const char *filename,
xmlDocPtr cur,
const char *encoding);
int htmlSaveFileFormat (const char *filename,
XMLPUBFUN int XMLCALL
htmlSaveFileFormat (const char *filename,
xmlDocPtr cur,
const char *encoding,
int format);
void htmlNodeDumpFormatOutput(xmlOutputBufferPtr buf,
XMLPUBFUN void XMLCALL
htmlNodeDumpFormatOutput(xmlOutputBufferPtr buf,
xmlDocPtr doc,
xmlNodePtr cur,
const char *encoding,
int format);
void htmlDocContentDumpOutput(xmlOutputBufferPtr buf,
XMLPUBFUN void XMLCALL
htmlDocContentDumpOutput(xmlOutputBufferPtr buf,
xmlDocPtr cur,
const char *encoding);
void htmlDocContentDumpFormatOutput(xmlOutputBufferPtr buf,
XMLPUBFUN void XMLCALL
htmlDocContentDumpFormatOutput(xmlOutputBufferPtr buf,
xmlDocPtr cur,
const char *encoding,
int format);
int htmlIsBooleanAttr (const xmlChar *name);
void htmlNodeDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
xmlNodePtr cur, const char *encoding);
XMLPUBFUN int XMLCALL
htmlIsBooleanAttr (const xmlChar *name);
XMLPUBFUN void XMLCALL
htmlNodeDumpOutput (xmlOutputBufferPtr buf,
xmlDocPtr doc,
xmlNodePtr cur,
const char *encoding);

76
include/libxml/SAX.h
View File

@ -12,112 +12,114 @@
#include <stdio.h>
#include <stdlib.h>
#include <libxml/xmlversion.h>
#include <libxml/parser.h>
#include <libxml/xlink.h>
#ifdef __cplusplus
extern "C" {
#endif
const xmlChar * getPublicId (void *ctx);
const xmlChar * getSystemId (void *ctx);
void setDocumentLocator (void *ctx,
XMLPUBFUN const xmlChar * XMLCALL
getPublicId (void *ctx);
XMLPUBFUN const xmlChar * XMLCALL getSystemId (void *ctx);
XMLPUBFUN void XMLCALL setDocumentLocator (void *ctx,
xmlSAXLocatorPtr loc);
int getLineNumber (void *ctx);
int getColumnNumber (void *ctx);
XMLPUBFUN int XMLCALL getLineNumber (void *ctx);
XMLPUBFUN int XMLCALL getColumnNumber (void *ctx);
int isStandalone (void *ctx);
int hasInternalSubset (void *ctx);
int hasExternalSubset (void *ctx);
XMLPUBFUN int XMLCALL isStandalone (void *ctx);
XMLPUBFUN int XMLCALL hasInternalSubset (void *ctx);
XMLPUBFUN int XMLCALL hasExternalSubset (void *ctx);
void internalSubset (void *ctx,
XMLPUBFUN void XMLCALL internalSubset (void *ctx,
const xmlChar *name,
const xmlChar *ExternalID,
const xmlChar *SystemID);
void externalSubset (void *ctx,
XMLPUBFUN void XMLCALL externalSubset (void *ctx,
const xmlChar *name,
const xmlChar *ExternalID,
const xmlChar *SystemID);
xmlEntityPtr getEntity (void *ctx,
XMLPUBFUN xmlEntityPtr XMLCALL getEntity (void *ctx,
const xmlChar *name);
xmlEntityPtr getParameterEntity (void *ctx,
XMLPUBFUN xmlEntityPtr XMLCALL getParameterEntity (void *ctx,
const xmlChar *name);
xmlParserInputPtr resolveEntity (void *ctx,
XMLPUBFUN xmlParserInputPtr XMLCALL resolveEntity (void *ctx,
const xmlChar *publicId,
const xmlChar *systemId);
void entityDecl (void *ctx,
XMLPUBFUN void XMLCALL entityDecl (void *ctx,
const xmlChar *name,
int type,
const xmlChar *publicId,
const xmlChar *systemId,
xmlChar *content);
void attributeDecl (void *ctx,
XMLPUBFUN void XMLCALL attributeDecl (void *ctx,
const xmlChar *elem,
const xmlChar *fullname,
int type,
int def,
const xmlChar *defaultValue,
xmlEnumerationPtr tree);
void elementDecl (void *ctx,
XMLPUBFUN void XMLCALL elementDecl (void *ctx,
const xmlChar *name,
int type,
xmlElementContentPtr content);
void notationDecl (void *ctx,
XMLPUBFUN void XMLCALL notationDecl (void *ctx,
const xmlChar *name,
const xmlChar *publicId,
const xmlChar *systemId);
void unparsedEntityDecl (void *ctx,
XMLPUBFUN void XMLCALL unparsedEntityDecl (void *ctx,
const xmlChar *name,
const xmlChar *publicId,
const xmlChar *systemId,
const xmlChar *notationName);
void startDocument (void *ctx);
void endDocument (void *ctx);
void attribute (void *ctx,
XMLPUBFUN void XMLCALL startDocument (void *ctx);
XMLPUBFUN void XMLCALL endDocument (void *ctx);
XMLPUBFUN void XMLCALL attribute (void *ctx,
const xmlChar *fullname,
const xmlChar *value);
void startElement (void *ctx,
XMLPUBFUN void XMLCALL startElement (void *ctx,
const xmlChar *fullname,
const xmlChar **atts);
void endElement (void *ctx,
XMLPUBFUN void XMLCALL endElement (void *ctx,
const xmlChar *name);
void reference (void *ctx,
XMLPUBFUN void XMLCALL reference (void *ctx,
const xmlChar *name);
void characters (void *ctx,
XMLPUBFUN void XMLCALL characters (void *ctx,
const xmlChar *ch,
int len);
void ignorableWhitespace (void *ctx,
XMLPUBFUN void XMLCALL ignorableWhitespace (void *ctx,
const xmlChar *ch,
int len);
void processingInstruction (void *ctx,
XMLPUBFUN void XMLCALL processingInstruction (void *ctx,
const xmlChar *target,
const xmlChar *data);
void globalNamespace (void *ctx,
XMLPUBFUN void XMLCALL globalNamespace (void *ctx,
const xmlChar *href,
const xmlChar *prefix);
void setNamespace (void *ctx,
XMLPUBFUN void XMLCALL setNamespace (void *ctx,
const xmlChar *name);
xmlNsPtr getNamespace (void *ctx);
int checkNamespace (void *ctx,
XMLPUBFUN xmlNsPtr XMLCALL getNamespace (void *ctx);
XMLPUBFUN int XMLCALL checkNamespace (void *ctx,
xmlChar *nameSpace);
void namespaceDecl (void *ctx,
XMLPUBFUN void XMLCALL namespaceDecl (void *ctx,
const xmlChar *href,
const xmlChar *prefix);
void comment (void *ctx,
XMLPUBFUN void XMLCALL comment (void *ctx,
const xmlChar *value);
void cdataBlock (void *ctx,
XMLPUBFUN void XMLCALL cdataBlock (void *ctx,
const xmlChar *value,
int len);
void initxmlDefaultSAXHandler (xmlSAXHandler *hdlr,
XMLPUBFUN void XMLCALL initxmlDefaultSAXHandler (xmlSAXHandler *hdlr,
int warning);
#ifdef LIBXML_HTML_ENABLED
void inithtmlDefaultSAXHandler (xmlSAXHandler *hdlr);
XMLPUBFUN void XMLCALL inithtmlDefaultSAXHandler (xmlSAXHandler *hdlr);
#endif
#ifdef LIBXML_DOCB_ENABLED
void initdocbDefaultSAXHandler (xmlSAXHandler *hdlr);
XMLPUBFUN void XMLCALL initdocbDefaultSAXHandler (xmlSAXHandler *hdlr);
#endif
#ifdef __cplusplus
}

80
include/libxml/SAX2.h
View File

@ -12,113 +12,115 @@
#include <stdio.h>
#include <stdlib.h>
#include <libxml/xmlversion.h>
#include <libxml/parser.h>
#include <libxml/xlink.h>
#ifdef __cplusplus
extern "C" {
#endif
const xmlChar * xmlSAX2GetPublicId (void *ctx);
const xmlChar * xmlSAX2GetSystemId (void *ctx);
void xmlSAX2SetDocumentLocator (void *ctx,
XMLPUBFUN const xmlChar * XMLCALL
xmlSAX2GetPublicId (void *ctx);
XMLPUBFUN const xmlChar * XMLCALL xmlSAX2GetSystemId (void *ctx);
XMLPUBFUN void XMLCALL xmlSAX2SetDocumentLocator (void *ctx,
xmlSAXLocatorPtr loc);
int xmlSAX2GetLineNumber (void *ctx);
int xmlSAX2GetColumnNumber (void *ctx);
XMLPUBFUN int XMLCALL xmlSAX2GetLineNumber (void *ctx);
XMLPUBFUN int XMLCALL xmlSAX2GetColumnNumber (void *ctx);
int xmlSAX2IsStandalone (void *ctx);
int xmlSAX2HasInternalSubset (void *ctx);
int xmlSAX2HasExternalSubset (void *ctx);
XMLPUBFUN int XMLCALL xmlSAX2IsStandalone (void *ctx);
XMLPUBFUN int XMLCALL xmlSAX2HasInternalSubset (void *ctx);
XMLPUBFUN int XMLCALL xmlSAX2HasExternalSubset (void *ctx);
void xmlSAX2InternalSubset (void *ctx,
XMLPUBFUN void XMLCALL xmlSAX2InternalSubset (void *ctx,
const xmlChar *name,
const xmlChar *ExternalID,
const xmlChar *SystemID);
void xmlSAX2ExternalSubset (void *ctx,
XMLPUBFUN void XMLCALL xmlSAX2ExternalSubset (void *ctx,
const xmlChar *name,
const xmlChar *ExternalID,
const xmlChar *SystemID);
xmlEntityPtr xmlSAX2GetEntity (void *ctx,
XMLPUBFUN xmlEntityPtr XMLCALL xmlSAX2GetEntity (void *ctx,
const xmlChar *name);
xmlEntityPtr xmlSAX2GetParameterEntity (void *ctx,
XMLPUBFUN xmlEntityPtr XMLCALL xmlSAX2GetParameterEntity (void *ctx,
const xmlChar *name);
xmlParserInputPtr xmlSAX2ResolveEntity (void *ctx,
XMLPUBFUN xmlParserInputPtr XMLCALL xmlSAX2ResolveEntity (void *ctx,
const xmlChar *publicId,
const xmlChar *systemId);
void xmlSAX2EntityDecl (void *ctx,
XMLPUBFUN void XMLCALL xmlSAX2EntityDecl (void *ctx,
const xmlChar *name,
int type,
const xmlChar *publicId,
const xmlChar *systemId,
xmlChar *content);
void xmlSAX2AttributeDecl (void *ctx,
XMLPUBFUN void XMLCALL xmlSAX2AttributeDecl (void *ctx,
const xmlChar *elem,
const xmlChar *fullname,
int type,
int def,
const xmlChar *defaultValue,
xmlEnumerationPtr tree);
void xmlSAX2ElementDecl (void *ctx,
XMLPUBFUN void XMLCALL xmlSAX2ElementDecl (void *ctx,
const xmlChar *name,
int type,
xmlElementContentPtr content);
void xmlSAX2NotationDecl (void *ctx,
XMLPUBFUN void XMLCALL xmlSAX2NotationDecl (void *ctx,
const xmlChar *name,
const xmlChar *publicId,
const xmlChar *systemId);
void xmlSAX2UnparsedEntityDecl (void *ctx,
XMLPUBFUN void XMLCALL xmlSAX2UnparsedEntityDecl (void *ctx,
const xmlChar *name,
const xmlChar *publicId,
const xmlChar *systemId,
const xmlChar *notationName);
void xmlSAX2StartDocument (void *ctx);
void xmlSAX2EndDocument (void *ctx);
void xmlSAX2StartElement (void *ctx,
XMLPUBFUN void XMLCALL xmlSAX2StartDocument (void *ctx);
XMLPUBFUN void XMLCALL xmlSAX2EndDocument (void *ctx);
XMLPUBFUN void XMLCALL xmlSAX2StartElement (void *ctx,
const xmlChar *fullname,
const xmlChar **atts);
void xmlSAX2EndElement (void *ctx,
XMLPUBFUN void XMLCALL xmlSAX2EndElement (void *ctx,
const xmlChar *name);
void xmlSAX2Reference (void *ctx,
XMLPUBFUN void XMLCALL xmlSAX2Reference (void *ctx,
const xmlChar *name);
void xmlSAX2Characters (void *ctx,
XMLPUBFUN void XMLCALL xmlSAX2Characters (void *ctx,
const xmlChar *ch,
int len);
void xmlSAX2IgnorableWhitespace (void *ctx,
XMLPUBFUN void XMLCALL xmlSAX2IgnorableWhitespace (void *ctx,
const xmlChar *ch,
int len);
void xmlSAX2ProcessingInstruction (void *ctx,
XMLPUBFUN void XMLCALL xmlSAX2ProcessingInstruction (void *ctx,
const xmlChar *target,
const xmlChar *data);
void xmlSAX2GlobalNamespace (void *ctx,
XMLPUBFUN void XMLCALL xmlSAX2GlobalNamespace (void *ctx,
const xmlChar *href,
const xmlChar *prefix);
void xmlSAX2SetNamespace (void *ctx,
XMLPUBFUN void XMLCALL xmlSAX2SetNamespace (void *ctx,
const xmlChar *name);
xmlNsPtr xmlSAX2GetNamespace (void *ctx);
int xmlSAX2CheckNamespace (void *ctx,
XMLPUBFUN xmlNsPtr XMLCALL xmlSAX2GetNamespace (void *ctx);
XMLPUBFUN int XMLCALL xmlSAX2CheckNamespace (void *ctx,
xmlChar *nameSpace);
void xmlSAX2NamespaceDecl (void *ctx,
XMLPUBFUN void XMLCALL xmlSAX2NamespaceDecl (void *ctx,
const xmlChar *href,
const xmlChar *prefix);
void xmlSAX2Comment (void *ctx,
XMLPUBFUN void XMLCALL xmlSAX2Comment (void *ctx,
const xmlChar *value);
void xmlSAX2CDataBlock (void *ctx,
XMLPUBFUN void XMLCALL xmlSAX2CDataBlock (void *ctx,
const xmlChar *value,
int len);
void xmlSAX2InitDefaultSAXHandler (xmlSAXHandler *hdlr,
XMLPUBFUN void XMLCALL xmlSAX2InitDefaultSAXHandler (xmlSAXHandler *hdlr,
int warning);
#ifdef LIBXML_HTML_ENABLED
void xmlSAX2InitHtmlDefaultSAXHandler(xmlSAXHandler *hdlr);
XMLPUBFUN void XMLCALL xmlSAX2InitHtmlDefaultSAXHandler(xmlSAXHandler *hdlr);
#endif
#ifdef LIBXML_DOCB_ENABLED
void xmlSAX2InitDocbDefaultSAXHandler(xmlSAXHandler *hdlr);
XMLPUBFUN void XMLCALL xmlSAX2InitDocbDefaultSAXHandler(xmlSAXHandler *hdlr);
#endif
void xmlDefaultSAXHandlerInit (void);
void htmlDefaultSAXHandlerInit (void);
void docbDefaultSAXHandlerInit (void);
XMLPUBFUN void XMLCALL xmlDefaultSAXHandlerInit (void);
XMLPUBFUN void XMLCALL htmlDefaultSAXHandlerInit (void);
XMLPUBFUN void XMLCALL docbDefaultSAXHandlerInit (void);
#ifdef __cplusplus
}
#endif

13
include/libxml/c14n.h
View File

@ -16,6 +16,7 @@
extern "C" {
#endif /* __cplusplus */
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#include <libxml/xpath.h>
@ -45,21 +46,24 @@ extern "C" {
*/
int xmlC14NDocSaveTo (xmlDocPtr doc,
XMLPUBFUN int XMLCALL
xmlC14NDocSaveTo (xmlDocPtr doc,
xmlNodeSetPtr nodes,
int exclusive,
xmlChar **inclusive_ns_prefixes,
int with_comments,
xmlOutputBufferPtr buf);
int xmlC14NDocDumpMemory (xmlDocPtr doc,
XMLPUBFUN int XMLCALL
xmlC14NDocDumpMemory (xmlDocPtr doc,
xmlNodeSetPtr nodes,
int exclusive,
xmlChar **inclusive_ns_prefixes,
int with_comments,
xmlChar **doc_txt_ptr);
int xmlC14NDocSave (xmlDocPtr doc,
XMLPUBFUN int XMLCALL
xmlC14NDocSave (xmlDocPtr doc,
xmlNodeSetPtr nodes,
int exclusive,
xmlChar **inclusive_ns_prefixes,
@ -75,7 +79,8 @@ typedef int (*xmlC14NIsVisibleCallback) (void* user_data,
xmlNodePtr node,
xmlNodePtr parent);
int xmlC14NExecute (xmlDocPtr doc,
XMLPUBFUN int XMLCALL
xmlC14NExecute (xmlDocPtr doc,
xmlC14NIsVisibleCallback is_visible_callback,
void* user_data,
int exclusive,

108
include/libxml/catalog.h
View File

@ -62,74 +62,110 @@ typedef xmlCatalog *xmlCatalogPtr;
/*
* Operations on a given catalog.
*/
xmlCatalogPtr xmlNewCatalog (int sgml);
xmlCatalogPtr xmlLoadACatalog (const char *filename);
xmlCatalogPtr xmlLoadSGMLSuperCatalog (const char *filename);
int xmlConvertSGMLCatalog (xmlCatalogPtr catal);
int xmlACatalogAdd (xmlCatalogPtr catal,
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);
int xmlACatalogRemove (xmlCatalogPtr catal,
XMLPUBFUN int XMLCALL
xmlACatalogRemove (xmlCatalogPtr catal,
const xmlChar *value);
xmlChar * xmlACatalogResolve (xmlCatalogPtr catal,
XMLPUBFUN xmlChar * XMLCALL
xmlACatalogResolve (xmlCatalogPtr catal,
const xmlChar *pubID,
const xmlChar *sysID);
xmlChar * xmlACatalogResolveSystem(xmlCatalogPtr catal,
XMLPUBFUN xmlChar * XMLCALL
xmlACatalogResolveSystem(xmlCatalogPtr catal,
const xmlChar *sysID);
xmlChar * xmlACatalogResolvePublic(xmlCatalogPtr catal,
XMLPUBFUN xmlChar * XMLCALL
xmlACatalogResolvePublic(xmlCatalogPtr catal,
const xmlChar *pubID);
xmlChar * xmlACatalogResolveURI (xmlCatalogPtr catal,
XMLPUBFUN xmlChar * XMLCALL
xmlACatalogResolveURI (xmlCatalogPtr catal,
const xmlChar *URI);
void xmlACatalogDump (xmlCatalogPtr catal,
XMLPUBFUN void XMLCALL
xmlACatalogDump (xmlCatalogPtr catal,
FILE *out);
void xmlFreeCatalog (xmlCatalogPtr catal);
int xmlCatalogIsEmpty (xmlCatalogPtr catal);
XMLPUBFUN void XMLCALL
xmlFreeCatalog (xmlCatalogPtr catal);
XMLPUBFUN int XMLCALL
xmlCatalogIsEmpty (xmlCatalogPtr catal);
/*
* Global operations.
*/
void xmlInitializeCatalog (void);
int xmlLoadCatalog (const char *filename);
void xmlLoadCatalogs (const char *paths);
void xmlCatalogCleanup (void);
void xmlCatalogDump (FILE *out);
xmlChar * xmlCatalogResolve (const xmlChar *pubID,
XMLPUBFUN void XMLCALL
xmlInitializeCatalog (void);
XMLPUBFUN int XMLCALL
xmlLoadCatalog (const char *filename);
XMLPUBFUN void XMLCALL
xmlLoadCatalogs (const char *paths);
XMLPUBFUN void XMLCALL
xmlCatalogCleanup (void);
XMLPUBFUN void XMLCALL
xmlCatalogDump (FILE *out);
XMLPUBFUN xmlChar * XMLCALL
xmlCatalogResolve (const xmlChar *pubID,
const xmlChar *sysID);
xmlChar * xmlCatalogResolveSystem (const xmlChar *sysID);
xmlChar * xmlCatalogResolvePublic (const xmlChar *pubID);
xmlChar * xmlCatalogResolveURI (const xmlChar *URI);
int xmlCatalogAdd (const xmlChar *type,
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);
int xmlCatalogRemove (const xmlChar *value);
xmlDocPtr xmlParseCatalogFile (const char *filename);
int xmlCatalogConvert (void);
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.
*/
void xmlCatalogFreeLocal (void *catalogs);
void * xmlCatalogAddLocal (void *catalogs,
XMLPUBFUN void XMLCALL
xmlCatalogFreeLocal (void *catalogs);
XMLPUBFUN void * XMLCALL
xmlCatalogAddLocal (void *catalogs,
const xmlChar *URL);
xmlChar * xmlCatalogLocalResolve (void *catalogs,
XMLPUBFUN xmlChar * XMLCALL
xmlCatalogLocalResolve (void *catalogs,
const xmlChar *pubID,
const xmlChar *sysID);
xmlChar * xmlCatalogLocalResolveURI(void *catalogs,
XMLPUBFUN xmlChar * XMLCALL
xmlCatalogLocalResolveURI(void *catalogs,
const xmlChar *URI);
/*
* Preference settings.
*/
int xmlCatalogSetDebug (int level);
xmlCatalogPrefer xmlCatalogSetDefaultPrefer(xmlCatalogPrefer prefer);
void xmlCatalogSetDefaults (xmlCatalogAllow allow);
xmlCatalogAllow xmlCatalogGetDefaults (void);
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 */
const xmlChar * xmlCatalogGetSystem (const xmlChar *sysID);
const xmlChar * xmlCatalogGetPublic (const xmlChar *pubID);
XMLPUBFUN const xmlChar * XMLCALL
xmlCatalogGetSystem (const xmlChar *sysID);
XMLPUBFUN const xmlChar * XMLCALL
xmlCatalogGetPublic (const xmlChar *pubID);
#ifdef __cplusplus
}

82
include/libxml/debugXML.h
View File

@ -8,6 +8,7 @@
#ifndef __DEBUG_XML__
#define __DEBUG_XML__
#include <stdio.h>
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#ifdef LIBXML_DEBUG_ENABLED
@ -21,36 +22,49 @@ extern "C" {
/*
* The standard Dump routines.
*/
void xmlDebugDumpString (FILE *output,
XMLPUBFUN void XMLCALL
xmlDebugDumpString (FILE *output,
const xmlChar *str);
void xmlDebugDumpAttr (FILE *output,
XMLPUBFUN void XMLCALL
xmlDebugDumpAttr (FILE *output,
xmlAttrPtr attr,
int depth);
void xmlDebugDumpAttrList (FILE *output,
XMLPUBFUN void XMLCALL
xmlDebugDumpAttrList (FILE *output,
xmlAttrPtr attr,
int depth);
void xmlDebugDumpOneNode (FILE *output,
XMLPUBFUN void XMLCALL
xmlDebugDumpOneNode (FILE *output,
xmlNodePtr node,
int depth);
void xmlDebugDumpNode (FILE *output,
XMLPUBFUN void XMLCALL
xmlDebugDumpNode (FILE *output,
xmlNodePtr node,
int depth);
void xmlDebugDumpNodeList (FILE *output,
XMLPUBFUN void XMLCALL
xmlDebugDumpNodeList (FILE *output,
xmlNodePtr node,
int depth);
void xmlDebugDumpDocumentHead(FILE *output,
XMLPUBFUN void XMLCALL
xmlDebugDumpDocumentHead(FILE *output,
xmlDocPtr doc);
void xmlDebugDumpDocument (FILE *output,
XMLPUBFUN void XMLCALL
xmlDebugDumpDocument (FILE *output,
xmlDocPtr doc);
void xmlDebugDumpDTD (FILE *output,
XMLPUBFUN void XMLCALL
xmlDebugDumpDTD (FILE *output,
xmlDtdPtr dtd);
void xmlDebugDumpEntities (FILE *output,
XMLPUBFUN void XMLCALL
xmlDebugDumpEntities (FILE *output,
xmlDocPtr doc);
void xmlLsOneNode (FILE *output, xmlNodePtr node);
int xmlLsCountNode (xmlNodePtr node);
XMLPUBFUN void XMLCALL
xmlLsOneNode (FILE *output, xmlNodePtr node);
XMLPUBFUN int XMLCALL
xmlLsCountNode (xmlNodePtr node);
LIBXML_DLL_IMPORT const char *xmlBoolToText (int boolval);
XMLPUBFUN const char * XMLCALL
xmlBoolToText (int boolval);
/****************************************************************
* *
@ -102,47 +116,60 @@ typedef int (* xmlShellCmd) (xmlShellCtxtPtr ctxt,
xmlNodePtr node,
xmlNodePtr node2);
void xmlShellPrintXPathError (int errorType,
XMLPUBFUN void XMLCALL
xmlShellPrintXPathError (int errorType,
const char *arg);
void xmlShellPrintNode (xmlNodePtr node);
void xmlShellPrintXPathResult(xmlXPathObjectPtr list);
int xmlShellList (xmlShellCtxtPtr ctxt,
XMLPUBFUN void XMLCALL
xmlShellPrintNode (xmlNodePtr node);
XMLPUBFUN void XMLCALL
xmlShellPrintXPathResult(xmlXPathObjectPtr list);
XMLPUBFUN int XMLCALL
xmlShellList (xmlShellCtxtPtr ctxt,
char *arg,
xmlNodePtr node,
xmlNodePtr node2);
int xmlShellBase (xmlShellCtxtPtr ctxt,
XMLPUBFUN int XMLCALL
xmlShellBase (xmlShellCtxtPtr ctxt,
char *arg,
xmlNodePtr node,
xmlNodePtr node2);
int xmlShellDir (xmlShellCtxtPtr ctxt,
XMLPUBFUN int XMLCALL
xmlShellDir (xmlShellCtxtPtr ctxt,
char *arg,
xmlNodePtr node,
xmlNodePtr node2);
int xmlShellCat (xmlShellCtxtPtr ctxt,
XMLPUBFUN int XMLCALL
xmlShellCat (xmlShellCtxtPtr ctxt,
char *arg,
xmlNodePtr node,
xmlNodePtr node2);
int xmlShellLoad (xmlShellCtxtPtr ctxt,
XMLPUBFUN int XMLCALL
xmlShellLoad (xmlShellCtxtPtr ctxt,
char *filename,
xmlNodePtr node,
xmlNodePtr node2);
int xmlShellWrite (xmlShellCtxtPtr ctxt,
XMLPUBFUN int XMLCALL
xmlShellWrite (xmlShellCtxtPtr ctxt,
char *filename,
xmlNodePtr node,
xmlNodePtr node2);
int xmlShellSave (xmlShellCtxtPtr ctxt,
XMLPUBFUN int XMLCALL
xmlShellSave (xmlShellCtxtPtr ctxt,
char *filename,
xmlNodePtr node,
xmlNodePtr node2);
int xmlShellValidate (xmlShellCtxtPtr ctxt,
XMLPUBFUN int XMLCALL
xmlShellValidate (xmlShellCtxtPtr ctxt,
char *dtd,
xmlNodePtr node,
xmlNodePtr node2);
int xmlShellDu (xmlShellCtxtPtr ctxt,
XMLPUBFUN int XMLCALL
xmlShellDu (xmlShellCtxtPtr ctxt,
char *arg,
xmlNodePtr tree,
xmlNodePtr node2);
int xmlShellPwd (xmlShellCtxtPtr ctxt,
XMLPUBFUN int XMLCALL
xmlShellPwd (xmlShellCtxtPtr ctxt,
char *buffer,
xmlNodePtr node,
xmlNodePtr node2);
@ -150,7 +177,8 @@ int xmlShellPwd (xmlShellCtxtPtr ctxt,
/*
* The Shell interface.
*/
void xmlShell (xmlDocPtr doc,
XMLPUBFUN void XMLCALL
xmlShell (xmlDocPtr doc,
char *filename,
xmlShellReadlineFunc input,
FILE *output);

13
include/libxml/dict.h
View File

@ -19,6 +19,7 @@
#ifndef __XML_DICT_H__
#define __XML_DICT_H__
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#ifdef __cplusplus
@ -34,16 +35,20 @@ typedef xmlDict *xmlDictPtr;
/*
* Constructor and destructor.
*/
xmlDictPtr xmlDictCreate (void);
void xmlDictFree (xmlDictPtr dict);
XMLPUBFUN xmlDictPtr XMLCALL
xmlDictCreate (void);
XMLPUBFUN void XMLCALL
xmlDictFree (xmlDictPtr dict);
/*
* Lookup of entry in the dictionnary.
*/
const xmlChar * xmlDictLookup (xmlDictPtr dict,
XMLPUBFUN const xmlChar * XMLCALL
xmlDictLookup (xmlDictPtr dict,
const xmlChar *name,
int len);
int xmlDictSize (xmlDictPtr dict);
XMLPUBFUN int XMLCALL
xmlDictSize (xmlDictPtr dict);
#ifdef __cplusplus
}
#endif

80
include/libxml/encoding.h
View File

@ -145,14 +145,17 @@ extern "C" {
/*
* Interfaces for encoding handlers.
*/
void xmlInitCharEncodingHandlers (void);
void xmlCleanupCharEncodingHandlers (void);
void xmlRegisterCharEncodingHandler (xmlCharEncodingHandlerPtr handler);
xmlCharEncodingHandlerPtr
XMLPUBFUN void XMLCALL
xmlInitCharEncodingHandlers (void);
XMLPUBFUN void XMLCALL
xmlCleanupCharEncodingHandlers (void);
XMLPUBFUN void XMLCALL
xmlRegisterCharEncodingHandler (xmlCharEncodingHandlerPtr handler);
XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL
xmlGetCharEncodingHandler (xmlCharEncoding enc);
xmlCharEncodingHandlerPtr
XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL
xmlFindCharEncodingHandler (const char *name);
xmlCharEncodingHandlerPtr
XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL
xmlNewCharEncodingHandler (const char *name,
xmlCharEncodingInputFunc input,
xmlCharEncodingOutputFunc output);
@ -160,68 +163,87 @@ xmlCharEncodingHandlerPtr
/*
* Interfaces for encoding names and aliases.
*/
int xmlAddEncodingAlias (const char *name,
XMLPUBFUN int XMLCALL
xmlAddEncodingAlias (const char *name,
const char *alias);
int xmlDelEncodingAlias (const char *alias);
const char *
XMLPUBFUN int XMLCALL
xmlDelEncodingAlias (const char *alias);
XMLPUBFUN const char * XMLCALL
xmlGetEncodingAlias (const char *alias);
void xmlCleanupEncodingAliases (void);
xmlCharEncoding
XMLPUBFUN void XMLCALL
xmlCleanupEncodingAliases (void);
XMLPUBFUN xmlCharEncoding XMLCALL
xmlParseCharEncoding (const char *name);
const char *
XMLPUBFUN const char * XMLCALL
xmlGetCharEncodingName (xmlCharEncoding enc);
/*
* Interfaces directly used by the parsers.
*/
xmlCharEncoding
XMLPUBFUN xmlCharEncoding XMLCALL
xmlDetectCharEncoding (const unsigned char *in,
int len);
int xmlCharEncOutFunc (xmlCharEncodingHandler *handler,
XMLPUBFUN int XMLCALL
xmlCharEncOutFunc (xmlCharEncodingHandler *handler,
xmlBufferPtr out,
xmlBufferPtr in);
int xmlCharEncInFunc (xmlCharEncodingHandler *handler,
XMLPUBFUN int XMLCALL
xmlCharEncInFunc (xmlCharEncodingHandler *handler,
xmlBufferPtr out,
xmlBufferPtr in);
int xmlCharEncFirstLine (xmlCharEncodingHandler *handler,
XMLPUBFUN int XMLCALL
xmlCharEncFirstLine (xmlCharEncodingHandler *handler,
xmlBufferPtr out,
xmlBufferPtr in);
int xmlCharEncCloseFunc (xmlCharEncodingHandler *handler);
XMLPUBFUN int XMLCALL
xmlCharEncCloseFunc (xmlCharEncodingHandler *handler);
/*
* Export a few useful functions
*/
int UTF8Toisolat1 (unsigned char *out,
XMLPUBFUN int XMLCALL
UTF8Toisolat1 (unsigned char *out,
int *outlen,
const unsigned char *in,
int *inlen);
int isolat1ToUTF8 (unsigned char *out,
XMLPUBFUN int XMLCALL
isolat1ToUTF8 (unsigned char *out,
int *outlen,
const unsigned char *in,
int *inlen);
int xmlGetUTF8Char (const unsigned char *utf,
XMLPUBFUN int XMLCALL
xmlGetUTF8Char (const unsigned char *utf,
int *len);
/*
* exports additional "UTF-8 aware" string routines which are.
*/
int xmlCheckUTF8 (const unsigned char *utf);
int xmlUTF8Strsize (const xmlChar *utf,
XMLPUBFUN int XMLCALL
xmlCheckUTF8 (const unsigned char *utf);
XMLPUBFUN int XMLCALL
xmlUTF8Strsize (const xmlChar *utf,
int len);
xmlChar * xmlUTF8Strndup (const xmlChar *utf,
XMLPUBFUN xmlChar * XMLCALL
xmlUTF8Strndup (const xmlChar *utf,
int len);
xmlChar * xmlUTF8Strpos (const xmlChar *utf,
XMLPUBFUN xmlChar * XMLCALL
xmlUTF8Strpos (const xmlChar *utf,
int pos);
int xmlUTF8Strloc (const xmlChar *utf,
XMLPUBFUN int XMLCALL
xmlUTF8Strloc (const xmlChar *utf,
const xmlChar *utfchar);
xmlChar * xmlUTF8Strsub (const xmlChar *utf,
XMLPUBFUN xmlChar * XMLCALL
xmlUTF8Strsub (const xmlChar *utf,
int start,
int len);
int xmlUTF8Strlen (const xmlChar *utf);
int xmlUTF8Size (const xmlChar *utf);
int xmlUTF8Charcmp (const xmlChar *utf1,
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
}

49
include/libxml/entities.h
View File

@ -9,6 +9,7 @@
#ifndef __XML_ENTITIES_H__
#define __XML_ENTITIES_H__
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#ifdef __cplusplus
@ -67,40 +68,56 @@ typedef xmlEntitiesTable *xmlEntitiesTablePtr;
* External functions:
*/
void xmlInitializePredefinedEntities (void);
xmlEntityPtr xmlAddDocEntity (xmlDocPtr doc,
XMLPUBFUN void XMLCALL
xmlInitializePredefinedEntities (void);
XMLPUBFUN xmlEntityPtr XMLCALL
xmlAddDocEntity (xmlDocPtr doc,
const xmlChar *name,
int type,
const xmlChar *ExternalID,
const xmlChar *SystemID,
const xmlChar *content);
xmlEntityPtr xmlAddDtdEntity (xmlDocPtr doc,
XMLPUBFUN xmlEntityPtr XMLCALL
xmlAddDtdEntity (xmlDocPtr doc,
const xmlChar *name,
int type,
const xmlChar *ExternalID,
const xmlChar *SystemID,
const xmlChar *content);
xmlEntityPtr xmlGetPredefinedEntity (const xmlChar *name);
xmlEntityPtr xmlGetDocEntity (xmlDocPtr doc,
XMLPUBFUN xmlEntityPtr XMLCALL
xmlGetPredefinedEntity (const xmlChar *name);
XMLPUBFUN xmlEntityPtr XMLCALL
xmlGetDocEntity (xmlDocPtr doc,
const xmlChar *name);
xmlEntityPtr xmlGetDtdEntity (xmlDocPtr doc,
XMLPUBFUN xmlEntityPtr XMLCALL
xmlGetDtdEntity (xmlDocPtr doc,
const xmlChar *name);
xmlEntityPtr xmlGetParameterEntity (xmlDocPtr doc,
XMLPUBFUN xmlEntityPtr XMLCALL
xmlGetParameterEntity (xmlDocPtr doc,
const xmlChar *name);
const xmlChar * xmlEncodeEntities (xmlDocPtr doc,
XMLPUBFUN const xmlChar * XMLCALL
xmlEncodeEntities (xmlDocPtr doc,
const xmlChar *input);
xmlChar * xmlEncodeEntitiesReentrant(xmlDocPtr doc,
XMLPUBFUN xmlChar * XMLCALL
xmlEncodeEntitiesReentrant(xmlDocPtr doc,
const xmlChar *input);
xmlChar * xmlEncodeSpecialChars (xmlDocPtr doc,
XMLPUBFUN xmlChar * XMLCALL
xmlEncodeSpecialChars (xmlDocPtr doc,
const xmlChar *input);
xmlEntitiesTablePtr xmlCreateEntitiesTable (void);
xmlEntitiesTablePtr xmlCopyEntitiesTable (xmlEntitiesTablePtr table);
void xmlFreeEntitiesTable (xmlEntitiesTablePtr table);
void xmlDumpEntitiesTable (xmlBufferPtr buf,
XMLPUBFUN xmlEntitiesTablePtr XMLCALL
xmlCreateEntitiesTable (void);
XMLPUBFUN xmlEntitiesTablePtr XMLCALL
xmlCopyEntitiesTable (xmlEntitiesTablePtr table);
XMLPUBFUN void XMLCALL
xmlFreeEntitiesTable (xmlEntitiesTablePtr table);
XMLPUBFUN void XMLCALL
xmlDumpEntitiesTable (xmlBufferPtr buf,
xmlEntitiesTablePtr table);
void xmlDumpEntityDecl (xmlBufferPtr buf,
XMLPUBFUN void XMLCALL
xmlDumpEntityDecl (xmlBufferPtr buf,
xmlEntityPtr ent);
void xmlCleanupPredefinedEntities(void);
XMLPUBFUN void XMLCALL
xmlCleanupPredefinedEntities(void);
#ifdef __cplusplus

161
include/libxml/globals.h
View File

@ -13,6 +13,7 @@
#ifndef __XML_GLOBALS_H
#define __XML_GLOBALS_H
#include <libxml/xmlversion.h>
#include <libxml/parser.h>
#include <libxml/xmlerror.h>
#include <libxml/SAX2.h>
@ -113,14 +114,14 @@ struct _xmlGlobalState
extern "C" {
#endif
void xmlInitializeGlobalState(xmlGlobalStatePtr gs);
XMLPUBFUN void XMLCALL xmlInitializeGlobalState(xmlGlobalStatePtr gs);
void xmlThrDefSetGenericErrorFunc(void *ctx, xmlGenericErrorFunc handler);
XMLPUBFUN void XMLCALL xmlThrDefSetGenericErrorFunc(void *ctx, xmlGenericErrorFunc handler);
xmlRegisterNodeFunc xmlRegisterNodeDefault(xmlRegisterNodeFunc func);
xmlRegisterNodeFunc xmlThrDefRegisterNodeDefault(xmlRegisterNodeFunc func);
xmlDeregisterNodeFunc xmlDeregisterNodeDefault(xmlDeregisterNodeFunc func);
xmlDeregisterNodeFunc xmlThrDefDeregisterNodeDefault(xmlDeregisterNodeFunc func);
XMLPUBFUN xmlRegisterNodeFunc XMLCALL xmlRegisterNodeDefault(xmlRegisterNodeFunc func);
XMLPUBFUN xmlRegisterNodeFunc XMLCALL xmlThrDefRegisterNodeDefault(xmlRegisterNodeFunc func);
XMLPUBFUN xmlDeregisterNodeFunc XMLCALL xmlDeregisterNodeDefault(xmlDeregisterNodeFunc func);
XMLPUBFUN xmlDeregisterNodeFunc XMLCALL xmlThrDefDeregisterNodeDefault(xmlDeregisterNodeFunc func);
/*
* In general the memory allocation entry points are not kept
@ -134,70 +135,70 @@ xmlDeregisterNodeFunc xmlThrDefDeregisterNodeDefault(xmlDeregisterNodeFunc func)
#ifdef LIBXML_THREAD_ALLOC_ENABLED
#ifdef LIBXML_THREAD_ENABLED
extern xmlMallocFunc *__xmlMalloc(void);
XMLPUBFUN xmlMallocFunc * XMLCALL __xmlMalloc(void);
#define xmlMalloc \
(*(__xmlMalloc()))
#else
LIBXML_DLL_IMPORT extern xmlMallocFunc xmlMalloc;
XMLPUBVAR xmlMallocFunc xmlMalloc;
#endif
#ifdef LIBXML_THREAD_ENABLED
extern xmlMallocFunc *__xmlMallocAtomic(void);
XMLPUBFUN xmlMallocFunc * XMLCALL __xmlMallocAtomic(void);
#define xmlMallocAtomic \
(*(__xmlMallocAtomic()))
#else
LIBXML_DLL_IMPORT extern xmlMallocFunc xmlMallocAtomic;
XMLPUBVAR xmlMallocFunc xmlMallocAtomic;
#endif
#ifdef LIBXML_THREAD_ENABLED
extern xmlReallocFunc *__xmlRealloc(void);
XMLPUBFUN xmlReallocFunc * XMLCALL __xmlRealloc(void);
#define xmlRealloc \
(*(__xmlRealloc()))
#else
LIBXML_DLL_IMPORT extern xmlReallocFunc xmlRealloc;
XMLPUBVAR xmlReallocFunc xmlRealloc;
#endif
#ifdef LIBXML_THREAD_ENABLED
extern xmlFreeFunc *__xmlFree(void);
XMLPUBFUN xmlFreeFunc * XMLCALL __xmlFree(void);
#define xmlFree \
(*(__xmlFree()))
#else
LIBXML_DLL_IMPORT extern xmlFreeFunc xmlFree;
XMLPUBVAR xmlFreeFunc xmlFree;
#endif
#ifdef LIBXML_THREAD_ENABLED
extern xmlStrdupFunc *__xmlMemStrdup(void);
XMLPUBFUN xmlStrdupFunc * XMLCALL __xmlMemStrdup(void);
#define xmlMemStrdup \
(*(__xmlMemStrdup()))
#else
LIBXML_DLL_IMPORT extern xmlStrdupFunc xmlMemStrdup;
XMLPUBVAR xmlStrdupFunc xmlMemStrdup;
#endif
#else /* !LIBXML_THREAD_ALLOC_ENABLED */
LIBXML_DLL_IMPORT extern xmlMallocFunc xmlMalloc;
LIBXML_DLL_IMPORT extern xmlMallocFunc xmlMallocAtomic;
LIBXML_DLL_IMPORT extern xmlReallocFunc xmlRealloc;
LIBXML_DLL_IMPORT extern xmlFreeFunc xmlFree;
LIBXML_DLL_IMPORT extern xmlStrdupFunc xmlMemStrdup;
XMLPUBVAR xmlMallocFunc xmlMalloc;
XMLPUBVAR xmlMallocFunc xmlMallocAtomic;
XMLPUBVAR xmlReallocFunc xmlRealloc;
XMLPUBVAR xmlFreeFunc xmlFree;
XMLPUBVAR xmlStrdupFunc xmlMemStrdup;
#endif /* LIBXML_THREAD_ALLOC_ENABLED */
#ifdef LIBXML_DOCB_ENABLED
extern xmlSAXHandler *__docbDefaultSAXHandler(void);
XMLPUBFUN xmlSAXHandler * XMLCALL __docbDefaultSAXHandler(void);
#ifdef LIBXML_THREAD_ENABLED
#define docbDefaultSAXHandler \
(*(__docbDefaultSAXHandler()))
#else
LIBXML_DLL_IMPORT extern xmlSAXHandler docbDefaultSAXHandler;
XMLPUBVAR xmlSAXHandler docbDefaultSAXHandler;
#endif
#endif
#ifdef LIBXML_HTML_ENABLED
extern xmlSAXHandler *__htmlDefaultSAXHandler(void);
XMLPUBFUN xmlSAXHandler * XMLCALL __htmlDefaultSAXHandler(void);
#ifdef LIBXML_THREAD_ENABLED
#define htmlDefaultSAXHandler \
(*(__htmlDefaultSAXHandler()))
#else
LIBXML_DLL_IMPORT extern xmlSAXHandler htmlDefaultSAXHandler;
XMLPUBVAR xmlSAXHandler htmlDefaultSAXHandler;
#endif
#endif
@ -209,185 +210,185 @@ LIBXML_DLL_IMPORT extern xmlSAXHandler htmlDefaultSAXHandler;
*/
extern int *__oldXMLWDcompatibility(void);
XMLPUBFUN int * XMLCALL __oldXMLWDcompatibility(void);
#ifdef LIBXML_THREAD_ENABLED
#define oldXMLWDcompatibility \
(*(__oldXMLWDcompatibility()))
#else
LIBXML_DLL_IMPORT extern int oldXMLWDcompatibility;
XMLPUBVAR int oldXMLWDcompatibility;
#endif
extern xmlBufferAllocationScheme *__xmlBufferAllocScheme(void);
XMLPUBFUN xmlBufferAllocationScheme * XMLCALL __xmlBufferAllocScheme(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlBufferAllocScheme \
(*(__xmlBufferAllocScheme()))
#else
LIBXML_DLL_IMPORT extern xmlBufferAllocationScheme xmlBufferAllocScheme;
XMLPUBVAR xmlBufferAllocationScheme xmlBufferAllocScheme;
#endif
xmlBufferAllocationScheme xmlThrDefBufferAllocScheme(xmlBufferAllocationScheme v);
XMLPUBFUN xmlBufferAllocationScheme XMLCALL xmlThrDefBufferAllocScheme(xmlBufferAllocationScheme v);
extern int *__xmlDefaultBufferSize(void);
XMLPUBFUN int * XMLCALL __xmlDefaultBufferSize(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlDefaultBufferSize \
(*(__xmlDefaultBufferSize()))
#else
LIBXML_DLL_IMPORT extern int xmlDefaultBufferSize;
XMLPUBVAR int xmlDefaultBufferSize;
#endif
int xmlThrDefDefaultBufferSize(int v);
XMLPUBFUN int XMLCALL xmlThrDefDefaultBufferSize(int v);
extern xmlSAXHandler *__xmlDefaultSAXHandler(void);
XMLPUBFUN xmlSAXHandler * XMLCALL __xmlDefaultSAXHandler(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlDefaultSAXHandler \
(*(__xmlDefaultSAXHandler()))
#else
LIBXML_DLL_IMPORT extern xmlSAXHandler xmlDefaultSAXHandler;
XMLPUBVAR xmlSAXHandler xmlDefaultSAXHandler;
#endif
extern xmlSAXLocator *__xmlDefaultSAXLocator(void);
XMLPUBFUN xmlSAXLocator * XMLCALL __xmlDefaultSAXLocator(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlDefaultSAXLocator \
(*(__xmlDefaultSAXLocator()))
#else
LIBXML_DLL_IMPORT extern xmlSAXLocator xmlDefaultSAXLocator;
XMLPUBVAR xmlSAXLocator xmlDefaultSAXLocator;
#endif
extern int *__xmlDoValidityCheckingDefaultValue(void);
XMLPUBFUN int * XMLCALL __xmlDoValidityCheckingDefaultValue(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlDoValidityCheckingDefaultValue \
(*(__xmlDoValidityCheckingDefaultValue()))
#else
LIBXML_DLL_IMPORT extern int xmlDoValidityCheckingDefaultValue;
XMLPUBVAR int xmlDoValidityCheckingDefaultValue;
#endif
int xmlThrDefDoValidityCheckingDefaultValue(int v);
XMLPUBFUN int XMLCALL xmlThrDefDoValidityCheckingDefaultValue(int v);
extern xmlGenericErrorFunc *__xmlGenericError(void);
XMLPUBFUN xmlGenericErrorFunc * XMLCALL __xmlGenericError(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlGenericError \
(*(__xmlGenericError()))
#else
LIBXML_DLL_IMPORT extern xmlGenericErrorFunc xmlGenericError;
XMLPUBVAR xmlGenericErrorFunc xmlGenericError;
#endif
extern void * *__xmlGenericErrorContext(void);
XMLPUBFUN void * * XMLCALL __xmlGenericErrorContext(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlGenericErrorContext \
(*(__xmlGenericErrorContext()))
#else
LIBXML_DLL_IMPORT extern void * xmlGenericErrorContext;
XMLPUBVAR void * xmlGenericErrorContext;
#endif
extern int *__xmlGetWarningsDefaultValue(void);
XMLPUBFUN int * XMLCALL __xmlGetWarningsDefaultValue(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlGetWarningsDefaultValue \
(*(__xmlGetWarningsDefaultValue()))
#else
LIBXML_DLL_IMPORT extern int xmlGetWarningsDefaultValue;
XMLPUBVAR int xmlGetWarningsDefaultValue;
#endif
int xmlThrDefGetWarningsDefaultValue(int v);
XMLPUBFUN int XMLCALL xmlThrDefGetWarningsDefaultValue(int v);
extern int *__xmlIndentTreeOutput(void);
XMLPUBFUN int * XMLCALL __xmlIndentTreeOutput(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlIndentTreeOutput \
(*(__xmlIndentTreeOutput()))
#else
LIBXML_DLL_IMPORT extern int xmlIndentTreeOutput;
XMLPUBVAR int xmlIndentTreeOutput;
#endif
int xmlThrDefIndentTreeOutput(int v);
XMLPUBFUN int XMLCALL xmlThrDefIndentTreeOutput(int v);
extern const char * *__xmlTreeIndentString(void);
XMLPUBFUN const char * * XMLCALL __xmlTreeIndentString(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlTreeIndentString \
(*(__xmlTreeIndentString()))
#else
LIBXML_DLL_IMPORT extern const char * xmlTreeIndentString;
XMLPUBVAR const char * xmlTreeIndentString;
#endif
const char * xmlThrDefTreeIndentString(const char * v);
XMLPUBFUN const char * XMLCALL xmlThrDefTreeIndentString(const char * v);
extern int *__xmlKeepBlanksDefaultValue(void);
XMLPUBFUN int * XMLCALL __xmlKeepBlanksDefaultValue(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlKeepBlanksDefaultValue \
(*(__xmlKeepBlanksDefaultValue()))
#else
LIBXML_DLL_IMPORT extern int xmlKeepBlanksDefaultValue;
XMLPUBVAR int xmlKeepBlanksDefaultValue;
#endif
int xmlThrDefKeepBlanksDefaultValue(int v);
XMLPUBFUN int XMLCALL xmlThrDefKeepBlanksDefaultValue(int v);
extern int *__xmlLineNumbersDefaultValue(void);
XMLPUBFUN int * XMLCALL __xmlLineNumbersDefaultValue(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlLineNumbersDefaultValue \
(*(__xmlLineNumbersDefaultValue()))
#else
LIBXML_DLL_IMPORT extern int xmlLineNumbersDefaultValue;
XMLPUBVAR int xmlLineNumbersDefaultValue;
#endif
int xmlThrDefLineNumbersDefaultValue(int v);
XMLPUBFUN int XMLCALL xmlThrDefLineNumbersDefaultValue(int v);
extern int *__xmlLoadExtDtdDefaultValue(void);
XMLPUBFUN int * XMLCALL __xmlLoadExtDtdDefaultValue(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlLoadExtDtdDefaultValue \
(*(__xmlLoadExtDtdDefaultValue()))
#else
LIBXML_DLL_IMPORT extern int xmlLoadExtDtdDefaultValue;
XMLPUBVAR int xmlLoadExtDtdDefaultValue;
#endif
int xmlThrDefLoadExtDtdDefaultValue(int v);
XMLPUBFUN int XMLCALL xmlThrDefLoadExtDtdDefaultValue(int v);
extern int *__xmlParserDebugEntities(void);
XMLPUBFUN int * XMLCALL __xmlParserDebugEntities(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlParserDebugEntities \
(*(__xmlParserDebugEntities()))
#else
LIBXML_DLL_IMPORT extern int xmlParserDebugEntities;
XMLPUBVAR int xmlParserDebugEntities;
#endif
int xmlThrDefParserDebugEntities(int v);
XMLPUBFUN int XMLCALL xmlThrDefParserDebugEntities(int v);
extern const char * *__xmlParserVersion(void);
XMLPUBFUN const char * * XMLCALL __xmlParserVersion(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlParserVersion \
(*(__xmlParserVersion()))
#else
LIBXML_DLL_IMPORT extern const char * xmlParserVersion;
XMLPUBVAR const char * xmlParserVersion;
#endif
extern int *__xmlPedanticParserDefaultValue(void);
XMLPUBFUN int * XMLCALL __xmlPedanticParserDefaultValue(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlPedanticParserDefaultValue \
(*(__xmlPedanticParserDefaultValue()))
#else
LIBXML_DLL_IMPORT extern int xmlPedanticParserDefaultValue;
XMLPUBVAR int xmlPedanticParserDefaultValue;
#endif
int xmlThrDefPedanticParserDefaultValue(int v);
XMLPUBFUN int XMLCALL xmlThrDefPedanticParserDefaultValue(int v);
extern int *__xmlSaveNoEmptyTags(void);
XMLPUBFUN int * XMLCALL __xmlSaveNoEmptyTags(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlSaveNoEmptyTags \
(*(__xmlSaveNoEmptyTags()))
#else
LIBXML_DLL_IMPORT extern int xmlSaveNoEmptyTags;
XMLPUBVAR int xmlSaveNoEmptyTags;
#endif
int xmlThrDefSaveNoEmptyTags(int v);
XMLPUBFUN int XMLCALL xmlThrDefSaveNoEmptyTags(int v);
extern int *__xmlSubstituteEntitiesDefaultValue(void);
XMLPUBFUN int * XMLCALL __xmlSubstituteEntitiesDefaultValue(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlSubstituteEntitiesDefaultValue \
(*(__xmlSubstituteEntitiesDefaultValue()))
#else
LIBXML_DLL_IMPORT extern int xmlSubstituteEntitiesDefaultValue;
XMLPUBVAR int xmlSubstituteEntitiesDefaultValue;
#endif
int xmlThrDefSubstituteEntitiesDefaultValue(int v);
XMLPUBFUN int XMLCALL xmlThrDefSubstituteEntitiesDefaultValue(int v);
extern xmlRegisterNodeFunc *__xmlRegisterNodeDefaultValue(void);
XMLPUBFUN xmlRegisterNodeFunc * XMLCALL __xmlRegisterNodeDefaultValue(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlRegisterNodeDefaultValue \
(*(__xmlRegisterNodeDefaultValue()))
#else
LIBXML_DLL_IMPORT extern xmlRegisterNodeFunc xmlRegisterNodeDefaultValue;
XMLPUBVAR xmlRegisterNodeFunc XMLCALL xmlRegisterNodeDefaultValue;
#endif
extern xmlDeregisterNodeFunc *__xmlDeregisterNodeDefaultValue(void);
XMLPUBFUN xmlDeregisterNodeFunc * XMLCALL __xmlDeregisterNodeDefaultValue(void);
#ifdef LIBXML_THREAD_ENABLED
#define xmlDeregisterNodeDefaultValue \
(*(__xmlDeregisterNodeDefaultValue()))
#else
LIBXML_DLL_IMPORT extern xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValue;
XMLPUBVAR xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValue;
#endif
#ifdef __cplusplus

61
include/libxml/hash.h
View File

@ -18,6 +18,7 @@
#ifndef __XML_HASH_H__
#define __XML_HASH_H__
#include <libxml/xmlversion.h>
#include <libxml/parser.h>
#ifdef __cplusplus
@ -77,35 +78,43 @@ typedef void (*xmlHashScannerFull)(void *payload, void *data,
/*
* Constructor and destructor.
*/
xmlHashTablePtr xmlHashCreate (int size);
void xmlHashFree (xmlHashTablePtr table,
XMLPUBFUN xmlHashTablePtr XMLCALL
xmlHashCreate (int size);
XMLPUBFUN void XMLCALL
xmlHashFree (xmlHashTablePtr table,
xmlHashDeallocator f);
/*
* Add a new entry to the hash table.
*/
int xmlHashAddEntry (xmlHashTablePtr table,
XMLPUBFUN int XMLCALL
xmlHashAddEntry (xmlHashTablePtr table,
const xmlChar *name,
void *userdata);
int xmlHashUpdateEntry(xmlHashTablePtr table,
XMLPUBFUN int XMLCALL
xmlHashUpdateEntry(xmlHashTablePtr table,
const xmlChar *name,
void *userdata,
xmlHashDeallocator f);
int xmlHashAddEntry2(xmlHashTablePtr table,
XMLPUBFUN int XMLCALL
xmlHashAddEntry2(xmlHashTablePtr table,
const xmlChar *name,
const xmlChar *name2,
void *userdata);
int xmlHashUpdateEntry2(xmlHashTablePtr table,
XMLPUBFUN int XMLCALL
xmlHashUpdateEntry2(xmlHashTablePtr table,
const xmlChar *name,
const xmlChar *name2,
void *userdata,
xmlHashDeallocator f);
int xmlHashAddEntry3(xmlHashTablePtr table,
XMLPUBFUN int XMLCALL
xmlHashAddEntry3(xmlHashTablePtr table,
const xmlChar *name,
const xmlChar *name2,
const xmlChar *name3,
void *userdata);
int xmlHashUpdateEntry3(xmlHashTablePtr table,
XMLPUBFUN int XMLCALL
xmlHashUpdateEntry3(xmlHashTablePtr table,
const xmlChar *name,
const xmlChar *name2,
const xmlChar *name3,
@ -115,23 +124,29 @@ int xmlHashUpdateEntry3(xmlHashTablePtr table,
/*
* Remove an entry from the hash table.
*/
int xmlHashRemoveEntry(xmlHashTablePtr table, const xmlChar *name,
XMLPUBFUN int XMLCALL
xmlHashRemoveEntry(xmlHashTablePtr table, const xmlChar *name,
xmlHashDeallocator f);
int xmlHashRemoveEntry2(xmlHashTablePtr table, const xmlChar *name,
XMLPUBFUN int XMLCALL
xmlHashRemoveEntry2(xmlHashTablePtr table, const xmlChar *name,
const xmlChar *name2, xmlHashDeallocator f);
int xmlHashRemoveEntry3(xmlHashTablePtr table, const xmlChar *name,
XMLPUBFUN int XMLCALL
xmlHashRemoveEntry3(xmlHashTablePtr table, const xmlChar *name,
const xmlChar *name2, const xmlChar *name3,
xmlHashDeallocator f);
/*
* Retrieve the userdata.
*/
void * xmlHashLookup (xmlHashTablePtr table,
XMLPUBFUN void * XMLCALL
xmlHashLookup (xmlHashTablePtr table,
const xmlChar *name);
void * xmlHashLookup2 (xmlHashTablePtr table,
XMLPUBFUN void * XMLCALL
xmlHashLookup2 (xmlHashTablePtr table,
const xmlChar *name,
const xmlChar *name2);
void * xmlHashLookup3 (xmlHashTablePtr table,
XMLPUBFUN void * XMLCALL
xmlHashLookup3 (xmlHashTablePtr table,
const xmlChar *name,
const xmlChar *name2,
const xmlChar *name3);
@ -139,22 +154,28 @@ void * xmlHashLookup3 (xmlHashTablePtr table,
/*
* Helpers.
*/
xmlHashTablePtr xmlHashCopy (xmlHashTablePtr table,
XMLPUBFUN xmlHashTablePtr XMLCALL
xmlHashCopy (xmlHashTablePtr table,
xmlHashCopier f);
int xmlHashSize (xmlHashTablePtr table);
void xmlHashScan (xmlHashTablePtr table,
XMLPUBFUN int XMLCALL
xmlHashSize (xmlHashTablePtr table);
XMLPUBFUN void XMLCALL
xmlHashScan (xmlHashTablePtr table,
xmlHashScanner f,
void *data);
void xmlHashScan3 (xmlHashTablePtr table,
XMLPUBFUN void XMLCALL
xmlHashScan3 (xmlHashTablePtr table,
const xmlChar *name,
const xmlChar *name2,
const xmlChar *name3,
xmlHashScanner f,
void *data);
void xmlHashScanFull (xmlHashTablePtr table,
XMLPUBFUN void XMLCALL
xmlHashScanFull (xmlHashTablePtr table,
xmlHashScannerFull f,
void *data);
void xmlHashScanFull3(xmlHashTablePtr table,
XMLPUBFUN void XMLCALL
xmlHashScanFull3(xmlHashTablePtr table,
const xmlChar *name,
const xmlChar *name2,
const xmlChar *name3,

80
include/libxml/list.h
View File

@ -18,6 +18,8 @@
#ifndef __XML_LINK_INCLUDE__
#define __XML_LINK_INCLUDE__
#include <libxml/xmlversion.h>
#ifdef __cplusplus
extern "C" {
#endif
@ -57,54 +59,80 @@ typedef int (*xmlListDataCompare) (const void *data0, const void *data1);
typedef int (*xmlListWalker) (const void *data, const void *user);
/* Creation/Deletion */
xmlListPtr xmlListCreate (xmlListDeallocator deallocator,
XMLPUBFUN xmlListPtr XMLCALL
xmlListCreate (xmlListDeallocator deallocator,
xmlListDataCompare compare);
void xmlListDelete (xmlListPtr l);
XMLPUBFUN void XMLCALL
xmlListDelete (xmlListPtr l);
/* Basic Operators */
void * xmlListSearch (xmlListPtr l,
XMLPUBFUN void * XMLCALL
xmlListSearch (xmlListPtr l,
void *data);
void * xmlListReverseSearch (xmlListPtr l,
XMLPUBFUN void * XMLCALL
xmlListReverseSearch (xmlListPtr l,
void *data);
int xmlListInsert (xmlListPtr l,
XMLPUBFUN int XMLCALL
xmlListInsert (xmlListPtr l,
void *data) ;
int xmlListAppend (xmlListPtr l,
XMLPUBFUN int XMLCALL
xmlListAppend (xmlListPtr l,
void *data) ;
int xmlListRemoveFirst (xmlListPtr l,
XMLPUBFUN int XMLCALL
xmlListRemoveFirst (xmlListPtr l,
void *data);
int xmlListRemoveLast (xmlListPtr l,
XMLPUBFUN int XMLCALL
xmlListRemoveLast (xmlListPtr l,
void *data);
int xmlListRemoveAll (xmlListPtr l,
XMLPUBFUN int XMLCALL
xmlListRemoveAll (xmlListPtr l,
void *data);
void xmlListClear (xmlListPtr l);
int xmlListEmpty (xmlListPtr l);
xmlLinkPtr xmlListFront (xmlListPtr l);
xmlLinkPtr xmlListEnd (xmlListPtr l);
int xmlListSize (xmlListPtr l);
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);
void xmlListPopFront (xmlListPtr l);
void xmlListPopBack (xmlListPtr l);
int xmlListPushFront (xmlListPtr l,
XMLPUBFUN void XMLCALL
xmlListPopFront (xmlListPtr l);
XMLPUBFUN void XMLCALL
xmlListPopBack (xmlListPtr l);
XMLPUBFUN int XMLCALL
xmlListPushFront (xmlListPtr l,
void *data);
int xmlListPushBack (xmlListPtr l,
XMLPUBFUN int XMLCALL
xmlListPushBack (xmlListPtr l,
void *data);
/* Advanced Operators */
void xmlListReverse (xmlListPtr l);
void xmlListSort (xmlListPtr l);
void xmlListWalk (xmlListPtr l,
XMLPUBFUN void XMLCALL
xmlListReverse (xmlListPtr l);
XMLPUBFUN void XMLCALL
xmlListSort (xmlListPtr l);
XMLPUBFUN void XMLCALL
xmlListWalk (xmlListPtr l,
xmlListWalker walker,
const void *user);
void xmlListReverseWalk (xmlListPtr l,
XMLPUBFUN void XMLCALL
xmlListReverseWalk (xmlListPtr l,
xmlListWalker walker,
const void *user);
void xmlListMerge (xmlListPtr l1,
XMLPUBFUN void XMLCALL
xmlListMerge (xmlListPtr l1,
xmlListPtr l2);
xmlListPtr xmlListDup (const xmlListPtr old);
int xmlListCopy (xmlListPtr cur,
XMLPUBFUN xmlListPtr XMLCALL
xmlListDup (const xmlListPtr old);
XMLPUBFUN int XMLCALL
xmlListCopy (xmlListPtr cur,
const xmlListPtr old);
/* Link operators */
void * xmlLinkGetData (xmlLinkPtr lk);
XMLPUBFUN void * XMLCALL
xmlLinkGetData (xmlLinkPtr lk);
/* xmlListUnique() */
/* xmlListSwap */

66
include/libxml/nanoftp.h
View File

@ -56,59 +56,81 @@ typedef void (*ftpDataCallback) (void *userData,
/*
* Init
*/
void xmlNanoFTPInit (void);
void xmlNanoFTPCleanup (void);
XMLPUBFUN void XMLCALL
xmlNanoFTPInit (void);
XMLPUBFUN void XMLCALL
xmlNanoFTPCleanup (void);
/*
* Creating/freeing contexts.
*/
void * xmlNanoFTPNewCtxt (const char *URL);
void xmlNanoFTPFreeCtxt (void * ctx);
void * xmlNanoFTPConnectTo (const char *server,
XMLPUBFUN void * XMLCALL
xmlNanoFTPNewCtxt (const char *URL);
XMLPUBFUN void XMLCALL
xmlNanoFTPFreeCtxt (void * ctx);
XMLPUBFUN void * XMLCALL
xmlNanoFTPConnectTo (const char *server,
int port);
/*
* Opening/closing session connections.
*/
void * xmlNanoFTPOpen (const char *URL);
int xmlNanoFTPConnect (void *ctx);
int xmlNanoFTPClose (void *ctx);
int xmlNanoFTPQuit (void *ctx);
void xmlNanoFTPScanProxy (const char *URL);
void xmlNanoFTPProxy (const char *host,
XMLPUBFUN void * XMLCALL
xmlNanoFTPOpen (const char *URL);
XMLPUBFUN int XMLCALL
xmlNanoFTPConnect (void *ctx);
XMLPUBFUN int XMLCALL
xmlNanoFTPClose (void *ctx);
XMLPUBFUN int XMLCALL
xmlNanoFTPQuit (void *ctx);
XMLPUBFUN void XMLCALL
xmlNanoFTPScanProxy (const char *URL);
XMLPUBFUN void XMLCALL
xmlNanoFTPProxy (const char *host,
int port,
const char *user,
const char *passwd,
int type);
int xmlNanoFTPUpdateURL (void *ctx,
XMLPUBFUN int XMLCALL
xmlNanoFTPUpdateURL (void *ctx,
const char *URL);
/*
* Rather internal commands.
*/
int xmlNanoFTPGetResponse (void *ctx);
int xmlNanoFTPCheckResponse (void *ctx);
XMLPUBFUN int XMLCALL
xmlNanoFTPGetResponse (void *ctx);
XMLPUBFUN int XMLCALL
xmlNanoFTPCheckResponse (void *ctx);
/*
* CD/DIR/GET handlers.
*/
int xmlNanoFTPCwd (void *ctx,
XMLPUBFUN int XMLCALL
xmlNanoFTPCwd (void *ctx,
char *directory);
int xmlNanoFTPDele (void *ctx,
XMLPUBFUN int XMLCALL
xmlNanoFTPDele (void *ctx,
char *file);
int xmlNanoFTPGetConnection (void *ctx);
int xmlNanoFTPCloseConnection(void *ctx);
int xmlNanoFTPList (void *ctx,
XMLPUBFUN int XMLCALL
xmlNanoFTPGetConnection (void *ctx);
XMLPUBFUN int XMLCALL
xmlNanoFTPCloseConnection(void *ctx);
XMLPUBFUN int XMLCALL
xmlNanoFTPList (void *ctx,
ftpListCallback callback,
void *userData,
char *filename);
int xmlNanoFTPGetSocket (void *ctx,
XMLPUBFUN int XMLCALL
xmlNanoFTPGetSocket (void *ctx,
const char *filename);
int xmlNanoFTPGet (void *ctx,
XMLPUBFUN int XMLCALL
xmlNanoFTPGet (void *ctx,
ftpDataCallback callback,
void *userData,
const char *filename);
int xmlNanoFTPRead (void *ctx,
XMLPUBFUN int XMLCALL
xmlNanoFTPRead (void *ctx,
void *dest,
int len);

41
include/libxml/nanohttp.h
View File

@ -16,41 +16,54 @@
#ifdef __cplusplus
extern "C" {
#endif
void xmlNanoHTTPInit (void);
void xmlNanoHTTPCleanup (void);
void xmlNanoHTTPScanProxy (const char *URL);
int xmlNanoHTTPFetch (const char *URL,
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);
void * xmlNanoHTTPMethod (const char *URL,
XMLPUBFUN void * XMLCALL
xmlNanoHTTPMethod (const char *URL,
const char *method,
const char *input,
char **contentType,
const char *headers,
int ilen);
void * xmlNanoHTTPMethodRedir (const char *URL,
XMLPUBFUN void * XMLCALL
xmlNanoHTTPMethodRedir (const char *URL,
const char *method,
const char *input,
char **contentType,
char **redir,
const char *headers,
int ilen);
void * xmlNanoHTTPOpen (const char *URL,
XMLPUBFUN void * XMLCALL
xmlNanoHTTPOpen (const char *URL,
char **contentType);
void * xmlNanoHTTPOpenRedir (const char *URL,
XMLPUBFUN void * XMLCALL
xmlNanoHTTPOpenRedir (const char *URL,
char **contentType,
char **redir);
int xmlNanoHTTPReturnCode (void *ctx);
const char * xmlNanoHTTPAuthHeader(void *ctx);
int xmlNanoHTTPRead (void *ctx,
XMLPUBFUN int XMLCALL
xmlNanoHTTPReturnCode (void *ctx);
XMLPUBFUN const char * XMLCALL
xmlNanoHTTPAuthHeader(void *ctx);
XMLPUBFUN int XMLCALL
xmlNanoHTTPRead (void *ctx,
void *dest,
int len);
int xmlNanoHTTPSave (void *ctxt,
XMLPUBFUN int XMLCALL
xmlNanoHTTPSave (void *ctxt,
const char *filename);
void xmlNanoHTTPClose (void *ctx);
XMLPUBFUN void XMLCALL
xmlNanoHTTPClose (void *ctx);
#ifdef __cplusplus
}
#endif
#endif /* LIBXML_HTTP_ENABLED */
#endif
#endif /* __NANO_HTTP_H__ */

207
include/libxml/parser.h
View File

@ -9,6 +9,7 @@
#ifndef __XML_PARSER_H__
#define __XML_PARSER_H__
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#include <libxml/dict.h>
#include <libxml/valid.h>
@ -736,9 +737,11 @@ LIBXML_DLL_IMPORT extern int xmlGetWarningsDefaultValue;
#ifdef __cplusplus
}
#endif
#include <libxml/encoding.h>
#include <libxml/xmlIO.h>
#include <libxml/globals.h>
#ifdef __cplusplus
extern "C" {
#endif
@ -747,138 +750,187 @@ extern "C" {
/*
* Init/Cleanup
*/
void xmlInitParser (void);
void xmlCleanupParser (void);
XMLPUBFUN void XMLCALL
xmlInitParser (void);
XMLPUBFUN void XMLCALL
xmlCleanupParser (void);
/*
* Input functions
*/
int xmlParserInputRead (xmlParserInputPtr in,
XMLPUBFUN int XMLCALL
xmlParserInputRead (xmlParserInputPtr in,
int len);
int xmlParserInputGrow (xmlParserInputPtr in,
XMLPUBFUN int XMLCALL
xmlParserInputGrow (xmlParserInputPtr in,
int len);
/*
* xmlChar handling
*/
xmlChar * xmlStrdup (const xmlChar *cur);
xmlChar * xmlStrndup (const xmlChar *cur,
XMLPUBFUN xmlChar * XMLCALL
xmlStrdup (const xmlChar *cur);
XMLPUBFUN xmlChar * XMLCALL
xmlStrndup (const xmlChar *cur,
int len);
xmlChar * xmlCharStrndup (const char *cur,
XMLPUBFUN xmlChar * XMLCALL
xmlCharStrndup (const char *cur,
int len);
xmlChar * xmlCharStrdup (const char *cur);
xmlChar * xmlStrsub (const xmlChar *str,
XMLPUBFUN xmlChar * XMLCALL
xmlCharStrdup (const char *cur);
XMLPUBFUN xmlChar * XMLCALL
xmlStrsub (const xmlChar *str,
int start,
int len);
const xmlChar * xmlStrchr (const xmlChar *str,
XMLPUBFUN const xmlChar * XMLCALL
xmlStrchr (const xmlChar *str,
xmlChar val);
const xmlChar * xmlStrstr (const xmlChar *str,
XMLPUBFUN const xmlChar * XMLCALL
xmlStrstr (const xmlChar *str,
const xmlChar *val);
const xmlChar * xmlStrcasestr (const xmlChar *str,
XMLPUBFUN const xmlChar * XMLCALL
xmlStrcasestr (const xmlChar *str,
xmlChar *val);
int xmlStrcmp (const xmlChar *str1,
XMLPUBFUN int XMLCALL
xmlStrcmp (const xmlChar *str1,
const xmlChar *str2);
int xmlStrncmp (const xmlChar *str1,
XMLPUBFUN int XMLCALL
xmlStrncmp (const xmlChar *str1,
const xmlChar *str2,
int len);
int xmlStrcasecmp (const xmlChar *str1,
XMLPUBFUN int XMLCALL
xmlStrcasecmp (const xmlChar *str1,
const xmlChar *str2);
int xmlStrncasecmp (const xmlChar *str1,
XMLPUBFUN int XMLCALL
xmlStrncasecmp (const xmlChar *str1,
const xmlChar *str2,
int len);
int xmlStrEqual (const xmlChar *str1,
XMLPUBFUN int XMLCALL
xmlStrEqual (const xmlChar *str1,
const xmlChar *str2);
int xmlStrlen (const xmlChar *str);
xmlChar * xmlStrcat (xmlChar *cur,
XMLPUBFUN int XMLCALL
xmlStrlen (const xmlChar *str);
XMLPUBFUN xmlChar * XMLCALL
xmlStrcat (xmlChar *cur,
const xmlChar *add);
xmlChar * xmlStrncat (xmlChar *cur,
XMLPUBFUN xmlChar * XMLCALL
xmlStrncat (xmlChar *cur,
const xmlChar *add,
int len);
/*
* Basic parsing Interfaces
*/
xmlDocPtr xmlParseDoc (xmlChar *cur);
xmlDocPtr xmlParseMemory (const char *buffer,
XMLPUBFUN xmlDocPtr XMLCALL
xmlParseDoc (xmlChar *cur);
XMLPUBFUN xmlDocPtr XMLCALL
xmlParseMemory (const char *buffer,
int size);
xmlDocPtr xmlParseFile (const char *filename);
int xmlSubstituteEntitiesDefault(int val);
int xmlKeepBlanksDefault (int val);
void xmlStopParser (xmlParserCtxtPtr ctxt);
int xmlPedanticParserDefault(int val);
int xmlLineNumbersDefault (int val);
XMLPUBFUN xmlDocPtr XMLCALL
xmlParseFile (const char *filename);
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);
/*
* Recovery mode
*/
xmlDocPtr xmlRecoverDoc (xmlChar *cur);
xmlDocPtr xmlRecoverMemory (const char *buffer,
XMLPUBFUN xmlDocPtr XMLCALL
xmlRecoverDoc (xmlChar *cur);
XMLPUBFUN xmlDocPtr XMLCALL
xmlRecoverMemory (const char *buffer,
int size);
xmlDocPtr xmlRecoverFile (const char *filename);
XMLPUBFUN xmlDocPtr XMLCALL
xmlRecoverFile (const char *filename);
/*
* Less common routines and SAX interfaces
*/
int xmlParseDocument (xmlParserCtxtPtr ctxt);
int xmlParseExtParsedEnt (xmlParserCtxtPtr ctxt);
xmlDocPtr xmlSAXParseDoc (xmlSAXHandlerPtr sax,
XMLPUBFUN int XMLCALL
xmlParseDocument (xmlParserCtxtPtr ctxt);
XMLPUBFUN int XMLCALL
xmlParseExtParsedEnt (xmlParserCtxtPtr ctxt);
XMLPUBFUN xmlDocPtr XMLCALL
xmlSAXParseDoc (xmlSAXHandlerPtr sax,
xmlChar *cur,
int recovery);
int xmlSAXUserParseFile (xmlSAXHandlerPtr sax,
XMLPUBFUN int XMLCALL
xmlSAXUserParseFile (xmlSAXHandlerPtr sax,
void *user_data,
const char *filename);
int xmlSAXUserParseMemory (xmlSAXHandlerPtr sax,
XMLPUBFUN int XMLCALL
xmlSAXUserParseMemory (xmlSAXHandlerPtr sax,
void *user_data,
const char *buffer,
int size);
xmlDocPtr xmlSAXParseMemory (xmlSAXHandlerPtr sax,
XMLPUBFUN xmlDocPtr XMLCALL
xmlSAXParseMemory (xmlSAXHandlerPtr sax,
const char *buffer,
int size,
int recovery);
xmlDocPtr xmlSAXParseMemoryWithData (xmlSAXHandlerPtr sax,
XMLPUBFUN xmlDocPtr XMLCALL
xmlSAXParseMemoryWithData (xmlSAXHandlerPtr sax,
const char *buffer,
int size,
int recovery,
void *data);
xmlDocPtr xmlSAXParseFile (xmlSAXHandlerPtr sax,
XMLPUBFUN xmlDocPtr XMLCALL
xmlSAXParseFile (xmlSAXHandlerPtr sax,
const char *filename,
int recovery);
xmlDocPtr xmlSAXParseFileWithData (xmlSAXHandlerPtr sax,
XMLPUBFUN xmlDocPtr XMLCALL
xmlSAXParseFileWithData (xmlSAXHandlerPtr sax,
const char *filename,
int recovery,
void *data);
xmlDocPtr xmlSAXParseEntity (xmlSAXHandlerPtr sax,
XMLPUBFUN xmlDocPtr XMLCALL
xmlSAXParseEntity (xmlSAXHandlerPtr sax,
const char *filename);
xmlDocPtr xmlParseEntity (const char *filename);
xmlDtdPtr xmlParseDTD (const xmlChar *ExternalID,
XMLPUBFUN xmlDocPtr XMLCALL
xmlParseEntity (const char *filename);
XMLPUBFUN xmlDtdPtr XMLCALL
xmlParseDTD (const xmlChar *ExternalID,
const xmlChar *SystemID);
xmlDtdPtr xmlSAXParseDTD (xmlSAXHandlerPtr sax,
XMLPUBFUN xmlDtdPtr XMLCALL
xmlSAXParseDTD (xmlSAXHandlerPtr sax,
const xmlChar *ExternalID,
const xmlChar *SystemID);
xmlDtdPtr xmlIOParseDTD (xmlSAXHandlerPtr sax,
XMLPUBFUN xmlDtdPtr XMLCALL
xmlIOParseDTD (xmlSAXHandlerPtr sax,
xmlParserInputBufferPtr input,
xmlCharEncoding enc);
int xmlParseBalancedChunkMemory(xmlDocPtr doc,
XMLPUBFUN int XMLCALL
xmlParseBalancedChunkMemory(xmlDocPtr doc,
xmlSAXHandlerPtr sax,
void *user_data,
int depth,
const xmlChar *string,
xmlNodePtr *lst);
int xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc,
XMLPUBFUN int XMLCALL
xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc,
xmlSAXHandlerPtr sax,
void *user_data,
int depth,
const xmlChar *string,
xmlNodePtr *lst,
int recover);
int xmlParseExternalEntity (xmlDocPtr doc,
XMLPUBFUN int XMLCALL
xmlParseExternalEntity (xmlDocPtr doc,
xmlSAXHandlerPtr sax,
void *user_data,
int depth,
const xmlChar *URL,
const xmlChar *ID,
xmlNodePtr *lst);
int xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx,
XMLPUBFUN int XMLCALL
xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx,
const xmlChar *URL,
const xmlChar *ID,
xmlNodePtr *lst);
@ -886,36 +938,46 @@ int xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx,
/*
* Parser contexts handling.
*/
int xmlInitParserCtxt (xmlParserCtxtPtr ctxt);
void xmlClearParserCtxt (xmlParserCtxtPtr ctxt);
void xmlFreeParserCtxt (xmlParserCtxtPtr ctxt);
void xmlSetupParserForBuffer (xmlParserCtxtPtr ctxt,
XMLPUBFUN int XMLCALL
xmlInitParserCtxt (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlClearParserCtxt (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlFreeParserCtxt (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
xmlSetupParserForBuffer (xmlParserCtxtPtr ctxt,
const xmlChar* buffer,
const char *filename);
xmlParserCtxtPtr xmlCreateDocParserCtxt (xmlChar *cur);
XMLPUBFUN xmlParserCtxtPtr XMLCALL
xmlCreateDocParserCtxt (xmlChar *cur);
/*
* Reading/setting optional parsing features.
*/
int xmlGetFeaturesList (int *len,
XMLPUBFUN int XMLCALL
xmlGetFeaturesList (int *len,
const char **result);
int xmlGetFeature (xmlParserCtxtPtr ctxt,
XMLPUBFUN int XMLCALL
xmlGetFeature (xmlParserCtxtPtr ctxt,
const char *name,
void *result);
int xmlSetFeature (xmlParserCtxtPtr ctxt,
XMLPUBFUN int XMLCALL
xmlSetFeature (xmlParserCtxtPtr ctxt,
const char *name,
void *value);
/*
* Interfaces for the Push mode.
*/
xmlParserCtxtPtr xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax,
XMLPUBFUN xmlParserCtxtPtr XMLCALL
xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax,
void *user_data,
const char *chunk,
int size,
const char *filename);
int xmlParseChunk (xmlParserCtxtPtr ctxt,
XMLPUBFUN int XMLCALL
xmlParseChunk (xmlParserCtxtPtr ctxt,
const char *chunk,
int size,
int terminate);
@ -924,38 +986,45 @@ int xmlParseChunk (xmlParserCtxtPtr ctxt,
* Special I/O mode.
*/
xmlParserCtxtPtr xmlCreateIOParserCtxt (xmlSAXHandlerPtr sax,
XMLPUBFUN xmlParserCtxtPtr XMLCALL
xmlCreateIOParserCtxt (xmlSAXHandlerPtr sax,
void *user_data,
xmlInputReadCallback ioread,
xmlInputCloseCallback ioclose,
void *ioctx,
xmlCharEncoding enc);
xmlParserInputPtr xmlNewIOInputStream (xmlParserCtxtPtr ctxt,
XMLPUBFUN xmlParserInputPtr XMLCALL
xmlNewIOInputStream (xmlParserCtxtPtr ctxt,
xmlParserInputBufferPtr input,
xmlCharEncoding enc);
/*
* Node infos.
*/
const xmlParserNodeInfo*
XMLPUBFUN const xmlParserNodeInfo* XMLCALL
xmlParserFindNodeInfo (const xmlParserCtxtPtr ctxt,
const xmlNodePtr node);
void xmlInitNodeInfoSeq (xmlParserNodeInfoSeqPtr seq);
void xmlClearNodeInfoSeq (xmlParserNodeInfoSeqPtr seq);
unsigned long xmlParserFindNodeInfoIndex(const xmlParserNodeInfoSeqPtr seq,
XMLPUBFUN void XMLCALL
xmlInitNodeInfoSeq (xmlParserNodeInfoSeqPtr seq);
XMLPUBFUN void XMLCALL
xmlClearNodeInfoSeq (xmlParserNodeInfoSeqPtr seq);
XMLPUBFUN unsigned long XMLCALL
xmlParserFindNodeInfoIndex(const xmlParserNodeInfoSeqPtr seq,
const xmlNodePtr node);
void xmlParserAddNodeInfo (xmlParserCtxtPtr ctxt,
XMLPUBFUN void XMLCALL
xmlParserAddNodeInfo (xmlParserCtxtPtr ctxt,
const xmlParserNodeInfoPtr info);
/*
* External entities handling actually implemented in xmlIO.
*/
void xmlSetExternalEntityLoader(xmlExternalEntityLoader f);
xmlExternalEntityLoader
XMLPUBFUN void XMLCALL
xmlSetExternalEntityLoader(xmlExternalEntityLoader f);
XMLPUBFUN xmlExternalEntityLoader XMLCALL
xmlGetExternalEntityLoader(void);
xmlParserInputPtr
XMLPUBFUN xmlParserInputPtr XMLCALL
xmlLoadExternalEntity (const char *URL,
const char *ID,
xmlParserCtxtPtr ctxt);

198
include/libxml/parserInternals.h
View File

@ -10,6 +10,7 @@
#ifndef __XML_PARSER_INTERNALS_H__
#define __XML_PARSER_INTERNALS_H__
#include <libxml/xmlversion.h>
#include <libxml/parser.h>
#include <libxml/HTMLparser.h>
@ -173,134 +174,135 @@ extern "C" {
/**
* Global variables used for predefined strings.
*/
LIBXML_DLL_IMPORT extern const xmlChar xmlStringText[];
LIBXML_DLL_IMPORT extern const xmlChar xmlStringTextNoenc[];
LIBXML_DLL_IMPORT extern const xmlChar xmlStringComment[];
XMLPUBVAR const xmlChar xmlStringText[];
XMLPUBVAR const xmlChar xmlStringTextNoenc[];
XMLPUBVAR const xmlChar xmlStringComment[];
/*
* Function to finish the work of the macros where needed.
*/
int xmlIsBaseChar (int c);
int xmlIsBlank (int c);
int xmlIsPubidChar (int c);
int xmlIsLetter (int c);
int xmlIsDigit (int c);
int xmlIsIdeographic(int c);
int xmlIsExtender (int c);
int xmlIsCombining (int c);
int xmlIsChar (int c);
XMLPUBFUN int XMLCALL xmlIsBaseChar (int c);
XMLPUBFUN int XMLCALL xmlIsBlank (int c);
XMLPUBFUN int XMLCALL xmlIsPubidChar (int c);
XMLPUBFUN int XMLCALL xmlIsLetter (int c);
XMLPUBFUN int XMLCALL xmlIsDigit (int c);
XMLPUBFUN int XMLCALL xmlIsIdeographic(int c);
XMLPUBFUN int XMLCALL xmlIsExtender (int c);
XMLPUBFUN int XMLCALL xmlIsCombining (int c);
XMLPUBFUN int XMLCALL xmlIsChar (int c);
/**
* Parser context.
*/
xmlParserCtxtPtr xmlCreateFileParserCtxt (const char *filename);
xmlParserCtxtPtr xmlCreateMemoryParserCtxt(const char *buffer,
XMLPUBFUN xmlParserCtxtPtr XMLCALL
xmlCreateFileParserCtxt (const char *filename);
XMLPUBFUN xmlParserCtxtPtr XMLCALL xmlCreateMemoryParserCtxt(const char *buffer,
int size);
xmlParserCtxtPtr xmlNewParserCtxt (void);
xmlParserCtxtPtr xmlCreateEntityParserCtxt(const xmlChar *URL,
XMLPUBFUN xmlParserCtxtPtr XMLCALL xmlNewParserCtxt (void);
XMLPUBFUN xmlParserCtxtPtr XMLCALL xmlCreateEntityParserCtxt(const xmlChar *URL,
const xmlChar *ID,
const xmlChar *base);
int xmlSwitchEncoding (xmlParserCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlSwitchEncoding (xmlParserCtxtPtr ctxt,
xmlCharEncoding enc);
int xmlSwitchToEncoding (xmlParserCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlSwitchToEncoding (xmlParserCtxtPtr ctxt,
xmlCharEncodingHandlerPtr handler);
/**
* Entities
*/
void xmlHandleEntity (xmlParserCtxtPtr ctxt,
XMLPUBFUN void XMLCALL xmlHandleEntity (xmlParserCtxtPtr ctxt,
xmlEntityPtr entity);
/**
* Input Streams.
*/
xmlParserInputPtr xmlNewStringInputStream (xmlParserCtxtPtr ctxt,
XMLPUBFUN xmlParserInputPtr XMLCALL xmlNewStringInputStream (xmlParserCtxtPtr ctxt,
const xmlChar *buffer);
xmlParserInputPtr xmlNewEntityInputStream (xmlParserCtxtPtr ctxt,
XMLPUBFUN xmlParserInputPtr XMLCALL xmlNewEntityInputStream (xmlParserCtxtPtr ctxt,
xmlEntityPtr entity);
void xmlPushInput (xmlParserCtxtPtr ctxt,
XMLPUBFUN void XMLCALL xmlPushInput (xmlParserCtxtPtr ctxt,
xmlParserInputPtr input);
xmlChar xmlPopInput (xmlParserCtxtPtr ctxt);
void xmlFreeInputStream (xmlParserInputPtr input);
xmlParserInputPtr xmlNewInputFromFile (xmlParserCtxtPtr ctxt,
XMLPUBFUN xmlChar XMLCALL xmlPopInput (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL xmlFreeInputStream (xmlParserInputPtr input);
XMLPUBFUN xmlParserInputPtr XMLCALL xmlNewInputFromFile (xmlParserCtxtPtr ctxt,
const char *filename);
xmlParserInputPtr xmlNewInputStream (xmlParserCtxtPtr ctxt);
XMLPUBFUN xmlParserInputPtr XMLCALL xmlNewInputStream (xmlParserCtxtPtr ctxt);
/**
* Namespaces.
*/
xmlChar * xmlSplitQName (xmlParserCtxtPtr ctxt,
XMLPUBFUN xmlChar * XMLCALL xmlSplitQName (xmlParserCtxtPtr ctxt,
const xmlChar *name,
xmlChar **prefix);
xmlChar * xmlNamespaceParseNCName (xmlParserCtxtPtr ctxt);
xmlChar * xmlNamespaceParseQName (xmlParserCtxtPtr ctxt,
XMLPUBFUN xmlChar * XMLCALL xmlNamespaceParseNCName (xmlParserCtxtPtr ctxt);
XMLPUBFUN xmlChar * XMLCALL xmlNamespaceParseQName (xmlParserCtxtPtr ctxt,
xmlChar **prefix);
xmlChar * xmlNamespaceParseNSDef (xmlParserCtxtPtr ctxt);
xmlChar * xmlParseQuotedString (xmlParserCtxtPtr ctxt);
void xmlParseNamespace (xmlParserCtxtPtr ctxt);
XMLPUBFUN xmlChar * XMLCALL xmlNamespaceParseNSDef (xmlParserCtxtPtr ctxt);
XMLPUBFUN xmlChar * XMLCALL xmlParseQuotedString (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL xmlParseNamespace (xmlParserCtxtPtr ctxt);
/**
* Generic production rules.
*/
xmlChar * xmlScanName (xmlParserCtxtPtr ctxt);
const xmlChar * xmlParseName (xmlParserCtxtPtr ctxt);
xmlChar * xmlParseNmtoken (xmlParserCtxtPtr ctxt);
xmlChar * xmlParseEntityValue (xmlParserCtxtPtr ctxt,
XMLPUBFUN xmlChar * XMLCALL xmlScanName (xmlParserCtxtPtr ctxt);
XMLPUBFUN const xmlChar * XMLCALL xmlParseName (xmlParserCtxtPtr ctxt);
XMLPUBFUN xmlChar * XMLCALL xmlParseNmtoken (xmlParserCtxtPtr ctxt);
XMLPUBFUN xmlChar * XMLCALL xmlParseEntityValue (xmlParserCtxtPtr ctxt,
xmlChar **orig);
xmlChar * xmlParseAttValue (xmlParserCtxtPtr ctxt);
xmlChar * xmlParseSystemLiteral (xmlParserCtxtPtr ctxt);
xmlChar * xmlParsePubidLiteral (xmlParserCtxtPtr ctxt);
void xmlParseCharData (xmlParserCtxtPtr ctxt,
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);
xmlChar * xmlParseExternalID (xmlParserCtxtPtr ctxt,
XMLPUBFUN xmlChar * XMLCALL xmlParseExternalID (xmlParserCtxtPtr ctxt,
xmlChar **publicID,
int strict);
void xmlParseComment (xmlParserCtxtPtr ctxt);
const xmlChar * xmlParsePITarget (xmlParserCtxtPtr ctxt);
void xmlParsePI (xmlParserCtxtPtr ctxt);
void xmlParseNotationDecl (xmlParserCtxtPtr ctxt);
void xmlParseEntityDecl (xmlParserCtxtPtr ctxt);
int xmlParseDefaultDecl (xmlParserCtxtPtr ctxt,
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);
xmlEnumerationPtr xmlParseNotationType (xmlParserCtxtPtr ctxt);
xmlEnumerationPtr xmlParseEnumerationType (xmlParserCtxtPtr ctxt);
int xmlParseEnumeratedType (xmlParserCtxtPtr ctxt,
XMLPUBFUN xmlEnumerationPtr XMLCALL xmlParseNotationType (xmlParserCtxtPtr ctxt);
XMLPUBFUN xmlEnumerationPtr XMLCALL xmlParseEnumerationType (xmlParserCtxtPtr ctxt);
XMLPUBFUN int XMLCALL xmlParseEnumeratedType (xmlParserCtxtPtr ctxt,
xmlEnumerationPtr *tree);
int xmlParseAttributeType (xmlParserCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlParseAttributeType (xmlParserCtxtPtr ctxt,
xmlEnumerationPtr *tree);
void xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt);
xmlElementContentPtr xmlParseElementMixedContentDecl
XMLPUBFUN void XMLCALL xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt);
XMLPUBFUN xmlElementContentPtr XMLCALL xmlParseElementMixedContentDecl
(xmlParserCtxtPtr ctxt,
xmlParserInputPtr inputchk);
xmlElementContentPtr xmlParseElementChildrenContentDecl
XMLPUBFUN xmlElementContentPtr XMLCALL xmlParseElementChildrenContentDecl
(xmlParserCtxtPtr ctxt,
xmlParserInputPtr inputchk);
int xmlParseElementContentDecl(xmlParserCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlParseElementContentDecl(xmlParserCtxtPtr ctxt,
const xmlChar *name,
xmlElementContentPtr *result);
int xmlParseElementDecl (xmlParserCtxtPtr ctxt);
void xmlParseMarkupDecl (xmlParserCtxtPtr ctxt);
int xmlParseCharRef (xmlParserCtxtPtr ctxt);
xmlEntityPtr xmlParseEntityRef (xmlParserCtxtPtr ctxt);
void xmlParseReference (xmlParserCtxtPtr ctxt);
void xmlParsePEReference (xmlParserCtxtPtr ctxt);
void xmlParseDocTypeDecl (xmlParserCtxtPtr ctxt);
const xmlChar * xmlParseAttribute (xmlParserCtxtPtr ctxt,
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);
XMLPUBFUN const xmlChar * XMLCALL xmlParseAttribute (xmlParserCtxtPtr ctxt,
xmlChar **value);
const xmlChar * xmlParseStartTag (xmlParserCtxtPtr ctxt);
void xmlParseEndTag (xmlParserCtxtPtr ctxt);
void xmlParseCDSect (xmlParserCtxtPtr ctxt);
void xmlParseContent (xmlParserCtxtPtr ctxt);
void xmlParseElement (xmlParserCtxtPtr ctxt);
xmlChar * xmlParseVersionNum (xmlParserCtxtPtr ctxt);
xmlChar * xmlParseVersionInfo (xmlParserCtxtPtr ctxt);
xmlChar * xmlParseEncName (xmlParserCtxtPtr ctxt);
const xmlChar * xmlParseEncodingDecl (xmlParserCtxtPtr ctxt);
int xmlParseSDDecl (xmlParserCtxtPtr ctxt);
void xmlParseXMLDecl (xmlParserCtxtPtr ctxt);
void xmlParseTextDecl (xmlParserCtxtPtr ctxt);
void xmlParseMisc (xmlParserCtxtPtr ctxt);
void xmlParseExternalSubset (xmlParserCtxtPtr ctxt,
XMLPUBFUN const xmlChar * XMLCALL xmlParseStartTag (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL xmlParseEndTag (xmlParserCtxtPtr ctxt);
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);
/**
@ -328,13 +330,13 @@ void xmlParseExternalSubset (xmlParserCtxtPtr ctxt,
*/
#define XML_SUBSTITUTE_BOTH 3
xmlChar * xmlDecodeEntities (xmlParserCtxtPtr ctxt,
XMLPUBFUN xmlChar * XMLCALL xmlDecodeEntities (xmlParserCtxtPtr ctxt,
int len,
int what,
xmlChar end,
xmlChar end2,
xmlChar end3);
xmlChar * xmlStringDecodeEntities (xmlParserCtxtPtr ctxt,
XMLPUBFUN xmlChar * XMLCALL xmlStringDecodeEntities (xmlParserCtxtPtr ctxt,
const xmlChar *str,
int what,
xmlChar end,
@ -344,46 +346,46 @@ xmlChar * xmlStringDecodeEntities (xmlParserCtxtPtr ctxt,
/*
* Generated by MACROS on top of parser.c c.f. PUSH_AND_POP.
*/
int nodePush (xmlParserCtxtPtr ctxt,
XMLPUBFUN int XMLCALL nodePush (xmlParserCtxtPtr ctxt,
xmlNodePtr value);
xmlNodePtr nodePop (xmlParserCtxtPtr ctxt);
int inputPush (xmlParserCtxtPtr ctxt,
XMLPUBFUN xmlNodePtr XMLCALL nodePop (xmlParserCtxtPtr ctxt);
XMLPUBFUN int XMLCALL inputPush (xmlParserCtxtPtr ctxt,
xmlParserInputPtr value);
xmlParserInputPtr inputPop (xmlParserCtxtPtr ctxt);
const xmlChar *namePop (xmlParserCtxtPtr ctxt);
int namePush (xmlParserCtxtPtr ctxt,
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.
*/
int xmlSkipBlankChars (xmlParserCtxtPtr ctxt);
int xmlStringCurrentChar (xmlParserCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlSkipBlankChars (xmlParserCtxtPtr ctxt);
XMLPUBFUN int XMLCALL xmlStringCurrentChar (xmlParserCtxtPtr ctxt,
const xmlChar *cur,
int *len);
void xmlParserHandlePEReference(xmlParserCtxtPtr ctxt);
void xmlParserHandleReference(xmlParserCtxtPtr ctxt);
int xmlCheckLanguageID (const xmlChar *lang);
XMLPUBFUN void XMLCALL xmlParserHandlePEReference(xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL xmlParserHandleReference(xmlParserCtxtPtr ctxt);
XMLPUBFUN int XMLCALL xmlCheckLanguageID (const xmlChar *lang);
/*
* Really core function shared with HTML parser.
*/
int xmlCurrentChar (xmlParserCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlCurrentChar (xmlParserCtxtPtr ctxt,
int *len);
int xmlCopyCharMultiByte (xmlChar *out,
XMLPUBFUN int XMLCALL xmlCopyCharMultiByte (xmlChar *out,
int val);
int xmlCopyChar (int len,
XMLPUBFUN int XMLCALL xmlCopyChar (int len,
xmlChar *out,
int val);
void xmlNextChar (xmlParserCtxtPtr ctxt);
void xmlParserInputShrink (xmlParserInputPtr in);
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.
*/
void htmlInitAutoClose (void);
htmlParserCtxtPtr htmlCreateFileParserCtxt(const char *filename,
XMLPUBFUN void XMLCALL htmlInitAutoClose (void);
XMLPUBFUN htmlParserCtxtPtr XMLCALL htmlCreateFileParserCtxt(const char *filename,
const char *encoding);
#endif
@ -404,7 +406,7 @@ typedef void (*xmlEntityReferenceFunc) (xmlEntityPtr ent,
xmlNodePtr firstNode,
xmlNodePtr lastNode);
void xmlSetEntityReferenceFunc (xmlEntityReferenceFunc func);
XMLPUBFUN void XMLCALL xmlSetEntityReferenceFunc (xmlEntityReferenceFunc func);
#ifdef __cplusplus

42
include/libxml/relaxng.h
View File

@ -9,6 +9,7 @@
#ifndef __XML_RELAX_NG__
#define __XML_RELAX_NG__
#include <libxml/xmlversion.h>
#include <libxml/hash.h>
typedef struct _xmlRelaxNG xmlRelaxNG;
@ -78,55 +79,56 @@ typedef enum {
/*
* Interfaces for parsing.
*/
xmlRelaxNGParserCtxtPtr xmlRelaxNGNewParserCtxt (const char *URL);
xmlRelaxNGParserCtxtPtr xmlRelaxNGNewMemParserCtxt(const char *buffer,
XMLPUBFUN xmlRelaxNGParserCtxtPtr XMLCALL
xmlRelaxNGNewParserCtxt (const char *URL);
XMLPUBFUN xmlRelaxNGParserCtxtPtr XMLCALL xmlRelaxNGNewMemParserCtxt(const char *buffer,
int size);
xmlRelaxNGParserCtxtPtr xmlRelaxNGNewDocParserCtxt(xmlDocPtr doc);
XMLPUBFUN xmlRelaxNGParserCtxtPtr XMLCALL xmlRelaxNGNewDocParserCtxt(xmlDocPtr doc);
void xmlRelaxNGFreeParserCtxt (xmlRelaxNGParserCtxtPtr ctxt);
void xmlRelaxNGSetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
XMLPUBFUN void XMLCALL xmlRelaxNGFreeParserCtxt (xmlRelaxNGParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL xmlRelaxNGSetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
xmlRelaxNGValidityErrorFunc err,
xmlRelaxNGValidityWarningFunc warn,
void *ctx);
int xmlRelaxNGGetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlRelaxNGGetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
xmlRelaxNGValidityErrorFunc *err,
xmlRelaxNGValidityWarningFunc *warn,
void **ctx);
xmlRelaxNGPtr xmlRelaxNGParse (xmlRelaxNGParserCtxtPtr ctxt);
void xmlRelaxNGFree (xmlRelaxNGPtr schema);
void xmlRelaxNGDump (FILE *output,
XMLPUBFUN xmlRelaxNGPtr XMLCALL xmlRelaxNGParse (xmlRelaxNGParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL xmlRelaxNGFree (xmlRelaxNGPtr schema);
XMLPUBFUN void XMLCALL xmlRelaxNGDump (FILE *output,
xmlRelaxNGPtr schema);
void xmlRelaxNGDumpTree (FILE * output,
XMLPUBFUN void XMLCALL xmlRelaxNGDumpTree (FILE * output,
xmlRelaxNGPtr schema);
/*
* Interfaces for validating
*/
void xmlRelaxNGSetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
XMLPUBFUN void XMLCALL xmlRelaxNGSetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
xmlRelaxNGValidityErrorFunc err,
xmlRelaxNGValidityWarningFunc warn,
void *ctx);
int xmlRelaxNGGetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlRelaxNGGetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
xmlRelaxNGValidityErrorFunc *err,
xmlRelaxNGValidityWarningFunc *warn,
void **ctx);
xmlRelaxNGValidCtxtPtr xmlRelaxNGNewValidCtxt (xmlRelaxNGPtr schema);
void xmlRelaxNGFreeValidCtxt (xmlRelaxNGValidCtxtPtr ctxt);
int xmlRelaxNGValidateDoc (xmlRelaxNGValidCtxtPtr ctxt,
XMLPUBFUN xmlRelaxNGValidCtxtPtr XMLCALL xmlRelaxNGNewValidCtxt (xmlRelaxNGPtr schema);
XMLPUBFUN void XMLCALL xmlRelaxNGFreeValidCtxt (xmlRelaxNGValidCtxtPtr ctxt);
XMLPUBFUN int XMLCALL xmlRelaxNGValidateDoc (xmlRelaxNGValidCtxtPtr ctxt,
xmlDocPtr doc);
void xmlRelaxNGCleanupTypes (void);
XMLPUBFUN void XMLCALL xmlRelaxNGCleanupTypes (void);
/*
* Interfaces for progressive validation when possible
*/
int xmlRelaxNGValidatePushElement (xmlRelaxNGValidCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlRelaxNGValidatePushElement (xmlRelaxNGValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlNodePtr elem);
int xmlRelaxNGValidatePushCData (xmlRelaxNGValidCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlRelaxNGValidatePushCData (xmlRelaxNGValidCtxtPtr ctxt,
const xmlChar *data,
int len);
int xmlRelaxNGValidatePopElement (xmlRelaxNGValidCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlRelaxNGValidatePopElement (xmlRelaxNGValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlNodePtr elem);
int xmlRelaxNGValidateFullElement (xmlRelaxNGValidCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlRelaxNGValidateFullElement (xmlRelaxNGValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlNodePtr elem);
#endif /* __XML_RELAX_NG__ */

2
include/libxml/schemasInternals.h
View File

@ -345,7 +345,7 @@ struct _xmlSchema {
xmlHashTablePtr groupDecl;
};
void xmlSchemaFreeType (xmlSchemaTypePtr type);
XMLPUBFUN void XMLCALL xmlSchemaFreeType (xmlSchemaTypePtr type);
#ifdef __cplusplus
}

33
include/libxml/threads.h
View File

@ -9,6 +9,8 @@
#ifndef __XML_THREADS_H__
#define __XML_THREADS_H__
#include <libxml/xmlversion.h>
#ifdef __cplusplus
extern "C" {
#endif
@ -33,26 +35,27 @@ typedef xmlRMutex *xmlRMutexPtr;
extern "C" {
#endif
xmlMutexPtr xmlNewMutex (void);
void xmlMutexLock (xmlMutexPtr tok);
void xmlMutexUnlock (xmlMutexPtr tok);
void xmlFreeMutex (xmlMutexPtr tok);
XMLPUBFUN xmlMutexPtr XMLCALL
xmlNewMutex (void);
XMLPUBFUN void XMLCALL xmlMutexLock (xmlMutexPtr tok);
XMLPUBFUN void XMLCALL xmlMutexUnlock (xmlMutexPtr tok);
XMLPUBFUN void XMLCALL xmlFreeMutex (xmlMutexPtr tok);
xmlRMutexPtr xmlNewRMutex (void);
void xmlRMutexLock (xmlRMutexPtr tok);
void xmlRMutexUnlock (xmlRMutexPtr tok);
void xmlFreeRMutex (xmlRMutexPtr 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.
*/
void xmlInitThreads (void);
void xmlLockLibrary (void);
void xmlUnlockLibrary(void);
int xmlGetThreadId (void);
int xmlIsMainThread (void);
void xmlCleanupThreads(void);
xmlGlobalStatePtr xmlGetGlobalState(void);
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);
XMLPUBFUN void XMLCALL xmlCleanupThreads(void);
XMLPUBFUN xmlGlobalStatePtr XMLCALL xmlGetGlobalState(void);
#ifdef __cplusplus
}

283
include/libxml/tree.h
View File

@ -541,374 +541,375 @@ LIBXML_DLL_IMPORT extern int xmlDefaultBufferSize; /* default buffer size */
/*
* Some helper functions
*/
int xmlValidateNCName (const xmlChar *value,
XMLPUBFUN int XMLCALL
xmlValidateNCName (const xmlChar *value,
int space);
int xmlValidateQName (const xmlChar *value,
XMLPUBFUN int XMLCALL xmlValidateQName (const xmlChar *value,
int space);
int xmlValidateName (const xmlChar *value,
XMLPUBFUN int XMLCALL xmlValidateName (const xmlChar *value,
int space);
int xmlValidateNMToken (const xmlChar *value,
XMLPUBFUN int XMLCALL xmlValidateNMToken (const xmlChar *value,
int space);
xmlChar * xmlBuildQName (const xmlChar *ncname,
XMLPUBFUN xmlChar * XMLCALL xmlBuildQName (const xmlChar *ncname,
const xmlChar *prefix,
xmlChar *memory,
int len);
xmlChar * xmlSplitQName2 (const xmlChar *name,
XMLPUBFUN xmlChar * XMLCALL xmlSplitQName2 (const xmlChar *name,
xmlChar **prefix);
const xmlChar * xmlSplitQName3 (const xmlChar *name,
XMLPUBFUN const xmlChar * XMLCALL xmlSplitQName3 (const xmlChar *name,
int *len);
/*
* Handling Buffers.
*/
void xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme);
xmlBufferAllocationScheme xmlGetBufferAllocationScheme(void);
XMLPUBFUN void XMLCALL xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme);
XMLPUBFUN xmlBufferAllocationScheme XMLCALL xmlGetBufferAllocationScheme(void);
xmlBufferPtr xmlBufferCreate (void);
xmlBufferPtr xmlBufferCreateSize (size_t size);
int xmlBufferResize (xmlBufferPtr buf,
XMLPUBFUN xmlBufferPtr XMLCALL xmlBufferCreate (void);
XMLPUBFUN xmlBufferPtr XMLCALL xmlBufferCreateSize (size_t size);
XMLPUBFUN int XMLCALL xmlBufferResize (xmlBufferPtr buf,
unsigned int size);
void xmlBufferFree (xmlBufferPtr buf);
int xmlBufferDump (FILE *file,
XMLPUBFUN void XMLCALL xmlBufferFree (xmlBufferPtr buf);
XMLPUBFUN int XMLCALL xmlBufferDump (FILE *file,
xmlBufferPtr buf);
void xmlBufferAdd (xmlBufferPtr buf,
XMLPUBFUN void XMLCALL xmlBufferAdd (xmlBufferPtr buf,
const xmlChar *str,
int len);
void xmlBufferAddHead (xmlBufferPtr buf,
XMLPUBFUN void XMLCALL xmlBufferAddHead (xmlBufferPtr buf,
const xmlChar *str,
int len);
void xmlBufferCat (xmlBufferPtr buf,
XMLPUBFUN void XMLCALL xmlBufferCat (xmlBufferPtr buf,
const xmlChar *str);
void xmlBufferCCat (xmlBufferPtr buf,
XMLPUBFUN void XMLCALL xmlBufferCCat (xmlBufferPtr buf,
const char *str);
int xmlBufferShrink (xmlBufferPtr buf,
XMLPUBFUN int XMLCALL xmlBufferShrink (xmlBufferPtr buf,
unsigned int len);
int xmlBufferGrow (xmlBufferPtr buf,
XMLPUBFUN int XMLCALL xmlBufferGrow (xmlBufferPtr buf,
unsigned int len);
void xmlBufferEmpty (xmlBufferPtr buf);
const xmlChar* xmlBufferContent (const xmlBufferPtr buf);
void xmlBufferSetAllocationScheme(xmlBufferPtr buf,
XMLPUBFUN void XMLCALL xmlBufferEmpty (xmlBufferPtr buf);
XMLPUBFUN const xmlChar* XMLCALL xmlBufferContent (const xmlBufferPtr buf);
XMLPUBFUN void XMLCALL xmlBufferSetAllocationScheme(xmlBufferPtr buf,
xmlBufferAllocationScheme scheme);
int xmlBufferLength (const xmlBufferPtr buf);
XMLPUBFUN int XMLCALL xmlBufferLength (const xmlBufferPtr buf);
/*
* Creating/freeing new structures.
*/
xmlDtdPtr xmlCreateIntSubset (xmlDocPtr doc,
XMLPUBFUN xmlDtdPtr XMLCALL xmlCreateIntSubset (xmlDocPtr doc,
const xmlChar *name,
const xmlChar *ExternalID,
const xmlChar *SystemID);
xmlDtdPtr xmlNewDtd (xmlDocPtr doc,
XMLPUBFUN xmlDtdPtr XMLCALL xmlNewDtd (xmlDocPtr doc,
const xmlChar *name,
const xmlChar *ExternalID,
const xmlChar *SystemID);
xmlDtdPtr xmlGetIntSubset (xmlDocPtr doc);
void xmlFreeDtd (xmlDtdPtr cur);
xmlNsPtr xmlNewGlobalNs (xmlDocPtr doc,
XMLPUBFUN xmlDtdPtr XMLCALL xmlGetIntSubset (xmlDocPtr doc);
XMLPUBFUN void XMLCALL xmlFreeDtd (xmlDtdPtr cur);
XMLPUBFUN xmlNsPtr XMLCALL xmlNewGlobalNs (xmlDocPtr doc,
const xmlChar *href,
const xmlChar *prefix);
xmlNsPtr xmlNewNs (xmlNodePtr node,
XMLPUBFUN xmlNsPtr XMLCALL xmlNewNs (xmlNodePtr node,
const xmlChar *href,
const xmlChar *prefix);
void xmlFreeNs (xmlNsPtr cur);
void xmlFreeNsList (xmlNsPtr cur);
xmlDocPtr xmlNewDoc (const xmlChar *version);
void xmlFreeDoc (xmlDocPtr cur);
xmlAttrPtr xmlNewDocProp (xmlDocPtr doc,
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);
xmlAttrPtr xmlNewProp (xmlNodePtr node,
XMLPUBFUN xmlAttrPtr XMLCALL xmlNewProp (xmlNodePtr node,
const xmlChar *name,
const xmlChar *value);
xmlAttrPtr xmlNewNsProp (xmlNodePtr node,
XMLPUBFUN xmlAttrPtr XMLCALL xmlNewNsProp (xmlNodePtr node,
xmlNsPtr ns,
const xmlChar *name,
const xmlChar *value);
xmlAttrPtr xmlNewNsPropEatName (xmlNodePtr node,
XMLPUBFUN xmlAttrPtr XMLCALL xmlNewNsPropEatName (xmlNodePtr node,
xmlNsPtr ns,
xmlChar *name,
const xmlChar *value);
void xmlFreePropList (xmlAttrPtr cur);
void xmlFreeProp (xmlAttrPtr cur);
xmlAttrPtr xmlCopyProp (xmlNodePtr target,
XMLPUBFUN void XMLCALL xmlFreePropList (xmlAttrPtr cur);
XMLPUBFUN void XMLCALL xmlFreeProp (xmlAttrPtr cur);
XMLPUBFUN xmlAttrPtr XMLCALL xmlCopyProp (xmlNodePtr target,
xmlAttrPtr cur);
xmlAttrPtr xmlCopyPropList (xmlNodePtr target,
XMLPUBFUN xmlAttrPtr XMLCALL xmlCopyPropList (xmlNodePtr target,
xmlAttrPtr cur);
xmlDtdPtr xmlCopyDtd (xmlDtdPtr dtd);
xmlDocPtr xmlCopyDoc (xmlDocPtr doc,
XMLPUBFUN xmlDtdPtr XMLCALL xmlCopyDtd (xmlDtdPtr dtd);
XMLPUBFUN xmlDocPtr XMLCALL xmlCopyDoc (xmlDocPtr doc,
int recursive);
/*
* Creating new nodes.
*/
xmlNodePtr xmlNewDocNode (xmlDocPtr doc,
XMLPUBFUN xmlNodePtr XMLCALL xmlNewDocNode (xmlDocPtr doc,
xmlNsPtr ns,
const xmlChar *name,
const xmlChar *content);
xmlNodePtr xmlNewDocNodeEatName (xmlDocPtr doc,
XMLPUBFUN xmlNodePtr XMLCALL xmlNewDocNodeEatName (xmlDocPtr doc,
xmlNsPtr ns,
xmlChar *name,
const xmlChar *content);
xmlNodePtr xmlNewDocRawNode (xmlDocPtr doc,
XMLPUBFUN xmlNodePtr XMLCALL xmlNewDocRawNode (xmlDocPtr doc,
xmlNsPtr ns,
const xmlChar *name,
const xmlChar *content);
xmlNodePtr xmlNewNode (xmlNsPtr ns,
XMLPUBFUN xmlNodePtr XMLCALL xmlNewNode (xmlNsPtr ns,
const xmlChar *name);
xmlNodePtr xmlNewNodeEatName (xmlNsPtr ns,
XMLPUBFUN xmlNodePtr XMLCALL xmlNewNodeEatName (xmlNsPtr ns,
xmlChar *name);
xmlNodePtr xmlNewChild (xmlNodePtr parent,
XMLPUBFUN xmlNodePtr XMLCALL xmlNewChild (xmlNodePtr parent,
xmlNsPtr ns,
const xmlChar *name,
const xmlChar *content);
xmlNodePtr xmlNewTextChild (xmlNodePtr parent,
XMLPUBFUN xmlNodePtr XMLCALL xmlNewTextChild (xmlNodePtr parent,
xmlNsPtr ns,
const xmlChar *name,
const xmlChar *content);
xmlNodePtr xmlNewDocText (xmlDocPtr doc,
XMLPUBFUN xmlNodePtr XMLCALL xmlNewDocText (xmlDocPtr doc,
const xmlChar *content);
xmlNodePtr xmlNewText (const xmlChar *content);
xmlNodePtr xmlNewPI (const xmlChar *name,
XMLPUBFUN xmlNodePtr XMLCALL xmlNewText (const xmlChar *content);
XMLPUBFUN xmlNodePtr XMLCALL xmlNewPI (const xmlChar *name,
const xmlChar *content);
xmlNodePtr xmlNewDocTextLen (xmlDocPtr doc,
XMLPUBFUN xmlNodePtr XMLCALL xmlNewDocTextLen (xmlDocPtr doc,
const xmlChar *content,
int len);
xmlNodePtr xmlNewTextLen (const xmlChar *content,
XMLPUBFUN xmlNodePtr XMLCALL xmlNewTextLen (const xmlChar *content,
int len);
xmlNodePtr xmlNewDocComment (xmlDocPtr doc,
XMLPUBFUN xmlNodePtr XMLCALL xmlNewDocComment (xmlDocPtr doc,
const xmlChar *content);
xmlNodePtr xmlNewComment (const xmlChar *content);
xmlNodePtr xmlNewCDataBlock (xmlDocPtr doc,
XMLPUBFUN xmlNodePtr XMLCALL xmlNewComment (const xmlChar *content);
XMLPUBFUN xmlNodePtr XMLCALL xmlNewCDataBlock (xmlDocPtr doc,
const xmlChar *content,
int len);
xmlNodePtr xmlNewCharRef (xmlDocPtr doc,
XMLPUBFUN xmlNodePtr XMLCALL xmlNewCharRef (xmlDocPtr doc,
const xmlChar *name);
xmlNodePtr xmlNewReference (xmlDocPtr doc,
XMLPUBFUN xmlNodePtr XMLCALL xmlNewReference (xmlDocPtr doc,
const xmlChar *name);
xmlNodePtr xmlCopyNode (const xmlNodePtr node,
XMLPUBFUN xmlNodePtr XMLCALL xmlCopyNode (const xmlNodePtr node,
int recursive);
xmlNodePtr xmlDocCopyNode (const xmlNodePtr node,
XMLPUBFUN xmlNodePtr XMLCALL xmlDocCopyNode (const xmlNodePtr node,
xmlDocPtr doc,
int recursive);
xmlNodePtr xmlCopyNodeList (const xmlNodePtr node);
xmlNodePtr xmlNewDocFragment (xmlDocPtr doc);
XMLPUBFUN xmlNodePtr XMLCALL xmlCopyNodeList (const xmlNodePtr node);
XMLPUBFUN xmlNodePtr XMLCALL xmlNewDocFragment (xmlDocPtr doc);
/*
* Navigating.
*/
long xmlGetLineNo (xmlNodePtr node);
xmlChar * xmlGetNodePath (xmlNodePtr node);
xmlNodePtr xmlDocGetRootElement (xmlDocPtr doc);
xmlNodePtr xmlGetLastChild (xmlNodePtr parent);
int xmlNodeIsText (xmlNodePtr node);
int xmlIsBlankNode (xmlNodePtr node);
XMLPUBFUN long XMLCALL xmlGetLineNo (xmlNodePtr node);
XMLPUBFUN xmlChar * XMLCALL xmlGetNodePath (xmlNodePtr node);
XMLPUBFUN xmlNodePtr XMLCALL xmlDocGetRootElement (xmlDocPtr doc);
XMLPUBFUN xmlNodePtr XMLCALL xmlGetLastChild (xmlNodePtr parent);
XMLPUBFUN int XMLCALL xmlNodeIsText (xmlNodePtr node);
XMLPUBFUN int XMLCALL xmlIsBlankNode (xmlNodePtr node);
/*
* Changing the structure.
*/
xmlNodePtr xmlDocSetRootElement (xmlDocPtr doc,
XMLPUBFUN xmlNodePtr XMLCALL xmlDocSetRootElement (xmlDocPtr doc,
xmlNodePtr root);
void xmlNodeSetName (xmlNodePtr cur,
XMLPUBFUN void XMLCALL xmlNodeSetName (xmlNodePtr cur,
const xmlChar *name);
xmlNodePtr xmlAddChild (xmlNodePtr parent,
XMLPUBFUN xmlNodePtr XMLCALL xmlAddChild (xmlNodePtr parent,
xmlNodePtr cur);
xmlNodePtr xmlAddChildList (xmlNodePtr parent,
XMLPUBFUN xmlNodePtr XMLCALL xmlAddChildList (xmlNodePtr parent,
xmlNodePtr cur);
xmlNodePtr xmlReplaceNode (xmlNodePtr old,
XMLPUBFUN xmlNodePtr XMLCALL xmlReplaceNode (xmlNodePtr old,
xmlNodePtr cur);
xmlNodePtr xmlAddSibling (xmlNodePtr cur,
XMLPUBFUN xmlNodePtr XMLCALL xmlAddSibling (xmlNodePtr cur,
xmlNodePtr elem);
xmlNodePtr xmlAddPrevSibling (xmlNodePtr cur,
XMLPUBFUN xmlNodePtr XMLCALL xmlAddPrevSibling (xmlNodePtr cur,
xmlNodePtr elem);
xmlNodePtr xmlAddNextSibling (xmlNodePtr cur,
XMLPUBFUN xmlNodePtr XMLCALL xmlAddNextSibling (xmlNodePtr cur,
xmlNodePtr elem);
void xmlUnlinkNode (xmlNodePtr cur);
xmlNodePtr xmlTextMerge (xmlNodePtr first,
XMLPUBFUN void XMLCALL xmlUnlinkNode (xmlNodePtr cur);
XMLPUBFUN xmlNodePtr XMLCALL xmlTextMerge (xmlNodePtr first,
xmlNodePtr second);
int xmlTextConcat (xmlNodePtr node,
XMLPUBFUN int XMLCALL xmlTextConcat (xmlNodePtr node,
const xmlChar *content,
int len);
void xmlFreeNodeList (xmlNodePtr cur);
void xmlFreeNode (xmlNodePtr cur);
void xmlSetTreeDoc (xmlNodePtr tree,
XMLPUBFUN void XMLCALL xmlFreeNodeList (xmlNodePtr cur);
XMLPUBFUN void XMLCALL xmlFreeNode (xmlNodePtr cur);
XMLPUBFUN void XMLCALL xmlSetTreeDoc (xmlNodePtr tree,
xmlDocPtr doc);
void xmlSetListDoc (xmlNodePtr list,
XMLPUBFUN void XMLCALL xmlSetListDoc (xmlNodePtr list,
xmlDocPtr doc);
/*
* Namespaces.
*/
xmlNsPtr xmlSearchNs (xmlDocPtr doc,
XMLPUBFUN xmlNsPtr XMLCALL xmlSearchNs (xmlDocPtr doc,
xmlNodePtr node,
const xmlChar *nameSpace);
xmlNsPtr xmlSearchNsByHref (xmlDocPtr doc,
XMLPUBFUN xmlNsPtr XMLCALL xmlSearchNsByHref (xmlDocPtr doc,
xmlNodePtr node,
const xmlChar *href);
xmlNsPtr * xmlGetNsList (xmlDocPtr doc,
XMLPUBFUN xmlNsPtr * XMLCALL xmlGetNsList (xmlDocPtr doc,
xmlNodePtr node);
void xmlSetNs (xmlNodePtr node,
XMLPUBFUN void XMLCALL xmlSetNs (xmlNodePtr node,
xmlNsPtr ns);
xmlNsPtr xmlCopyNamespace (xmlNsPtr cur);
xmlNsPtr xmlCopyNamespaceList (xmlNsPtr cur);
XMLPUBFUN xmlNsPtr XMLCALL xmlCopyNamespace (xmlNsPtr cur);
XMLPUBFUN xmlNsPtr XMLCALL xmlCopyNamespaceList (xmlNsPtr cur);
/*
* Changing the content.
*/
xmlAttrPtr xmlSetProp (xmlNodePtr node,
XMLPUBFUN xmlAttrPtr XMLCALL xmlSetProp (xmlNodePtr node,
const xmlChar *name,
const xmlChar *value);
xmlChar * xmlGetProp (xmlNodePtr node,
XMLPUBFUN xmlChar * XMLCALL xmlGetProp (xmlNodePtr node,
const xmlChar *name);
xmlChar * xmlGetNoNsProp (xmlNodePtr node,
XMLPUBFUN xmlChar * XMLCALL xmlGetNoNsProp (xmlNodePtr node,
const xmlChar *name);
xmlAttrPtr xmlHasProp (xmlNodePtr node,
XMLPUBFUN xmlAttrPtr XMLCALL xmlHasProp (xmlNodePtr node,
const xmlChar *name);
xmlAttrPtr xmlHasNsProp (xmlNodePtr node,
XMLPUBFUN xmlAttrPtr XMLCALL xmlHasNsProp (xmlNodePtr node,
const xmlChar *name,
const xmlChar *nameSpace);
xmlAttrPtr xmlSetNsProp (xmlNodePtr node,
XMLPUBFUN xmlAttrPtr XMLCALL xmlSetNsProp (xmlNodePtr node,
xmlNsPtr ns,
const xmlChar *name,
const xmlChar *value);
xmlChar * xmlGetNsProp (xmlNodePtr node,
XMLPUBFUN xmlChar * XMLCALL xmlGetNsProp (xmlNodePtr node,
const xmlChar *name,
const xmlChar *nameSpace);
xmlNodePtr xmlStringGetNodeList (xmlDocPtr doc,
XMLPUBFUN xmlNodePtr XMLCALL xmlStringGetNodeList (xmlDocPtr doc,
const xmlChar *value);
xmlNodePtr xmlStringLenGetNodeList (xmlDocPtr doc,
XMLPUBFUN xmlNodePtr XMLCALL xmlStringLenGetNodeList (xmlDocPtr doc,
const xmlChar *value,
int len);
xmlChar * xmlNodeListGetString (xmlDocPtr doc,
XMLPUBFUN xmlChar * XMLCALL xmlNodeListGetString (xmlDocPtr doc,
xmlNodePtr list,
int inLine);
xmlChar * xmlNodeListGetRawString (xmlDocPtr doc,
XMLPUBFUN xmlChar * XMLCALL xmlNodeListGetRawString (xmlDocPtr doc,
xmlNodePtr list,
int inLine);
void xmlNodeSetContent (xmlNodePtr cur,
XMLPUBFUN void XMLCALL xmlNodeSetContent (xmlNodePtr cur,
const xmlChar *content);
void xmlNodeSetContentLen (xmlNodePtr cur,
XMLPUBFUN void XMLCALL xmlNodeSetContentLen (xmlNodePtr cur,
const xmlChar *content,
int len);
void xmlNodeAddContent (xmlNodePtr cur,
XMLPUBFUN void XMLCALL xmlNodeAddContent (xmlNodePtr cur,
const xmlChar *content);
void xmlNodeAddContentLen (xmlNodePtr cur,
XMLPUBFUN void XMLCALL xmlNodeAddContentLen (xmlNodePtr cur,
const xmlChar *content,
int len);
xmlChar * xmlNodeGetContent (xmlNodePtr cur);
xmlChar * xmlNodeGetLang (xmlNodePtr cur);
void xmlNodeSetLang (xmlNodePtr cur,
XMLPUBFUN xmlChar * XMLCALL xmlNodeGetContent (xmlNodePtr cur);
XMLPUBFUN xmlChar * XMLCALL xmlNodeGetLang (xmlNodePtr cur);
XMLPUBFUN void XMLCALL xmlNodeSetLang (xmlNodePtr cur,
const xmlChar *lang);
int xmlNodeGetSpacePreserve (xmlNodePtr cur);
void xmlNodeSetSpacePreserve (xmlNodePtr cur,
XMLPUBFUN int XMLCALL xmlNodeGetSpacePreserve (xmlNodePtr cur);
XMLPUBFUN void XMLCALL xmlNodeSetSpacePreserve (xmlNodePtr cur,
int val);
xmlChar * xmlNodeGetBase (xmlDocPtr doc,
XMLPUBFUN xmlChar * XMLCALL xmlNodeGetBase (xmlDocPtr doc,
xmlNodePtr cur);
void xmlNodeSetBase (xmlNodePtr cur,
XMLPUBFUN void XMLCALL xmlNodeSetBase (xmlNodePtr cur,
xmlChar *uri);
/*
* Removing content.
*/
int xmlRemoveProp (xmlAttrPtr cur);
int xmlUnsetProp (xmlNodePtr node,
XMLPUBFUN int XMLCALL xmlRemoveProp (xmlAttrPtr cur);
XMLPUBFUN int XMLCALL xmlUnsetProp (xmlNodePtr node,
const xmlChar *name);
int xmlUnsetNsProp (xmlNodePtr node,
XMLPUBFUN int XMLCALL xmlUnsetNsProp (xmlNodePtr node,
xmlNsPtr ns,
const xmlChar *name);
/*
* Internal, don't use.
*/
void xmlBufferWriteCHAR (xmlBufferPtr buf,
XMLPUBFUN void XMLCALL xmlBufferWriteCHAR (xmlBufferPtr buf,
const xmlChar *string);
void xmlBufferWriteChar (xmlBufferPtr buf,
XMLPUBFUN void XMLCALL xmlBufferWriteChar (xmlBufferPtr buf,
const char *string);
void xmlBufferWriteQuotedString(xmlBufferPtr buf,
XMLPUBFUN void XMLCALL xmlBufferWriteQuotedString(xmlBufferPtr buf,
const xmlChar *string);
/*
* Namespace handling.
*/
int xmlReconciliateNs (xmlDocPtr doc,
XMLPUBFUN int XMLCALL xmlReconciliateNs (xmlDocPtr doc,
xmlNodePtr tree);
/*
* Saving.
*/
void xmlDocDumpFormatMemory (xmlDocPtr cur,
XMLPUBFUN void XMLCALL xmlDocDumpFormatMemory (xmlDocPtr cur,
xmlChar **mem,
int *size,
int format);
void xmlDocDumpMemory (xmlDocPtr cur,
XMLPUBFUN void XMLCALL xmlDocDumpMemory (xmlDocPtr cur,
xmlChar **mem,
int *size);
void xmlDocDumpMemoryEnc (xmlDocPtr out_doc,
XMLPUBFUN void XMLCALL xmlDocDumpMemoryEnc (xmlDocPtr out_doc,
xmlChar **doc_txt_ptr,
int * doc_txt_len,
const char *txt_encoding);
void xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc,
XMLPUBFUN void XMLCALL xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc,
xmlChar **doc_txt_ptr,
int * doc_txt_len,
const char *txt_encoding,
int format);
int xmlDocFormatDump(FILE *f,
XMLPUBFUN int XMLCALL xmlDocFormatDump(FILE *f,
xmlDocPtr cur,
int format);
int xmlDocDump (FILE *f,
XMLPUBFUN int XMLCALL xmlDocDump (FILE *f,
xmlDocPtr cur);
void xmlElemDump (FILE *f,
XMLPUBFUN void XMLCALL xmlElemDump (FILE *f,
xmlDocPtr doc,
xmlNodePtr cur);
int xmlSaveFile (const char *filename,
XMLPUBFUN int XMLCALL xmlSaveFile (const char *filename,
xmlDocPtr cur);
int xmlSaveFormatFile (const char *filename,
XMLPUBFUN int XMLCALL xmlSaveFormatFile (const char *filename,
xmlDocPtr cur,
int format);
int xmlNodeDump (xmlBufferPtr buf,
XMLPUBFUN int XMLCALL xmlNodeDump (xmlBufferPtr buf,
xmlDocPtr doc,
xmlNodePtr cur,
int level,
int format);
int xmlSaveFileTo (xmlOutputBufferPtr buf,
XMLPUBFUN int XMLCALL xmlSaveFileTo (xmlOutputBufferPtr buf,
xmlDocPtr cur,
const char *encoding);
int xmlSaveFormatFileTo (xmlOutputBufferPtr buf,
XMLPUBFUN int XMLCALL xmlSaveFormatFileTo (xmlOutputBufferPtr buf,
xmlDocPtr cur,
const char *encoding,
int format);
void xmlNodeDumpOutput (xmlOutputBufferPtr buf,
XMLPUBFUN void XMLCALL xmlNodeDumpOutput (xmlOutputBufferPtr buf,
xmlDocPtr doc,
xmlNodePtr cur,
int level,
int format,
const char *encoding);
int xmlSaveFormatFileEnc (const char *filename,
XMLPUBFUN int XMLCALL xmlSaveFormatFileEnc (const char *filename,
xmlDocPtr cur,
const char *encoding,
int format);
int xmlSaveFileEnc (const char *filename,
XMLPUBFUN int XMLCALL xmlSaveFileEnc (const char *filename,
xmlDocPtr cur,
const char *encoding);
/*
* XHTML
*/
int xmlIsXHTML (const xmlChar *systemID,
XMLPUBFUN int XMLCALL xmlIsXHTML (const xmlChar *systemID,
const xmlChar *publicID);
/*
* Compression.
*/
int xmlGetDocCompressMode (xmlDocPtr doc);
void xmlSetDocCompressMode (xmlDocPtr doc,
XMLPUBFUN int XMLCALL xmlGetDocCompressMode (xmlDocPtr doc);
XMLPUBFUN void XMLCALL xmlSetDocCompressMode (xmlDocPtr doc,
int mode);
int xmlGetCompressMode (void);
void xmlSetCompressMode (int mode);
XMLPUBFUN int XMLCALL xmlGetCompressMode (void);
XMLPUBFUN void XMLCALL xmlSetCompressMode (int mode);
#ifdef __cplusplus
}

27
include/libxml/uri.h
View File

@ -11,6 +11,7 @@
#ifndef __XML_URI_H__
#define __XML_URI_H__
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#ifdef __cplusplus
@ -43,24 +44,26 @@ struct _xmlURI {
* xmlChar * xmlNodeGetBase (xmlDocPtr doc,
* xmlNodePtr cur);
*/
xmlURIPtr xmlCreateURI (void);
xmlChar * xmlBuildURI (const xmlChar *URI,
XMLPUBFUN xmlURIPtr XMLCALL
xmlCreateURI (void);
XMLPUBFUN xmlChar * XMLCALL
xmlBuildURI (const xmlChar *URI,
const xmlChar *base);
xmlURIPtr xmlParseURI (const char *str);
int xmlParseURIReference (xmlURIPtr uri,
XMLPUBFUN xmlURIPtr XMLCALL xmlParseURI (const char *str);
XMLPUBFUN int XMLCALL xmlParseURIReference (xmlURIPtr uri,
const char *str);
xmlChar * xmlSaveUri (xmlURIPtr uri);
void xmlPrintURI (FILE *stream,
XMLPUBFUN xmlChar * XMLCALL xmlSaveUri (xmlURIPtr uri);
XMLPUBFUN void XMLCALL xmlPrintURI (FILE *stream,
xmlURIPtr uri);
xmlChar * xmlURIEscapeStr (const xmlChar *str,
XMLPUBFUN xmlChar * XMLCALL xmlURIEscapeStr (const xmlChar *str,
const xmlChar *list);
char * xmlURIUnescapeString (const char *str,
XMLPUBFUN char * XMLCALL xmlURIUnescapeString (const char *str,
int len,
char *target);
int xmlNormalizeURIPath (char *path);
xmlChar * xmlURIEscape (const xmlChar *str);
void xmlFreeURI (xmlURIPtr uri);
xmlChar* xmlCanonicPath (const xmlChar *path);
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);
#ifdef __cplusplus
}

136
include/libxml/valid.h
View File

@ -10,6 +10,7 @@
#ifndef __XML_VALID_H__
#define __XML_VALID_H__
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#include <libxml/list.h>
#include <libxml/xmlautomata.h>
@ -128,57 +129,58 @@ typedef struct _xmlHashTable xmlRefTable;
typedef xmlRefTable *xmlRefTablePtr;
/* Allocate/Release Validation Contexts */
xmlValidCtxtPtr xmlNewValidCtxt(void);
void xmlFreeValidCtxt(xmlValidCtxtPtr);
XMLPUBFUN xmlValidCtxtPtr XMLCALL xmlNewValidCtxt(void);
XMLPUBFUN void XMLCALL xmlFreeValidCtxt(xmlValidCtxtPtr);
/* Notation */
xmlNotationPtr xmlAddNotationDecl (xmlValidCtxtPtr ctxt,
XMLPUBFUN xmlNotationPtr XMLCALL
xmlAddNotationDecl (xmlValidCtxtPtr ctxt,
xmlDtdPtr dtd,
const xmlChar *name,
const xmlChar *PublicID,
const xmlChar *SystemID);
xmlNotationTablePtr xmlCopyNotationTable(xmlNotationTablePtr table);
void xmlFreeNotationTable(xmlNotationTablePtr table);
void xmlDumpNotationDecl (xmlBufferPtr buf,
XMLPUBFUN xmlNotationTablePtr XMLCALL xmlCopyNotationTable(xmlNotationTablePtr table);
XMLPUBFUN void XMLCALL xmlFreeNotationTable(xmlNotationTablePtr table);
XMLPUBFUN void XMLCALL xmlDumpNotationDecl (xmlBufferPtr buf,
xmlNotationPtr nota);
void xmlDumpNotationTable(xmlBufferPtr buf,
XMLPUBFUN void XMLCALL xmlDumpNotationTable(xmlBufferPtr buf,
xmlNotationTablePtr table);
/* Element Content */
xmlElementContentPtr xmlNewElementContent (const xmlChar *name,
XMLPUBFUN xmlElementContentPtr XMLCALL xmlNewElementContent (const xmlChar *name,
xmlElementContentType type);
xmlElementContentPtr xmlCopyElementContent(xmlElementContentPtr content);
void xmlFreeElementContent(xmlElementContentPtr cur);
void xmlSnprintfElementContent(char *buf,
XMLPUBFUN xmlElementContentPtr XMLCALL xmlCopyElementContent(xmlElementContentPtr content);
XMLPUBFUN void XMLCALL xmlFreeElementContent(xmlElementContentPtr cur);
XMLPUBFUN void XMLCALL xmlSnprintfElementContent(char *buf,
int size,
xmlElementContentPtr content,
int glob);
/* DEPRECATED */
void xmlSprintfElementContent(char *buf,
XMLPUBFUN void XMLCALL xmlSprintfElementContent(char *buf,
xmlElementContentPtr content,
int glob);
/* DEPRECATED */
/* Element */
xmlElementPtr xmlAddElementDecl (xmlValidCtxtPtr ctxt,
XMLPUBFUN xmlElementPtr XMLCALL xmlAddElementDecl (xmlValidCtxtPtr ctxt,
xmlDtdPtr dtd,
const xmlChar *name,
xmlElementTypeVal type,
xmlElementContentPtr content);
xmlElementTablePtr xmlCopyElementTable (xmlElementTablePtr table);
void xmlFreeElementTable (xmlElementTablePtr table);
void xmlDumpElementTable (xmlBufferPtr buf,
XMLPUBFUN xmlElementTablePtr XMLCALL xmlCopyElementTable (xmlElementTablePtr table);
XMLPUBFUN void XMLCALL xmlFreeElementTable (xmlElementTablePtr table);
XMLPUBFUN void XMLCALL xmlDumpElementTable (xmlBufferPtr buf,
xmlElementTablePtr table);
void xmlDumpElementDecl (xmlBufferPtr buf,
XMLPUBFUN void XMLCALL xmlDumpElementDecl (xmlBufferPtr buf,
xmlElementPtr elem);
/* Enumeration */
xmlEnumerationPtr xmlCreateEnumeration (const xmlChar *name);
void xmlFreeEnumeration (xmlEnumerationPtr cur);
xmlEnumerationPtr xmlCopyEnumeration (xmlEnumerationPtr cur);
XMLPUBFUN xmlEnumerationPtr XMLCALL xmlCreateEnumeration (const xmlChar *name);
XMLPUBFUN void XMLCALL xmlFreeEnumeration (xmlEnumerationPtr cur);
XMLPUBFUN xmlEnumerationPtr XMLCALL xmlCopyEnumeration (xmlEnumerationPtr cur);
/* Attribute */
xmlAttributePtr xmlAddAttributeDecl (xmlValidCtxtPtr ctxt,
XMLPUBFUN xmlAttributePtr XMLCALL xmlAddAttributeDecl (xmlValidCtxtPtr ctxt,
xmlDtdPtr dtd,
const xmlChar *elem,
const xmlChar *name,
@ -187,139 +189,139 @@ xmlAttributePtr xmlAddAttributeDecl (xmlValidCtxtPtr ctxt,
xmlAttributeDefault def,
const xmlChar *defaultValue,
xmlEnumerationPtr tree);
xmlAttributeTablePtr xmlCopyAttributeTable (xmlAttributeTablePtr table);
void xmlFreeAttributeTable (xmlAttributeTablePtr table);
void xmlDumpAttributeTable (xmlBufferPtr buf,
XMLPUBFUN xmlAttributeTablePtr XMLCALL xmlCopyAttributeTable (xmlAttributeTablePtr table);
XMLPUBFUN void XMLCALL xmlFreeAttributeTable (xmlAttributeTablePtr table);
XMLPUBFUN void XMLCALL xmlDumpAttributeTable (xmlBufferPtr buf,
xmlAttributeTablePtr table);
void xmlDumpAttributeDecl (xmlBufferPtr buf,
XMLPUBFUN void XMLCALL xmlDumpAttributeDecl (xmlBufferPtr buf,
xmlAttributePtr attr);
/* IDs */
xmlIDPtr xmlAddID (xmlValidCtxtPtr ctxt,
XMLPUBFUN xmlIDPtr XMLCALL xmlAddID (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
const xmlChar *value,
xmlAttrPtr attr);
void xmlFreeIDTable (xmlIDTablePtr table);
xmlAttrPtr xmlGetID (xmlDocPtr doc,
XMLPUBFUN void XMLCALL xmlFreeIDTable (xmlIDTablePtr table);
XMLPUBFUN xmlAttrPtr XMLCALL xmlGetID (xmlDocPtr doc,
const xmlChar *ID);
int xmlIsID (xmlDocPtr doc,
XMLPUBFUN int XMLCALL xmlIsID (xmlDocPtr doc,
xmlNodePtr elem,
xmlAttrPtr attr);
int xmlRemoveID (xmlDocPtr doc, xmlAttrPtr attr);
XMLPUBFUN int XMLCALL xmlRemoveID (xmlDocPtr doc, xmlAttrPtr attr);
/* IDREFs */
xmlRefPtr xmlAddRef (xmlValidCtxtPtr ctxt,
XMLPUBFUN xmlRefPtr XMLCALL xmlAddRef (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
const xmlChar *value,
xmlAttrPtr attr);
void xmlFreeRefTable (xmlRefTablePtr table);
int xmlIsRef (xmlDocPtr doc,
XMLPUBFUN void XMLCALL xmlFreeRefTable (xmlRefTablePtr table);
XMLPUBFUN int XMLCALL xmlIsRef (xmlDocPtr doc,
xmlNodePtr elem,
xmlAttrPtr attr);
int xmlRemoveRef (xmlDocPtr doc, xmlAttrPtr attr);
xmlListPtr xmlGetRefs (xmlDocPtr doc,
XMLPUBFUN int XMLCALL xmlRemoveRef (xmlDocPtr doc, xmlAttrPtr attr);
XMLPUBFUN xmlListPtr XMLCALL xmlGetRefs (xmlDocPtr doc,
const xmlChar *ID);
/**
* The public function calls related to validity checking.
*/
int xmlValidateRoot (xmlValidCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlValidateRoot (xmlValidCtxtPtr ctxt,
xmlDocPtr doc);
int xmlValidateElementDecl (xmlValidCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlValidateElementDecl (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlElementPtr elem);
xmlChar * xmlValidNormalizeAttributeValue(xmlDocPtr doc,
XMLPUBFUN xmlChar * XMLCALL xmlValidNormalizeAttributeValue(xmlDocPtr doc,
xmlNodePtr elem,
const xmlChar *name,
const xmlChar *value);
xmlChar * xmlValidCtxtNormalizeAttributeValue(xmlValidCtxtPtr ctxt,
XMLPUBFUN xmlChar * XMLCALL xmlValidCtxtNormalizeAttributeValue(xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlNodePtr elem,
const xmlChar *name,
const xmlChar *value);
int xmlValidateAttributeDecl(xmlValidCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlValidateAttributeDecl(xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlAttributePtr attr);
int xmlValidateAttributeValue(xmlAttributeType type,
XMLPUBFUN int XMLCALL xmlValidateAttributeValue(xmlAttributeType type,
const xmlChar *value);
int xmlValidateNotationDecl (xmlValidCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlValidateNotationDecl (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlNotationPtr nota);
int xmlValidateDtd (xmlValidCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlValidateDtd (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlDtdPtr dtd);
int xmlValidateDtdFinal (xmlValidCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlValidateDtdFinal (xmlValidCtxtPtr ctxt,
xmlDocPtr doc);
int xmlValidateDocument (xmlValidCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlValidateDocument (xmlValidCtxtPtr ctxt,
xmlDocPtr doc);
int xmlValidateElement (xmlValidCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlValidateElement (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlNodePtr elem);
int xmlValidateOneElement (xmlValidCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlValidateOneElement (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlNodePtr elem);
int xmlValidateOneAttribute (xmlValidCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlValidateOneAttribute (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlNodePtr elem,
xmlAttrPtr attr,
const xmlChar *value);
int xmlValidateOneNamespace (xmlValidCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlValidateOneNamespace (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlNodePtr elem,
const xmlChar *prefix,
xmlNsPtr ns,
const xmlChar *value);
int xmlValidateDocumentFinal(xmlValidCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlValidateDocumentFinal(xmlValidCtxtPtr ctxt,
xmlDocPtr doc);
int xmlValidateNotationUse (xmlValidCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlValidateNotationUse (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
const xmlChar *notationName);
int xmlIsMixedElement (xmlDocPtr doc,
XMLPUBFUN int XMLCALL xmlIsMixedElement (xmlDocPtr doc,
const xmlChar *name);
xmlAttributePtr xmlGetDtdAttrDesc (xmlDtdPtr dtd,
XMLPUBFUN xmlAttributePtr XMLCALL xmlGetDtdAttrDesc (xmlDtdPtr dtd,
const xmlChar *elem,
const xmlChar *name);
xmlAttributePtr xmlGetDtdQAttrDesc (xmlDtdPtr dtd,
XMLPUBFUN xmlAttributePtr XMLCALL xmlGetDtdQAttrDesc (xmlDtdPtr dtd,
const xmlChar *elem,
const xmlChar *name,
const xmlChar *prefix);
xmlNotationPtr xmlGetDtdNotationDesc (xmlDtdPtr dtd,
XMLPUBFUN xmlNotationPtr XMLCALL xmlGetDtdNotationDesc (xmlDtdPtr dtd,
const xmlChar *name);
xmlElementPtr xmlGetDtdQElementDesc (xmlDtdPtr dtd,
XMLPUBFUN xmlElementPtr XMLCALL xmlGetDtdQElementDesc (xmlDtdPtr dtd,
const xmlChar *name,
const xmlChar *prefix);
xmlElementPtr xmlGetDtdElementDesc (xmlDtdPtr dtd,
XMLPUBFUN xmlElementPtr XMLCALL xmlGetDtdElementDesc (xmlDtdPtr dtd,
const xmlChar *name);
int xmlValidGetValidElements(xmlNode *prev,
XMLPUBFUN int XMLCALL xmlValidGetValidElements(xmlNode *prev,
xmlNode *next,
const xmlChar **list,
int max);
int xmlValidGetPotentialChildren(xmlElementContent *ctree,
XMLPUBFUN int XMLCALL xmlValidGetPotentialChildren(xmlElementContent *ctree,
const xmlChar **list,
int *len,
int max);
int xmlValidateNameValue (const xmlChar *value);
int xmlValidateNamesValue (const xmlChar *value);
int xmlValidateNmtokenValue (const xmlChar *value);
int xmlValidateNmtokensValue(const xmlChar *value);
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
*/
int xmlValidBuildContentModel(xmlValidCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlValidBuildContentModel(xmlValidCtxtPtr ctxt,
xmlElementPtr elem);
int xmlValidatePushElement (xmlValidCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlValidatePushElement (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlNodePtr elem,
const xmlChar *qname);
int xmlValidatePushCData (xmlValidCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlValidatePushCData (xmlValidCtxtPtr ctxt,
const xmlChar *data,
int len);
int xmlValidatePopElement (xmlValidCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlValidatePopElement (xmlValidCtxtPtr ctxt,
xmlDocPtr doc,
xmlNodePtr elem,
const xmlChar *qname);

5
include/libxml/xinclude.h
View File

@ -12,14 +12,15 @@
#ifndef __XML_XINCLUDE_H__
#define __XML_XINCLUDE_H__
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#ifdef __cplusplus
extern "C" {
#endif
int xmlXIncludeProcess (xmlDocPtr doc);
int xmlXIncludeProcessTree (xmlNodePtr tree);
XMLPUBFUN int XMLCALL xmlXIncludeProcess (xmlDocPtr doc);
XMLPUBFUN int XMLCALL xmlXIncludeProcessTree (xmlNodePtr tree);
#ifdef __cplusplus
}

11
include/libxml/xlink.h
View File

@ -13,6 +13,7 @@
#ifndef __XML_XLINK_H__
#define __XML_XLINK_H__
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#ifdef __cplusplus
@ -159,19 +160,19 @@ struct _xlinkHandler {
* detection callbacks.
*/
xlinkNodeDetectFunc xlinkGetDefaultDetect (void);
void xlinkSetDefaultDetect (xlinkNodeDetectFunc func);
XMLPUBFUN xlinkNodeDetectFunc XMLCALL xlinkGetDefaultDetect (void);
XMLPUBFUN void XMLCALL xlinkSetDefaultDetect (xlinkNodeDetectFunc func);
/*
* Routines to set/get the default handlers.
*/
xlinkHandlerPtr xlinkGetDefaultHandler (void);
void xlinkSetDefaultHandler (xlinkHandlerPtr handler);
XMLPUBFUN xlinkHandlerPtr XMLCALL xlinkGetDefaultHandler (void);
XMLPUBFUN void XMLCALL xlinkSetDefaultHandler (xlinkHandlerPtr handler);
/*
* Link detection module itself.
*/
xlinkType xlinkIsLink (xmlDocPtr doc,
XMLPUBFUN xlinkType XMLCALL xlinkIsLink (xmlDocPtr doc,
xmlNodePtr node);
#ifdef __cplusplus

86
include/libxml/xmlIO.h
View File

@ -147,95 +147,95 @@ struct _xmlOutputBuffer {
/*
* Interfaces for input
*/
void xmlCleanupInputCallbacks (void);
void xmlCleanupOutputCallbacks (void);
XMLPUBFUN void XMLCALL xmlCleanupInputCallbacks (void);
XMLPUBFUN void XMLCALL xmlCleanupOutputCallbacks (void);
void xmlRegisterDefaultInputCallbacks (void);
xmlParserInputBufferPtr
XMLPUBFUN void XMLCALL xmlRegisterDefaultInputCallbacks (void);
XMLPUBFUN xmlParserInputBufferPtr XMLCALL
xmlAllocParserInputBuffer (xmlCharEncoding enc);
xmlParserInputBufferPtr
XMLPUBFUN xmlParserInputBufferPtr XMLCALL
xmlParserInputBufferCreateFilename (const char *URI,
xmlCharEncoding enc);
xmlParserInputBufferPtr
XMLPUBFUN xmlParserInputBufferPtr XMLCALL
xmlParserInputBufferCreateFile (FILE *file,
xmlCharEncoding enc);
xmlParserInputBufferPtr
XMLPUBFUN xmlParserInputBufferPtr XMLCALL
xmlParserInputBufferCreateFd (int fd,
xmlCharEncoding enc);
xmlParserInputBufferPtr
XMLPUBFUN xmlParserInputBufferPtr XMLCALL
xmlParserInputBufferCreateMem (const char *mem, int size,
xmlCharEncoding enc);
xmlParserInputBufferPtr
XMLPUBFUN xmlParserInputBufferPtr XMLCALL
xmlParserInputBufferCreateIO (xmlInputReadCallback ioread,
xmlInputCloseCallback ioclose,
void *ioctx,
xmlCharEncoding enc);
int xmlParserInputBufferRead (xmlParserInputBufferPtr in,
XMLPUBFUN int XMLCALL xmlParserInputBufferRead (xmlParserInputBufferPtr in,
int len);
int xmlParserInputBufferGrow (xmlParserInputBufferPtr in,
XMLPUBFUN int XMLCALL xmlParserInputBufferGrow (xmlParserInputBufferPtr in,
int len);
int xmlParserInputBufferPush (xmlParserInputBufferPtr in,
XMLPUBFUN int XMLCALL xmlParserInputBufferPush (xmlParserInputBufferPtr in,
int len,
const char *buf);
void xmlFreeParserInputBuffer (xmlParserInputBufferPtr in);
char * xmlParserGetDirectory (const char *filename);
XMLPUBFUN void XMLCALL xmlFreeParserInputBuffer (xmlParserInputBufferPtr in);
XMLPUBFUN char * XMLCALL xmlParserGetDirectory (const char *filename);
int xmlRegisterInputCallbacks (xmlInputMatchCallback matchFunc,
XMLPUBFUN int XMLCALL xmlRegisterInputCallbacks (xmlInputMatchCallback matchFunc,
xmlInputOpenCallback openFunc,
xmlInputReadCallback readFunc,
xmlInputCloseCallback closeFunc);
/*
* Interfaces for output
*/
void xmlRegisterDefaultOutputCallbacks(void);
xmlOutputBufferPtr
XMLPUBFUN void XMLCALL xmlRegisterDefaultOutputCallbacks(void);
XMLPUBFUN xmlOutputBufferPtr XMLCALL
xmlAllocOutputBuffer (xmlCharEncodingHandlerPtr encoder);
xmlOutputBufferPtr
XMLPUBFUN xmlOutputBufferPtr XMLCALL
xmlOutputBufferCreateFilename (const char *URI,
xmlCharEncodingHandlerPtr encoder,
int compression);
xmlOutputBufferPtr
XMLPUBFUN xmlOutputBufferPtr XMLCALL
xmlOutputBufferCreateFile (FILE *file,
xmlCharEncodingHandlerPtr encoder);
xmlOutputBufferPtr
XMLPUBFUN xmlOutputBufferPtr XMLCALL
xmlOutputBufferCreateFd (int fd,
xmlCharEncodingHandlerPtr encoder);
xmlOutputBufferPtr
XMLPUBFUN xmlOutputBufferPtr XMLCALL
xmlOutputBufferCreateIO (xmlOutputWriteCallback iowrite,
xmlOutputCloseCallback ioclose,
void *ioctx,
xmlCharEncodingHandlerPtr encoder);
int xmlOutputBufferWrite (xmlOutputBufferPtr out,
XMLPUBFUN int XMLCALL xmlOutputBufferWrite (xmlOutputBufferPtr out,
int len,
const char *buf);
int xmlOutputBufferWriteString (xmlOutputBufferPtr out,
XMLPUBFUN int XMLCALL xmlOutputBufferWriteString (xmlOutputBufferPtr out,
const char *str);
int xmlOutputBufferFlush (xmlOutputBufferPtr out);
int xmlOutputBufferClose (xmlOutputBufferPtr out);
XMLPUBFUN int XMLCALL xmlOutputBufferFlush (xmlOutputBufferPtr out);
XMLPUBFUN int XMLCALL xmlOutputBufferClose (xmlOutputBufferPtr out);
int xmlRegisterOutputCallbacks (xmlOutputMatchCallback matchFunc,
XMLPUBFUN int XMLCALL xmlRegisterOutputCallbacks (xmlOutputMatchCallback matchFunc,
xmlOutputOpenCallback openFunc,
xmlOutputWriteCallback writeFunc,
xmlOutputCloseCallback closeFunc);
/* This function only exists if HTTP support built into the library */
#ifdef LIBXML_HTTP_ENABLED
void * xmlIOHTTPOpenW (const char * post_uri,
XMLPUBFUN void * XMLCALL xmlIOHTTPOpenW (const char * post_uri,
int compression );
void xmlRegisterHTTPPostCallbacks (void );
XMLPUBFUN void XMLCALL xmlRegisterHTTPPostCallbacks (void );
#endif
/*
* A predefined entity loader disabling network accesses
*/
xmlParserInputPtr xmlNoNetExternalEntityLoader(const char *URL,
XMLPUBFUN xmlParserInputPtr XMLCALL xmlNoNetExternalEntityLoader(const char *URL,
const char *ID,
xmlParserCtxtPtr ctxt);
@ -243,41 +243,41 @@ xmlParserInputPtr xmlNoNetExternalEntityLoader(const char *URL,
* xmlNormalizeWindowsPath is obsolete, don't use it.
* Check xmlCanonicPath in uri.h for a better alternative.
*/
xmlChar * xmlNormalizeWindowsPath (const xmlChar *path);
XMLPUBFUN xmlChar * XMLCALL xmlNormalizeWindowsPath (const xmlChar *path);
int xmlCheckFilename (const char *path);
XMLPUBFUN int XMLCALL xmlCheckFilename (const char *path);
/**
* Default 'file://' protocol callbacks
*/
int xmlFileMatch (const char *filename);
void * xmlFileOpen (const char *filename);
int xmlFileRead (void * context,
XMLPUBFUN int XMLCALL xmlFileMatch (const char *filename);
XMLPUBFUN void * XMLCALL xmlFileOpen (const char *filename);
XMLPUBFUN int XMLCALL xmlFileRead (void * context,
char * buffer,
int len);
int xmlFileClose (void * context);
XMLPUBFUN int XMLCALL xmlFileClose (void * context);
/**
* Default 'http://' protocol callbacks
*/
#ifdef LIBXML_HTTP_ENABLED
int xmlIOHTTPMatch (const char *filename);
void * xmlIOHTTPOpen (const char *filename);
int xmlIOHTTPRead (void * context,
XMLPUBFUN int XMLCALL xmlIOHTTPMatch (const char *filename);
XMLPUBFUN void * XMLCALL xmlIOHTTPOpen (const char *filename);
XMLPUBFUN int XMLCALL xmlIOHTTPRead (void * context,
char * buffer,
int len);
int xmlIOHTTPClose (void * context);
XMLPUBFUN int XMLCALL xmlIOHTTPClose (void * context);
#endif /* LIBXML_HTTP_ENABLED */
/**
* Default 'ftp://' protocol callbacks
*/
#ifdef LIBXML_FTP_ENABLED
int xmlIOFTPMatch (const char *filename);
void * xmlIOFTPOpen (const char *filename);
int xmlIOFTPRead (void * context,
XMLPUBFUN int XMLCALL xmlIOFTPMatch (const char *filename);
XMLPUBFUN void * XMLCALL xmlIOFTPOpen (const char *filename);
XMLPUBFUN int XMLCALL xmlIOFTPRead (void * context,
char * buffer,
int len);
int xmlIOFTPClose (void * context);
XMLPUBFUN int XMLCALL xmlIOFTPClose (void * context);
#endif /* LIBXML_FTP_ENABLED */
#ifdef __cplusplus

32
include/libxml/xmlautomata.h
View File

@ -38,59 +38,59 @@ typedef xmlAutomataState *xmlAutomataStatePtr;
/*
* Building API
*/
xmlAutomataPtr xmlNewAutomata (void);
void xmlFreeAutomata (xmlAutomataPtr am);
XMLPUBFUN xmlAutomataPtr XMLCALL xmlNewAutomata (void);
XMLPUBFUN void XMLCALL xmlFreeAutomata (xmlAutomataPtr am);
xmlAutomataStatePtr xmlAutomataGetInitState (xmlAutomataPtr am);
int xmlAutomataSetFinalState(xmlAutomataPtr am,
XMLPUBFUN xmlAutomataStatePtr XMLCALL xmlAutomataGetInitState (xmlAutomataPtr am);
XMLPUBFUN int XMLCALL xmlAutomataSetFinalState(xmlAutomataPtr am,
xmlAutomataStatePtr state);
xmlAutomataStatePtr xmlAutomataNewState (xmlAutomataPtr am);
xmlAutomataStatePtr xmlAutomataNewTransition(xmlAutomataPtr am,
XMLPUBFUN xmlAutomataStatePtr XMLCALL xmlAutomataNewState (xmlAutomataPtr am);
XMLPUBFUN xmlAutomataStatePtr XMLCALL xmlAutomataNewTransition(xmlAutomataPtr am,
xmlAutomataStatePtr from,
xmlAutomataStatePtr to,
const xmlChar *token,
void *data);
xmlAutomataStatePtr xmlAutomataNewTransition2(xmlAutomataPtr am,
XMLPUBFUN xmlAutomataStatePtr XMLCALL xmlAutomataNewTransition2(xmlAutomataPtr am,
xmlAutomataStatePtr from,
xmlAutomataStatePtr to,
const xmlChar *token,
const xmlChar *token2,
void *data);
xmlAutomataStatePtr xmlAutomataNewCountTrans(xmlAutomataPtr am,
XMLPUBFUN xmlAutomataStatePtr XMLCALL xmlAutomataNewCountTrans(xmlAutomataPtr am,
xmlAutomataStatePtr from,
xmlAutomataStatePtr to,
const xmlChar *token,
int min,
int max,
void *data);
xmlAutomataStatePtr xmlAutomataNewOnceTrans (xmlAutomataPtr am,
XMLPUBFUN xmlAutomataStatePtr XMLCALL xmlAutomataNewOnceTrans (xmlAutomataPtr am,
xmlAutomataStatePtr from,
xmlAutomataStatePtr to,
const xmlChar *token,
int min,
int max,
void *data);
xmlAutomataStatePtr xmlAutomataNewAllTrans (xmlAutomataPtr am,
XMLPUBFUN xmlAutomataStatePtr XMLCALL xmlAutomataNewAllTrans (xmlAutomataPtr am,
xmlAutomataStatePtr from,
xmlAutomataStatePtr to,
int lax);
xmlAutomataStatePtr xmlAutomataNewEpsilon (xmlAutomataPtr am,
XMLPUBFUN xmlAutomataStatePtr XMLCALL xmlAutomataNewEpsilon (xmlAutomataPtr am,
xmlAutomataStatePtr from,
xmlAutomataStatePtr to);
xmlAutomataStatePtr xmlAutomataNewCountedTrans(xmlAutomataPtr am,
XMLPUBFUN xmlAutomataStatePtr XMLCALL xmlAutomataNewCountedTrans(xmlAutomataPtr am,
xmlAutomataStatePtr from,
xmlAutomataStatePtr to,
int counter);
xmlAutomataStatePtr xmlAutomataNewCounterTrans(xmlAutomataPtr am,
XMLPUBFUN xmlAutomataStatePtr XMLCALL xmlAutomataNewCounterTrans(xmlAutomataPtr am,
xmlAutomataStatePtr from,
xmlAutomataStatePtr to,
int counter);
int xmlAutomataNewCounter (xmlAutomataPtr am,
XMLPUBFUN int XMLCALL xmlAutomataNewCounter (xmlAutomataPtr am,
int min,
int max);
xmlRegexpPtr xmlAutomataCompile (xmlAutomataPtr am);
int xmlAutomataIsDeterminist(xmlAutomataPtr am);
XMLPUBFUN xmlRegexpPtr XMLCALL xmlAutomataCompile (xmlAutomataPtr am);
XMLPUBFUN int XMLCALL xmlAutomataIsDeterminist(xmlAutomataPtr am);
#ifdef __cplusplus
}

16
include/libxml/xmlerror.h
View File

@ -155,28 +155,28 @@ typedef void (*xmlGenericErrorFunc) (void *ctx,
* Use the following function to reset the two global variables
* xmlGenericError and xmlGenericErrorContext.
*/
void xmlSetGenericErrorFunc (void *ctx,
XMLPUBFUN void XMLCALL xmlSetGenericErrorFunc (void *ctx,
xmlGenericErrorFunc handler);
void initGenericErrorDefaultFunc(xmlGenericErrorFunc *handler);
XMLPUBFUN void XMLCALL initGenericErrorDefaultFunc(xmlGenericErrorFunc *handler);
/*
* Default message routines used by SAX and Valid context for error
* and warning reporting.
*/
void xmlParserError (void *ctx,
XMLPUBFUN void XMLCALL xmlParserError (void *ctx,
const char *msg,
...);
void xmlParserWarning (void *ctx,
XMLPUBFUN void XMLCALL xmlParserWarning (void *ctx,
const char *msg,
...);
void xmlParserValidityError (void *ctx,
XMLPUBFUN void XMLCALL xmlParserValidityError (void *ctx,
const char *msg,
...);
void xmlParserValidityWarning(void *ctx,
XMLPUBFUN void XMLCALL xmlParserValidityWarning(void *ctx,
const char *msg,
...);
void xmlParserPrintFileInfo (xmlParserInputPtr input);
void xmlParserPrintFileContext(xmlParserInputPtr input);
XMLPUBFUN void XMLCALL xmlParserPrintFileInfo (xmlParserInputPtr input);
XMLPUBFUN void XMLCALL xmlParserPrintFileContext(xmlParserInputPtr input);
#ifdef __cplusplus
}

35
include/libxml/xmlmemory.h
View File

@ -96,20 +96,21 @@ LIBXML_DLL_IMPORT extern xmlStrdupFunc xmlMemStrdup;
* The xmlGc function have an extra entry for atomic block
* allocations useful for garbage collected memory allocators
*/
int xmlMemSetup (xmlFreeFunc freeFunc,
XMLPUBFUN int XMLCALL
xmlMemSetup (xmlFreeFunc freeFunc,
xmlMallocFunc mallocFunc,
xmlReallocFunc reallocFunc,
xmlStrdupFunc strdupFunc);
int xmlMemGet (xmlFreeFunc *freeFunc,
XMLPUBFUN int XMLCALL xmlMemGet (xmlFreeFunc *freeFunc,
xmlMallocFunc *mallocFunc,
xmlReallocFunc *reallocFunc,
xmlStrdupFunc *strdupFunc);
int xmlGcMemSetup (xmlFreeFunc freeFunc,
XMLPUBFUN int XMLCALL xmlGcMemSetup (xmlFreeFunc freeFunc,
xmlMallocFunc mallocFunc,
xmlMallocFunc mallocAtomicFunc,
xmlReallocFunc reallocFunc,
xmlStrdupFunc strdupFunc);
int xmlGcMemGet (xmlFreeFunc *freeFunc,
XMLPUBFUN int XMLCALL xmlGcMemGet (xmlFreeFunc *freeFunc,
xmlMallocFunc *mallocFunc,
xmlMallocFunc *mallocAtomicFunc,
xmlReallocFunc *reallocFunc,
@ -118,23 +119,23 @@ int xmlGcMemGet (xmlFreeFunc *freeFunc,
/*
* Initialization of the memory layer.
*/
int xmlInitMemory (void);
XMLPUBFUN int XMLCALL xmlInitMemory (void);
/*
* These are specific to the XML debug memory wrapper.
*/
int xmlMemUsed (void);
void xmlMemDisplay (FILE *fp);
void xmlMemShow (FILE *fp, int nr);
void xmlMemoryDump (void);
void * xmlMemMalloc (size_t size);
void * xmlMemRealloc (void *ptr,size_t size);
void xmlMemFree (void *ptr);
char * xmlMemoryStrdup (const char *str);
void * xmlMallocLoc (size_t size, const char *file, int line);
void * xmlReallocLoc (void *ptr, size_t size, const char *file, int line);
void * xmlMallocAtomicLoc (size_t size, const char *file, int line);
char * xmlMemStrdupLoc (const char *str, const char *file, int line);
XMLPUBFUN int XMLCALL xmlMemUsed (void);
XMLPUBFUN void XMLCALL xmlMemDisplay (FILE *fp);
XMLPUBFUN void XMLCALL xmlMemShow (FILE *fp, int nr);
XMLPUBFUN void XMLCALL xmlMemoryDump (void);
XMLPUBFUN void * XMLCALL xmlMemMalloc (size_t size);
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);
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);
XMLPUBFUN char * XMLCALL xmlMemStrdupLoc (const char *str, const char *file, int line);
#ifdef DEBUG_MEMORY_LOCATION

102
include/libxml/xmlreader.h
View File

@ -9,6 +9,7 @@
#ifndef __XML_XMLREADER_H__
#define __XML_XMLREADER_H__
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#include <libxml/xmlIO.h>
#ifdef LIBXML_SCHEMAS_ENABLED
@ -60,83 +61,84 @@ typedef xmlTextReader *xmlTextReaderPtr;
/*
* Constructors & Destructor
*/
xmlTextReaderPtr xmlNewTextReader (xmlParserInputBufferPtr input,
XMLPUBFUN xmlTextReaderPtr XMLCALL
xmlNewTextReader (xmlParserInputBufferPtr input,
const char *URI);
xmlTextReaderPtr xmlNewTextReaderFilename(const char *URI);
void xmlFreeTextReader (xmlTextReaderPtr reader);
XMLPUBFUN xmlTextReaderPtr XMLCALL xmlNewTextReaderFilename(const char *URI);
XMLPUBFUN void XMLCALL xmlFreeTextReader (xmlTextReaderPtr reader);
/*
* Iterators
*/
int xmlTextReaderRead (xmlTextReaderPtr reader);
xmlChar * xmlTextReaderReadInnerXml (xmlTextReaderPtr reader);
xmlChar * xmlTextReaderReadOuterXml (xmlTextReaderPtr reader);
xmlChar * xmlTextReaderReadString (xmlTextReaderPtr reader);
int xmlTextReaderReadAttributeValue (xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL xmlTextReaderRead (xmlTextReaderPtr reader);
XMLPUBFUN xmlChar * XMLCALL xmlTextReaderReadInnerXml (xmlTextReaderPtr reader);
XMLPUBFUN xmlChar * XMLCALL xmlTextReaderReadOuterXml (xmlTextReaderPtr reader);
XMLPUBFUN xmlChar * XMLCALL xmlTextReaderReadString (xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL xmlTextReaderReadAttributeValue (xmlTextReaderPtr reader);
/*
* Attributes of the node
*/
int xmlTextReaderAttributeCount(xmlTextReaderPtr reader);
xmlChar * xmlTextReaderBaseUri (xmlTextReaderPtr reader);
int xmlTextReaderDepth (xmlTextReaderPtr reader);
int xmlTextReaderHasAttributes(xmlTextReaderPtr reader);
int xmlTextReaderHasValue(xmlTextReaderPtr reader);
int xmlTextReaderIsDefault (xmlTextReaderPtr reader);
int xmlTextReaderIsEmptyElement(xmlTextReaderPtr reader);
xmlChar * xmlTextReaderLocalName (xmlTextReaderPtr reader);
xmlChar * xmlTextReaderName (xmlTextReaderPtr reader);
xmlChar * xmlTextReaderNamespaceUri(xmlTextReaderPtr reader);
int xmlTextReaderNodeType (xmlTextReaderPtr reader);
xmlChar * xmlTextReaderPrefix (xmlTextReaderPtr reader);
int xmlTextReaderQuoteChar (xmlTextReaderPtr reader);
xmlChar * xmlTextReaderValue (xmlTextReaderPtr reader);
xmlChar * xmlTextReaderXmlLang (xmlTextReaderPtr reader);
int xmlTextReaderReadState (xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL xmlTextReaderAttributeCount(xmlTextReaderPtr reader);
XMLPUBFUN xmlChar * XMLCALL xmlTextReaderBaseUri (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 xmlChar * XMLCALL xmlTextReaderLocalName (xmlTextReaderPtr reader);
XMLPUBFUN xmlChar * XMLCALL xmlTextReaderName (xmlTextReaderPtr reader);
XMLPUBFUN xmlChar * XMLCALL xmlTextReaderNamespaceUri(xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL xmlTextReaderNodeType (xmlTextReaderPtr reader);
XMLPUBFUN xmlChar * XMLCALL xmlTextReaderPrefix (xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL xmlTextReaderQuoteChar (xmlTextReaderPtr reader);
XMLPUBFUN xmlChar * XMLCALL xmlTextReaderValue (xmlTextReaderPtr reader);
XMLPUBFUN xmlChar * XMLCALL xmlTextReaderXmlLang (xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL xmlTextReaderReadState (xmlTextReaderPtr reader);
/*
* Methods of the XmlTextReader
*/
int xmlTextReaderClose (xmlTextReaderPtr reader);
xmlChar * xmlTextReaderGetAttributeNo (xmlTextReaderPtr reader,
XMLPUBFUN int XMLCALL xmlTextReaderClose (xmlTextReaderPtr reader);
XMLPUBFUN xmlChar * XMLCALL xmlTextReaderGetAttributeNo (xmlTextReaderPtr reader,
int no);
xmlChar * xmlTextReaderGetAttribute (xmlTextReaderPtr reader,
XMLPUBFUN xmlChar * XMLCALL xmlTextReaderGetAttribute (xmlTextReaderPtr reader,
const xmlChar *name);
xmlChar * xmlTextReaderGetAttributeNs (xmlTextReaderPtr reader,
XMLPUBFUN xmlChar * XMLCALL xmlTextReaderGetAttributeNs (xmlTextReaderPtr reader,
const xmlChar *localName,
const xmlChar *namespaceURI);
xmlParserInputBufferPtr xmlTextReaderGetRemainder(xmlTextReaderPtr reader);
xmlChar * xmlTextReaderLookupNamespace (xmlTextReaderPtr reader,
XMLPUBFUN xmlParserInputBufferPtr XMLCALL xmlTextReaderGetRemainder(xmlTextReaderPtr reader);
XMLPUBFUN xmlChar * XMLCALL xmlTextReaderLookupNamespace (xmlTextReaderPtr reader,
const xmlChar *prefix);
int xmlTextReaderMoveToAttributeNo (xmlTextReaderPtr reader,
XMLPUBFUN int XMLCALL xmlTextReaderMoveToAttributeNo (xmlTextReaderPtr reader,
int no);
int xmlTextReaderMoveToAttribute (xmlTextReaderPtr reader,
XMLPUBFUN int XMLCALL xmlTextReaderMoveToAttribute (xmlTextReaderPtr reader,
const xmlChar *name);
int xmlTextReaderMoveToAttributeNs (xmlTextReaderPtr reader,
XMLPUBFUN int XMLCALL xmlTextReaderMoveToAttributeNs (xmlTextReaderPtr reader,
const xmlChar *localName,
const xmlChar *namespaceURI);
int xmlTextReaderMoveToFirstAttribute(xmlTextReaderPtr reader);
int xmlTextReaderMoveToNextAttribute(xmlTextReaderPtr reader);
int xmlTextReaderMoveToElement (xmlTextReaderPtr reader);
int xmlTextReaderNormalization (xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL xmlTextReaderMoveToFirstAttribute(xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL xmlTextReaderMoveToNextAttribute(xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL xmlTextReaderMoveToElement (xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL xmlTextReaderNormalization (xmlTextReaderPtr reader);
/*
* Extensions
*/
int xmlTextReaderSetParserProp (xmlTextReaderPtr reader,
XMLPUBFUN int XMLCALL xmlTextReaderSetParserProp (xmlTextReaderPtr reader,
int prop,
int value);
int xmlTextReaderGetParserProp (xmlTextReaderPtr reader,
XMLPUBFUN int XMLCALL xmlTextReaderGetParserProp (xmlTextReaderPtr reader,
int prop);
xmlNodePtr xmlTextReaderCurrentNode (xmlTextReaderPtr reader);
xmlDocPtr xmlTextReaderCurrentDoc (xmlTextReaderPtr reader);
xmlNodePtr xmlTextReaderExpand (xmlTextReaderPtr reader);
int xmlTextReaderNext (xmlTextReaderPtr reader);
int xmlTextReaderIsValid (xmlTextReaderPtr reader);
XMLPUBFUN xmlNodePtr XMLCALL xmlTextReaderCurrentNode (xmlTextReaderPtr reader);
XMLPUBFUN xmlDocPtr XMLCALL xmlTextReaderCurrentDoc (xmlTextReaderPtr reader);
XMLPUBFUN xmlNodePtr XMLCALL xmlTextReaderExpand (xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL xmlTextReaderNext (xmlTextReaderPtr reader);
XMLPUBFUN int XMLCALL xmlTextReaderIsValid (xmlTextReaderPtr reader);
#ifdef LIBXML_SCHEMAS_ENABLED
int xmlTextReaderRelaxNGValidate (xmlTextReaderPtr reader,
XMLPUBFUN int XMLCALL xmlTextReaderRelaxNGValidate (xmlTextReaderPtr reader,
const char *rng);
int xmlTextReaderRelaxNGSetSchema (xmlTextReaderPtr reader,
XMLPUBFUN int XMLCALL xmlTextReaderRelaxNGSetSchema (xmlTextReaderPtr reader,
xmlRelaxNGPtr schema);
#endif
@ -148,13 +150,13 @@ typedef void (*xmlTextReaderErrorFunc) (void *arg,
const char *msg,
xmlParserSeverities severity,
xmlTextReaderLocatorPtr locator);
int xmlTextReaderLocatorLineNumber (xmlTextReaderLocatorPtr locator);
XMLPUBFUN int XMLCALL xmlTextReaderLocatorLineNumber (xmlTextReaderLocatorPtr locator);
/*int xmlTextReaderLocatorLinePosition(xmlTextReaderLocatorPtr locator);*/
xmlChar * xmlTextReaderLocatorBaseURI (xmlTextReaderLocatorPtr locator);
void xmlTextReaderSetErrorHandler (xmlTextReaderPtr reader,
XMLPUBFUN xmlChar * XMLCALL xmlTextReaderLocatorBaseURI (xmlTextReaderLocatorPtr locator);
XMLPUBFUN void XMLCALL xmlTextReaderSetErrorHandler (xmlTextReaderPtr reader,
xmlTextReaderErrorFunc f,
void *arg);
void xmlTextReaderGetErrorHandler (xmlTextReaderPtr reader,
XMLPUBFUN void XMLCALL xmlTextReaderGetErrorHandler (xmlTextReaderPtr reader,
xmlTextReaderErrorFunc *f,
void **arg);

19
include/libxml/xmlregexp.h
View File

@ -45,13 +45,14 @@ extern "C" {
/*
* The POSIX like API
*/
xmlRegexpPtr xmlRegexpCompile(const xmlChar *regexp);
void xmlRegFreeRegexp(xmlRegexpPtr regexp);
int xmlRegexpExec (xmlRegexpPtr comp,
XMLPUBFUN xmlRegexpPtr XMLCALL
xmlRegexpCompile(const xmlChar *regexp);
XMLPUBFUN void XMLCALL xmlRegFreeRegexp(xmlRegexpPtr regexp);
XMLPUBFUN int XMLCALL xmlRegexpExec (xmlRegexpPtr comp,
const xmlChar *value);
void xmlRegexpPrint (FILE *output,
XMLPUBFUN void XMLCALL xmlRegexpPrint (FILE *output,
xmlRegexpPtr regexp);
int xmlRegexpIsDeterminist(xmlRegexpPtr comp);
XMLPUBFUN int XMLCALL xmlRegexpIsDeterminist(xmlRegexpPtr comp);
/*
* Callback function when doing a transition in the automata
@ -64,14 +65,14 @@ typedef void (*xmlRegExecCallbacks) (xmlRegExecCtxtPtr exec,
/*
* The progressive API
*/
xmlRegExecCtxtPtr xmlRegNewExecCtxt (xmlRegexpPtr comp,
XMLPUBFUN xmlRegExecCtxtPtr XMLCALL xmlRegNewExecCtxt (xmlRegexpPtr comp,
xmlRegExecCallbacks callback,
void *data);
void xmlRegFreeExecCtxt (xmlRegExecCtxtPtr exec);
int xmlRegExecPushString (xmlRegExecCtxtPtr exec,
XMLPUBFUN void XMLCALL xmlRegFreeExecCtxt (xmlRegExecCtxtPtr exec);
XMLPUBFUN int XMLCALL xmlRegExecPushString (xmlRegExecCtxtPtr exec,
const xmlChar *value,
void *data);
int xmlRegExecPushString2 (xmlRegExecCtxtPtr exec,
XMLPUBFUN int XMLCALL xmlRegExecPushString2 (xmlRegExecCtxtPtr exec,
const xmlChar *value,
const xmlChar *value2,
void *data);

24
include/libxml/xmlschemas.h
View File

@ -72,30 +72,30 @@ typedef xmlSchemaValidCtxt *xmlSchemaValidCtxtPtr;
/*
* Interfaces for parsing.
*/
xmlSchemaParserCtxtPtr xmlSchemaNewParserCtxt (const char *URL);
xmlSchemaParserCtxtPtr xmlSchemaNewMemParserCtxt(const char *buffer,
XMLPUBFUN xmlSchemaParserCtxtPtr XMLCALL xmlSchemaNewParserCtxt (const char *URL);
XMLPUBFUN xmlSchemaParserCtxtPtr XMLCALL xmlSchemaNewMemParserCtxt(const char *buffer,
int size);
void xmlSchemaFreeParserCtxt (xmlSchemaParserCtxtPtr ctxt);
void xmlSchemaSetParserErrors(xmlSchemaParserCtxtPtr ctxt,
XMLPUBFUN void XMLCALL xmlSchemaFreeParserCtxt (xmlSchemaParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL xmlSchemaSetParserErrors(xmlSchemaParserCtxtPtr ctxt,
xmlSchemaValidityErrorFunc err,
xmlSchemaValidityWarningFunc warn,
void *ctx);
xmlSchemaPtr xmlSchemaParse (xmlSchemaParserCtxtPtr ctxt);
void xmlSchemaFree (xmlSchemaPtr schema);
void xmlSchemaDump (FILE *output,
XMLPUBFUN xmlSchemaPtr XMLCALL xmlSchemaParse (xmlSchemaParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL xmlSchemaFree (xmlSchemaPtr schema);
XMLPUBFUN void XMLCALL xmlSchemaDump (FILE *output,
xmlSchemaPtr schema);
/*
* Interfaces for validating
*/
void xmlSchemaSetValidErrors (xmlSchemaValidCtxtPtr ctxt,
XMLPUBFUN void XMLCALL xmlSchemaSetValidErrors (xmlSchemaValidCtxtPtr ctxt,
xmlSchemaValidityErrorFunc err,
xmlSchemaValidityWarningFunc warn,
void *ctx);
xmlSchemaValidCtxtPtr xmlSchemaNewValidCtxt (xmlSchemaPtr schema);
void xmlSchemaFreeValidCtxt (xmlSchemaValidCtxtPtr ctxt);
int xmlSchemaValidateDoc (xmlSchemaValidCtxtPtr ctxt,
XMLPUBFUN xmlSchemaValidCtxtPtr XMLCALL xmlSchemaNewValidCtxt (xmlSchemaPtr schema);
XMLPUBFUN void XMLCALL xmlSchemaFreeValidCtxt (xmlSchemaValidCtxtPtr ctxt);
XMLPUBFUN int XMLCALL xmlSchemaValidateDoc (xmlSchemaValidCtxtPtr ctxt,
xmlDocPtr instance);
int xmlSchemaValidateStream (xmlSchemaValidCtxtPtr ctxt,
XMLPUBFUN int XMLCALL xmlSchemaValidateStream (xmlSchemaValidCtxtPtr ctxt,
xmlParserInputBufferPtr input,
xmlCharEncoding enc,
xmlSAXHandlerPtr sax,

22
include/libxml/xmlschemastypes.h
View File

@ -22,29 +22,29 @@
extern "C" {
#endif
void xmlSchemaInitTypes (void);
void xmlSchemaCleanupTypes (void);
xmlSchemaTypePtr xmlSchemaGetPredefinedType (const xmlChar *name,
XMLPUBFUN void XMLCALL xmlSchemaInitTypes (void);
XMLPUBFUN void XMLCALL xmlSchemaCleanupTypes (void);
XMLPUBFUN xmlSchemaTypePtr XMLCALL xmlSchemaGetPredefinedType (const xmlChar *name,
const xmlChar *ns);
int xmlSchemaValidatePredefinedType (xmlSchemaTypePtr type,
XMLPUBFUN int XMLCALL xmlSchemaValidatePredefinedType (xmlSchemaTypePtr type,
const xmlChar *value,
xmlSchemaValPtr *val);
int xmlSchemaValPredefTypeNode (xmlSchemaTypePtr type,
XMLPUBFUN int XMLCALL xmlSchemaValPredefTypeNode (xmlSchemaTypePtr type,
const xmlChar *value,
xmlSchemaValPtr *val,
xmlNodePtr node);
int xmlSchemaValidateFacet (xmlSchemaTypePtr base,
XMLPUBFUN int XMLCALL xmlSchemaValidateFacet (xmlSchemaTypePtr base,
xmlSchemaFacetPtr facet,
const xmlChar *value,
xmlSchemaValPtr val);
void xmlSchemaFreeValue (xmlSchemaValPtr val);
xmlSchemaFacetPtr xmlSchemaNewFacet (void);
int xmlSchemaCheckFacet (xmlSchemaFacetPtr facet,
XMLPUBFUN void XMLCALL xmlSchemaFreeValue (xmlSchemaValPtr val);
XMLPUBFUN xmlSchemaFacetPtr XMLCALL xmlSchemaNewFacet (void);
XMLPUBFUN int XMLCALL xmlSchemaCheckFacet (xmlSchemaFacetPtr facet,
xmlSchemaTypePtr typeDecl,
xmlSchemaParserCtxtPtr ctxt,
const xmlChar *name);
void xmlSchemaFreeFacet (xmlSchemaFacetPtr facet);
int xmlSchemaCompareValues (xmlSchemaValPtr x,
XMLPUBFUN void XMLCALL xmlSchemaFreeFacet (xmlSchemaFacetPtr facet);
XMLPUBFUN int XMLCALL xmlSchemaCompareValues (xmlSchemaValPtr x,
xmlSchemaValPtr y);
#ifdef __cplusplus

272
include/libxml/xmlunicode.h
View File

@ -6,7 +6,7 @@
* http://www.unicode.org/Public/3.1-Update/UnicodeCharacterDatabase-3.1.0.html
* using the genUnicode.py Python script.
*
* Generation date: Tue Apr 16 17:28:05 2002
* Generation date: Mon Aug 25 10:45:50 2003
* Sources: Blocks-4.txt UnicodeData-3.1.0.txt
* Daniel Veillard <veillard@redhat.com>
*/
@ -14,148 +14,150 @@
#ifndef __XML_UNICODE_H__
#define __XML_UNICODE_H__
#include <libxml/xmlversion.h>
#ifdef __cplusplus
extern "C" {
#endif
int xmlUCSIsAlphabeticPresentationForms (int code);
int xmlUCSIsArabic (int code);
int xmlUCSIsArabicPresentationFormsA (int code);
int xmlUCSIsArabicPresentationFormsB (int code);
int xmlUCSIsArmenian (int code);
int xmlUCSIsArrows (int code);
int xmlUCSIsBasicLatin (int code);
int xmlUCSIsBengali (int code);
int xmlUCSIsBlockElements (int code);
int xmlUCSIsBopomofo (int code);
int xmlUCSIsBopomofoExtended (int code);
int xmlUCSIsBoxDrawing (int code);
int xmlUCSIsBraillePatterns (int code);
int xmlUCSIsByzantineMusicalSymbols (int code);
int xmlUCSIsCJKCompatibility (int code);
int xmlUCSIsCJKCompatibilityForms (int code);
int xmlUCSIsCJKCompatibilityIdeographs (int code);
int xmlUCSIsCJKCompatibilityIdeographsSupplement (int code);
int xmlUCSIsCJKRadicalsSupplement (int code);
int xmlUCSIsCJKSymbolsandPunctuation (int code);
int xmlUCSIsCJKUnifiedIdeographs (int code);
int xmlUCSIsCJKUnifiedIdeographsExtensionA (int code);
int xmlUCSIsCJKUnifiedIdeographsExtensionB (int code);
int xmlUCSIsCherokee (int code);
int xmlUCSIsCombiningDiacriticalMarks (int code);
int xmlUCSIsCombiningHalfMarks (int code);
int xmlUCSIsCombiningMarksforSymbols (int code);
int xmlUCSIsControlPictures (int code);
int xmlUCSIsCurrencySymbols (int code);
int xmlUCSIsCyrillic (int code);
int xmlUCSIsDeseret (int code);
int xmlUCSIsDevanagari (int code);
int xmlUCSIsDingbats (int code);
int xmlUCSIsEnclosedAlphanumerics (int code);
int xmlUCSIsEnclosedCJKLettersandMonths (int code);
int xmlUCSIsEthiopic (int code);
int xmlUCSIsGeneralPunctuation (int code);
int xmlUCSIsGeometricShapes (int code);
int xmlUCSIsGeorgian (int code);
int xmlUCSIsGothic (int code);
int xmlUCSIsGreek (int code);
int xmlUCSIsGreekExtended (int code);
int xmlUCSIsGujarati (int code);
int xmlUCSIsGurmukhi (int code);
int xmlUCSIsHalfwidthandFullwidthForms (int code);
int xmlUCSIsHangulCompatibilityJamo (int code);
int xmlUCSIsHangulJamo (int code);
int xmlUCSIsHangulSyllables (int code);
int xmlUCSIsHebrew (int code);
int xmlUCSIsHighPrivateUseSurrogates (int code);
int xmlUCSIsHighSurrogates (int code);
int xmlUCSIsHiragana (int code);
int xmlUCSIsIPAExtensions (int code);
int xmlUCSIsIdeographicDescriptionCharacters (int code);
int xmlUCSIsKanbun (int code);
int xmlUCSIsKangxiRadicals (int code);
int xmlUCSIsKannada (int code);
int xmlUCSIsKatakana (int code);
int xmlUCSIsKhmer (int code);
int xmlUCSIsLao (int code);
int xmlUCSIsLatin1Supplement (int code);
int xmlUCSIsLatinExtendedA (int code);
int xmlUCSIsLatinExtendedB (int code);
int xmlUCSIsLatinExtendedAdditional (int code);
int xmlUCSIsLetterlikeSymbols (int code);
int xmlUCSIsLowSurrogates (int code);
int xmlUCSIsMalayalam (int code);
int xmlUCSIsMathematicalAlphanumericSymbols (int code);
int xmlUCSIsMathematicalOperators (int code);
int xmlUCSIsMiscellaneousSymbols (int code);
int xmlUCSIsMiscellaneousTechnical (int code);
int xmlUCSIsMongolian (int code);
int xmlUCSIsMusicalSymbols (int code);
int xmlUCSIsMyanmar (int code);
int xmlUCSIsNumberForms (int code);
int xmlUCSIsOgham (int code);
int xmlUCSIsOldItalic (int code);
int xmlUCSIsOpticalCharacterRecognition (int code);
int xmlUCSIsOriya (int code);
int xmlUCSIsPrivateUse (int code);
int xmlUCSIsRunic (int code);
int xmlUCSIsSinhala (int code);
int xmlUCSIsSmallFormVariants (int code);
int xmlUCSIsSpacingModifierLetters (int code);
int xmlUCSIsSpecials (int code);
int xmlUCSIsSuperscriptsandSubscripts (int code);
int xmlUCSIsSyriac (int code);
int xmlUCSIsTags (int code);
int xmlUCSIsTamil (int code);
int xmlUCSIsTelugu (int code);
int xmlUCSIsThaana (int code);
int xmlUCSIsThai (int code);
int xmlUCSIsTibetan (int code);
int xmlUCSIsUnifiedCanadianAboriginalSyllabics (int code);
int xmlUCSIsYiRadicals (int code);
int xmlUCSIsYiSyllables (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 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 xmlUCSIsCombiningHalfMarks (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCombiningMarksforSymbols (int code);
XMLPUBFUN int XMLCALL xmlUCSIsControlPictures (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCurrencySymbols (int code);
XMLPUBFUN int XMLCALL xmlUCSIsCyrillic (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 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 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 xmlUCSIsKhmer (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 xmlUCSIsLowSurrogates (int code);
XMLPUBFUN int XMLCALL xmlUCSIsMalayalam (int code);
XMLPUBFUN int XMLCALL xmlUCSIsMathematicalAlphanumericSymbols (int code);
XMLPUBFUN int XMLCALL xmlUCSIsMathematicalOperators (int code);
XMLPUBFUN int XMLCALL xmlUCSIsMiscellaneousSymbols (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 xmlUCSIsPrivateUse (int code);
XMLPUBFUN int XMLCALL xmlUCSIsRunic (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 xmlUCSIsSyriac (int code);
XMLPUBFUN int XMLCALL xmlUCSIsTags (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 xmlUCSIsUnifiedCanadianAboriginalSyllabics (int code);
XMLPUBFUN int XMLCALL xmlUCSIsYiRadicals (int code);
XMLPUBFUN int XMLCALL xmlUCSIsYiSyllables (int code);
int xmlUCSIsBlock (int code,
XMLPUBFUN int XMLCALL xmlUCSIsBlock (int code,
const char *block);
int xmlUCSIsCatC (int code);
int xmlUCSIsCatCc (int code);
int xmlUCSIsCatCf (int code);
int xmlUCSIsCatCo (int code);
int xmlUCSIsCatCs (int code);
int xmlUCSIsCatL (int code);
int xmlUCSIsCatLl (int code);
int xmlUCSIsCatLm (int code);
int xmlUCSIsCatLo (int code);
int xmlUCSIsCatLt (int code);
int xmlUCSIsCatLu (int code);
int xmlUCSIsCatM (int code);
int xmlUCSIsCatMc (int code);
int xmlUCSIsCatMe (int code);
int xmlUCSIsCatMn (int code);
int xmlUCSIsCatN (int code);
int xmlUCSIsCatNd (int code);
int xmlUCSIsCatNl (int code);
int xmlUCSIsCatNo (int code);
int xmlUCSIsCatP (int code);
int xmlUCSIsCatPc (int code);
int xmlUCSIsCatPd (int code);
int xmlUCSIsCatPe (int code);
int xmlUCSIsCatPf (int code);
int xmlUCSIsCatPi (int code);
int xmlUCSIsCatPo (int code);
int xmlUCSIsCatPs (int code);
int xmlUCSIsCatS (int code);
int xmlUCSIsCatSc (int code);
int xmlUCSIsCatSk (int code);
int xmlUCSIsCatSm (int code);
int xmlUCSIsCatSo (int code);
int xmlUCSIsCatZ (int code);
int xmlUCSIsCatZl (int code);
int xmlUCSIsCatZp (int code);
int xmlUCSIsCatZs (int code);
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);
int xmlUCSIsCat (int code,
XMLPUBFUN int XMLCALL xmlUCSIsCat (int code,
const char *cat);
#ifdef __cplusplus

98
include/libxml/xmlversion.h.in
View File

@ -9,6 +9,79 @@
#ifndef __XML_VERSION_H__
#define __XML_VERSION_H__
/**
* XMLPUBFUN, XMLPUBVAR, XMLCALL
*
* Macros which declare an exportable function, an exportable variable and
* the calling convention used for functions.
*
* Please use an extra block for every platform/compiler combination when
* modifying this, rather than overlong #ifdef lines. This helps
* readability as well as the fact that different compilers on the same
* platform might need different definitions.
*/
#define XMLPUBFUN
#define XMLPUBVAR
#define XMLCALL
/* Windows platform with MS compiler */
#if defined(_WIN32) && defined(_MSC_VER)
#undef XMLPUBFUN
#undef XMLPUBVAR
#undef XMLCALL
#if defined(IN_LIBXML) && !defined(LIBXML_STATIC)
#define XMLPUBFUN __declspec(dllexport)
#define XMLPUBVAR __declspec(dllexport)
#else
#define XMLPUBFUN
#if !defined(LIBXML_STATIC)
#define XMLPUBVAR __declspec(dllimport) extern
#else
#define XMLPUBVAR
#endif
#endif
#define XMLCALL __cdecl
#endif
/* Windows platform with Borland compiler */
#if defined(_WIN32) && defined(__BORLANDC__)
#undef XMLPUBFUN
#undef XMLPUBVAR
#undef XMLCALL
#if defined(IN_LIBXML) && !defined(LIBXML_STATIC)
#define XMLPUBFUN __declspec(dllexport)
#define XMLPUBVAR __declspec(dllexport)
#else
#define XMLPUBFUN
#if !defined(LIBXML_STATIC)
#define XMLPUBVAR __declspec(dllimport) extern
#else
#define XMLPUBVAR
#endif
#endif
#define XMLCALL __cdecl
#endif
/* Cygwin platform, GNU compiler */
#if defined(_WIN32) && defined(__CYGWIN__)
#undef XMLPUBFUN
#undef XMLPUBVAR
#undef XMLCALL
#if defined(IN_LIBXML) && !defined(LIBXML_STATIC)
#define XMLPUBFUN __declspec(dllexport)
#define XMLPUBVAR __declspec(dllexport)
#else
#define XMLPUBFUN
#if !defined(LIBXML_STATIC)
#define XMLPUBVAR __declspec(dllimport) extern
#else
#define XMLPUBVAR
#endif
#endif
#define XMLCALL __cdecl
#endif
/* Compatibility */
#if !defined(LIBXML_DLL_IMPORT)
#define LIBXML_DLL_IMPORT XMLPUBVAR
#endif
#ifdef __cplusplus
extern "C" {
#endif
@ -18,7 +91,7 @@ extern "C" {
* your library and includes mismatch
*/
#ifndef LIBXML2_COMPILING_MSCCDEF
extern void xmlCheckVersion(int version);
XMLPUBFUN void XMLCALL xmlCheckVersion(int version);
#endif /* LIBXML2_COMPILING_MSCCDEF */
/**
@ -234,29 +307,6 @@ extern void xmlCheckVersion(int version);
#define LIBXML_SCHEMAS_ENABLED
#endif
/**
* LIBXML_DLL_IMPORT:
*
* Used on Windows (MS C compiler only) to declare a variable as
* imported from the library. This macro should be empty when compiling
* libxml itself. It should expand to __declspec(dllimport)
* when the client code includes this header, and that only if the client
* links dynamically against libxml.
* For this to work, we need three macros. One tells us which compiler is
* being used and luckily the compiler defines such a thing: _MSC_VER. The
* second macro tells us if we are compiling libxml or the client code and
* we define the macro IN_LIBXML on the compiler's command line for this
* purpose. The third macro, LIBXML_STATIC, must be defined by any client
* code which links against libxml statically.
*/
#ifndef LIBXML_DLL_IMPORT
#if (defined(_MSC_VER) || defined(__BORLANDC__) || defined(__CYGWIN__)) && !defined(IN_LIBXML) && !defined(LIBXML_STATIC)
#define LIBXML_DLL_IMPORT __declspec(dllimport)
#else
#define LIBXML_DLL_IMPORT
#endif
#endif
/**
* ATTRIBUTE_UNUSED:
*

77
include/libxml/xpath.h
View File

@ -12,6 +12,7 @@
#ifndef __XML_XPATH_H__
#define __XML_XPATH_H__
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#include <libxml/hash.h>
@ -306,12 +307,12 @@ typedef void (*xmlXPathFunction) (xmlXPathParserContextPtr ctxt, int nargs);
* Objects and Nodesets handling
*/
LIBXML_DLL_IMPORT extern double xmlXPathNAN;
LIBXML_DLL_IMPORT extern double xmlXPathPINF;
LIBXML_DLL_IMPORT extern double xmlXPathNINF;
XMLPUBVAR double xmlXPathNAN;
XMLPUBVAR double xmlXPathPINF;
XMLPUBVAR double xmlXPathNINF;
int xmlXPathIsNaN (double val);
int xmlXPathIsInf (double val);
XMLPUBFUN int XMLCALL xmlXPathIsNaN (double val);
XMLPUBFUN int XMLCALL xmlXPathIsInf (double val);
/* These macros may later turn into functions */
/**
@ -350,61 +351,61 @@ int xmlXPathIsInf (double val);
(((ns) == NULL) || ((ns)->nodeNr == 0) || ((ns)->nodeTab == NULL))
void xmlXPathFreeObject (xmlXPathObjectPtr obj);
xmlNodeSetPtr xmlXPathNodeSetCreate (xmlNodePtr val);
void xmlXPathFreeNodeSetList (xmlXPathObjectPtr obj);
void xmlXPathFreeNodeSet (xmlNodeSetPtr obj);
xmlXPathObjectPtr xmlXPathObjectCopy (xmlXPathObjectPtr val);
int xmlXPathCmpNodes (xmlNodePtr node1,
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.
*/
int xmlXPathCastNumberToBoolean (double val);
int xmlXPathCastStringToBoolean (const xmlChar * val);
int xmlXPathCastNodeSetToBoolean (xmlNodeSetPtr ns);
int xmlXPathCastToBoolean (xmlXPathObjectPtr val);
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);
double xmlXPathCastBooleanToNumber (int val);
double xmlXPathCastStringToNumber (const xmlChar * val);
double xmlXPathCastNodeToNumber (xmlNodePtr node);
double xmlXPathCastNodeSetToNumber (xmlNodeSetPtr ns);
double xmlXPathCastToNumber (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);
xmlChar * xmlXPathCastBooleanToString (int val);
xmlChar * xmlXPathCastNumberToString (double val);
xmlChar * xmlXPathCastNodeToString (xmlNodePtr node);
xmlChar * xmlXPathCastNodeSetToString (xmlNodeSetPtr ns);
xmlChar * xmlXPathCastToString (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);
xmlXPathObjectPtr xmlXPathConvertBoolean (xmlXPathObjectPtr val);
xmlXPathObjectPtr xmlXPathConvertNumber (xmlXPathObjectPtr val);
xmlXPathObjectPtr xmlXPathConvertString (xmlXPathObjectPtr val);
XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPathConvertBoolean (xmlXPathObjectPtr val);
XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPathConvertNumber (xmlXPathObjectPtr val);
XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPathConvertString (xmlXPathObjectPtr val);
/**
* Context handling.
*/
void xmlXPathInit (void);
xmlXPathContextPtr xmlXPathNewContext (xmlDocPtr doc);
void xmlXPathFreeContext (xmlXPathContextPtr ctxt);
XMLPUBFUN void XMLCALL xmlXPathInit (void);
XMLPUBFUN xmlXPathContextPtr XMLCALL xmlXPathNewContext (xmlDocPtr doc);
XMLPUBFUN void XMLCALL xmlXPathFreeContext (xmlXPathContextPtr ctxt);
/**
* Evaluation functions.
*/
long xmlXPathOrderDocElems (xmlDocPtr doc);
xmlXPathObjectPtr xmlXPathEval (const xmlChar *str,
XMLPUBFUN long XMLCALL xmlXPathOrderDocElems (xmlDocPtr doc);
XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPathEval (const xmlChar *str,
xmlXPathContextPtr ctx);
xmlXPathObjectPtr xmlXPathEvalExpression (const xmlChar *str,
XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPathEvalExpression (const xmlChar *str,
xmlXPathContextPtr ctxt);
int xmlXPathEvalPredicate (xmlXPathContextPtr ctxt,
XMLPUBFUN int XMLCALL xmlXPathEvalPredicate (xmlXPathContextPtr ctxt,
xmlXPathObjectPtr res);
/**
* Separate compilation/evaluation entry points.
*/
xmlXPathCompExprPtr xmlXPathCompile (const xmlChar *str);
xmlXPathObjectPtr xmlXPathCompiledEval (xmlXPathCompExprPtr comp,
XMLPUBFUN xmlXPathCompExprPtr XMLCALL xmlXPathCompile (const xmlChar *str);
XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPathCompiledEval (xmlXPathCompExprPtr comp,
xmlXPathContextPtr ctx);
void xmlXPathFreeCompExpr (xmlXPathCompExprPtr comp);
XMLPUBFUN void XMLCALL xmlXPathFreeCompExpr (xmlXPathCompExprPtr comp);
#ifdef __cplusplus
}
#endif

232
include/libxml/xpathInternals.h
View File

@ -96,11 +96,11 @@ extern "C" {
*/
#define xmlXPathGetContextNode(ctxt) ((ctxt)->context->node)
int xmlXPathPopBoolean (xmlXPathParserContextPtr ctxt);
double xmlXPathPopNumber (xmlXPathParserContextPtr ctxt);
xmlChar * xmlXPathPopString (xmlXPathParserContextPtr ctxt);
xmlNodeSetPtr xmlXPathPopNodeSet (xmlXPathParserContextPtr ctxt);
void * xmlXPathPopExternal (xmlXPathParserContextPtr ctxt);
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:
@ -335,7 +335,7 @@ typedef xmlXPathObjectPtr (*xmlXPathVariableLookupFunc) (void *ctxt,
const xmlChar *name,
const xmlChar *ns_uri);
void xmlXPathRegisterVariableLookup (xmlXPathContextPtr ctxt,
XMLPUBFUN void XMLCALL xmlXPathRegisterVariableLookup (xmlXPathContextPtr ctxt,
xmlXPathVariableLookupFunc f,
void *data);
@ -357,57 +357,57 @@ typedef xmlXPathFunction (*xmlXPathFuncLookupFunc) (void *ctxt,
const xmlChar *name,
const xmlChar *ns_uri);
void xmlXPathRegisterFuncLookup (xmlXPathContextPtr ctxt,
XMLPUBFUN void XMLCALL xmlXPathRegisterFuncLookup (xmlXPathContextPtr ctxt,
xmlXPathFuncLookupFunc f,
void *funcCtxt);
/*
* Error reporting.
*/
void xmlXPatherror (xmlXPathParserContextPtr ctxt,
XMLPUBFUN void XMLCALL xmlXPatherror (xmlXPathParserContextPtr ctxt,
const char *file,
int line,
int no);
void xmlXPathDebugDumpObject (FILE *output,
XMLPUBFUN void XMLCALL xmlXPathDebugDumpObject (FILE *output,
xmlXPathObjectPtr cur,
int depth);
void xmlXPathDebugDumpCompExpr(FILE *output,
XMLPUBFUN void XMLCALL xmlXPathDebugDumpCompExpr(FILE *output,
xmlXPathCompExprPtr comp,
int depth);
/**
* NodeSet handling.
*/
int xmlXPathNodeSetContains (xmlNodeSetPtr cur,
XMLPUBFUN int XMLCALL xmlXPathNodeSetContains (xmlNodeSetPtr cur,
xmlNodePtr val);
xmlNodeSetPtr xmlXPathDifference (xmlNodeSetPtr nodes1,
XMLPUBFUN xmlNodeSetPtr XMLCALL xmlXPathDifference (xmlNodeSetPtr nodes1,
xmlNodeSetPtr nodes2);
xmlNodeSetPtr xmlXPathIntersection (xmlNodeSetPtr nodes1,
XMLPUBFUN xmlNodeSetPtr XMLCALL xmlXPathIntersection (xmlNodeSetPtr nodes1,
xmlNodeSetPtr nodes2);
xmlNodeSetPtr xmlXPathDistinctSorted (xmlNodeSetPtr nodes);
xmlNodeSetPtr xmlXPathDistinct (xmlNodeSetPtr nodes);
XMLPUBFUN xmlNodeSetPtr XMLCALL xmlXPathDistinctSorted (xmlNodeSetPtr nodes);
XMLPUBFUN xmlNodeSetPtr XMLCALL xmlXPathDistinct (xmlNodeSetPtr nodes);
int xmlXPathHasSameNodes (xmlNodeSetPtr nodes1,
XMLPUBFUN int XMLCALL xmlXPathHasSameNodes (xmlNodeSetPtr nodes1,
xmlNodeSetPtr nodes2);
xmlNodeSetPtr xmlXPathNodeLeadingSorted (xmlNodeSetPtr nodes,
XMLPUBFUN xmlNodeSetPtr XMLCALL xmlXPathNodeLeadingSorted (xmlNodeSetPtr nodes,
xmlNodePtr node);
xmlNodeSetPtr xmlXPathLeadingSorted (xmlNodeSetPtr nodes1,
XMLPUBFUN xmlNodeSetPtr XMLCALL xmlXPathLeadingSorted (xmlNodeSetPtr nodes1,
xmlNodeSetPtr nodes2);
xmlNodeSetPtr xmlXPathNodeLeading (xmlNodeSetPtr nodes,
XMLPUBFUN xmlNodeSetPtr XMLCALL xmlXPathNodeLeading (xmlNodeSetPtr nodes,
xmlNodePtr node);
xmlNodeSetPtr xmlXPathLeading (xmlNodeSetPtr nodes1,
XMLPUBFUN xmlNodeSetPtr XMLCALL xmlXPathLeading (xmlNodeSetPtr nodes1,
xmlNodeSetPtr nodes2);
xmlNodeSetPtr xmlXPathNodeTrailingSorted (xmlNodeSetPtr nodes,
XMLPUBFUN xmlNodeSetPtr XMLCALL xmlXPathNodeTrailingSorted (xmlNodeSetPtr nodes,
xmlNodePtr node);
xmlNodeSetPtr xmlXPathTrailingSorted (xmlNodeSetPtr nodes1,
XMLPUBFUN xmlNodeSetPtr XMLCALL xmlXPathTrailingSorted (xmlNodeSetPtr nodes1,
xmlNodeSetPtr nodes2);
xmlNodeSetPtr xmlXPathNodeTrailing (xmlNodeSetPtr nodes,
XMLPUBFUN xmlNodeSetPtr XMLCALL xmlXPathNodeTrailing (xmlNodeSetPtr nodes,
xmlNodePtr node);
xmlNodeSetPtr xmlXPathTrailing (xmlNodeSetPtr nodes1,
XMLPUBFUN xmlNodeSetPtr XMLCALL xmlXPathTrailing (xmlNodeSetPtr nodes1,
xmlNodeSetPtr nodes2);
@ -415,164 +415,164 @@ xmlNodeSetPtr xmlXPathTrailing (xmlNodeSetPtr nodes1,
* Extending a context.
*/
int xmlXPathRegisterNs (xmlXPathContextPtr ctxt,
XMLPUBFUN int XMLCALL xmlXPathRegisterNs (xmlXPathContextPtr ctxt,
const xmlChar *prefix,
const xmlChar *ns_uri);
const xmlChar * xmlXPathNsLookup (xmlXPathContextPtr ctxt,
XMLPUBFUN const xmlChar * XMLCALL xmlXPathNsLookup (xmlXPathContextPtr ctxt,
const xmlChar *prefix);
void xmlXPathRegisteredNsCleanup (xmlXPathContextPtr ctxt);
XMLPUBFUN void XMLCALL xmlXPathRegisteredNsCleanup (xmlXPathContextPtr ctxt);
int xmlXPathRegisterFunc (xmlXPathContextPtr ctxt,
XMLPUBFUN int XMLCALL xmlXPathRegisterFunc (xmlXPathContextPtr ctxt,
const xmlChar *name,
xmlXPathFunction f);
int xmlXPathRegisterFuncNS (xmlXPathContextPtr ctxt,
XMLPUBFUN int XMLCALL xmlXPathRegisterFuncNS (xmlXPathContextPtr ctxt,
const xmlChar *name,
const xmlChar *ns_uri,
xmlXPathFunction f);
int xmlXPathRegisterVariable (xmlXPathContextPtr ctxt,
XMLPUBFUN int XMLCALL xmlXPathRegisterVariable (xmlXPathContextPtr ctxt,
const xmlChar *name,
xmlXPathObjectPtr value);
int xmlXPathRegisterVariableNS (xmlXPathContextPtr ctxt,
XMLPUBFUN int XMLCALL xmlXPathRegisterVariableNS (xmlXPathContextPtr ctxt,
const xmlChar *name,
const xmlChar *ns_uri,
xmlXPathObjectPtr value);
xmlXPathFunction xmlXPathFunctionLookup (xmlXPathContextPtr ctxt,
XMLPUBFUN xmlXPathFunction XMLCALL xmlXPathFunctionLookup (xmlXPathContextPtr ctxt,
const xmlChar *name);
xmlXPathFunction xmlXPathFunctionLookupNS (xmlXPathContextPtr ctxt,
XMLPUBFUN xmlXPathFunction XMLCALL xmlXPathFunctionLookupNS (xmlXPathContextPtr ctxt,
const xmlChar *name,
const xmlChar *ns_uri);
void xmlXPathRegisteredFuncsCleanup(xmlXPathContextPtr ctxt);
xmlXPathObjectPtr xmlXPathVariableLookup (xmlXPathContextPtr ctxt,
XMLPUBFUN void XMLCALL xmlXPathRegisteredFuncsCleanup(xmlXPathContextPtr ctxt);
XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPathVariableLookup (xmlXPathContextPtr ctxt,
const xmlChar *name);
xmlXPathObjectPtr xmlXPathVariableLookupNS (xmlXPathContextPtr ctxt,
XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPathVariableLookupNS (xmlXPathContextPtr ctxt,
const xmlChar *name,
const xmlChar *ns_uri);
void xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt);
XMLPUBFUN void XMLCALL xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt);
/**
* Utilities to extend XPath.
*/
xmlXPathParserContextPtr
XMLPUBFUN xmlXPathParserContextPtr XMLCALL
xmlXPathNewParserContext (const xmlChar *str,
xmlXPathContextPtr ctxt);
void xmlXPathFreeParserContext (xmlXPathParserContextPtr ctxt);
XMLPUBFUN void XMLCALL xmlXPathFreeParserContext (xmlXPathParserContextPtr ctxt);
/* TODO: remap to xmlXPathValuePop and Push. */
xmlXPathObjectPtr valuePop (xmlXPathParserContextPtr ctxt);
int valuePush (xmlXPathParserContextPtr ctxt,
XMLPUBFUN xmlXPathObjectPtr XMLCALL valuePop (xmlXPathParserContextPtr ctxt);
XMLPUBFUN int XMLCALL valuePush (xmlXPathParserContextPtr ctxt,
xmlXPathObjectPtr value);
xmlXPathObjectPtr xmlXPathNewString (const xmlChar *val);
xmlXPathObjectPtr xmlXPathNewCString (const char *val);
xmlXPathObjectPtr xmlXPathWrapString (xmlChar *val);
xmlXPathObjectPtr xmlXPathWrapCString (char * val);
xmlXPathObjectPtr xmlXPathNewFloat (double val);
xmlXPathObjectPtr xmlXPathNewBoolean (int val);
xmlXPathObjectPtr xmlXPathNewNodeSet (xmlNodePtr val);
xmlXPathObjectPtr xmlXPathNewValueTree (xmlNodePtr val);
void xmlXPathNodeSetAdd (xmlNodeSetPtr cur,
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 void XMLCALL xmlXPathNodeSetAdd (xmlNodeSetPtr cur,
xmlNodePtr val);
void xmlXPathNodeSetAddUnique (xmlNodeSetPtr cur,
XMLPUBFUN void XMLCALL xmlXPathNodeSetAddUnique (xmlNodeSetPtr cur,
xmlNodePtr val);
void xmlXPathNodeSetAddNs (xmlNodeSetPtr cur,
XMLPUBFUN void XMLCALL xmlXPathNodeSetAddNs (xmlNodeSetPtr cur,
xmlNodePtr node,
xmlNsPtr ns);
void xmlXPathNodeSetSort (xmlNodeSetPtr set);
XMLPUBFUN void XMLCALL xmlXPathNodeSetSort (xmlNodeSetPtr set);
void xmlXPathRoot (xmlXPathParserContextPtr ctxt);
void xmlXPathEvalExpr (xmlXPathParserContextPtr ctxt);
xmlChar * xmlXPathParseName (xmlXPathParserContextPtr ctxt);
xmlChar * xmlXPathParseNCName (xmlXPathParserContextPtr ctxt);
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.
*/
double xmlXPathStringEvalNumber(const xmlChar *str);
int xmlXPathEvaluatePredicateResult(xmlXPathParserContextPtr ctxt,
XMLPUBFUN double XMLCALL xmlXPathStringEvalNumber(const xmlChar *str);
XMLPUBFUN int XMLCALL xmlXPathEvaluatePredicateResult(xmlXPathParserContextPtr ctxt,
xmlXPathObjectPtr res);
void xmlXPathRegisterAllFunctions(xmlXPathContextPtr ctxt);
xmlNodeSetPtr xmlXPathNodeSetMerge(xmlNodeSetPtr val1, xmlNodeSetPtr val2);
void xmlXPathNodeSetDel(xmlNodeSetPtr cur, xmlNodePtr val);
void xmlXPathNodeSetRemove(xmlNodeSetPtr cur, int val);
xmlXPathObjectPtr xmlXPathNewNodeSetList(xmlNodeSetPtr val);
xmlXPathObjectPtr xmlXPathWrapNodeSet(xmlNodeSetPtr val);
xmlXPathObjectPtr xmlXPathWrapExternal(void *val);
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);
int xmlXPathEqualValues(xmlXPathParserContextPtr ctxt);
int xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt);
int xmlXPathCompareValues(xmlXPathParserContextPtr ctxt, int inf, int strict);
void xmlXPathValueFlipSign(xmlXPathParserContextPtr ctxt);
void xmlXPathAddValues(xmlXPathParserContextPtr ctxt);
void xmlXPathSubValues(xmlXPathParserContextPtr ctxt);
void xmlXPathMultValues(xmlXPathParserContextPtr ctxt);
void xmlXPathDivValues(xmlXPathParserContextPtr ctxt);
void xmlXPathModValues(xmlXPathParserContextPtr ctxt);
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);
int xmlXPathIsNodeType(const xmlChar *name);
XMLPUBFUN int XMLCALL xmlXPathIsNodeType(const xmlChar *name);
/*
* Some of the axis navigation routines.
*/
xmlNodePtr xmlXPathNextSelf(xmlXPathParserContextPtr ctxt,
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextSelf(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
xmlNodePtr xmlXPathNextChild(xmlXPathParserContextPtr ctxt,
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextChild(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
xmlNodePtr xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt,
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
xmlNodePtr xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr ctxt,
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
xmlNodePtr xmlXPathNextParent(xmlXPathParserContextPtr ctxt,
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextParent(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
xmlNodePtr xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt,
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
xmlNodePtr xmlXPathNextFollowingSibling(xmlXPathParserContextPtr ctxt,
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextFollowingSibling(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
xmlNodePtr xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt,
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
xmlNodePtr xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt,
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
xmlNodePtr xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt,
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
xmlNodePtr xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt,
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
xmlNodePtr xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt,
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
xmlNodePtr xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt,
XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt,
xmlNodePtr cur);
/*
* The official core of XPath functions.
*/
void xmlXPathLastFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathPositionFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathCountFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathIdFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathLocalNameFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathNamespaceURIFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathStringLengthFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathConcatFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathContainsFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathStartsWithFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathSubstringBeforeFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathTranslateFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathNotFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathTrueFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathFalseFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathLangFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathNumberFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathSumFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathFloorFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathRoundFunction(xmlXPathParserContextPtr ctxt, int nargs);
void xmlXPathBooleanFunction(xmlXPathParserContextPtr ctxt, int nargs);
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
*/
void xmlXPathNodeSetFreeNs(xmlNsPtr ns);
XMLPUBFUN void XMLCALL xmlXPathNodeSetFreeNs(xmlNsPtr ns);
#ifdef __cplusplus
}

43
include/libxml/xpointer.h
View File

@ -12,6 +12,7 @@
#ifndef __XML_XPTR_H__
#define __XML_XPTR_H__
#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#include <libxml/xpath.h>
@ -34,48 +35,48 @@ struct _xmlLocationSet {
* Handling of location sets.
*/
xmlLocationSetPtr xmlXPtrLocationSetCreate(xmlXPathObjectPtr val);
void xmlXPtrFreeLocationSet (xmlLocationSetPtr obj);
xmlLocationSetPtr xmlXPtrLocationSetMerge (xmlLocationSetPtr val1,
XMLPUBFUN xmlLocationSetPtr XMLCALL xmlXPtrLocationSetCreate(xmlXPathObjectPtr val);
XMLPUBFUN void XMLCALL xmlXPtrFreeLocationSet (xmlLocationSetPtr obj);
XMLPUBFUN xmlLocationSetPtr XMLCALL xmlXPtrLocationSetMerge (xmlLocationSetPtr val1,
xmlLocationSetPtr val2);
xmlXPathObjectPtr xmlXPtrNewRange (xmlNodePtr start,
XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPtrNewRange (xmlNodePtr start,
int startindex,
xmlNodePtr end,
int endindex);
xmlXPathObjectPtr xmlXPtrNewRangePoints (xmlXPathObjectPtr start,
XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPtrNewRangePoints (xmlXPathObjectPtr start,
xmlXPathObjectPtr end);
xmlXPathObjectPtr xmlXPtrNewRangeNodePoint(xmlNodePtr start,
XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPtrNewRangeNodePoint(xmlNodePtr start,
xmlXPathObjectPtr end);
xmlXPathObjectPtr xmlXPtrNewRangePointNode(xmlXPathObjectPtr start,
XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPtrNewRangePointNode(xmlXPathObjectPtr start,
xmlNodePtr end);
xmlXPathObjectPtr xmlXPtrNewRangeNodes (xmlNodePtr start,
XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPtrNewRangeNodes (xmlNodePtr start,
xmlNodePtr end);
xmlXPathObjectPtr xmlXPtrNewLocationSetNodes(xmlNodePtr start,
XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPtrNewLocationSetNodes(xmlNodePtr start,
xmlNodePtr end);
xmlXPathObjectPtr xmlXPtrNewLocationSetNodeSet(xmlNodeSetPtr set);
xmlXPathObjectPtr xmlXPtrNewRangeNodeObject(xmlNodePtr start,
XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPtrNewLocationSetNodeSet(xmlNodeSetPtr set);
XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPtrNewRangeNodeObject(xmlNodePtr start,
xmlXPathObjectPtr end);
xmlXPathObjectPtr xmlXPtrNewCollapsedRange(xmlNodePtr start);
void xmlXPtrLocationSetAdd (xmlLocationSetPtr cur,
XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPtrNewCollapsedRange(xmlNodePtr start);
XMLPUBFUN void XMLCALL xmlXPtrLocationSetAdd (xmlLocationSetPtr cur,
xmlXPathObjectPtr val);
xmlXPathObjectPtr xmlXPtrWrapLocationSet (xmlLocationSetPtr val);
void xmlXPtrLocationSetDel (xmlLocationSetPtr cur,
XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPtrWrapLocationSet (xmlLocationSetPtr val);
XMLPUBFUN void XMLCALL xmlXPtrLocationSetDel (xmlLocationSetPtr cur,
xmlXPathObjectPtr val);
void xmlXPtrLocationSetRemove(xmlLocationSetPtr cur,
XMLPUBFUN void XMLCALL xmlXPtrLocationSetRemove(xmlLocationSetPtr cur,
int val);
/*
* Functions.
*/
xmlXPathContextPtr xmlXPtrNewContext (xmlDocPtr doc,
XMLPUBFUN xmlXPathContextPtr XMLCALL xmlXPtrNewContext (xmlDocPtr doc,
xmlNodePtr here,
xmlNodePtr origin);
xmlXPathObjectPtr xmlXPtrEval (const xmlChar *str,
XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPtrEval (const xmlChar *str,
xmlXPathContextPtr ctx);
void xmlXPtrRangeToFunction (xmlXPathParserContextPtr ctxt,
XMLPUBFUN void XMLCALL xmlXPtrRangeToFunction (xmlXPathParserContextPtr ctxt,
int nargs);
xmlNodePtr xmlXPtrBuildNodeList (xmlXPathObjectPtr obj);
void xmlXPtrEvalRangePredicate (xmlXPathParserContextPtr ctxt);
XMLPUBFUN xmlNodePtr XMLCALL xmlXPtrBuildNodeList (xmlXPathObjectPtr obj);
XMLPUBFUN void XMLCALL xmlXPtrEvalRangePredicate (xmlXPathParserContextPtr ctxt);
#ifdef __cplusplus
}

10
win32/Makefile.msvc
View File

@ -128,6 +128,7 @@ LDFLAGS = $(LDFLAGS) /OPT:NOWIN98
XML_OBJS = $(XML_INTDIR)\c14n.obj\
$(XML_INTDIR)\catalog.obj\
$(XML_INTDIR)\debugXML.obj\
$(XML_INTDIR)\dict.obj\
$(XML_INTDIR)\DOCBparser.obj\
$(XML_INTDIR)\encoding.obj\
$(XML_INTDIR)\entities.obj\
@ -142,6 +143,7 @@ XML_OBJS = $(XML_INTDIR)\c14n.obj\
$(XML_INTDIR)\parser.obj\
$(XML_INTDIR)\parserInternals.obj\
$(XML_INTDIR)\relaxng.obj\
$(XML_INTDIR)\SAX2.obj\
$(XML_INTDIR)\SAX.obj\
$(XML_INTDIR)\threads.obj\
$(XML_INTDIR)\tree.obj\
@ -163,6 +165,7 @@ XML_OBJS = $(XML_INTDIR)\c14n.obj\
XML_OBJS_A = $(XML_INTDIR_A)\c14n.obj\
$(XML_INTDIR_A)\catalog.obj\
$(XML_INTDIR_A)\debugXML.obj\
$(XML_INTDIR_A)\dict.obj\
$(XML_INTDIR_A)\DOCBparser.obj\
$(XML_INTDIR_A)\encoding.obj\
$(XML_INTDIR_A)\entities.obj\
@ -177,6 +180,7 @@ XML_OBJS_A = $(XML_INTDIR_A)\c14n.obj\
$(XML_INTDIR_A)\parser.obj\
$(XML_INTDIR_A)\parserInternals.obj\
$(XML_INTDIR_A)\relaxng.obj\
$(XML_INTDIR_A)\SAX2.obj\
$(XML_INTDIR_A)\SAX.obj\
$(XML_INTDIR_A)\threads.obj\
$(XML_INTDIR_A)\tree.obj\
@ -287,9 +291,13 @@ $(XML_INTDIR)\$(XML_DEF) : $(XML_INTDIR) $(XML_DEF).src
# Creates the libxml shared object.
$(BINDIR)\$(XML_SO) : $(BINDIR) $(XML_OBJS) $(XML_INTDIR)\$(XML_DEF)
$(LD) $(LDFLAGS) /DLL /DEF:$(XML_INTDIR)\$(XML_DEF) \
$(LD) $(LDFLAGS) /DLL \
/IMPLIB:$(BINDIR)\$(XML_IMP) /OUT:$(BINDIR)\$(XML_SO) $(XML_OBJS) $(LIBS)
#$(BINDIR)\$(XML_SO) : $(BINDIR) $(XML_OBJS) $(XML_INTDIR)\$(XML_DEF)
# $(LD) $(LDFLAGS) /DLL /DEF:$(XML_INTDIR)\$(XML_DEF) \
# /IMPLIB:$(BINDIR)\$(XML_IMP) /OUT:$(BINDIR)\$(XML_SO) $(XML_OBJS) $(LIBS)
# Creates the libxml archive.
$(BINDIR)\$(XML_A) : $(BINDIR) $(XML_OBJS_A)
$(AR) $(ARFLAGS) /OUT:$(BINDIR)\$(XML_A) $(XML_OBJS_A)

2
xmlunicode.c
View File

@ -6,7 +6,7 @@
* http://www.unicode.org/Public/3.1-Update/UnicodeCharacterDatabase-3.1.0.html
* using the genUnicode.py Python script.
*
* Generation date: Tue Apr 16 17:28:05 2002
* Generation date: Mon Aug 25 10:45:50 2003
* Sources: Blocks-4.txt UnicodeData-3.1.0.txt
* Daniel Veillard <veillard@redhat.com>
*/