Exportability taint of the headers

genUnicode.py

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

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 @@ typedef xmlNodePtr docbNodePtr;
 /*
  * There is only few public functions.
  */
-int                    docbEncodeEntities(unsigned char *out,
+XMLPUBFUN int XMLCALL
+		     docbEncodeEntities(unsigned char *out,
                                         int *outlen,
                                         const unsigned char *in,
                                         int *inlen, int quoteChar);
 
-docbDocPtr             docbSAXParseDoc (xmlChar *cur,
+XMLPUBFUN docbDocPtr XMLCALL             
+		     docbSAXParseDoc   (xmlChar *cur,
                                         const char *encoding,
                                         docbSAXHandlerPtr sax,
                                         void *userData);
-docbDocPtr             docbParseDoc    (xmlChar *cur,
+XMLPUBFUN docbDocPtr XMLCALL             
+		     docbParseDoc      (xmlChar *cur,
                                         const char *encoding);
-docbDocPtr             docbSAXParseFile(const char *filename,
+XMLPUBFUN docbDocPtr XMLCALL             
+		     docbSAXParseFile  (const char *filename,
                                         const char *encoding,
                                         docbSAXHandlerPtr sax,
                                         void *userData);
-docbDocPtr             docbParseFile   (const char *filename,
+XMLPUBFUN docbDocPtr XMLCALL             
+		     docbParseFile     (const char *filename,
                                         const char *encoding);
 
 /**
  * Interfaces for the Push mode.
  */
-void                   docbFreeParserCtxt      (docbParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL                  
-docbParserCtxtPtr      docbCreatePushParserCtxt(docbSAXHandlerPtr sax,
+		     docbFreeParserCtxt      (docbParserCtxtPtr ctxt);
-                                                void *user_data,
+XMLPUBFUN docbParserCtxtPtr XMLCALL     
-                                                const char *chunk,
+		     docbCreatePushParserCtxt(docbSAXHandlerPtr sax,
-                                                int size,
+                                              void *user_data,
-                                                const char *filename,
+                                              const char *chunk,
-                                                xmlCharEncoding enc);
+                                              int size,
-int                    docbParseChunk          (docbParserCtxtPtr ctxt,
+                                              const char *filename,
-                                                const char *chunk,
+                                              xmlCharEncoding enc);
-                                                int size,
+XMLPUBFUN int XMLCALL                   
-                                                int terminate);
+		     docbParseChunk          (docbParserCtxtPtr ctxt,
-docbParserCtxtPtr       docbCreateFileParserCtxt(const char *filename,
+                                              const char *chunk,
-                                                const char *encoding);
+                                              int size,
-int                     docbParseDocument       (docbParserCtxtPtr ctxt);
+                                              int terminate);
+XMLPUBFUN docbParserCtxtPtr XMLCALL       
+		     docbCreateFileParserCtxt(const char *filename,
+                                              const char *encoding);
+XMLPUBFUN int XMLCALL                   
+		     docbParseDocument       (docbParserCtxtPtr ctxt);
 
 #ifdef __cplusplus
 }

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 @@ struct _htmlEntityDesc {
 /*
  * There is only few public functions.
  */
-const htmlElemDesc * 	htmlTagLookup	(const xmlChar *tag);
+XMLPUBFUN const htmlElemDesc * XMLCALL 	
-const htmlEntityDesc * 	htmlEntityLookup(const xmlChar *name);
+			htmlTagLookup	(const xmlChar *tag);
-const htmlEntityDesc * 	htmlEntityValueLookup(unsigned int value);
+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);
+XMLPUBFUN int XMLCALL			
-void			htmlParseElement(htmlParserCtxtPtr ctxt);
+			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);
+XMLPUBFUN int XMLCALL			
-htmlDocPtr		htmlSAXParseDoc	(xmlChar *cur,
+			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);
+XMLPUBFUN int XMLCALL			
-int			htmlHandleOmittedElem(int val);
+			htmlIsScriptAttribute(const xmlChar *name);
+XMLPUBFUN int XMLCALL			
+			htmlHandleOmittedElem(int val);
 
 /**
  * Interfaces for the Push mode.
  */
-void			htmlFreeParserCtxt	(htmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			
-htmlParserCtxtPtr	htmlCreatePushParserCtxt(htmlSAXHandlerPtr sax,
+			htmlFreeParserCtxt	(htmlParserCtxtPtr ctxt);
+XMLPUBFUN htmlParserCtxtPtr XMLCALL	
+			htmlCreatePushParserCtxt(htmlSAXHandlerPtr sax,
 						 void *user_data,
 						 const char *chunk,
 						 int size,
 						 const char *filename,
 						 xmlCharEncoding enc);
-int			htmlParseChunk		(htmlParserCtxtPtr ctxt,
+XMLPUBFUN int XMLCALL			
+			htmlParseChunk		(htmlParserCtxtPtr ctxt,
 						 const char *chunk,
 						 int size,
 						 int terminate);
@@ -145,10 +167,10 @@ typedef enum {
 /* Using htmlElemDesc rather than name here, to emphasise the fact
    that otherwise there's a lookup overhead
 */
-htmlStatus htmlAttrAllowed(const htmlElemDesc*, const xmlChar*, int) ;
+XMLPUBFUN htmlStatus XMLCALL htmlAttrAllowed(const htmlElemDesc*, const xmlChar*, int) ;
-int htmlElementAllowedHere(const htmlElemDesc*, const xmlChar*) ;
+XMLPUBFUN int XMLCALL htmlElementAllowedHere(const htmlElemDesc*, const xmlChar*) ;
-htmlStatus htmlElementStatusHere(const htmlElemDesc*, const htmlElemDesc*) ;
+XMLPUBFUN htmlStatus XMLCALL htmlElementStatusHere(const htmlElemDesc*, const htmlElemDesc*) ;
-htmlStatus htmlNodeStatus(const htmlNodePtr, int) ;
+XMLPUBFUN htmlStatus XMLCALL htmlNodeStatus(const htmlNodePtr, int) ;
 /**
  * htmlDefaultSubelement:
  * @elt: HTML element

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 @@ extern "C" {
  */
 #define HTML_PI_NODE		XML_PI_NODE
 
-htmlDocPtr	htmlNewDoc		(const xmlChar *URI,
+XMLPUBFUN htmlDocPtr XMLCALL
+		htmlNewDoc		(const xmlChar *URI,
 					 const xmlChar *ExternalID);
-htmlDocPtr	htmlNewDocNoDtD		(const xmlChar *URI,
+XMLPUBFUN htmlDocPtr XMLCALL	
+		htmlNewDocNoDtD		(const xmlChar *URI,
 					 const xmlChar *ExternalID);
-const xmlChar *	htmlGetMetaEncoding	(htmlDocPtr doc);
+XMLPUBFUN const xmlChar * XMLCALL	
-int		htmlSetMetaEncoding	(htmlDocPtr doc,
+		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);
+XMLPUBFUN int XMLCALL		
-void htmlNodeDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
+		htmlIsBooleanAttr	(const xmlChar *name);
-	                xmlNodePtr cur, const char *encoding);
+XMLPUBFUN void XMLCALL 
+		htmlNodeDumpOutput	(xmlOutputBufferPtr buf, 
+					 xmlDocPtr doc,
+					 xmlNodePtr cur, 
+					 const char *encoding);
 
 
 

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);
+XMLPUBFUN const xmlChar * XMLCALL
-const xmlChar *	getSystemId			(void *ctx);
+		getPublicId			(void *ctx);
-void		setDocumentLocator		(void *ctx,
+XMLPUBFUN const xmlChar * XMLCALL	getSystemId			(void *ctx);
+XMLPUBFUN void XMLCALL		setDocumentLocator		(void *ctx,
 						 xmlSAXLocatorPtr loc);
     
-int		getLineNumber			(void *ctx);
+XMLPUBFUN int XMLCALL		getLineNumber			(void *ctx);
-int		getColumnNumber			(void *ctx);
+XMLPUBFUN int XMLCALL		getColumnNumber			(void *ctx);
 
-int		isStandalone			(void *ctx);
+XMLPUBFUN int XMLCALL		isStandalone			(void *ctx);
-int		hasInternalSubset		(void *ctx);
+XMLPUBFUN int XMLCALL		hasInternalSubset		(void *ctx);
-int		hasExternalSubset		(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);
+XMLPUBFUN void XMLCALL		startDocument			(void *ctx);
-void		endDocument			(void *ctx);
+XMLPUBFUN void XMLCALL		endDocument			(void *ctx);
-void		attribute			(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);
+XMLPUBFUN xmlNsPtr XMLCALL	getNamespace			(void *ctx);
-int		checkNamespace			(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
 }

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);
+XMLPUBFUN const xmlChar * XMLCALL
-const xmlChar *	xmlSAX2GetSystemId		(void *ctx);
+		xmlSAX2GetPublicId		(void *ctx);
-void		xmlSAX2SetDocumentLocator	(void *ctx,
+XMLPUBFUN const xmlChar * XMLCALL	xmlSAX2GetSystemId		(void *ctx);
+XMLPUBFUN void XMLCALL		xmlSAX2SetDocumentLocator	(void *ctx,
 						 xmlSAXLocatorPtr loc);
     
-int		xmlSAX2GetLineNumber		(void *ctx);
+XMLPUBFUN int XMLCALL		xmlSAX2GetLineNumber		(void *ctx);
-int		xmlSAX2GetColumnNumber		(void *ctx);
+XMLPUBFUN int XMLCALL		xmlSAX2GetColumnNumber		(void *ctx);
 
-int		xmlSAX2IsStandalone		(void *ctx);
+XMLPUBFUN int XMLCALL		xmlSAX2IsStandalone		(void *ctx);
-int		xmlSAX2HasInternalSubset	(void *ctx);
+XMLPUBFUN int XMLCALL		xmlSAX2HasInternalSubset	(void *ctx);
-int		xmlSAX2HasExternalSubset	(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);
+XMLPUBFUN void XMLCALL		xmlSAX2StartDocument		(void *ctx);
-void		xmlSAX2EndDocument		(void *ctx);
+XMLPUBFUN void XMLCALL		xmlSAX2EndDocument		(void *ctx);
-void		xmlSAX2StartElement		(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);
+XMLPUBFUN xmlNsPtr XMLCALL	xmlSAX2GetNamespace		(void *ctx);
-int		xmlSAX2CheckNamespace		(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);
+XMLPUBFUN void XMLCALL		xmlDefaultSAXHandlerInit	(void);
-void		htmlDefaultSAXHandlerInit	(void);
+XMLPUBFUN void XMLCALL		htmlDefaultSAXHandlerInit	(void);
-void		docbDefaultSAXHandlerInit	(void);
+XMLPUBFUN void XMLCALL		docbDefaultSAXHandlerInit	(void);
 #ifdef __cplusplus
 }
 #endif

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 @@ extern "C" {
  */
 
 
-int 		xmlC14NDocSaveTo	(xmlDocPtr doc,
+XMLPUBFUN int XMLCALL 		
+		xmlC14NDocSaveTo	(xmlDocPtr doc,
 					 xmlNodeSetPtr nodes,
 					 int exclusive,
 					 xmlChar **inclusive_ns_prefixes,
 					 int with_comments, 
 					 xmlOutputBufferPtr buf);
 
-int 		xmlC14NDocDumpMemory	(xmlDocPtr doc,
+XMLPUBFUN int XMLCALL
+		xmlC14NDocDumpMemory	(xmlDocPtr doc,
 					 xmlNodeSetPtr nodes,
 					 int exclusive,
 					 xmlChar **inclusive_ns_prefixes,
 					 int with_comments, 
 					 xmlChar **doc_txt_ptr);
 
-int 		xmlC14NDocSave		(xmlDocPtr doc,
+XMLPUBFUN int XMLCALL
+		xmlC14NDocSave		(xmlDocPtr doc,
 					 xmlNodeSetPtr nodes,
 					 int exclusive,
 					 xmlChar **inclusive_ns_prefixes,
@@ -75,7 +79,8 @@ typedef int (*xmlC14NIsVisibleCallback)	(void* user_data,
 					 xmlNodePtr node,
 					 xmlNodePtr parent);
 
-int 		xmlC14NExecute		(xmlDocPtr doc,
+XMLPUBFUN int XMLCALL
+		xmlC14NExecute		(xmlDocPtr doc,
 					 xmlC14NIsVisibleCallback is_visible_callback,
 					 void* user_data,				 
 					 int exclusive,

include/libxml/catalog.h

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

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

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 @@ typedef xmlDict *xmlDictPtr;
 /*
  * Constructor and destructor.
  */
-xmlDictPtr		xmlDictCreate	(void);
+XMLPUBFUN xmlDictPtr XMLCALL
-void			xmlDictFree	(xmlDictPtr dict);
+			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

include/libxml/encoding.h

@@ -145,14 +145,17 @@ extern "C" {
 /*
  * Interfaces for encoding handlers.
  */
-void	xmlInitCharEncodingHandlers	(void);
+XMLPUBFUN void XMLCALL	
-void	xmlCleanupCharEncodingHandlers	(void);
+	xmlInitCharEncodingHandlers	(void);
-void	xmlRegisterCharEncodingHandler	(xmlCharEncodingHandlerPtr handler);
+XMLPUBFUN void XMLCALL	
-xmlCharEncodingHandlerPtr
+	xmlCleanupCharEncodingHandlers	(void);
+XMLPUBFUN void XMLCALL	
+	xmlRegisterCharEncodingHandler	(xmlCharEncodingHandlerPtr handler);
+XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL
 	xmlGetCharEncodingHandler	(xmlCharEncoding enc);
-xmlCharEncodingHandlerPtr
+XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL
 	xmlFindCharEncodingHandler	(const char *name);
-xmlCharEncodingHandlerPtr
+XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL
 	xmlNewCharEncodingHandler	(const char *name, 
                           		 xmlCharEncodingInputFunc input,
                           		 xmlCharEncodingOutputFunc output);
@@ -160,68 +163,87 @@ xmlCharEncodingHandlerPtr
 /*
  * Interfaces for encoding names and aliases.
  */
-int	xmlAddEncodingAlias		(const char *name,
+XMLPUBFUN int XMLCALL	
+	xmlAddEncodingAlias		(const char *name,
 					 const char *alias);
-int	xmlDelEncodingAlias		(const char *alias);
+XMLPUBFUN int XMLCALL	
-const char *
+	xmlDelEncodingAlias		(const char *alias);
+XMLPUBFUN const char * XMLCALL
 	xmlGetEncodingAlias		(const char *alias);
-void	xmlCleanupEncodingAliases	(void);
+XMLPUBFUN void XMLCALL	
-xmlCharEncoding
+	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);
+XMLPUBFUN int XMLCALL	
-int	xmlUTF8Strsize			(const xmlChar *utf,
+	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);
+XMLPUBFUN int XMLCALL	
-int	xmlUTF8Size			(const xmlChar *utf);
+	xmlUTF8Strlen			(const xmlChar *utf);
-int	xmlUTF8Charcmp			(const xmlChar *utf1,
+XMLPUBFUN int XMLCALL	
+	xmlUTF8Size			(const xmlChar *utf);
+XMLPUBFUN int XMLCALL	
+	xmlUTF8Charcmp			(const xmlChar *utf1,
 					 const xmlChar *utf2);
 #ifdef __cplusplus
 }

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 @@ typedef xmlEntitiesTable *xmlEntitiesTablePtr;
  * External functions:
  */
 
-void		xmlInitializePredefinedEntities	(void);
+XMLPUBFUN void XMLCALL		
-xmlEntityPtr		xmlAddDocEntity		(xmlDocPtr doc,
+		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);
+XMLPUBFUN xmlEntityPtr XMLCALL		
-xmlEntityPtr		xmlGetDocEntity		(xmlDocPtr doc,
+			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);
+XMLPUBFUN xmlEntitiesTablePtr XMLCALL	
-xmlEntitiesTablePtr	xmlCopyEntitiesTable	(xmlEntitiesTablePtr table);
+			xmlCreateEntitiesTable	(void);
-void			xmlFreeEntitiesTable	(xmlEntitiesTablePtr table);
+XMLPUBFUN xmlEntitiesTablePtr XMLCALL	
-void			xmlDumpEntitiesTable	(xmlBufferPtr buf,
+			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

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

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 @@ typedef void (*xmlHashScannerFull)(void *payload, void *data,
 /*
  * Constructor and destructor.
  */
-xmlHashTablePtr		xmlHashCreate	(int size);
+XMLPUBFUN xmlHashTablePtr XMLCALL
-void			xmlHashFree	(xmlHashTablePtr table,
+			xmlHashCreate	(int size);
+XMLPUBFUN void XMLCALL			
+			xmlHashFree	(xmlHashTablePtr table,
 					 xmlHashDeallocator f);
 
 /*
  * Add a new entry to the hash table.
  */
-int			xmlHashAddEntry	(xmlHashTablePtr table,
+XMLPUBFUN int XMLCALL			
+			xmlHashAddEntry	(xmlHashTablePtr table,
 		                         const xmlChar *name,
 		                         void *userdata);
-int			xmlHashUpdateEntry(xmlHashTablePtr table,
+XMLPUBFUN int XMLCALL			
+			xmlHashUpdateEntry(xmlHashTablePtr table,
 		                         const xmlChar *name,
 		                         void *userdata,
 					 xmlHashDeallocator f);
-int			xmlHashAddEntry2(xmlHashTablePtr table,
+XMLPUBFUN int XMLCALL		    
+			xmlHashAddEntry2(xmlHashTablePtr table,
 		                         const xmlChar *name,
 		                         const xmlChar *name2,
 		                         void *userdata);
-int			xmlHashUpdateEntry2(xmlHashTablePtr table,
+XMLPUBFUN int XMLCALL			
+			xmlHashUpdateEntry2(xmlHashTablePtr table,
 		                         const xmlChar *name,
 		                         const xmlChar *name2,
 		                         void *userdata,
 					 xmlHashDeallocator f);
-int			xmlHashAddEntry3(xmlHashTablePtr table,
+XMLPUBFUN int XMLCALL			
+			xmlHashAddEntry3(xmlHashTablePtr table,
 		                         const xmlChar *name,
 		                         const xmlChar *name2,
 		                         const xmlChar *name3,
 		                         void *userdata);
-int			xmlHashUpdateEntry3(xmlHashTablePtr table,
+XMLPUBFUN int XMLCALL			
+			xmlHashUpdateEntry3(xmlHashTablePtr table,
 		                         const xmlChar *name,
 		                         const xmlChar *name2,
 		                         const xmlChar *name3,
@@ -115,23 +124,29 @@ int			xmlHashUpdateEntry3(xmlHashTablePtr table,
 /*
  * Remove an entry from the hash table.
  */
-int     xmlHashRemoveEntry(xmlHashTablePtr table, const xmlChar *name,
+XMLPUBFUN int XMLCALL     
+			xmlHashRemoveEntry(xmlHashTablePtr table, const xmlChar *name,
                            xmlHashDeallocator f);
-int     xmlHashRemoveEntry2(xmlHashTablePtr table, const xmlChar *name,
+XMLPUBFUN int XMLCALL     
+			xmlHashRemoveEntry2(xmlHashTablePtr table, const xmlChar *name,
                             const xmlChar *name2, xmlHashDeallocator f);
-int     xmlHashRemoveEntry3(xmlHashTablePtr table, const xmlChar *name,
+XMLPUBFUN int  XMLCALL    
+			xmlHashRemoveEntry3(xmlHashTablePtr table, const xmlChar *name,
                             const xmlChar *name2, const xmlChar *name3,
                             xmlHashDeallocator f);
 
 /*
  * Retrieve the userdata.
  */
-void *			xmlHashLookup	(xmlHashTablePtr table,
+XMLPUBFUN void * XMLCALL			
+			xmlHashLookup	(xmlHashTablePtr table,
 					 const xmlChar *name);
-void *			xmlHashLookup2	(xmlHashTablePtr table,
+XMLPUBFUN void * XMLCALL			
+			xmlHashLookup2	(xmlHashTablePtr table,
 					 const xmlChar *name,
 					 const xmlChar *name2);
-void *			xmlHashLookup3	(xmlHashTablePtr table,
+XMLPUBFUN void * XMLCALL			
+			xmlHashLookup3	(xmlHashTablePtr table,
 					 const xmlChar *name,
 					 const xmlChar *name2,
 					 const xmlChar *name3);
@@ -139,22 +154,28 @@ void *			xmlHashLookup3	(xmlHashTablePtr table,
 /*
  * Helpers.
  */
-xmlHashTablePtr		xmlHashCopy	(xmlHashTablePtr table,
+XMLPUBFUN xmlHashTablePtr XMLCALL		
+			xmlHashCopy	(xmlHashTablePtr table,
 					 xmlHashCopier f);
-int			xmlHashSize	(xmlHashTablePtr table);
+XMLPUBFUN int XMLCALL			
-void			xmlHashScan	(xmlHashTablePtr table,
+			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,

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  (*xmlListDataCompare) (const void *data0, const void *data1);
 typedef int (*xmlListWalker) (const void *data, const void *user);
 
 /* Creation/Deletion */
-xmlListPtr	xmlListCreate		(xmlListDeallocator deallocator,
+XMLPUBFUN xmlListPtr XMLCALL
+		xmlListCreate		(xmlListDeallocator deallocator,
 	                                 xmlListDataCompare compare);
-void		xmlListDelete		(xmlListPtr l);
+XMLPUBFUN void XMLCALL		
+		xmlListDelete		(xmlListPtr l);
 
 /* Basic Operators */
-void *		xmlListSearch		(xmlListPtr l,
+XMLPUBFUN void * XMLCALL		
+		xmlListSearch		(xmlListPtr l,
 					 void *data);
-void *		xmlListReverseSearch	(xmlListPtr l,
+XMLPUBFUN void * XMLCALL		
+		xmlListReverseSearch	(xmlListPtr l,
 					 void *data);
-int		xmlListInsert		(xmlListPtr l,
+XMLPUBFUN int XMLCALL		
+		xmlListInsert		(xmlListPtr l,
 					 void *data) ;
-int		xmlListAppend		(xmlListPtr l,
+XMLPUBFUN int XMLCALL		
+		xmlListAppend		(xmlListPtr l,
 					 void *data) ;
-int		xmlListRemoveFirst	(xmlListPtr l,
+XMLPUBFUN int XMLCALL		
+		xmlListRemoveFirst	(xmlListPtr l,
 					 void *data);
-int		xmlListRemoveLast	(xmlListPtr l,
+XMLPUBFUN int XMLCALL		
+		xmlListRemoveLast	(xmlListPtr l,
 					 void *data);
-int		xmlListRemoveAll	(xmlListPtr l,
+XMLPUBFUN int XMLCALL		
+		xmlListRemoveAll	(xmlListPtr l,
 					 void *data);
-void		xmlListClear		(xmlListPtr l);
+XMLPUBFUN void XMLCALL		
-int		xmlListEmpty		(xmlListPtr l);
+		xmlListClear		(xmlListPtr l);
-xmlLinkPtr	xmlListFront		(xmlListPtr l);
+XMLPUBFUN int XMLCALL		
-xmlLinkPtr	xmlListEnd		(xmlListPtr l);
+		xmlListEmpty		(xmlListPtr l);
-int		xmlListSize		(xmlListPtr l);
+XMLPUBFUN xmlLinkPtr XMLCALL	
+		xmlListFront		(xmlListPtr l);
+XMLPUBFUN xmlLinkPtr XMLCALL	
+		xmlListEnd		(xmlListPtr l);
+XMLPUBFUN int XMLCALL		
+		xmlListSize		(xmlListPtr l);
 
-void		xmlListPopFront		(xmlListPtr l);
+XMLPUBFUN void XMLCALL		
-void		xmlListPopBack		(xmlListPtr l);
+		xmlListPopFront		(xmlListPtr l);
-int		xmlListPushFront	(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);
+XMLPUBFUN void XMLCALL		
-void		xmlListSort		(xmlListPtr l);
+		xmlListReverse		(xmlListPtr l);
-void		xmlListWalk		(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);
+XMLPUBFUN xmlListPtr XMLCALL	
-int		xmlListCopy		(xmlListPtr cur,
+		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 */

include/libxml/nanoftp.h

@@ -56,59 +56,81 @@ typedef void (*ftpDataCallback) (void *userData,
 /*
  * Init
  */
-void	xmlNanoFTPInit		(void);
+XMLPUBFUN void XMLCALL
-void	xmlNanoFTPCleanup	(void);
+	xmlNanoFTPInit		(void);
+XMLPUBFUN void XMLCALL	
+	xmlNanoFTPCleanup	(void);
 
 /*
  * Creating/freeing contexts.
  */
-void *	xmlNanoFTPNewCtxt	(const char *URL);
+XMLPUBFUN void * XMLCALL	
-void	xmlNanoFTPFreeCtxt	(void * ctx);
+	xmlNanoFTPNewCtxt	(const char *URL);
-void * 	xmlNanoFTPConnectTo	(const char *server,
+XMLPUBFUN void XMLCALL	
+	xmlNanoFTPFreeCtxt	(void * ctx);
+XMLPUBFUN void * XMLCALL 	
+	xmlNanoFTPConnectTo	(const char *server,
 				 int port);
 /*
  * Opening/closing session connections.
  */
-void * 	xmlNanoFTPOpen		(const char *URL);
+XMLPUBFUN void * XMLCALL 	
-int	xmlNanoFTPConnect	(void *ctx);
+	xmlNanoFTPOpen		(const char *URL);
-int	xmlNanoFTPClose		(void *ctx);
+XMLPUBFUN int XMLCALL	
-int	xmlNanoFTPQuit		(void *ctx);
+	xmlNanoFTPConnect	(void *ctx);
-void	xmlNanoFTPScanProxy	(const char *URL);
+XMLPUBFUN int XMLCALL	
-void	xmlNanoFTPProxy		(const char *host,
+	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);
+XMLPUBFUN int XMLCALL	
-int	xmlNanoFTPCheckResponse	(void *ctx);
+	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);
+XMLPUBFUN int XMLCALL	
-int	xmlNanoFTPCloseConnection(void *ctx);
+	xmlNanoFTPGetConnection	(void *ctx);
-int	xmlNanoFTPList		(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);
 

include/libxml/nanohttp.h

@@ -16,41 +16,54 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-void	xmlNanoHTTPInit		(void);
+XMLPUBFUN void XMLCALL
-void	xmlNanoHTTPCleanup	(void);
+	xmlNanoHTTPInit		(void);
-void	xmlNanoHTTPScanProxy	(const char *URL);
+XMLPUBFUN void XMLCALL	
-int	xmlNanoHTTPFetch	(const char *URL,
+	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);
+XMLPUBFUN int XMLCALL	
-const char * xmlNanoHTTPAuthHeader(void *ctx);
+	xmlNanoHTTPReturnCode	(void *ctx);
-int	xmlNanoHTTPRead		(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__ */

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 @@ LIBXML_DLL_IMPORT extern int xmlGetWarningsDefaultValue;
 #ifdef __cplusplus
 }
 #endif
+
 #include <libxml/encoding.h>
 #include <libxml/xmlIO.h>
 #include <libxml/globals.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -747,138 +750,187 @@ extern "C" {
 /*
  * Init/Cleanup
  */
-void		xmlInitParser		(void);
+XMLPUBFUN void XMLCALL		
-void		xmlCleanupParser	(void);
+		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);
+XMLPUBFUN xmlChar * XMLCALL	
-xmlChar *	xmlStrndup		(const xmlChar *cur,
+		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);
+XMLPUBFUN xmlChar * XMLCALL	
-xmlChar *	xmlStrsub		(const xmlChar *str,
+		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);
+XMLPUBFUN int XMLCALL		
-xmlChar *	xmlStrcat		(xmlChar *cur,
+		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);
+XMLPUBFUN xmlDocPtr XMLCALL	
-xmlDocPtr	xmlParseMemory		(const char *buffer,
+		xmlParseDoc		(xmlChar *cur);
+XMLPUBFUN xmlDocPtr XMLCALL	
+		xmlParseMemory		(const char *buffer,
 					 int size);
-xmlDocPtr	xmlParseFile		(const char *filename);
+XMLPUBFUN xmlDocPtr XMLCALL	
-int		xmlSubstituteEntitiesDefault(int val);
+		xmlParseFile		(const char *filename);
-int		xmlKeepBlanksDefault	(int val);
+XMLPUBFUN int XMLCALL		
-void		xmlStopParser		(xmlParserCtxtPtr ctxt);
+		xmlSubstituteEntitiesDefault(int val);
-int		xmlPedanticParserDefault(int val);
+XMLPUBFUN int XMLCALL		
-int		xmlLineNumbersDefault	(int val);
+		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);
+XMLPUBFUN xmlDocPtr XMLCALL	
-xmlDocPtr	xmlRecoverMemory	(const char *buffer,
+		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);
+XMLPUBFUN int XMLCALL		
-int		xmlParseExtParsedEnt	(xmlParserCtxtPtr ctxt);
+		xmlParseDocument	(xmlParserCtxtPtr ctxt);
-xmlDocPtr	xmlSAXParseDoc		(xmlSAXHandlerPtr sax,
+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);
+XMLPUBFUN xmlDocPtr XMLCALL	
-xmlDtdPtr	xmlParseDTD		(const xmlChar *ExternalID,
+		xmlParseEntity		(const char *filename);
+XMLPUBFUN xmlDtdPtr XMLCALL	
+		xmlParseDTD		(const xmlChar *ExternalID,
 					 const xmlChar *SystemID);
-xmlDtdPtr	xmlSAXParseDTD		(xmlSAXHandlerPtr sax,
+XMLPUBFUN xmlDtdPtr XMLCALL	
+		xmlSAXParseDTD		(xmlSAXHandlerPtr sax,
 					 const xmlChar *ExternalID,
 					 const xmlChar *SystemID);
-xmlDtdPtr	xmlIOParseDTD		(xmlSAXHandlerPtr sax,
+XMLPUBFUN xmlDtdPtr XMLCALL	
+		xmlIOParseDTD		(xmlSAXHandlerPtr sax,
 					 xmlParserInputBufferPtr input,
 					 xmlCharEncoding enc);
-int		xmlParseBalancedChunkMemory(xmlDocPtr doc,
+XMLPUBFUN int XMLCALL	
+		xmlParseBalancedChunkMemory(xmlDocPtr doc,
 					 xmlSAXHandlerPtr sax,
 					 void *user_data,
 					 int depth,
 					 const xmlChar *string,
 					 xmlNodePtr *lst);
-int           xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc,
+XMLPUBFUN int XMLCALL          
+		xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc,
                      xmlSAXHandlerPtr sax,
                      void *user_data,
                      int depth,
                      const xmlChar *string,
                      xmlNodePtr *lst,
                      int recover);
-int		xmlParseExternalEntity	(xmlDocPtr doc,
+XMLPUBFUN int XMLCALL		
+		xmlParseExternalEntity	(xmlDocPtr doc,
 					 xmlSAXHandlerPtr sax,
 					 void *user_data,
 					 int depth,
 					 const xmlChar *URL,
 					 const xmlChar *ID,
 					 xmlNodePtr *lst);
-int		xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx,
+XMLPUBFUN int XMLCALL		
+		xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx,
 					 const xmlChar *URL,
 					 const xmlChar *ID,
 					 xmlNodePtr *lst);
@@ -886,36 +938,46 @@ int		xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx,
 /*
  * Parser contexts handling.
  */
-int		xmlInitParserCtxt	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN int XMLCALL		
-void		xmlClearParserCtxt	(xmlParserCtxtPtr ctxt);
+		xmlInitParserCtxt	(xmlParserCtxtPtr ctxt);
-void		xmlFreeParserCtxt	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL		
-void		xmlSetupParserForBuffer	(xmlParserCtxtPtr ctxt,
+		xmlClearParserCtxt	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL		
+		xmlFreeParserCtxt	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL		
+		xmlSetupParserForBuffer	(xmlParserCtxtPtr ctxt,
 					 const xmlChar* buffer,
 					 const char *filename);
-xmlParserCtxtPtr xmlCreateDocParserCtxt	(xmlChar *cur);
+XMLPUBFUN xmlParserCtxtPtr XMLCALL 
+		xmlCreateDocParserCtxt	(xmlChar *cur);
 
 /*
  * Reading/setting optional parsing features.
  */
 
-int		xmlGetFeaturesList	(int *len,
+XMLPUBFUN int XMLCALL		
+		xmlGetFeaturesList	(int *len,
 					 const char **result);
-int		xmlGetFeature		(xmlParserCtxtPtr ctxt,
+XMLPUBFUN int XMLCALL		
+		xmlGetFeature		(xmlParserCtxtPtr ctxt,
 					 const char *name,
 					 void *result);
-int		xmlSetFeature		(xmlParserCtxtPtr ctxt,
+XMLPUBFUN int XMLCALL		
+		xmlSetFeature		(xmlParserCtxtPtr ctxt,
 					 const char *name,
 					 void *value);
 
 /*
  * Interfaces for the Push mode.
  */
-xmlParserCtxtPtr xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax,
+XMLPUBFUN xmlParserCtxtPtr XMLCALL 
+		xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax,
 					 void *user_data,
 					 const char *chunk,
 					 int size,
 					 const char *filename);
-int		 xmlParseChunk		(xmlParserCtxtPtr ctxt,
+XMLPUBFUN int XMLCALL		 
+		xmlParseChunk		(xmlParserCtxtPtr ctxt,
 					 const char *chunk,
 					 int size,
 					 int terminate);
@@ -924,38 +986,45 @@ int		 xmlParseChunk		(xmlParserCtxtPtr ctxt,
  * Special I/O mode.
  */
 
-xmlParserCtxtPtr xmlCreateIOParserCtxt	(xmlSAXHandlerPtr sax,
+XMLPUBFUN xmlParserCtxtPtr XMLCALL 
+		xmlCreateIOParserCtxt	(xmlSAXHandlerPtr sax,
 					 void *user_data,
 					 xmlInputReadCallback   ioread,
 					 xmlInputCloseCallback  ioclose,
 					 void *ioctx,
 					 xmlCharEncoding enc);
 
-xmlParserInputPtr xmlNewIOInputStream	(xmlParserCtxtPtr ctxt,
+XMLPUBFUN xmlParserInputPtr XMLCALL 
+		xmlNewIOInputStream	(xmlParserCtxtPtr ctxt,
 					 xmlParserInputBufferPtr input,
 					 xmlCharEncoding enc);
 
 /*
  * Node infos.
  */
-const xmlParserNodeInfo*
+XMLPUBFUN const xmlParserNodeInfo* XMLCALL
 		xmlParserFindNodeInfo	(const xmlParserCtxtPtr ctxt,
 				         const xmlNodePtr node);
-void		xmlInitNodeInfoSeq	(xmlParserNodeInfoSeqPtr seq);
+XMLPUBFUN void XMLCALL		
-void		xmlClearNodeInfoSeq	(xmlParserNodeInfoSeqPtr seq);
+		xmlInitNodeInfoSeq	(xmlParserNodeInfoSeqPtr seq);
-unsigned long xmlParserFindNodeInfoIndex(const 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);
+XMLPUBFUN void XMLCALL		
-xmlExternalEntityLoader
+		xmlSetExternalEntityLoader(xmlExternalEntityLoader f);
+XMLPUBFUN xmlExternalEntityLoader XMLCALL
 		xmlGetExternalEntityLoader(void);
-xmlParserInputPtr
+XMLPUBFUN xmlParserInputPtr XMLCALL
 		xmlLoadExternalEntity	(const char *URL,
 					 const char *ID,
 					 xmlParserCtxtPtr ctxt);

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 @@ extern "C" {
 /**
  * Global variables used for predefined strings.
  */
-LIBXML_DLL_IMPORT extern const xmlChar xmlStringText[];
+XMLPUBVAR const xmlChar xmlStringText[];
-LIBXML_DLL_IMPORT extern const xmlChar xmlStringTextNoenc[];
+XMLPUBVAR const xmlChar xmlStringTextNoenc[];
-LIBXML_DLL_IMPORT extern const xmlChar xmlStringComment[];
+XMLPUBVAR const xmlChar xmlStringComment[];
 
 /*
  * Function to finish the work of the macros where needed.
  */
-int			xmlIsBaseChar	(int c);
+XMLPUBFUN int XMLCALL			xmlIsBaseChar	(int c);
-int			xmlIsBlank	(int c);
+XMLPUBFUN int XMLCALL			xmlIsBlank	(int c);
-int			xmlIsPubidChar	(int c);
+XMLPUBFUN int XMLCALL			xmlIsPubidChar	(int c);
-int			xmlIsLetter	(int c);
+XMLPUBFUN int XMLCALL			xmlIsLetter	(int c);
-int			xmlIsDigit	(int c);
+XMLPUBFUN int XMLCALL			xmlIsDigit	(int c);
-int			xmlIsIdeographic(int c);
+XMLPUBFUN int XMLCALL			xmlIsIdeographic(int c);
-int			xmlIsExtender	(int c);
+XMLPUBFUN int XMLCALL			xmlIsExtender	(int c);
-int			xmlIsCombining	(int c);
+XMLPUBFUN int XMLCALL			xmlIsCombining	(int c);
-int			xmlIsChar	(int c);
+XMLPUBFUN int XMLCALL			xmlIsChar	(int c);
 
 /**
  * Parser context.
  */
-xmlParserCtxtPtr	xmlCreateFileParserCtxt	(const char *filename);
+XMLPUBFUN xmlParserCtxtPtr XMLCALL	
-xmlParserCtxtPtr	xmlCreateMemoryParserCtxt(const char *buffer,
+			xmlCreateFileParserCtxt	(const char *filename);
+XMLPUBFUN xmlParserCtxtPtr XMLCALL	xmlCreateMemoryParserCtxt(const char *buffer,
 						 int size);
-xmlParserCtxtPtr	xmlNewParserCtxt	(void);
+XMLPUBFUN xmlParserCtxtPtr XMLCALL	xmlNewParserCtxt	(void);
-xmlParserCtxtPtr	xmlCreateEntityParserCtxt(const xmlChar *URL,
+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);
+XMLPUBFUN xmlChar XMLCALL			xmlPopInput		(xmlParserCtxtPtr ctxt);
-void			xmlFreeInputStream	(xmlParserInputPtr input);
+XMLPUBFUN void XMLCALL			xmlFreeInputStream	(xmlParserInputPtr input);
-xmlParserInputPtr	xmlNewInputFromFile	(xmlParserCtxtPtr ctxt,
+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);
+XMLPUBFUN xmlChar * XMLCALL		xmlNamespaceParseNCName	(xmlParserCtxtPtr ctxt);
-xmlChar *		xmlNamespaceParseQName	(xmlParserCtxtPtr ctxt,
+XMLPUBFUN xmlChar * XMLCALL		xmlNamespaceParseQName	(xmlParserCtxtPtr ctxt,
 						 xmlChar **prefix);
-xmlChar *		xmlNamespaceParseNSDef	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL		xmlNamespaceParseNSDef	(xmlParserCtxtPtr ctxt);
-xmlChar *		xmlParseQuotedString	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL		xmlParseQuotedString	(xmlParserCtxtPtr ctxt);
-void			xmlParseNamespace	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			xmlParseNamespace	(xmlParserCtxtPtr ctxt);
 
 /**
  * Generic production rules.
  */
-xmlChar *		xmlScanName		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL		xmlScanName		(xmlParserCtxtPtr ctxt);
-const xmlChar *		xmlParseName		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN const xmlChar * XMLCALL		xmlParseName		(xmlParserCtxtPtr ctxt);
-xmlChar *		xmlParseNmtoken		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL		xmlParseNmtoken		(xmlParserCtxtPtr ctxt);
-xmlChar *		xmlParseEntityValue	(xmlParserCtxtPtr ctxt,
+XMLPUBFUN xmlChar * XMLCALL		xmlParseEntityValue	(xmlParserCtxtPtr ctxt,
 						 xmlChar **orig);
-xmlChar *		xmlParseAttValue	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL		xmlParseAttValue	(xmlParserCtxtPtr ctxt);
-xmlChar *		xmlParseSystemLiteral	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL		xmlParseSystemLiteral	(xmlParserCtxtPtr ctxt);
-xmlChar *		xmlParsePubidLiteral	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL		xmlParsePubidLiteral	(xmlParserCtxtPtr ctxt);
-void			xmlParseCharData	(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);
+XMLPUBFUN void XMLCALL			xmlParseComment		(xmlParserCtxtPtr ctxt);
-const xmlChar *		xmlParsePITarget	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN const xmlChar * XMLCALL		xmlParsePITarget	(xmlParserCtxtPtr ctxt);
-void			xmlParsePI		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			xmlParsePI		(xmlParserCtxtPtr ctxt);
-void			xmlParseNotationDecl	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			xmlParseNotationDecl	(xmlParserCtxtPtr ctxt);
-void			xmlParseEntityDecl	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			xmlParseEntityDecl	(xmlParserCtxtPtr ctxt);
-int			xmlParseDefaultDecl	(xmlParserCtxtPtr ctxt,
+XMLPUBFUN int XMLCALL			xmlParseDefaultDecl	(xmlParserCtxtPtr ctxt,
 						 xmlChar **value);
-xmlEnumerationPtr	xmlParseNotationType	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlEnumerationPtr XMLCALL	xmlParseNotationType	(xmlParserCtxtPtr ctxt);
-xmlEnumerationPtr	xmlParseEnumerationType	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlEnumerationPtr XMLCALL	xmlParseEnumerationType	(xmlParserCtxtPtr ctxt);
-int			xmlParseEnumeratedType	(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);
+XMLPUBFUN void XMLCALL			xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt);
-xmlElementContentPtr	xmlParseElementMixedContentDecl
+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);
+XMLPUBFUN int XMLCALL			xmlParseElementDecl	(xmlParserCtxtPtr ctxt);
-void			xmlParseMarkupDecl	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			xmlParseMarkupDecl	(xmlParserCtxtPtr ctxt);
-int			xmlParseCharRef		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN int XMLCALL			xmlParseCharRef		(xmlParserCtxtPtr ctxt);
-xmlEntityPtr		xmlParseEntityRef	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlEntityPtr XMLCALL		xmlParseEntityRef	(xmlParserCtxtPtr ctxt);
-void			xmlParseReference	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			xmlParseReference	(xmlParserCtxtPtr ctxt);
-void			xmlParsePEReference	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			xmlParsePEReference	(xmlParserCtxtPtr ctxt);
-void			xmlParseDocTypeDecl	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			xmlParseDocTypeDecl	(xmlParserCtxtPtr ctxt);
-const xmlChar *		xmlParseAttribute	(xmlParserCtxtPtr ctxt,
+XMLPUBFUN const xmlChar * XMLCALL		xmlParseAttribute	(xmlParserCtxtPtr ctxt,
 						 xmlChar **value);
-const xmlChar *		xmlParseStartTag	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN const xmlChar * XMLCALL		xmlParseStartTag	(xmlParserCtxtPtr ctxt);
-void			xmlParseEndTag		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			xmlParseEndTag		(xmlParserCtxtPtr ctxt);
-void			xmlParseCDSect		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			xmlParseCDSect		(xmlParserCtxtPtr ctxt);
-void			xmlParseContent		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			xmlParseContent		(xmlParserCtxtPtr ctxt);
-void			xmlParseElement		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			xmlParseElement		(xmlParserCtxtPtr ctxt);
-xmlChar *		xmlParseVersionNum	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL		xmlParseVersionNum	(xmlParserCtxtPtr ctxt);
-xmlChar *		xmlParseVersionInfo	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL		xmlParseVersionInfo	(xmlParserCtxtPtr ctxt);
-xmlChar *		xmlParseEncName		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL		xmlParseEncName		(xmlParserCtxtPtr ctxt);
-const xmlChar *		xmlParseEncodingDecl	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN const xmlChar * XMLCALL		xmlParseEncodingDecl	(xmlParserCtxtPtr ctxt);
-int			xmlParseSDDecl		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN int XMLCALL			xmlParseSDDecl		(xmlParserCtxtPtr ctxt);
-void			xmlParseXMLDecl		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			xmlParseXMLDecl		(xmlParserCtxtPtr ctxt);
-void			xmlParseTextDecl	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			xmlParseTextDecl	(xmlParserCtxtPtr ctxt);
-void			xmlParseMisc		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			xmlParseMisc		(xmlParserCtxtPtr ctxt);
-void			xmlParseExternalSubset	(xmlParserCtxtPtr ctxt,
+XMLPUBFUN void XMLCALL			xmlParseExternalSubset	(xmlParserCtxtPtr ctxt,
 						 const xmlChar *ExternalID,
 						 const xmlChar *SystemID); 
 /**
@@ -328,13 +330,13 @@ void			xmlParseExternalSubset	(xmlParserCtxtPtr ctxt,
  */
 #define XML_SUBSTITUTE_BOTH 	3
 
-xmlChar *		xmlDecodeEntities	(xmlParserCtxtPtr ctxt,
+XMLPUBFUN xmlChar * XMLCALL		xmlDecodeEntities	(xmlParserCtxtPtr ctxt,
 						 int len,
 						 int what,
 						 xmlChar end,
 						 xmlChar  end2,
 						 xmlChar end3);
-xmlChar *		xmlStringDecodeEntities	(xmlParserCtxtPtr ctxt,
+XMLPUBFUN xmlChar * XMLCALL		xmlStringDecodeEntities	(xmlParserCtxtPtr ctxt,
 						 const xmlChar *str,
 						 int what,
 						 xmlChar end,
@@ -344,46 +346,46 @@ xmlChar *		xmlStringDecodeEntities	(xmlParserCtxtPtr ctxt,
 /*
  * Generated by MACROS on top of parser.c c.f. PUSH_AND_POP.
  */
-int			nodePush		(xmlParserCtxtPtr ctxt,
+XMLPUBFUN int XMLCALL			nodePush		(xmlParserCtxtPtr ctxt,
 						 xmlNodePtr value);
-xmlNodePtr		nodePop			(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlNodePtr XMLCALL		nodePop			(xmlParserCtxtPtr ctxt);
-int			inputPush		(xmlParserCtxtPtr ctxt,
+XMLPUBFUN int XMLCALL			inputPush		(xmlParserCtxtPtr ctxt,
 						 xmlParserInputPtr value);
-xmlParserInputPtr	inputPop		(xmlParserCtxtPtr ctxt);
+XMLPUBFUN xmlParserInputPtr XMLCALL	inputPop		(xmlParserCtxtPtr ctxt);
-const xmlChar          *namePop			(xmlParserCtxtPtr ctxt);
+XMLPUBFUN const xmlChar * XMLCALL	namePop			(xmlParserCtxtPtr ctxt);
-int			namePush		(xmlParserCtxtPtr ctxt,
+XMLPUBFUN int XMLCALL			namePush		(xmlParserCtxtPtr ctxt,
 						 const xmlChar *value);
 
 /*
  * other commodities shared between parser.c and parserInternals.
  */
-int			xmlSkipBlankChars	(xmlParserCtxtPtr ctxt);
+XMLPUBFUN int XMLCALL			xmlSkipBlankChars	(xmlParserCtxtPtr ctxt);
-int			xmlStringCurrentChar	(xmlParserCtxtPtr ctxt,
+XMLPUBFUN int XMLCALL			xmlStringCurrentChar	(xmlParserCtxtPtr ctxt,
 						 const xmlChar *cur,
 						 int *len);
-void			xmlParserHandlePEReference(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			xmlParserHandlePEReference(xmlParserCtxtPtr ctxt);
-void			xmlParserHandleReference(xmlParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			xmlParserHandleReference(xmlParserCtxtPtr ctxt);
-int			xmlCheckLanguageID	(const xmlChar *lang);
+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);
+XMLPUBFUN void XMLCALL			xmlNextChar		(xmlParserCtxtPtr ctxt);
-void			xmlParserInputShrink	(xmlParserInputPtr in);
+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);
+XMLPUBFUN void XMLCALL			htmlInitAutoClose	(void);
-htmlParserCtxtPtr	htmlCreateFileParserCtxt(const char *filename,
+XMLPUBFUN htmlParserCtxtPtr XMLCALL	htmlCreateFileParserCtxt(const char *filename,
 	                                         const char *encoding);
 #endif
 
@@ -404,7 +406,7 @@ typedef	void	(*xmlEntityReferenceFunc)	(xmlEntityPtr ent,
 						 xmlNodePtr firstNode,
 						 xmlNodePtr lastNode);
   
-void		xmlSetEntityReferenceFunc	(xmlEntityReferenceFunc func);
+XMLPUBFUN void XMLCALL		xmlSetEntityReferenceFunc	(xmlEntityReferenceFunc func);
 
 
 #ifdef __cplusplus

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 @@ typedef enum {
 /*
  * Interfaces for parsing.
  */
-xmlRelaxNGParserCtxtPtr xmlRelaxNGNewParserCtxt	(const char *URL);
+XMLPUBFUN xmlRelaxNGParserCtxtPtr XMLCALL 
-xmlRelaxNGParserCtxtPtr xmlRelaxNGNewMemParserCtxt(const char *buffer,
+		    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);
+XMLPUBFUN void XMLCALL		xmlRelaxNGFreeParserCtxt	(xmlRelaxNGParserCtxtPtr ctxt);
-void		xmlRelaxNGSetParserErrors(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);
+XMLPUBFUN xmlRelaxNGPtr XMLCALL	xmlRelaxNGParse		(xmlRelaxNGParserCtxtPtr ctxt);
-void		xmlRelaxNGFree		(xmlRelaxNGPtr schema);
+XMLPUBFUN void XMLCALL		xmlRelaxNGFree		(xmlRelaxNGPtr schema);
-void		xmlRelaxNGDump		(FILE *output,
+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);
+XMLPUBFUN xmlRelaxNGValidCtxtPtr XMLCALL	xmlRelaxNGNewValidCtxt	(xmlRelaxNGPtr schema);
-void			xmlRelaxNGFreeValidCtxt	(xmlRelaxNGValidCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			xmlRelaxNGFreeValidCtxt	(xmlRelaxNGValidCtxtPtr ctxt);
-int			xmlRelaxNGValidateDoc	(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__ */

include/libxml/schemasInternals.h

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

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 @@ typedef xmlRMutex *xmlRMutexPtr;
 extern "C" {
 #endif
 
-xmlMutexPtr		xmlNewMutex	(void);
+XMLPUBFUN xmlMutexPtr XMLCALL		
-void			xmlMutexLock	(xmlMutexPtr tok);
+			xmlNewMutex	(void);
-void			xmlMutexUnlock	(xmlMutexPtr tok);
+XMLPUBFUN void XMLCALL			xmlMutexLock	(xmlMutexPtr tok);
-void			xmlFreeMutex	(xmlMutexPtr tok);
+XMLPUBFUN void XMLCALL			xmlMutexUnlock	(xmlMutexPtr tok);
+XMLPUBFUN void XMLCALL			xmlFreeMutex	(xmlMutexPtr tok);
 
-xmlRMutexPtr		xmlNewRMutex	(void);
+XMLPUBFUN xmlRMutexPtr XMLCALL		xmlNewRMutex	(void);
-void			xmlRMutexLock	(xmlRMutexPtr tok);
+XMLPUBFUN void XMLCALL			xmlRMutexLock	(xmlRMutexPtr tok);
-void			xmlRMutexUnlock	(xmlRMutexPtr tok);
+XMLPUBFUN void XMLCALL			xmlRMutexUnlock	(xmlRMutexPtr tok);
-void			xmlFreeRMutex	(xmlRMutexPtr tok);
+XMLPUBFUN void XMLCALL			xmlFreeRMutex	(xmlRMutexPtr tok);
 
 /*
  * Library wide APIs.
  */
-void			xmlInitThreads	(void);
+XMLPUBFUN void XMLCALL			xmlInitThreads	(void);
-void			xmlLockLibrary	(void);
+XMLPUBFUN void XMLCALL			xmlLockLibrary	(void);
-void			xmlUnlockLibrary(void);
+XMLPUBFUN void XMLCALL			xmlUnlockLibrary(void);
-int			xmlGetThreadId	(void);
+XMLPUBFUN int XMLCALL			xmlGetThreadId	(void);
-int			xmlIsMainThread	(void);
+XMLPUBFUN int XMLCALL			xmlIsMainThread	(void);
-void			xmlCleanupThreads(void);
+XMLPUBFUN void XMLCALL			xmlCleanupThreads(void);
-xmlGlobalStatePtr	xmlGetGlobalState(void);
+XMLPUBFUN xmlGlobalStatePtr XMLCALL	xmlGetGlobalState(void);
 
 #ifdef __cplusplus
 }

include/libxml/tree.h

@@ -541,374 +541,375 @@ LIBXML_DLL_IMPORT extern int xmlDefaultBufferSize; /* default buffer size */
 /*
  * Some helper functions
  */
-int		xmlValidateNCName	(const xmlChar *value,
+XMLPUBFUN int XMLCALL
+		xmlValidateNCName	(const xmlChar *value,
 					 int space);
-int		xmlValidateQName	(const xmlChar *value,
+XMLPUBFUN int XMLCALL		xmlValidateQName	(const xmlChar *value,
 					 int space);
-int		xmlValidateName		(const xmlChar *value,
+XMLPUBFUN int XMLCALL		xmlValidateName		(const xmlChar *value,
 					 int space);
-int		xmlValidateNMToken	(const xmlChar *value,
+XMLPUBFUN int XMLCALL		xmlValidateNMToken	(const xmlChar *value,
 					 int space);
 
-xmlChar *	xmlBuildQName		(const xmlChar *ncname,
+XMLPUBFUN xmlChar * XMLCALL	xmlBuildQName		(const xmlChar *ncname,
 					 const xmlChar *prefix,
 					 xmlChar *memory,
 					 int len);
-xmlChar *	xmlSplitQName2		(const xmlChar *name,
+XMLPUBFUN xmlChar * XMLCALL	xmlSplitQName2		(const xmlChar *name,
 					 xmlChar **prefix);
-const xmlChar *	xmlSplitQName3		(const xmlChar *name,
+XMLPUBFUN const xmlChar * XMLCALL	xmlSplitQName3		(const xmlChar *name,
 					 int *len);
 
 /*
  * Handling Buffers.
  */
 
-void		xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme);
+XMLPUBFUN void XMLCALL		xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme);
-xmlBufferAllocationScheme	 xmlGetBufferAllocationScheme(void);
+XMLPUBFUN xmlBufferAllocationScheme XMLCALL	 xmlGetBufferAllocationScheme(void);
 
-xmlBufferPtr	xmlBufferCreate		(void);
+XMLPUBFUN xmlBufferPtr XMLCALL	xmlBufferCreate		(void);
-xmlBufferPtr	xmlBufferCreateSize	(size_t size);
+XMLPUBFUN xmlBufferPtr XMLCALL	xmlBufferCreateSize	(size_t size);
-int		xmlBufferResize		(xmlBufferPtr buf,
+XMLPUBFUN int XMLCALL		xmlBufferResize		(xmlBufferPtr buf,
 					 unsigned int size);
-void		xmlBufferFree		(xmlBufferPtr buf);
+XMLPUBFUN void XMLCALL		xmlBufferFree		(xmlBufferPtr buf);
-int		xmlBufferDump		(FILE *file,
+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);
+XMLPUBFUN void XMLCALL		xmlBufferEmpty		(xmlBufferPtr buf);
-const xmlChar*	xmlBufferContent	(const xmlBufferPtr buf);
+XMLPUBFUN const xmlChar* XMLCALL	xmlBufferContent	(const xmlBufferPtr buf);
-void		xmlBufferSetAllocationScheme(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);
+XMLPUBFUN xmlDtdPtr XMLCALL	xmlGetIntSubset		(xmlDocPtr doc);
-void		xmlFreeDtd		(xmlDtdPtr cur);
+XMLPUBFUN void XMLCALL		xmlFreeDtd		(xmlDtdPtr cur);
-xmlNsPtr	xmlNewGlobalNs		(xmlDocPtr doc,
+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);
+XMLPUBFUN void XMLCALL		xmlFreeNs		(xmlNsPtr cur);
-void		xmlFreeNsList		(xmlNsPtr cur);
+XMLPUBFUN void XMLCALL		xmlFreeNsList		(xmlNsPtr cur);
-xmlDocPtr 	xmlNewDoc		(const xmlChar *version);
+XMLPUBFUN xmlDocPtr XMLCALL 	xmlNewDoc		(const xmlChar *version);
-void		xmlFreeDoc		(xmlDocPtr cur);
+XMLPUBFUN void XMLCALL		xmlFreeDoc		(xmlDocPtr cur);
-xmlAttrPtr	xmlNewDocProp		(xmlDocPtr doc,
+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);
+XMLPUBFUN void XMLCALL		xmlFreePropList		(xmlAttrPtr cur);
-void		xmlFreeProp		(xmlAttrPtr cur);
+XMLPUBFUN void XMLCALL		xmlFreeProp		(xmlAttrPtr cur);
-xmlAttrPtr	xmlCopyProp		(xmlNodePtr target,
+XMLPUBFUN xmlAttrPtr XMLCALL	xmlCopyProp		(xmlNodePtr target,
 					 xmlAttrPtr cur);
-xmlAttrPtr	xmlCopyPropList		(xmlNodePtr target,
+XMLPUBFUN xmlAttrPtr XMLCALL	xmlCopyPropList		(xmlNodePtr target,
 					 xmlAttrPtr cur);
-xmlDtdPtr	xmlCopyDtd		(xmlDtdPtr dtd);
+XMLPUBFUN xmlDtdPtr XMLCALL	xmlCopyDtd		(xmlDtdPtr dtd);
-xmlDocPtr	xmlCopyDoc		(xmlDocPtr doc,
+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);
+XMLPUBFUN xmlNodePtr XMLCALL	xmlNewText		(const xmlChar *content);
-xmlNodePtr	xmlNewPI		(const xmlChar *name,
+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);
+XMLPUBFUN xmlNodePtr XMLCALL	xmlNewComment		(const xmlChar *content);
-xmlNodePtr	xmlNewCDataBlock	(xmlDocPtr doc,
+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);
+XMLPUBFUN xmlNodePtr XMLCALL	xmlCopyNodeList		(const xmlNodePtr node);
-xmlNodePtr	xmlNewDocFragment	(xmlDocPtr doc);
+XMLPUBFUN xmlNodePtr XMLCALL	xmlNewDocFragment	(xmlDocPtr doc);
 
 /*
  * Navigating.
  */
-long		xmlGetLineNo		(xmlNodePtr node);
+XMLPUBFUN long XMLCALL		xmlGetLineNo		(xmlNodePtr node);
-xmlChar *	xmlGetNodePath		(xmlNodePtr node);
+XMLPUBFUN xmlChar * XMLCALL	xmlGetNodePath		(xmlNodePtr node);
-xmlNodePtr	xmlDocGetRootElement	(xmlDocPtr doc);
+XMLPUBFUN xmlNodePtr XMLCALL	xmlDocGetRootElement	(xmlDocPtr doc);
-xmlNodePtr	xmlGetLastChild		(xmlNodePtr parent);
+XMLPUBFUN xmlNodePtr XMLCALL	xmlGetLastChild		(xmlNodePtr parent);
-int		xmlNodeIsText		(xmlNodePtr node);
+XMLPUBFUN int XMLCALL		xmlNodeIsText		(xmlNodePtr node);
-int		xmlIsBlankNode		(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);
+XMLPUBFUN void XMLCALL		xmlUnlinkNode		(xmlNodePtr cur);
-xmlNodePtr	xmlTextMerge		(xmlNodePtr first,
+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);
+XMLPUBFUN void XMLCALL		xmlFreeNodeList		(xmlNodePtr cur);
-void		xmlFreeNode		(xmlNodePtr cur);
+XMLPUBFUN void XMLCALL		xmlFreeNode		(xmlNodePtr cur);
-void		xmlSetTreeDoc		(xmlNodePtr tree,
+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);
+XMLPUBFUN xmlNsPtr XMLCALL	xmlCopyNamespace	(xmlNsPtr cur);
-xmlNsPtr	xmlCopyNamespaceList	(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);
+XMLPUBFUN xmlChar * XMLCALL	xmlNodeGetContent	(xmlNodePtr cur);
-xmlChar *	xmlNodeGetLang		(xmlNodePtr cur);
+XMLPUBFUN xmlChar * XMLCALL	xmlNodeGetLang		(xmlNodePtr cur);
-void		xmlNodeSetLang		(xmlNodePtr cur,
+XMLPUBFUN void XMLCALL		xmlNodeSetLang		(xmlNodePtr cur,
 					 const xmlChar *lang);
-int		xmlNodeGetSpacePreserve	(xmlNodePtr cur);
+XMLPUBFUN int XMLCALL		xmlNodeGetSpacePreserve	(xmlNodePtr cur);
-void		xmlNodeSetSpacePreserve (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);
+XMLPUBFUN int XMLCALL		xmlRemoveProp		(xmlAttrPtr cur);
-int		xmlUnsetProp		(xmlNodePtr node,
+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);
+XMLPUBFUN int XMLCALL		xmlGetDocCompressMode	(xmlDocPtr doc);
-void		xmlSetDocCompressMode	(xmlDocPtr doc,
+XMLPUBFUN void XMLCALL		xmlSetDocCompressMode	(xmlDocPtr doc,
 					 int mode);
-int		xmlGetCompressMode	(void);
+XMLPUBFUN int XMLCALL		xmlGetCompressMode	(void);
-void		xmlSetCompressMode	(int mode);
+XMLPUBFUN void XMLCALL		xmlSetCompressMode	(int mode);
 
 #ifdef __cplusplus
 }

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 @@ struct _xmlURI {
  * xmlChar *	xmlNodeGetBase	(xmlDocPtr doc,
  *                               xmlNodePtr cur);
  */
-xmlURIPtr	xmlCreateURI		(void);
+XMLPUBFUN xmlURIPtr XMLCALL	
-xmlChar *	xmlBuildURI		(const xmlChar *URI,
+		xmlCreateURI		(void);
+XMLPUBFUN xmlChar * XMLCALL	
+		xmlBuildURI		(const xmlChar *URI,
 	                        	 const xmlChar *base);
-xmlURIPtr	xmlParseURI		(const char *str);
+XMLPUBFUN xmlURIPtr XMLCALL	xmlParseURI		(const char *str);
-int		xmlParseURIReference	(xmlURIPtr uri,
+XMLPUBFUN int XMLCALL		xmlParseURIReference	(xmlURIPtr uri,
 					 const char *str);
-xmlChar *	xmlSaveUri		(xmlURIPtr uri);
+XMLPUBFUN xmlChar * XMLCALL	xmlSaveUri		(xmlURIPtr uri);
-void		xmlPrintURI		(FILE *stream,
+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);
+XMLPUBFUN int XMLCALL		xmlNormalizeURIPath	(char *path);
-xmlChar *	xmlURIEscape		(const xmlChar *str);
+XMLPUBFUN xmlChar * XMLCALL	xmlURIEscape		(const xmlChar *str);
-void		xmlFreeURI		(xmlURIPtr uri);
+XMLPUBFUN void XMLCALL		xmlFreeURI		(xmlURIPtr uri);
-xmlChar*	xmlCanonicPath		(const xmlChar *path);
+XMLPUBFUN xmlChar* XMLCALL	xmlCanonicPath		(const xmlChar *path);
 
 #ifdef __cplusplus
 }

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 struct _xmlHashTable xmlRefTable;
 typedef xmlRefTable *xmlRefTablePtr;
 
 /* Allocate/Release Validation Contexts */
-xmlValidCtxtPtr	    xmlNewValidCtxt(void);
+XMLPUBFUN xmlValidCtxtPtr XMLCALL	    xmlNewValidCtxt(void);
-void		    xmlFreeValidCtxt(xmlValidCtxtPtr);
+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);
+XMLPUBFUN xmlNotationTablePtr XMLCALL xmlCopyNotationTable(xmlNotationTablePtr table);
-void		    xmlFreeNotationTable(xmlNotationTablePtr table);
+XMLPUBFUN void XMLCALL		    xmlFreeNotationTable(xmlNotationTablePtr table);
-void		    xmlDumpNotationDecl	(xmlBufferPtr buf,
+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);
+XMLPUBFUN xmlElementContentPtr XMLCALL xmlCopyElementContent(xmlElementContentPtr content);
-void		     xmlFreeElementContent(xmlElementContentPtr cur);
+XMLPUBFUN void XMLCALL		     xmlFreeElementContent(xmlElementContentPtr cur);
-void		     xmlSnprintfElementContent(char *buf,
+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);
+XMLPUBFUN xmlElementTablePtr XMLCALL xmlCopyElementTable	(xmlElementTablePtr table);
-void		   xmlFreeElementTable	(xmlElementTablePtr table);
+XMLPUBFUN void XMLCALL		   xmlFreeElementTable	(xmlElementTablePtr table);
-void		   xmlDumpElementTable	(xmlBufferPtr buf,
+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);
+XMLPUBFUN xmlEnumerationPtr XMLCALL  xmlCreateEnumeration	(const xmlChar *name);
-void		   xmlFreeEnumeration	(xmlEnumerationPtr cur);
+XMLPUBFUN void XMLCALL		   xmlFreeEnumeration	(xmlEnumerationPtr cur);
-xmlEnumerationPtr  xmlCopyEnumeration	(xmlEnumerationPtr cur);
+XMLPUBFUN xmlEnumerationPtr XMLCALL  xmlCopyEnumeration	(xmlEnumerationPtr cur);
 
 /* Attribute */
-xmlAttributePtr	    xmlAddAttributeDecl	    (xmlValidCtxtPtr ctxt,
+XMLPUBFUN xmlAttributePtr XMLCALL	    xmlAddAttributeDecl	    (xmlValidCtxtPtr ctxt,
 					     xmlDtdPtr dtd,
 					     const xmlChar *elem,
 					     const xmlChar *name,
@@ -187,139 +189,139 @@ xmlAttributePtr	    xmlAddAttributeDecl	    (xmlValidCtxtPtr ctxt,
 					     xmlAttributeDefault def,
 					     const xmlChar *defaultValue,
 					     xmlEnumerationPtr tree);
-xmlAttributeTablePtr xmlCopyAttributeTable  (xmlAttributeTablePtr table);
+XMLPUBFUN xmlAttributeTablePtr XMLCALL xmlCopyAttributeTable  (xmlAttributeTablePtr table);
-void		     xmlFreeAttributeTable  (xmlAttributeTablePtr table);
+XMLPUBFUN void XMLCALL		     xmlFreeAttributeTable  (xmlAttributeTablePtr table);
-void		     xmlDumpAttributeTable  (xmlBufferPtr buf,
+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);
+XMLPUBFUN void XMLCALL		xmlFreeIDTable	(xmlIDTablePtr table);
-xmlAttrPtr	xmlGetID	(xmlDocPtr doc,
+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);
+XMLPUBFUN void XMLCALL		xmlFreeRefTable	(xmlRefTablePtr table);
-int		xmlIsRef	(xmlDocPtr doc,
+XMLPUBFUN int XMLCALL		xmlIsRef	(xmlDocPtr doc,
 				 xmlNodePtr elem,
 				 xmlAttrPtr attr);
-int		xmlRemoveRef	(xmlDocPtr doc, xmlAttrPtr attr);
+XMLPUBFUN int XMLCALL		xmlRemoveRef	(xmlDocPtr doc, xmlAttrPtr attr);
-xmlListPtr	xmlGetRefs	(xmlDocPtr doc,
+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);
+XMLPUBFUN int XMLCALL		xmlValidateNameValue	(const xmlChar *value);
-int		xmlValidateNamesValue	(const xmlChar *value);
+XMLPUBFUN int XMLCALL		xmlValidateNamesValue	(const xmlChar *value);
-int		xmlValidateNmtokenValue	(const xmlChar *value);
+XMLPUBFUN int XMLCALL		xmlValidateNmtokenValue	(const xmlChar *value);
-int		xmlValidateNmtokensValue(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);

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);
+XMLPUBFUN int XMLCALL	xmlXIncludeProcess	(xmlDocPtr doc);
-int	xmlXIncludeProcessTree	(xmlNodePtr tree);
+XMLPUBFUN int XMLCALL	xmlXIncludeProcessTree	(xmlNodePtr tree);
 
 #ifdef __cplusplus
 }

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 @@ struct _xlinkHandler {
  * detection callbacks. 
  */
 
-xlinkNodeDetectFunc	xlinkGetDefaultDetect	(void);
+XMLPUBFUN xlinkNodeDetectFunc XMLCALL	xlinkGetDefaultDetect	(void);
-void			xlinkSetDefaultDetect	(xlinkNodeDetectFunc func);
+XMLPUBFUN void XMLCALL			xlinkSetDefaultDetect	(xlinkNodeDetectFunc func);
 
 /*
  * Routines to set/get the default handlers.
  */
-xlinkHandlerPtr	xlinkGetDefaultHandler	(void);
+XMLPUBFUN xlinkHandlerPtr XMLCALL	xlinkGetDefaultHandler	(void);
-void		xlinkSetDefaultHandler	(xlinkHandlerPtr handler);
+XMLPUBFUN void XMLCALL		xlinkSetDefaultHandler	(xlinkHandlerPtr handler);
 
 /*
  * Link detection module itself.
  */
-xlinkType	 xlinkIsLink		(xmlDocPtr doc,
+XMLPUBFUN xlinkType XMLCALL	 xlinkIsLink		(xmlDocPtr doc,
 					 xmlNodePtr node);
 
 #ifdef __cplusplus

include/libxml/xmlIO.h

@@ -147,95 +147,95 @@ struct _xmlOutputBuffer {
 /*
  * Interfaces for input
  */
-void	xmlCleanupInputCallbacks		(void);
+XMLPUBFUN void XMLCALL	xmlCleanupInputCallbacks		(void);
-void	xmlCleanupOutputCallbacks		(void);
+XMLPUBFUN void XMLCALL	xmlCleanupOutputCallbacks		(void);
 
-void	xmlRegisterDefaultInputCallbacks	(void);
+XMLPUBFUN void XMLCALL	xmlRegisterDefaultInputCallbacks	(void);
-xmlParserInputBufferPtr
+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);
+XMLPUBFUN void XMLCALL	xmlFreeParserInputBuffer		(xmlParserInputBufferPtr in);
-char *	xmlParserGetDirectory			(const char *filename);
+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);
+XMLPUBFUN void XMLCALL	xmlRegisterDefaultOutputCallbacks(void);
-xmlOutputBufferPtr
+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);
+XMLPUBFUN int XMLCALL	xmlOutputBufferFlush		(xmlOutputBufferPtr out);
-int	xmlOutputBufferClose		(xmlOutputBufferPtr out);
+XMLPUBFUN int XMLCALL	xmlOutputBufferClose		(xmlOutputBufferPtr out);
 
-int     xmlRegisterOutputCallbacks	(xmlOutputMatchCallback matchFunc,
+XMLPUBFUN int XMLCALL     xmlRegisterOutputCallbacks	(xmlOutputMatchCallback matchFunc,
 					 xmlOutputOpenCallback openFunc,
 					 xmlOutputWriteCallback writeFunc,
 					 xmlOutputCloseCallback closeFunc);
 
 /*  This function only exists if HTTP support built into the library  */
 #ifdef LIBXML_HTTP_ENABLED
-void *	xmlIOHTTPOpenW			(const char * post_uri,
+XMLPUBFUN void * XMLCALL	xmlIOHTTPOpenW			(const char * post_uri,
 					 int   compression );
-void	xmlRegisterHTTPPostCallbacks	(void );
+XMLPUBFUN void XMLCALL	xmlRegisterHTTPPostCallbacks	(void );
 #endif
 
 /*
  * A predefined entity loader disabling network accesses
  */
-xmlParserInputPtr xmlNoNetExternalEntityLoader(const char *URL,
+XMLPUBFUN xmlParserInputPtr XMLCALL xmlNoNetExternalEntityLoader(const char *URL,
 					 const char *ID,
 					 xmlParserCtxtPtr ctxt);
 
@@ -243,41 +243,41 @@ xmlParserInputPtr xmlNoNetExternalEntityLoader(const char *URL,
  * xmlNormalizeWindowsPath is obsolete, don't use it. 
  * Check xmlCanonicPath in uri.h for a better alternative.
  */
-xmlChar * xmlNormalizeWindowsPath	(const xmlChar *path);
+XMLPUBFUN xmlChar * XMLCALL xmlNormalizeWindowsPath	(const xmlChar *path);
 
-int	xmlCheckFilename		(const char *path);
+XMLPUBFUN int XMLCALL	xmlCheckFilename		(const char *path);
 /**
  * Default 'file://' protocol callbacks 
  */
-int	xmlFileMatch 			(const char *filename);
+XMLPUBFUN int XMLCALL	xmlFileMatch 			(const char *filename);
-void *	xmlFileOpen 			(const char *filename);
+XMLPUBFUN void * XMLCALL	xmlFileOpen 			(const char *filename);
-int	xmlFileRead 			(void * context, 
+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);
+XMLPUBFUN int XMLCALL	xmlIOHTTPMatch 			(const char *filename);
-void *	xmlIOHTTPOpen 			(const char *filename);
+XMLPUBFUN void * XMLCALL	xmlIOHTTPOpen 			(const char *filename);
-int 	xmlIOHTTPRead			(void * context, 
+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);
+XMLPUBFUN int XMLCALL	xmlIOFTPMatch 			(const char *filename);
-void *	xmlIOFTPOpen 			(const char *filename);
+XMLPUBFUN void * XMLCALL	xmlIOFTPOpen 			(const char *filename);
-int 	xmlIOFTPRead			(void * context, 
+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

include/libxml/xmlautomata.h

@@ -38,59 +38,59 @@ typedef xmlAutomataState *xmlAutomataStatePtr;
 /*
  * Building API
  */
-xmlAutomataPtr		xmlNewAutomata		(void);
+XMLPUBFUN xmlAutomataPtr XMLCALL		xmlNewAutomata		(void);
-void			xmlFreeAutomata		(xmlAutomataPtr am);
+XMLPUBFUN void XMLCALL			xmlFreeAutomata		(xmlAutomataPtr am);
 
-xmlAutomataStatePtr	xmlAutomataGetInitState	(xmlAutomataPtr am);
+XMLPUBFUN xmlAutomataStatePtr XMLCALL	xmlAutomataGetInitState	(xmlAutomataPtr am);
-int			xmlAutomataSetFinalState(xmlAutomataPtr am,
+XMLPUBFUN int XMLCALL			xmlAutomataSetFinalState(xmlAutomataPtr am,
 						 xmlAutomataStatePtr state);
-xmlAutomataStatePtr	xmlAutomataNewState	(xmlAutomataPtr am);
+XMLPUBFUN xmlAutomataStatePtr XMLCALL	xmlAutomataNewState	(xmlAutomataPtr am);
-xmlAutomataStatePtr	xmlAutomataNewTransition(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);
+XMLPUBFUN xmlRegexpPtr XMLCALL		xmlAutomataCompile	(xmlAutomataPtr am);
-int	    		xmlAutomataIsDeterminist(xmlAutomataPtr am);
+XMLPUBFUN int XMLCALL	    		xmlAutomataIsDeterminist(xmlAutomataPtr am);
 
 #ifdef __cplusplus
 }

include/libxml/xmlerror.h

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

include/libxml/xmlmemory.h

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

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 @@ typedef xmlTextReader *xmlTextReaderPtr;
 /*
  * Constructors & Destructor
  */
-xmlTextReaderPtr	xmlNewTextReader	(xmlParserInputBufferPtr input,
+XMLPUBFUN xmlTextReaderPtr XMLCALL
+			xmlNewTextReader	(xmlParserInputBufferPtr input,
 	                                         const char *URI);
-xmlTextReaderPtr	xmlNewTextReaderFilename(const char *URI);
+XMLPUBFUN xmlTextReaderPtr XMLCALL	xmlNewTextReaderFilename(const char *URI);
-void			xmlFreeTextReader	(xmlTextReaderPtr reader);
+XMLPUBFUN void XMLCALL			xmlFreeTextReader	(xmlTextReaderPtr reader);
 
 /*
  * Iterators
  */
-int		xmlTextReaderRead	(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		xmlTextReaderRead	(xmlTextReaderPtr reader);
-xmlChar *	xmlTextReaderReadInnerXml	(xmlTextReaderPtr reader);
+XMLPUBFUN xmlChar * XMLCALL	xmlTextReaderReadInnerXml	(xmlTextReaderPtr reader);
-xmlChar *	xmlTextReaderReadOuterXml	(xmlTextReaderPtr reader);
+XMLPUBFUN xmlChar * XMLCALL	xmlTextReaderReadOuterXml	(xmlTextReaderPtr reader);
-xmlChar *	xmlTextReaderReadString		(xmlTextReaderPtr reader);
+XMLPUBFUN xmlChar * XMLCALL	xmlTextReaderReadString		(xmlTextReaderPtr reader);
-int		xmlTextReaderReadAttributeValue	(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		xmlTextReaderReadAttributeValue	(xmlTextReaderPtr reader);
 
 /*
  * Attributes of the node
  */
-int		xmlTextReaderAttributeCount(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		xmlTextReaderAttributeCount(xmlTextReaderPtr reader);
-xmlChar *	xmlTextReaderBaseUri	(xmlTextReaderPtr reader);
+XMLPUBFUN xmlChar * XMLCALL	xmlTextReaderBaseUri	(xmlTextReaderPtr reader);
-int		xmlTextReaderDepth	(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		xmlTextReaderDepth	(xmlTextReaderPtr reader);
-int		xmlTextReaderHasAttributes(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		xmlTextReaderHasAttributes(xmlTextReaderPtr reader);
-int		xmlTextReaderHasValue(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		xmlTextReaderHasValue(xmlTextReaderPtr reader);
-int		xmlTextReaderIsDefault	(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		xmlTextReaderIsDefault	(xmlTextReaderPtr reader);
-int		xmlTextReaderIsEmptyElement(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		xmlTextReaderIsEmptyElement(xmlTextReaderPtr reader);
-xmlChar *	xmlTextReaderLocalName	(xmlTextReaderPtr reader);
+XMLPUBFUN xmlChar * XMLCALL	xmlTextReaderLocalName	(xmlTextReaderPtr reader);
-xmlChar *	xmlTextReaderName	(xmlTextReaderPtr reader);
+XMLPUBFUN xmlChar * XMLCALL	xmlTextReaderName	(xmlTextReaderPtr reader);
-xmlChar *	xmlTextReaderNamespaceUri(xmlTextReaderPtr reader);
+XMLPUBFUN xmlChar * XMLCALL	xmlTextReaderNamespaceUri(xmlTextReaderPtr reader);
-int		xmlTextReaderNodeType	(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		xmlTextReaderNodeType	(xmlTextReaderPtr reader);
-xmlChar *	xmlTextReaderPrefix	(xmlTextReaderPtr reader);
+XMLPUBFUN xmlChar * XMLCALL	xmlTextReaderPrefix	(xmlTextReaderPtr reader);
-int		xmlTextReaderQuoteChar	(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		xmlTextReaderQuoteChar	(xmlTextReaderPtr reader);
-xmlChar *	xmlTextReaderValue	(xmlTextReaderPtr reader);
+XMLPUBFUN xmlChar * XMLCALL	xmlTextReaderValue	(xmlTextReaderPtr reader);
-xmlChar *	xmlTextReaderXmlLang	(xmlTextReaderPtr reader);
+XMLPUBFUN xmlChar * XMLCALL	xmlTextReaderXmlLang	(xmlTextReaderPtr reader);
-int		xmlTextReaderReadState	(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		xmlTextReaderReadState	(xmlTextReaderPtr reader);
 
 /*
  * Methods of the XmlTextReader
  */
-int		xmlTextReaderClose		(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		xmlTextReaderClose		(xmlTextReaderPtr reader);
-xmlChar *	xmlTextReaderGetAttributeNo	(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);
+XMLPUBFUN xmlParserInputBufferPtr XMLCALL xmlTextReaderGetRemainder(xmlTextReaderPtr reader);
-xmlChar *	xmlTextReaderLookupNamespace	(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);
+XMLPUBFUN int XMLCALL		xmlTextReaderMoveToFirstAttribute(xmlTextReaderPtr reader);
-int		xmlTextReaderMoveToNextAttribute(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		xmlTextReaderMoveToNextAttribute(xmlTextReaderPtr reader);
-int		xmlTextReaderMoveToElement	(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		xmlTextReaderMoveToElement	(xmlTextReaderPtr reader);
-int		xmlTextReaderNormalization	(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);
+XMLPUBFUN xmlNodePtr XMLCALL	xmlTextReaderCurrentNode	(xmlTextReaderPtr reader);
-xmlDocPtr	xmlTextReaderCurrentDoc		(xmlTextReaderPtr reader);
+XMLPUBFUN xmlDocPtr XMLCALL	xmlTextReaderCurrentDoc		(xmlTextReaderPtr reader);
-xmlNodePtr	xmlTextReaderExpand		(xmlTextReaderPtr reader);
+XMLPUBFUN xmlNodePtr XMLCALL	xmlTextReaderExpand		(xmlTextReaderPtr reader);
-int		xmlTextReaderNext		(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		xmlTextReaderNext		(xmlTextReaderPtr reader);
-int		xmlTextReaderIsValid		(xmlTextReaderPtr reader);
+XMLPUBFUN int XMLCALL		xmlTextReaderIsValid		(xmlTextReaderPtr reader);
 #ifdef LIBXML_SCHEMAS_ENABLED
-int		xmlTextReaderRelaxNGValidate	(xmlTextReaderPtr reader,
+XMLPUBFUN int XMLCALL		xmlTextReaderRelaxNGValidate	(xmlTextReaderPtr reader,
 						 const char *rng);
-int		xmlTextReaderRelaxNGSetSchema	(xmlTextReaderPtr reader,
+XMLPUBFUN int XMLCALL		xmlTextReaderRelaxNGSetSchema	(xmlTextReaderPtr reader,
 						 xmlRelaxNGPtr schema);
 #endif
 
@@ -148,13 +150,13 @@ typedef void   (*xmlTextReaderErrorFunc)        (void *arg,
 						 const char *msg,
 						 xmlParserSeverities severity,
 						 xmlTextReaderLocatorPtr locator);
-int             xmlTextReaderLocatorLineNumber  (xmlTextReaderLocatorPtr locator);
+XMLPUBFUN int XMLCALL             xmlTextReaderLocatorLineNumber  (xmlTextReaderLocatorPtr locator);
 /*int             xmlTextReaderLocatorLinePosition(xmlTextReaderLocatorPtr locator);*/
-xmlChar *       xmlTextReaderLocatorBaseURI     (xmlTextReaderLocatorPtr locator);
+XMLPUBFUN xmlChar * XMLCALL       xmlTextReaderLocatorBaseURI     (xmlTextReaderLocatorPtr locator);
-void            xmlTextReaderSetErrorHandler    (xmlTextReaderPtr reader, 
+XMLPUBFUN void XMLCALL            xmlTextReaderSetErrorHandler    (xmlTextReaderPtr reader, 
 						 xmlTextReaderErrorFunc f, 
 						 void *arg);
-void            xmlTextReaderGetErrorHandler    (xmlTextReaderPtr reader, 
+XMLPUBFUN void XMLCALL            xmlTextReaderGetErrorHandler    (xmlTextReaderPtr reader, 
 						 xmlTextReaderErrorFunc *f, 
 						 void **arg);
 

include/libxml/xmlregexp.h

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

include/libxml/xmlschemas.h

@@ -72,30 +72,30 @@ typedef xmlSchemaValidCtxt *xmlSchemaValidCtxtPtr;
 /*
  * Interfaces for parsing.
  */
-xmlSchemaParserCtxtPtr xmlSchemaNewParserCtxt	(const char *URL);
+XMLPUBFUN xmlSchemaParserCtxtPtr XMLCALL xmlSchemaNewParserCtxt	(const char *URL);
-xmlSchemaParserCtxtPtr xmlSchemaNewMemParserCtxt(const char *buffer,
+XMLPUBFUN xmlSchemaParserCtxtPtr XMLCALL xmlSchemaNewMemParserCtxt(const char *buffer,
 						 int size);
-void		xmlSchemaFreeParserCtxt	(xmlSchemaParserCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL		xmlSchemaFreeParserCtxt	(xmlSchemaParserCtxtPtr ctxt);
-void		xmlSchemaSetParserErrors(xmlSchemaParserCtxtPtr ctxt,
+XMLPUBFUN void XMLCALL		xmlSchemaSetParserErrors(xmlSchemaParserCtxtPtr ctxt,
 					 xmlSchemaValidityErrorFunc err,
 					 xmlSchemaValidityWarningFunc warn,
 					 void *ctx);
-xmlSchemaPtr	xmlSchemaParse		(xmlSchemaParserCtxtPtr ctxt);
+XMLPUBFUN xmlSchemaPtr XMLCALL	xmlSchemaParse		(xmlSchemaParserCtxtPtr ctxt);
-void		xmlSchemaFree		(xmlSchemaPtr schema);
+XMLPUBFUN void XMLCALL		xmlSchemaFree		(xmlSchemaPtr schema);
-void		xmlSchemaDump		(FILE *output,
+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);
+XMLPUBFUN xmlSchemaValidCtxtPtr XMLCALL	xmlSchemaNewValidCtxt	(xmlSchemaPtr schema);
-void			xmlSchemaFreeValidCtxt	(xmlSchemaValidCtxtPtr ctxt);
+XMLPUBFUN void XMLCALL			xmlSchemaFreeValidCtxt	(xmlSchemaValidCtxtPtr ctxt);
-int			xmlSchemaValidateDoc	(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,

include/libxml/xmlschemastypes.h

@@ -22,29 +22,29 @@
 extern "C" {
 #endif
 
-void		xmlSchemaInitTypes		(void);
+XMLPUBFUN void XMLCALL		xmlSchemaInitTypes		(void);
-void		xmlSchemaCleanupTypes		(void);
+XMLPUBFUN void XMLCALL		xmlSchemaCleanupTypes		(void);
-xmlSchemaTypePtr xmlSchemaGetPredefinedType	(const xmlChar *name,
+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);
+XMLPUBFUN void XMLCALL		xmlSchemaFreeValue		(xmlSchemaValPtr val);
-xmlSchemaFacetPtr xmlSchemaNewFacet		(void);
+XMLPUBFUN xmlSchemaFacetPtr XMLCALL xmlSchemaNewFacet		(void);
-int		xmlSchemaCheckFacet		(xmlSchemaFacetPtr facet,
+XMLPUBFUN int XMLCALL		xmlSchemaCheckFacet		(xmlSchemaFacetPtr facet,
 						 xmlSchemaTypePtr typeDecl,
 						 xmlSchemaParserCtxtPtr ctxt,
 						 const xmlChar *name);
-void		xmlSchemaFreeFacet		(xmlSchemaFacetPtr facet);
+XMLPUBFUN void XMLCALL		xmlSchemaFreeFacet		(xmlSchemaFacetPtr facet);
-int		xmlSchemaCompareValues		(xmlSchemaValPtr x,
+XMLPUBFUN int XMLCALL		xmlSchemaCompareValues		(xmlSchemaValPtr x,
 						 xmlSchemaValPtr y);
 
 #ifdef __cplusplus

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);
+XMLPUBFUN int XMLCALL xmlUCSIsAlphabeticPresentationForms	(int code);
-int	xmlUCSIsArabic	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsArabic	(int code);
-int	xmlUCSIsArabicPresentationFormsA	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsArabicPresentationFormsA	(int code);
-int	xmlUCSIsArabicPresentationFormsB	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsArabicPresentationFormsB	(int code);
-int	xmlUCSIsArmenian	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsArmenian	(int code);
-int	xmlUCSIsArrows	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsArrows	(int code);
-int	xmlUCSIsBasicLatin	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsBasicLatin	(int code);
-int	xmlUCSIsBengali	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsBengali	(int code);
-int	xmlUCSIsBlockElements	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsBlockElements	(int code);
-int	xmlUCSIsBopomofo	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsBopomofo	(int code);
-int	xmlUCSIsBopomofoExtended	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsBopomofoExtended	(int code);
-int	xmlUCSIsBoxDrawing	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsBoxDrawing	(int code);
-int	xmlUCSIsBraillePatterns	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsBraillePatterns	(int code);
-int	xmlUCSIsByzantineMusicalSymbols	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsByzantineMusicalSymbols	(int code);
-int	xmlUCSIsCJKCompatibility	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCJKCompatibility	(int code);
-int	xmlUCSIsCJKCompatibilityForms	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCJKCompatibilityForms	(int code);
-int	xmlUCSIsCJKCompatibilityIdeographs	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCJKCompatibilityIdeographs	(int code);
-int	xmlUCSIsCJKCompatibilityIdeographsSupplement	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCJKCompatibilityIdeographsSupplement	(int code);
-int	xmlUCSIsCJKRadicalsSupplement	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCJKRadicalsSupplement	(int code);
-int	xmlUCSIsCJKSymbolsandPunctuation	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCJKSymbolsandPunctuation	(int code);
-int	xmlUCSIsCJKUnifiedIdeographs	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCJKUnifiedIdeographs	(int code);
-int	xmlUCSIsCJKUnifiedIdeographsExtensionA	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCJKUnifiedIdeographsExtensionA	(int code);
-int	xmlUCSIsCJKUnifiedIdeographsExtensionB	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCJKUnifiedIdeographsExtensionB	(int code);
-int	xmlUCSIsCherokee	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCherokee	(int code);
-int	xmlUCSIsCombiningDiacriticalMarks	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCombiningDiacriticalMarks	(int code);
-int	xmlUCSIsCombiningHalfMarks	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCombiningHalfMarks	(int code);
-int	xmlUCSIsCombiningMarksforSymbols	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCombiningMarksforSymbols	(int code);
-int	xmlUCSIsControlPictures	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsControlPictures	(int code);
-int	xmlUCSIsCurrencySymbols	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCurrencySymbols	(int code);
-int	xmlUCSIsCyrillic	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCyrillic	(int code);
-int	xmlUCSIsDeseret	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsDeseret	(int code);
-int	xmlUCSIsDevanagari	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsDevanagari	(int code);
-int	xmlUCSIsDingbats	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsDingbats	(int code);
-int	xmlUCSIsEnclosedAlphanumerics	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsEnclosedAlphanumerics	(int code);
-int	xmlUCSIsEnclosedCJKLettersandMonths	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsEnclosedCJKLettersandMonths	(int code);
-int	xmlUCSIsEthiopic	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsEthiopic	(int code);
-int	xmlUCSIsGeneralPunctuation	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsGeneralPunctuation	(int code);
-int	xmlUCSIsGeometricShapes	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsGeometricShapes	(int code);
-int	xmlUCSIsGeorgian	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsGeorgian	(int code);
-int	xmlUCSIsGothic	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsGothic	(int code);
-int	xmlUCSIsGreek	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsGreek	(int code);
-int	xmlUCSIsGreekExtended	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsGreekExtended	(int code);
-int	xmlUCSIsGujarati	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsGujarati	(int code);
-int	xmlUCSIsGurmukhi	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsGurmukhi	(int code);
-int	xmlUCSIsHalfwidthandFullwidthForms	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsHalfwidthandFullwidthForms	(int code);
-int	xmlUCSIsHangulCompatibilityJamo	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsHangulCompatibilityJamo	(int code);
-int	xmlUCSIsHangulJamo	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsHangulJamo	(int code);
-int	xmlUCSIsHangulSyllables	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsHangulSyllables	(int code);
-int	xmlUCSIsHebrew	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsHebrew	(int code);
-int	xmlUCSIsHighPrivateUseSurrogates	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsHighPrivateUseSurrogates	(int code);
-int	xmlUCSIsHighSurrogates	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsHighSurrogates	(int code);
-int	xmlUCSIsHiragana	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsHiragana	(int code);
-int	xmlUCSIsIPAExtensions	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsIPAExtensions	(int code);
-int	xmlUCSIsIdeographicDescriptionCharacters	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsIdeographicDescriptionCharacters	(int code);
-int	xmlUCSIsKanbun	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsKanbun	(int code);
-int	xmlUCSIsKangxiRadicals	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsKangxiRadicals	(int code);
-int	xmlUCSIsKannada	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsKannada	(int code);
-int	xmlUCSIsKatakana	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsKatakana	(int code);
-int	xmlUCSIsKhmer	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsKhmer	(int code);
-int	xmlUCSIsLao	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsLao	(int code);
-int	xmlUCSIsLatin1Supplement	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsLatin1Supplement	(int code);
-int	xmlUCSIsLatinExtendedA	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsLatinExtendedA	(int code);
-int	xmlUCSIsLatinExtendedB	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsLatinExtendedB	(int code);
-int	xmlUCSIsLatinExtendedAdditional	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsLatinExtendedAdditional	(int code);
-int	xmlUCSIsLetterlikeSymbols	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsLetterlikeSymbols	(int code);
-int	xmlUCSIsLowSurrogates	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsLowSurrogates	(int code);
-int	xmlUCSIsMalayalam	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsMalayalam	(int code);
-int	xmlUCSIsMathematicalAlphanumericSymbols	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsMathematicalAlphanumericSymbols	(int code);
-int	xmlUCSIsMathematicalOperators	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsMathematicalOperators	(int code);
-int	xmlUCSIsMiscellaneousSymbols	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsMiscellaneousSymbols	(int code);
-int	xmlUCSIsMiscellaneousTechnical	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsMiscellaneousTechnical	(int code);
-int	xmlUCSIsMongolian	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsMongolian	(int code);
-int	xmlUCSIsMusicalSymbols	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsMusicalSymbols	(int code);
-int	xmlUCSIsMyanmar	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsMyanmar	(int code);
-int	xmlUCSIsNumberForms	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsNumberForms	(int code);
-int	xmlUCSIsOgham	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsOgham	(int code);
-int	xmlUCSIsOldItalic	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsOldItalic	(int code);
-int	xmlUCSIsOpticalCharacterRecognition	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsOpticalCharacterRecognition	(int code);
-int	xmlUCSIsOriya	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsOriya	(int code);
-int	xmlUCSIsPrivateUse	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsPrivateUse	(int code);
-int	xmlUCSIsRunic	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsRunic	(int code);
-int	xmlUCSIsSinhala	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsSinhala	(int code);
-int	xmlUCSIsSmallFormVariants	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsSmallFormVariants	(int code);
-int	xmlUCSIsSpacingModifierLetters	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsSpacingModifierLetters	(int code);
-int	xmlUCSIsSpecials	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsSpecials	(int code);
-int	xmlUCSIsSuperscriptsandSubscripts	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsSuperscriptsandSubscripts	(int code);
-int	xmlUCSIsSyriac	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsSyriac	(int code);
-int	xmlUCSIsTags	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsTags	(int code);
-int	xmlUCSIsTamil	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsTamil	(int code);
-int	xmlUCSIsTelugu	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsTelugu	(int code);
-int	xmlUCSIsThaana	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsThaana	(int code);
-int	xmlUCSIsThai	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsThai	(int code);
-int	xmlUCSIsTibetan	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsTibetan	(int code);
-int	xmlUCSIsUnifiedCanadianAboriginalSyllabics	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsUnifiedCanadianAboriginalSyllabics	(int code);
-int	xmlUCSIsYiRadicals	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsYiRadicals	(int code);
-int	xmlUCSIsYiSyllables	(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);
+XMLPUBFUN int XMLCALL xmlUCSIsCatC	(int code);
-int	xmlUCSIsCatCc	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatCc	(int code);
-int	xmlUCSIsCatCf	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatCf	(int code);
-int	xmlUCSIsCatCo	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatCo	(int code);
-int	xmlUCSIsCatCs	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatCs	(int code);
-int	xmlUCSIsCatL	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatL	(int code);
-int	xmlUCSIsCatLl	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatLl	(int code);
-int	xmlUCSIsCatLm	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatLm	(int code);
-int	xmlUCSIsCatLo	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatLo	(int code);
-int	xmlUCSIsCatLt	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatLt	(int code);
-int	xmlUCSIsCatLu	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatLu	(int code);
-int	xmlUCSIsCatM	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatM	(int code);
-int	xmlUCSIsCatMc	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatMc	(int code);
-int	xmlUCSIsCatMe	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatMe	(int code);
-int	xmlUCSIsCatMn	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatMn	(int code);
-int	xmlUCSIsCatN	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatN	(int code);
-int	xmlUCSIsCatNd	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatNd	(int code);
-int	xmlUCSIsCatNl	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatNl	(int code);
-int	xmlUCSIsCatNo	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatNo	(int code);
-int	xmlUCSIsCatP	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatP	(int code);
-int	xmlUCSIsCatPc	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatPc	(int code);
-int	xmlUCSIsCatPd	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatPd	(int code);
-int	xmlUCSIsCatPe	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatPe	(int code);
-int	xmlUCSIsCatPf	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatPf	(int code);
-int	xmlUCSIsCatPi	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatPi	(int code);
-int	xmlUCSIsCatPo	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatPo	(int code);
-int	xmlUCSIsCatPs	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatPs	(int code);
-int	xmlUCSIsCatS	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatS	(int code);
-int	xmlUCSIsCatSc	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatSc	(int code);
-int	xmlUCSIsCatSk	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatSk	(int code);
-int	xmlUCSIsCatSm	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatSm	(int code);
-int	xmlUCSIsCatSo	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatSo	(int code);
-int	xmlUCSIsCatZ	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatZ	(int code);
-int	xmlUCSIsCatZl	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatZl	(int code);
-int	xmlUCSIsCatZp	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatZp	(int code);
-int	xmlUCSIsCatZs	(int code);
+XMLPUBFUN int XMLCALL xmlUCSIsCatZs	(int code);
 
-int	xmlUCSIsCat	(int code,
+XMLPUBFUN int XMLCALL xmlUCSIsCat	(int code,
 			 const char *cat);
 
 #ifdef __cplusplus

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 @@ extern "C" {
  * your library and includes mismatch
  */
 #ifndef LIBXML2_COMPILING_MSCCDEF
-extern void xmlCheckVersion(int version);
+XMLPUBFUN void XMLCALL xmlCheckVersion(int version);
 #endif /* LIBXML2_COMPILING_MSCCDEF */
 
 /**
@@ -234,29 +307,6 @@ extern void xmlCheckVersion(int version);
 #define LIBXML_SCHEMAS_ENABLED
 #endif
 
-/**
- * LIBXML_DLL_IMPORT:
- *
- * Used on Windows (MS C compiler only) to declare a variable as 
- * imported from the library. This macro should be empty when compiling
- * libxml itself. It should expand to __declspec(dllimport)
- * when the client code includes this header, and that only if the client
- * links dynamically against libxml.
- * For this to work, we need three macros. One tells us which compiler is
- * being used and luckily the compiler defines such a thing: _MSC_VER. The
- * second macro tells us if we are compiling libxml or the client code and
- * we define the macro IN_LIBXML on the compiler's command line for this 
- * purpose. The third macro, LIBXML_STATIC, must be defined by any client 
- * code which links against libxml statically. 
- */
-#ifndef LIBXML_DLL_IMPORT
-#if (defined(_MSC_VER) || defined(__BORLANDC__) || defined(__CYGWIN__)) && !defined(IN_LIBXML) && !defined(LIBXML_STATIC)
-#define LIBXML_DLL_IMPORT __declspec(dllimport)
-#else
-#define LIBXML_DLL_IMPORT
-#endif
-#endif
-
 /**
  * ATTRIBUTE_UNUSED:
  *

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

include/libxml/xpathInternals.h

@@ -96,11 +96,11 @@ extern "C" {
  */
 #define xmlXPathGetContextNode(ctxt)	((ctxt)->context->node)
 
-int		xmlXPathPopBoolean	(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN int XMLCALL		xmlXPathPopBoolean	(xmlXPathParserContextPtr ctxt);
-double		xmlXPathPopNumber	(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN double XMLCALL		xmlXPathPopNumber	(xmlXPathParserContextPtr ctxt);
-xmlChar *	xmlXPathPopString	(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL	xmlXPathPopString	(xmlXPathParserContextPtr ctxt);
-xmlNodeSetPtr	xmlXPathPopNodeSet	(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN xmlNodeSetPtr XMLCALL	xmlXPathPopNodeSet	(xmlXPathParserContextPtr ctxt);
-void *		xmlXPathPopExternal	(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN void * XMLCALL		xmlXPathPopExternal	(xmlXPathParserContextPtr ctxt);
 
 /**
  * xmlXPathReturnBoolean:
@@ -335,7 +335,7 @@ typedef xmlXPathObjectPtr (*xmlXPathVariableLookupFunc) (void *ctxt,
 					 const xmlChar *name,
 					 const xmlChar *ns_uri);
 
-void	xmlXPathRegisterVariableLookup	(xmlXPathContextPtr ctxt,
+XMLPUBFUN void XMLCALL	xmlXPathRegisterVariableLookup	(xmlXPathContextPtr ctxt,
 					 xmlXPathVariableLookupFunc f,
 					 void *data);
 
@@ -357,57 +357,57 @@ typedef xmlXPathFunction (*xmlXPathFuncLookupFunc) (void *ctxt,
 					 const xmlChar *name,
 					 const xmlChar *ns_uri);
 
-void	xmlXPathRegisterFuncLookup	(xmlXPathContextPtr ctxt,
+XMLPUBFUN void XMLCALL	xmlXPathRegisterFuncLookup	(xmlXPathContextPtr ctxt,
 					 xmlXPathFuncLookupFunc f,
 					 void *funcCtxt);
 
 /*
  * Error reporting.
  */
-void		xmlXPatherror	(xmlXPathParserContextPtr ctxt,
+XMLPUBFUN void XMLCALL		xmlXPatherror	(xmlXPathParserContextPtr ctxt,
 				 const char *file,
 				 int line,
 				 int no);
 
-void		xmlXPathDebugDumpObject	(FILE *output,
+XMLPUBFUN void XMLCALL		xmlXPathDebugDumpObject	(FILE *output,
 					 xmlXPathObjectPtr cur,
 					 int depth);
-void		xmlXPathDebugDumpCompExpr(FILE *output,
+XMLPUBFUN void XMLCALL		xmlXPathDebugDumpCompExpr(FILE *output,
 					 xmlXPathCompExprPtr comp,
 					 int depth);
 
 /**
  * NodeSet handling.
  */
-int		xmlXPathNodeSetContains		(xmlNodeSetPtr cur,
+XMLPUBFUN int XMLCALL		xmlXPathNodeSetContains		(xmlNodeSetPtr cur,
 						 xmlNodePtr val);
-xmlNodeSetPtr	xmlXPathDifference		(xmlNodeSetPtr nodes1,
+XMLPUBFUN xmlNodeSetPtr XMLCALL	xmlXPathDifference		(xmlNodeSetPtr nodes1,
 						 xmlNodeSetPtr nodes2);
-xmlNodeSetPtr	xmlXPathIntersection		(xmlNodeSetPtr nodes1,
+XMLPUBFUN xmlNodeSetPtr XMLCALL	xmlXPathIntersection		(xmlNodeSetPtr nodes1,
 						 xmlNodeSetPtr nodes2);
 
-xmlNodeSetPtr	xmlXPathDistinctSorted		(xmlNodeSetPtr nodes);
+XMLPUBFUN xmlNodeSetPtr XMLCALL	xmlXPathDistinctSorted		(xmlNodeSetPtr nodes);
-xmlNodeSetPtr	xmlXPathDistinct		(xmlNodeSetPtr nodes);
+XMLPUBFUN xmlNodeSetPtr XMLCALL	xmlXPathDistinct		(xmlNodeSetPtr nodes);
 
-int		xmlXPathHasSameNodes		(xmlNodeSetPtr nodes1,
+XMLPUBFUN int XMLCALL		xmlXPathHasSameNodes		(xmlNodeSetPtr nodes1,
 						 xmlNodeSetPtr nodes2);
 
-xmlNodeSetPtr	xmlXPathNodeLeadingSorted	(xmlNodeSetPtr nodes,
+XMLPUBFUN xmlNodeSetPtr XMLCALL	xmlXPathNodeLeadingSorted	(xmlNodeSetPtr nodes,
 						 xmlNodePtr node);
-xmlNodeSetPtr	xmlXPathLeadingSorted		(xmlNodeSetPtr nodes1,
+XMLPUBFUN xmlNodeSetPtr XMLCALL	xmlXPathLeadingSorted		(xmlNodeSetPtr nodes1,
 						 xmlNodeSetPtr nodes2);
-xmlNodeSetPtr	xmlXPathNodeLeading		(xmlNodeSetPtr nodes,
+XMLPUBFUN xmlNodeSetPtr XMLCALL	xmlXPathNodeLeading		(xmlNodeSetPtr nodes,
 						 xmlNodePtr node);
-xmlNodeSetPtr	xmlXPathLeading			(xmlNodeSetPtr nodes1,
+XMLPUBFUN xmlNodeSetPtr XMLCALL	xmlXPathLeading			(xmlNodeSetPtr nodes1,
 						 xmlNodeSetPtr nodes2);
 
-xmlNodeSetPtr	xmlXPathNodeTrailingSorted	(xmlNodeSetPtr nodes,
+XMLPUBFUN xmlNodeSetPtr XMLCALL	xmlXPathNodeTrailingSorted	(xmlNodeSetPtr nodes,
 						 xmlNodePtr node);
-xmlNodeSetPtr	xmlXPathTrailingSorted		(xmlNodeSetPtr nodes1,
+XMLPUBFUN xmlNodeSetPtr XMLCALL	xmlXPathTrailingSorted		(xmlNodeSetPtr nodes1,
 						 xmlNodeSetPtr nodes2);
-xmlNodeSetPtr	xmlXPathNodeTrailing		(xmlNodeSetPtr nodes,
+XMLPUBFUN xmlNodeSetPtr XMLCALL	xmlXPathNodeTrailing		(xmlNodeSetPtr nodes,
 						 xmlNodePtr node);
-xmlNodeSetPtr	xmlXPathTrailing		(xmlNodeSetPtr nodes1,
+XMLPUBFUN xmlNodeSetPtr XMLCALL	xmlXPathTrailing		(xmlNodeSetPtr nodes1,
 						 xmlNodeSetPtr nodes2);
 
 
@@ -415,164 +415,164 @@ xmlNodeSetPtr	xmlXPathTrailing		(xmlNodeSetPtr nodes1,
  * Extending a context.
  */
 
-int		   xmlXPathRegisterNs		(xmlXPathContextPtr ctxt,
+XMLPUBFUN int XMLCALL		   xmlXPathRegisterNs		(xmlXPathContextPtr ctxt,
 						 const xmlChar *prefix,
 						 const xmlChar *ns_uri);
-const xmlChar *	   xmlXPathNsLookup		(xmlXPathContextPtr ctxt,
+XMLPUBFUN const xmlChar * XMLCALL	   xmlXPathNsLookup		(xmlXPathContextPtr ctxt,
 						 const xmlChar *prefix);
-void		   xmlXPathRegisteredNsCleanup	(xmlXPathContextPtr ctxt);
+XMLPUBFUN void XMLCALL		   xmlXPathRegisteredNsCleanup	(xmlXPathContextPtr ctxt);
 
-int		   xmlXPathRegisterFunc		(xmlXPathContextPtr ctxt,
+XMLPUBFUN int XMLCALL		   xmlXPathRegisterFunc		(xmlXPathContextPtr ctxt,
 						 const xmlChar *name,
 						 xmlXPathFunction f);
-int		   xmlXPathRegisterFuncNS	(xmlXPathContextPtr ctxt,
+XMLPUBFUN int XMLCALL		   xmlXPathRegisterFuncNS	(xmlXPathContextPtr ctxt,
 						 const xmlChar *name,
 						 const xmlChar *ns_uri,
 						 xmlXPathFunction f);
-int		   xmlXPathRegisterVariable	(xmlXPathContextPtr ctxt,
+XMLPUBFUN int XMLCALL		   xmlXPathRegisterVariable	(xmlXPathContextPtr ctxt,
 						 const xmlChar *name,
 						 xmlXPathObjectPtr value);
-int		   xmlXPathRegisterVariableNS	(xmlXPathContextPtr ctxt,
+XMLPUBFUN int XMLCALL		   xmlXPathRegisterVariableNS	(xmlXPathContextPtr ctxt,
 						 const xmlChar *name,
 						 const xmlChar *ns_uri,
 						 xmlXPathObjectPtr value);
-xmlXPathFunction   xmlXPathFunctionLookup	(xmlXPathContextPtr ctxt,
+XMLPUBFUN xmlXPathFunction XMLCALL   xmlXPathFunctionLookup	(xmlXPathContextPtr ctxt,
 						 const xmlChar *name);
-xmlXPathFunction   xmlXPathFunctionLookupNS	(xmlXPathContextPtr ctxt,
+XMLPUBFUN xmlXPathFunction XMLCALL   xmlXPathFunctionLookupNS	(xmlXPathContextPtr ctxt,
 						 const xmlChar *name,
 						 const xmlChar *ns_uri);
-void		   xmlXPathRegisteredFuncsCleanup(xmlXPathContextPtr ctxt);
+XMLPUBFUN void XMLCALL		   xmlXPathRegisteredFuncsCleanup(xmlXPathContextPtr ctxt);
-xmlXPathObjectPtr  xmlXPathVariableLookup	(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);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL valuePop			(xmlXPathParserContextPtr ctxt);
-int		  valuePush			(xmlXPathParserContextPtr ctxt,
+XMLPUBFUN int XMLCALL		  valuePush			(xmlXPathParserContextPtr ctxt,
 					 	xmlXPathObjectPtr value);
 
-xmlXPathObjectPtr xmlXPathNewString		(const xmlChar *val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPathNewString		(const xmlChar *val);
-xmlXPathObjectPtr xmlXPathNewCString		(const char *val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPathNewCString		(const char *val);
-xmlXPathObjectPtr xmlXPathWrapString		(xmlChar *val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPathWrapString		(xmlChar *val);
-xmlXPathObjectPtr xmlXPathWrapCString		(char * val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPathWrapCString		(char * val);
-xmlXPathObjectPtr xmlXPathNewFloat		(double val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPathNewFloat		(double val);
-xmlXPathObjectPtr xmlXPathNewBoolean		(int val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPathNewBoolean		(int val);
-xmlXPathObjectPtr xmlXPathNewNodeSet		(xmlNodePtr val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPathNewNodeSet		(xmlNodePtr val);
-xmlXPathObjectPtr xmlXPathNewValueTree		(xmlNodePtr val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPathNewValueTree		(xmlNodePtr val);
-void		  xmlXPathNodeSetAdd		(xmlNodeSetPtr cur,
+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);
+XMLPUBFUN void XMLCALL		  xmlXPathRoot			(xmlXPathParserContextPtr ctxt);
-void		  xmlXPathEvalExpr		(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN void XMLCALL		  xmlXPathEvalExpr		(xmlXPathParserContextPtr ctxt);
-xmlChar *	  xmlXPathParseName		(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL	  xmlXPathParseName		(xmlXPathParserContextPtr ctxt);
-xmlChar *	  xmlXPathParseNCName		(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN xmlChar * XMLCALL	  xmlXPathParseNCName		(xmlXPathParserContextPtr ctxt);
 
 /*
  * Existing functions.
  */
-double xmlXPathStringEvalNumber(const xmlChar *str);
+XMLPUBFUN double XMLCALL xmlXPathStringEvalNumber(const xmlChar *str);
-int xmlXPathEvaluatePredicateResult(xmlXPathParserContextPtr ctxt, 
+XMLPUBFUN int XMLCALL xmlXPathEvaluatePredicateResult(xmlXPathParserContextPtr ctxt, 
                                     xmlXPathObjectPtr res);
-void xmlXPathRegisterAllFunctions(xmlXPathContextPtr ctxt);
+XMLPUBFUN void XMLCALL xmlXPathRegisterAllFunctions(xmlXPathContextPtr ctxt);
-xmlNodeSetPtr xmlXPathNodeSetMerge(xmlNodeSetPtr val1, xmlNodeSetPtr val2);
+XMLPUBFUN xmlNodeSetPtr XMLCALL xmlXPathNodeSetMerge(xmlNodeSetPtr val1, xmlNodeSetPtr val2);
-void xmlXPathNodeSetDel(xmlNodeSetPtr cur, xmlNodePtr val);
+XMLPUBFUN void XMLCALL xmlXPathNodeSetDel(xmlNodeSetPtr cur, xmlNodePtr val);
-void xmlXPathNodeSetRemove(xmlNodeSetPtr cur, int val);
+XMLPUBFUN void XMLCALL xmlXPathNodeSetRemove(xmlNodeSetPtr cur, int val);
-xmlXPathObjectPtr xmlXPathNewNodeSetList(xmlNodeSetPtr val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPathNewNodeSetList(xmlNodeSetPtr val);
-xmlXPathObjectPtr xmlXPathWrapNodeSet(xmlNodeSetPtr val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPathWrapNodeSet(xmlNodeSetPtr val);
-xmlXPathObjectPtr xmlXPathWrapExternal(void *val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL xmlXPathWrapExternal(void *val);
 
-int xmlXPathEqualValues(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN int XMLCALL xmlXPathEqualValues(xmlXPathParserContextPtr ctxt);
-int xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN int XMLCALL xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt);
-int xmlXPathCompareValues(xmlXPathParserContextPtr ctxt, int inf, int strict);
+XMLPUBFUN int XMLCALL xmlXPathCompareValues(xmlXPathParserContextPtr ctxt, int inf, int strict);
-void xmlXPathValueFlipSign(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN void XMLCALL xmlXPathValueFlipSign(xmlXPathParserContextPtr ctxt);
-void xmlXPathAddValues(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN void XMLCALL xmlXPathAddValues(xmlXPathParserContextPtr ctxt);
-void xmlXPathSubValues(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN void XMLCALL xmlXPathSubValues(xmlXPathParserContextPtr ctxt);
-void xmlXPathMultValues(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN void XMLCALL xmlXPathMultValues(xmlXPathParserContextPtr ctxt);
-void xmlXPathDivValues(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN void XMLCALL xmlXPathDivValues(xmlXPathParserContextPtr ctxt);
-void xmlXPathModValues(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);
+XMLPUBFUN void XMLCALL xmlXPathLastFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathPositionFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathPositionFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathCountFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathCountFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathIdFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathIdFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathLocalNameFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathLocalNameFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathNamespaceURIFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathNamespaceURIFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathStringLengthFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathStringLengthFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathConcatFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathConcatFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathContainsFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathContainsFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathStartsWithFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathStartsWithFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathSubstringBeforeFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathSubstringBeforeFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathTranslateFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathTranslateFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathNotFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathNotFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathTrueFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathTrueFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathFalseFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathFalseFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathLangFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathLangFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathNumberFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathNumberFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathSumFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathSumFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathFloorFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathFloorFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathRoundFunction(xmlXPathParserContextPtr ctxt, int nargs);
+XMLPUBFUN void XMLCALL xmlXPathRoundFunction(xmlXPathParserContextPtr ctxt, int nargs);
-void xmlXPathBooleanFunction(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
 }

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 @@ struct _xmlLocationSet {
  * Handling of location sets.
  */
 
-xmlLocationSetPtr	xmlXPtrLocationSetCreate(xmlXPathObjectPtr val);
+XMLPUBFUN xmlLocationSetPtr XMLCALL	xmlXPtrLocationSetCreate(xmlXPathObjectPtr val);
-void			xmlXPtrFreeLocationSet	(xmlLocationSetPtr obj);
+XMLPUBFUN void XMLCALL			xmlXPtrFreeLocationSet	(xmlLocationSetPtr obj);
-xmlLocationSetPtr	xmlXPtrLocationSetMerge	(xmlLocationSetPtr val1,
+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);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL	xmlXPtrNewLocationSetNodeSet(xmlNodeSetPtr set);
-xmlXPathObjectPtr	xmlXPtrNewRangeNodeObject(xmlNodePtr start,
+XMLPUBFUN xmlXPathObjectPtr XMLCALL	xmlXPtrNewRangeNodeObject(xmlNodePtr start,
 						 xmlXPathObjectPtr end);
-xmlXPathObjectPtr	xmlXPtrNewCollapsedRange(xmlNodePtr start);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL	xmlXPtrNewCollapsedRange(xmlNodePtr start);
-void			xmlXPtrLocationSetAdd	(xmlLocationSetPtr cur,
+XMLPUBFUN void XMLCALL			xmlXPtrLocationSetAdd	(xmlLocationSetPtr cur,
 						 xmlXPathObjectPtr val);
-xmlXPathObjectPtr	xmlXPtrWrapLocationSet	(xmlLocationSetPtr val);
+XMLPUBFUN xmlXPathObjectPtr XMLCALL	xmlXPtrWrapLocationSet	(xmlLocationSetPtr val);
-void			xmlXPtrLocationSetDel	(xmlLocationSetPtr cur,
+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);
+XMLPUBFUN xmlNodePtr XMLCALL		xmlXPtrBuildNodeList	(xmlXPathObjectPtr obj);
-void		xmlXPtrEvalRangePredicate	(xmlXPathParserContextPtr ctxt);
+XMLPUBFUN void XMLCALL		xmlXPtrEvalRangePredicate	(xmlXPathParserContextPtr ctxt);
 
 #ifdef __cplusplus
 }

win32/Makefile.msvc

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

xmlunicode.c

@@ -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>
  */