Exportability taint of the headers
diff --git a/include/libxml/DOCBparser.h b/include/libxml/DOCBparser.h
index 4b7230f..9c90896 100644
--- a/include/libxml/DOCBparser.h
+++ b/include/libxml/DOCBparser.h
@@ -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 @@
/*
* 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
}
diff --git a/include/libxml/HTMLparser.h b/include/libxml/HTMLparser.h
index 646cf2b..7e008bd 100644
--- a/include/libxml/HTMLparser.h
+++ b/include/libxml/HTMLparser.h
@@ -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 @@
/*
* 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 @@
/* 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
diff --git a/include/libxml/HTMLtree.h b/include/libxml/HTMLtree.h
index 3a441c4..c40df38 100644
--- a/include/libxml/HTMLtree.h
+++ b/include/libxml/HTMLtree.h
@@ -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 @@
*/
#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);
diff --git a/include/libxml/SAX.h b/include/libxml/SAX.h
index 05cb9f8..2f16c23 100644
--- a/include/libxml/SAX.h
+++ b/include/libxml/SAX.h
@@ -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
}
diff --git a/include/libxml/SAX2.h b/include/libxml/SAX2.h
index f2b1e19..37bfdc7 100644
--- a/include/libxml/SAX2.h
+++ b/include/libxml/SAX2.h
@@ -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
diff --git a/include/libxml/c14n.h b/include/libxml/c14n.h
index 75ace8a..a2d9aed 100644
--- a/include/libxml/c14n.h
+++ b/include/libxml/c14n.h
@@ -16,6 +16,7 @@
extern "C" {
#endif /* __cplusplus */
+#include <libxml/xmlversion.h>
#include <libxml/tree.h>
#include <libxml/xpath.h>
@@ -45,21 +46,24 @@
*/
-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 @@
xmlNodePtr node,
xmlNodePtr parent);
-int xmlC14NExecute (xmlDocPtr doc,
+XMLPUBFUN int XMLCALL
+ xmlC14NExecute (xmlDocPtr doc,
xmlC14NIsVisibleCallback is_visible_callback,
void* user_data,
int exclusive,
diff --git a/include/libxml/catalog.h b/include/libxml/catalog.h
index 037e7e8..689e7ce 100644
--- a/include/libxml/catalog.h
+++ b/include/libxml/catalog.h
@@ -62,74 +62,110 @@
/*
* 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
}
diff --git a/include/libxml/debugXML.h b/include/libxml/debugXML.h
index cf017a4..f71e670 100644
--- a/include/libxml/debugXML.h
+++ b/include/libxml/debugXML.h
@@ -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 @@
/*
* 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 @@
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 @@
/*
* The Shell interface.
*/
-void xmlShell (xmlDocPtr doc,
+XMLPUBFUN void XMLCALL
+ xmlShell (xmlDocPtr doc,
char *filename,
xmlShellReadlineFunc input,
FILE *output);
diff --git a/include/libxml/dict.h b/include/libxml/dict.h
index eeea460..5b4a59a 100644
--- a/include/libxml/dict.h
+++ b/include/libxml/dict.h
@@ -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 @@
/*
* 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
diff --git a/include/libxml/encoding.h b/include/libxml/encoding.h
index 9841e14..4a4fe7b 100644
--- a/include/libxml/encoding.h
+++ b/include/libxml/encoding.h
@@ -145,14 +145,17 @@
/*
* 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 @@
/*
* 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
}
diff --git a/include/libxml/entities.h b/include/libxml/entities.h
index ea7f202..6355863 100644
--- a/include/libxml/entities.h
+++ b/include/libxml/entities.h
@@ -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 @@
* 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
diff --git a/include/libxml/globals.h b/include/libxml/globals.h
index 717b6df..2d35bad 100644
--- a/include/libxml/globals.h
+++ b/include/libxml/globals.h
@@ -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 @@
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 @@
#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 @@
*/
-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
diff --git a/include/libxml/hash.h b/include/libxml/hash.h
index ec590c9..3822922 100644
--- a/include/libxml/hash.h
+++ b/include/libxml/hash.h
@@ -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 @@
/*
* 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 @@
/*
* 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 @@
/*
* 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,
diff --git a/include/libxml/list.h b/include/libxml/list.h
index 8c9515f..297831a 100644
--- a/include/libxml/list.h
+++ b/include/libxml/list.h
@@ -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 (*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 */
diff --git a/include/libxml/nanoftp.h b/include/libxml/nanoftp.h
index f19194d..2156c79 100644
--- a/include/libxml/nanoftp.h
+++ b/include/libxml/nanoftp.h
@@ -56,59 +56,81 @@
/*
* 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);
diff --git a/include/libxml/nanohttp.h b/include/libxml/nanohttp.h
index 4fb4e1d..8897fda 100644
--- a/include/libxml/nanohttp.h
+++ b/include/libxml/nanohttp.h
@@ -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__ */
diff --git a/include/libxml/parser.h b/include/libxml/parser.h
index 43dbe35..cb555ef 100644
--- a/include/libxml/parser.h
+++ b/include/libxml/parser.h
@@ -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 @@
#ifdef __cplusplus
}
#endif
+
#include <libxml/encoding.h>
#include <libxml/xmlIO.h>
#include <libxml/globals.h>
+
#ifdef __cplusplus
extern "C" {
#endif
@@ -747,138 +750,187 @@
/*
* 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 @@
/*
* 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 @@
* 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);
diff --git a/include/libxml/parserInternals.h b/include/libxml/parserInternals.h
index e5e1fe7..64359ec 100644
--- a/include/libxml/parserInternals.h
+++ b/include/libxml/parserInternals.h
@@ -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 @@
/**
* 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 @@
*/
#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 @@
/*
* 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 @@
xmlNodePtr firstNode,
xmlNodePtr lastNode);
-void xmlSetEntityReferenceFunc (xmlEntityReferenceFunc func);
+XMLPUBFUN void XMLCALL xmlSetEntityReferenceFunc (xmlEntityReferenceFunc func);
#ifdef __cplusplus
diff --git a/include/libxml/relaxng.h b/include/libxml/relaxng.h
index 929d0e6..2e543ff 100644
--- a/include/libxml/relaxng.h
+++ b/include/libxml/relaxng.h
@@ -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 @@
/*
* 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__ */
diff --git a/include/libxml/schemasInternals.h b/include/libxml/schemasInternals.h
index 3cf3ff6..38b5bd4 100644
--- a/include/libxml/schemasInternals.h
+++ b/include/libxml/schemasInternals.h
@@ -345,7 +345,7 @@
xmlHashTablePtr groupDecl;
};
-void xmlSchemaFreeType (xmlSchemaTypePtr type);
+XMLPUBFUN void XMLCALL xmlSchemaFreeType (xmlSchemaTypePtr type);
#ifdef __cplusplus
}
diff --git a/include/libxml/threads.h b/include/libxml/threads.h
index afca78f..1fdf9bc 100644
--- a/include/libxml/threads.h
+++ b/include/libxml/threads.h
@@ -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 @@
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
}
diff --git a/include/libxml/tree.h b/include/libxml/tree.h
index b029ffc..6bc839d 100644
--- a/include/libxml/tree.h
+++ b/include/libxml/tree.h
@@ -541,374 +541,375 @@
/*
* 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
}
diff --git a/include/libxml/uri.h b/include/libxml/uri.h
index 319c509..a2e5201 100644
--- a/include/libxml/uri.h
+++ b/include/libxml/uri.h
@@ -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 @@
* 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
}
diff --git a/include/libxml/valid.h b/include/libxml/valid.h
index 7bf9656..f13688f 100644
--- a/include/libxml/valid.h
+++ b/include/libxml/valid.h
@@ -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 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 @@
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);
diff --git a/include/libxml/xinclude.h b/include/libxml/xinclude.h
index 25be1fe..537e56a 100644
--- a/include/libxml/xinclude.h
+++ b/include/libxml/xinclude.h
@@ -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
}
diff --git a/include/libxml/xlink.h b/include/libxml/xlink.h
index c7f48c8..ddc4eee 100644
--- a/include/libxml/xlink.h
+++ b/include/libxml/xlink.h
@@ -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 @@
* 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
diff --git a/include/libxml/xmlIO.h b/include/libxml/xmlIO.h
index 16cc8e5..8086034 100644
--- a/include/libxml/xmlIO.h
+++ b/include/libxml/xmlIO.h
@@ -147,95 +147,95 @@
/*
* 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 @@
* 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
diff --git a/include/libxml/xmlautomata.h b/include/libxml/xmlautomata.h
index 4e45d40..d8c4297 100644
--- a/include/libxml/xmlautomata.h
+++ b/include/libxml/xmlautomata.h
@@ -38,59 +38,59 @@
/*
* 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
}
diff --git a/include/libxml/xmlerror.h b/include/libxml/xmlerror.h
index 33e2275..420fe66 100644
--- a/include/libxml/xmlerror.h
+++ b/include/libxml/xmlerror.h
@@ -155,28 +155,28 @@
* 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
}
diff --git a/include/libxml/xmlmemory.h b/include/libxml/xmlmemory.h
index 0e6292e..9314725 100644
--- a/include/libxml/xmlmemory.h
+++ b/include/libxml/xmlmemory.h
@@ -96,20 +96,21 @@
* 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 @@
/*
* 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
diff --git a/include/libxml/xmlreader.h b/include/libxml/xmlreader.h
index 8ece600..432c152 100644
--- a/include/libxml/xmlreader.h
+++ b/include/libxml/xmlreader.h
@@ -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 @@
/*
* 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 @@
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);
diff --git a/include/libxml/xmlregexp.h b/include/libxml/xmlregexp.h
index c93e103..37da512 100644
--- a/include/libxml/xmlregexp.h
+++ b/include/libxml/xmlregexp.h
@@ -45,13 +45,14 @@
/*
* 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 @@
/*
* 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);
diff --git a/include/libxml/xmlschemas.h b/include/libxml/xmlschemas.h
index 1fc525a..08fbe5a 100644
--- a/include/libxml/xmlschemas.h
+++ b/include/libxml/xmlschemas.h
@@ -72,30 +72,30 @@
/*
* 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,
diff --git a/include/libxml/xmlschemastypes.h b/include/libxml/xmlschemastypes.h
index b226c55..7345e9e 100644
--- a/include/libxml/xmlschemastypes.h
+++ b/include/libxml/xmlschemastypes.h
@@ -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
diff --git a/include/libxml/xmlunicode.h b/include/libxml/xmlunicode.h
index f0f1fe9..8c24096 100644
--- a/include/libxml/xmlunicode.h
+++ b/include/libxml/xmlunicode.h
@@ -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
diff --git a/include/libxml/xmlversion.h.in b/include/libxml/xmlversion.h.in
index 2014682..aad6f89 100644
--- a/include/libxml/xmlversion.h.in
+++ b/include/libxml/xmlversion.h.in
@@ -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 @@
* your library and includes mismatch
*/
#ifndef LIBXML2_COMPILING_MSCCDEF
-extern void xmlCheckVersion(int version);
+XMLPUBFUN void XMLCALL xmlCheckVersion(int version);
#endif /* LIBXML2_COMPILING_MSCCDEF */
/**
@@ -235,29 +308,6 @@
#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:
*
* Macro used to signal to GCC unused function parameters
diff --git a/include/libxml/xpath.h b/include/libxml/xpath.h
index 6a1f76c..d53e2eb 100644
--- a/include/libxml/xpath.h
+++ b/include/libxml/xpath.h
@@ -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 @@
* 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 @@
(((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
diff --git a/include/libxml/xpathInternals.h b/include/libxml/xpathInternals.h
index 59a4e35..ae36638 100644
--- a/include/libxml/xpathInternals.h
+++ b/include/libxml/xpathInternals.h
@@ -96,11 +96,11 @@
*/
#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 @@
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 @@
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 @@
* 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
}
diff --git a/include/libxml/xpointer.h b/include/libxml/xpointer.h
index 80c465c..942a05e 100644
--- a/include/libxml/xpointer.h
+++ b/include/libxml/xpointer.h
@@ -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 @@
* 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
}