* made libxml2 headers Lazarus "Codetools" compatible

* prepeared headers for dynamic loading (not enabled right now)

git-svn-id: trunk@12678 -

.gitattributes

@@ -3315,11 +3315,12 @@ packages/libxml/src/uri.inc svneol=native#text/plain
 packages/libxml/src/valid.inc svneol=native#text/plain
 packages/libxml/src/xinclude.inc svneol=native#text/plain
 packages/libxml/src/xlink.inc svneol=native#text/plain
+packages/libxml/src/xml2.inc svneol=native#text/plain
 packages/libxml/src/xml2.pas svneol=native#text/plain
+packages/libxml/src/xml2dyn.pas svneol=native#text/plain
 packages/libxml/src/xmlIO.inc svneol=native#text/plain
 packages/libxml/src/xmlautomata.inc svneol=native#text/plain
 packages/libxml/src/xmlerror.inc svneol=native#text/plain
-packages/libxml/src/xmlexports.inc svneol=native#text/plain
 packages/libxml/src/xmlmemory.inc svneol=native#text/plain
 packages/libxml/src/xmlmodule.inc svneol=native#text/plain
 packages/libxml/src/xmlreader.inc svneol=native#text/plain

packages/libxml/src/HTMLparser.inc

@@ -78,37 +78,37 @@
 (*
  * There is only few public functions.
  *)
-function htmlTagLookup(tag: xmlCharPtr): htmlElemDescPtr; XMLCALL; XMLPUBFUN;
-function htmlEntityLookup(tag: xmlCharPtr): htmlEntityDescPtr; XMLCALL; XMLPUBFUN;
-function htmlEntityValueLookup(value: cuint): htmlEntityDescPtr; XMLCALL; XMLPUBFUN;
-
-function htmlIsAutoClosed(doc: htmlDocPtr; elem: htmlNodePtr): cint; XMLCALL; XMLPUBFUN;
-function htmlAutoCloseTag(doc: htmlDocPtr; name: xmlCharPtr; elem: htmlNodePtr): cint; XMLCALL; XMLPUBFUN;
-function htmlParseEntityRef(ctxt: htmlParserCtxtPtr; str: xmlCharPtrPtr): htmlEntityDescPtr; XMLCALL; XMLPUBFUN;
-
-function htmlParseCharRef(ctxt: htmlParserCtxtPtr): cint; XMLCALL; XMLPUBFUN;
-function htmlParseElement(ctxt: htmlParserCtxtPtr): cint; XMLCALL; XMLPUBFUN;
-function htmlNewParserCtxt: htmlParserCtxtPtr; XMLCALL; XMLPUBFUN;
-function htmlCreateMemoryParserCtxt(buffer: pchar; size: cint): htmlParserCtxtPtr; XMLCALL; XMLPUBFUN;
-
-function htmlParseDocument(doc: htmlDocPtr; elem: htmlNodePtr): cint; XMLCALL; XMLPUBFUN;
-function htmlSAXParseDoc(cur: xmlCharPtr; encoding: pchar; sax: htmlSAXHandlerPtr; userdata: pointer): htmlDocPtr; XMLCALL; XMLPUBFUN;
-function htmlParseDoc(cur: xmlCharPtr; encoding: pchar): htmlDocPtr; XMLCALL; XMLPUBFUN;
-function htmlSAXParseFile(filename, encoding: pchar; sax: htmlSAXHandlerPtr; userdata: pointer): htmlDocPtr; XMLCALL; XMLPUBFUN;
-function htmlParseFile(filename, encoding: pchar): htmlDocPtr; XMLCALL; XMLPUBFUN;
-function UTF8ToHtml(_out: pointer; outlen: cint; _in: pointer; inlen: cint): cint; XMLCALL; XMLPUBFUN;
-function htmlEncodeEntities(_out: pointer; outlen: cint; _in: pointer; inlen, quoteChar: cint): cint; XMLCALL; XMLPUBFUN;
-function htmlIsScriptAttribute(name: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function htmlHandleOmittedElem(val: cint): cint; XMLCALL; XMLPUBFUN;
+function htmlTagLookup(tag: xmlCharPtr): htmlElemDescPtr; EXTDECL; external xml2lib;
+function htmlEntityLookup(tag: xmlCharPtr): htmlEntityDescPtr; EXTDECL; external xml2lib;
+function htmlEntityValueLookup(value: cuint): htmlEntityDescPtr; EXTDECL; external xml2lib;
+
+function htmlIsAutoClosed(doc: htmlDocPtr; elem: htmlNodePtr): cint; EXTDECL; external xml2lib;
+function htmlAutoCloseTag(doc: htmlDocPtr; name: xmlCharPtr; elem: htmlNodePtr): cint; EXTDECL; external xml2lib;
+function htmlParseEntityRef(ctxt: htmlParserCtxtPtr; str: xmlCharPtrPtr): htmlEntityDescPtr; EXTDECL; external xml2lib;
+
+function htmlParseCharRef(ctxt: htmlParserCtxtPtr): cint; EXTDECL; external xml2lib;
+function htmlParseElement(ctxt: htmlParserCtxtPtr): cint; EXTDECL; external xml2lib;
+function htmlNewParserCtxt: htmlParserCtxtPtr; EXTDECL; external xml2lib;
+function htmlCreateMemoryParserCtxt(buffer: pchar; size: cint): htmlParserCtxtPtr; EXTDECL; external xml2lib;
+
+function htmlParseDocument(doc: htmlDocPtr; elem: htmlNodePtr): cint; EXTDECL; external xml2lib;
+function htmlSAXParseDoc(cur: xmlCharPtr; encoding: pchar; sax: htmlSAXHandlerPtr; userdata: pointer): htmlDocPtr; EXTDECL; external xml2lib;
+function htmlParseDoc(cur: xmlCharPtr; encoding: pchar): htmlDocPtr; EXTDECL; external xml2lib;
+function htmlSAXParseFile(filename, encoding: pchar; sax: htmlSAXHandlerPtr; userdata: pointer): htmlDocPtr; EXTDECL; external xml2lib;
+function htmlParseFile(filename, encoding: pchar): htmlDocPtr; EXTDECL; external xml2lib;
+function UTF8ToHtml(_out: pointer; outlen: cint; _in: pointer; inlen: cint): cint; EXTDECL; external xml2lib;
+function htmlEncodeEntities(_out: pointer; outlen: cint; _in: pointer; inlen, quoteChar: cint): cint; EXTDECL; external xml2lib;
+function htmlIsScriptAttribute(name: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function htmlHandleOmittedElem(val: cint): cint; EXTDECL; external xml2lib;
 
 {$IFDEF LIBXML_PUSH_ENABLED}
 (**
  * Interfaces for the Push mode.
  *)
-function htmlCreatePushParserCtxt(sax: htmlSAXHandlerPtr; userdata: pointer; chunk: pchar; size: cint; filename: pchar; enc: xmlCharEncoding): htmlParserCtxtPtr; XMLCALL; XMLPUBFUN;
-function htmlParseChunk(ctxt: htmlParserCtxtPtr; chunk: pchar; size, terminate: cint): htmlParserCtxtPtr; XMLCALL; XMLPUBFUN;
+function htmlCreatePushParserCtxt(sax: htmlSAXHandlerPtr; userdata: pointer; chunk: pchar; size: cint; filename: pchar; enc: xmlCharEncoding): htmlParserCtxtPtr; EXTDECL; external xml2lib;
+function htmlParseChunk(ctxt: htmlParserCtxtPtr; chunk: pchar; size, terminate: cint): htmlParserCtxtPtr; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_PUSH_ENABLED *)
-procedure htmlFreeParserCtxt(ctxt: htmlParserCtxtPtr); XMLCALL; XMLPUBFUN;
+procedure htmlFreeParserCtxt(ctxt: htmlParserCtxtPtr); EXTDECL; external xml2lib;
 {$ENDIF}
 
 {$IFDEF TYPE}
@@ -134,18 +134,18 @@ procedure htmlFreeParserCtxt(ctxt: htmlParserCtxtPtr); XMLCALL; XMLPUBFUN;
 {$ENDIF}
 
 {$IFDEF FUNCTION}
-procedure htmlCtxtReset(ctxt: htmlParserCtxtPtr); XMLCALL; XMLPUBFUN;
-function htmlParseChunk(ctxt: htmlParserCtxtPtr; options: cint): cint; XMLCALL; XMLPUBFUN;
-function htmlReadDoc(cur: xmlCharPtr; URL, encoding: pchar; options: cint): htmlDocPtr; XMLCALL; XMLPUBFUN;
-function htmlReadFile(URL, encoding: pchar; options: cint): htmlDocPtr; XMLCALL; XMLPUBFUN;
-function htmlReadMemory(buffer: pchar; size: cint; URL, encoding: pchar; options: cint): htmlDocPtr; XMLCALL; XMLPUBFUN;
-function htmlReadFd(fd: cint; URL, encoding: pchar; options: cint): htmlDocPtr; XMLCALL; XMLPUBFUN;
-function htmlReadIO(ioread: xmlInputReadCallback; ioclose: xmlInputCloseCallback; ioctx: pointer; URL, encoding: pchar; options: cint): htmlDocPtr; XMLCALL; XMLPUBFUN;
-function htmlCtxtReadDoc(ctxt: xmlParserCtxtPtr; cur: xmlCharPtr; URL, encoding: pchar; options: cint): htmlDocPtr; XMLCALL; XMLPUBFUN;
-function htmlCtxtReadFile(ctxt: xmlParserCtxtPtr; filename, encoding: pchar; options: cint): htmlDocPtr; XMLCALL; XMLPUBFUN;
-function htmlCtxtReadMemory(ctxt: xmlParserCtxtPtr; buffer: pchar; size: cint; URL, encoding: pchar; options: cint): htmlDocPtr; XMLCALL; XMLPUBFUN;
-function htmlCtxtReadFd(ctxt: xmlParserCtxtPtr; fd: cint; URL, encoding: pchar; options: cint): htmlDocPtr; XMLCALL; XMLPUBFUN;
-function htmlCtxtReadIO(ctxt: xmlParserCtxtPtr; ioread: xmlInputReadCallback; ioclose: xmlInputCloseCallback; ioctx: pointer; URL, encoding: pchar; options: cint): htmlDocPtr; XMLCALL; XMLPUBFUN;
+procedure htmlCtxtReset(ctxt: htmlParserCtxtPtr); EXTDECL; external xml2lib;
+function htmlParseChunk(ctxt: htmlParserCtxtPtr; options: cint): cint; EXTDECL; external xml2lib;
+function htmlReadDoc(cur: xmlCharPtr; URL, encoding: pchar; options: cint): htmlDocPtr; EXTDECL; external xml2lib;
+function htmlReadFile(URL, encoding: pchar; options: cint): htmlDocPtr; EXTDECL; external xml2lib;
+function htmlReadMemory(buffer: pchar; size: cint; URL, encoding: pchar; options: cint): htmlDocPtr; EXTDECL; external xml2lib;
+function htmlReadFd(fd: cint; URL, encoding: pchar; options: cint): htmlDocPtr; EXTDECL; external xml2lib;
+function htmlReadIO(ioread: xmlInputReadCallback; ioclose: xmlInputCloseCallback; ioctx: pointer; URL, encoding: pchar; options: cint): htmlDocPtr; EXTDECL; external xml2lib;
+function htmlCtxtReadDoc(ctxt: xmlParserCtxtPtr; cur: xmlCharPtr; URL, encoding: pchar; options: cint): htmlDocPtr; EXTDECL; external xml2lib;
+function htmlCtxtReadFile(ctxt: xmlParserCtxtPtr; filename, encoding: pchar; options: cint): htmlDocPtr; EXTDECL; external xml2lib;
+function htmlCtxtReadMemory(ctxt: xmlParserCtxtPtr; buffer: pchar; size: cint; URL, encoding: pchar; options: cint): htmlDocPtr; EXTDECL; external xml2lib;
+function htmlCtxtReadFd(ctxt: xmlParserCtxtPtr; fd: cint; URL, encoding: pchar; options: cint): htmlDocPtr; EXTDECL; external xml2lib;
+function htmlCtxtReadIO(ctxt: xmlParserCtxtPtr; ioread: xmlInputReadCallback; ioclose: xmlInputCloseCallback; ioctx: pointer; URL, encoding: pchar; options: cint): htmlDocPtr; EXTDECL; external xml2lib;
 {$ENDIF}
 
 {$IFDEF TYPE}
@@ -165,10 +165,10 @@ function htmlCtxtReadIO(ctxt: xmlParserCtxtPtr; ioread: xmlInputReadCallback; io
 (* Using htmlElemDesc rather than name here, to emphasise the fact
    that otherwise there's a lookup overhead
 *)
-function htmlAttrAllowed(desc: htmlElemDescPtr; str: xmlCharPtr; val: cint): htmlStatus; XMLCALL; XMLPUBFUN;
-function htmlElementAllowedHere(desc: htmlElemDescPtr; str: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function htmlAttrAllowed(desc1, desc2: htmlElemDescPtr): htmlStatus; XMLCALL; XMLPUBFUN;
-function htmlNodeStatus(node: htmlNodePtr; val: cint): htmlStatus; XMLCALL; XMLPUBFUN;
+function htmlAttrAllowed(desc: htmlElemDescPtr; str: xmlCharPtr; val: cint): htmlStatus; EXTDECL; external xml2lib;
+function htmlElementAllowedHere(desc: htmlElemDescPtr; str: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function htmlAttrAllowed(desc1, desc2: htmlElemDescPtr): htmlStatus; EXTDECL; external xml2lib;
+function htmlNodeStatus(node: htmlNodePtr; val: cint): htmlStatus; EXTDECL; external xml2lib;
 
 (**
  * htmlDefaultSubelement:

packages/libxml/src/HTMLtree.inc

@@ -49,26 +49,26 @@
 {$ENDIF}
 
 {$IFDEF FUNCTION}
-function htmlNewDoc(URI, ExternalID: xmlCharPtr): htmlDocPtr; XMLCALL; XMLPUBFUN;
-function htmlNewDocNoDtD(URI, ExternalID: xmlCharPtr): htmlDocPtr; XMLCALL; XMLPUBFUN;
-function htmlGetMetaEncoding(doc: htmlDocPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function htmlSetMetaEncoding(doc: htmlDocPtr; encoding: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
+function htmlNewDoc(URI, ExternalID: xmlCharPtr): htmlDocPtr; EXTDECL; external xml2lib;
+function htmlNewDocNoDtD(URI, ExternalID: xmlCharPtr): htmlDocPtr; EXTDECL; external xml2lib;
+function htmlGetMetaEncoding(doc: htmlDocPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function htmlSetMetaEncoding(doc: htmlDocPtr; encoding: xmlCharPtr): cint; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_OUTPUT_ENABLED}
-procedure htmlDocDumpMemory(cur: xmlDocPtr; mem: xmlCharPtrPtr; size: pcint); XMLCALL; XMLPUBFUN;
-procedure htmlDocDumpMemoryFormat(cur: xmlDocPtr; mem: xmlCharPtrPtr; size: pcint; format: cint); XMLCALL; XMLPUBFUN;
-procedure htmlDocDump(f: PFILE; cur: xmlDocPtr); XMLCALL; XMLPUBFUN;
-function htmlSaveFile(filename: pchar; doc: htmlDocPtr): cint; XMLCALL; XMLPUBFUN;
-function htmlNodeDump(buf: xmlBufferPtr; doc: htmlDocPtr; cur: xmlNodePtr): cint; XMLCALL; XMLPUBFUN;
-procedure htmlNodeDumpFile(_out: PFILE; doc: xmlDocPtr; cur: xmlNodePtr); XMLCALL; XMLPUBFUN;
-function htmlNodeDumpFileFormat(_out: PFILE; doc: htmlDocPtr; cur: xmlNodePtr; encoding: pchar; format: cint): cint; XMLCALL; XMLPUBFUN;
-function htmlSaveFileEnc(filename: pchar; cur: htmlDocPtr; encoding: pchar): cint; XMLCALL; XMLPUBFUN;
-function htmlSaveFileFormat(filename: pchar; cur: htmlDocPtr; encoding: pchar; format: cint): cint; XMLCALL; XMLPUBFUN;
-procedure htmlNodeDumpFormatOutput(buf: xmlOutputBufferPtr; doc: xmlDocPtr; cur: xmlNodePtr; encoding: pchar; format: cint); XMLCALL; XMLPUBFUN;
-procedure htmlDocContentDumpOutput(buf: xmlOutputBufferPtr; cur: xmlNodePtr; encoding: pchar); XMLCALL; XMLPUBFUN;
-procedure htmlDocContentDumpFormatOutput(buf: xmlOutputBufferPtr; cur: xmlNodePtr; encoding: pchar; format: cint); XMLCALL; XMLPUBFUN;
-procedure htmlNodeDumpOutput(buf: xmlOutputBufferPtr; doc: xmlDocPtr; cur: xmlNodePtr; encoding: pchar); XMLCALL; XMLPUBFUN;
+procedure htmlDocDumpMemory(cur: xmlDocPtr; mem: xmlCharPtrPtr; size: pcint); EXTDECL; external xml2lib;
+procedure htmlDocDumpMemoryFormat(cur: xmlDocPtr; mem: xmlCharPtrPtr; size: pcint; format: cint); EXTDECL; external xml2lib;
+procedure htmlDocDump(f: PFILE; cur: xmlDocPtr); EXTDECL; external xml2lib;
+function htmlSaveFile(filename: pchar; doc: htmlDocPtr): cint; EXTDECL; external xml2lib;
+function htmlNodeDump(buf: xmlBufferPtr; doc: htmlDocPtr; cur: xmlNodePtr): cint; EXTDECL; external xml2lib;
+procedure htmlNodeDumpFile(_out: PFILE; doc: xmlDocPtr; cur: xmlNodePtr); EXTDECL; external xml2lib;
+function htmlNodeDumpFileFormat(_out: PFILE; doc: htmlDocPtr; cur: xmlNodePtr; encoding: pchar; format: cint): cint; EXTDECL; external xml2lib;
+function htmlSaveFileEnc(filename: pchar; cur: htmlDocPtr; encoding: pchar): cint; EXTDECL; external xml2lib;
+function htmlSaveFileFormat(filename: pchar; cur: htmlDocPtr; encoding: pchar; format: cint): cint; EXTDECL; external xml2lib;
+procedure htmlNodeDumpFormatOutput(buf: xmlOutputBufferPtr; doc: xmlDocPtr; cur: xmlNodePtr; encoding: pchar; format: cint); EXTDECL; external xml2lib;
+procedure htmlDocContentDumpOutput(buf: xmlOutputBufferPtr; cur: xmlNodePtr; encoding: pchar); EXTDECL; external xml2lib;
+procedure htmlDocContentDumpFormatOutput(buf: xmlOutputBufferPtr; cur: xmlNodePtr; encoding: pchar; format: cint); EXTDECL; external xml2lib;
+procedure htmlNodeDumpOutput(buf: xmlOutputBufferPtr; doc: xmlDocPtr; cur: xmlNodePtr; encoding: pchar); EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
-function htmlIsBooleanAttr(name: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
+function htmlIsBooleanAttr(name: xmlCharPtr): cint; EXTDECL; external xml2lib;
 {$ENDIF}
 
 {$ENDIF} (* LIBXML_HTML_ENABLED *)

packages/libxml/src/SAX.inc

@@ -11,53 +11,53 @@
 {$IFDEF LIBXML_LEGACY_ENABLED}
 
 {$IFDEF FUNCTION}
-function getPublicId(ctx: pointer): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function getSystemId(ctx: pointer): xmlCharPtr; XMLCALL; XMLPUBFUN;
-procedure setDocumentLocator(ctx: pointer; loc: xmlSAXLocatorPtr); XMLCALL; XMLPUBFUN;
+function getPublicId(ctx: pointer): xmlCharPtr; EXTDECL; external xml2lib;
+function getSystemId(ctx: pointer): xmlCharPtr; EXTDECL; external xml2lib;
+procedure setDocumentLocator(ctx: pointer; loc: xmlSAXLocatorPtr); EXTDECL; external xml2lib;
 
-function getLineNumber(ctx: pointer): cint; XMLCALL; XMLPUBFUN;
-function getColumnNumber(ctx: pointer): cint; XMLCALL; XMLPUBFUN;
+function getLineNumber(ctx: pointer): cint; EXTDECL; external xml2lib;
+function getColumnNumber(ctx: pointer): cint; EXTDECL; external xml2lib;
 
-function isStandalone(ctx: pointer): cint; XMLCALL; XMLPUBFUN;
-function hasInternalSubset(ctx: pointer): cint; XMLCALL; XMLPUBFUN;
-function hasExternalSubset(ctx: pointer): cint; XMLCALL; XMLPUBFUN;
+function isStandalone(ctx: pointer): cint; EXTDECL; external xml2lib;
+function hasInternalSubset(ctx: pointer): cint; EXTDECL; external xml2lib;
+function hasExternalSubset(ctx: pointer): cint; EXTDECL; external xml2lib;
 
-procedure internalSubset(ctx: pointer; name, ExternalID, SystemID: xmlCharPtr); XMLCALL; XMLPUBFUN;
-procedure externalSubset(ctx: pointer; name, ExternalID, SystemID: xmlCharPtr); XMLCALL; XMLPUBFUN;
-function getEntity(ctx: pointer; name: xmlCharPtr): xmlEntityPtr; XMLCALL; XMLPUBFUN;
-function getParameterEntity(ctx: pointer; name: xmlCharPtr): xmlEntityPtr; XMLCALL; XMLPUBFUN;
-function resolveEntity(ctx: pointer; publicId, systemId: xmlCharPtr): xmlParserInputPtr; XMLCALL; XMLPUBFUN;
+procedure internalSubset(ctx: pointer; name, ExternalID, SystemID: xmlCharPtr); EXTDECL; external xml2lib;
+procedure externalSubset(ctx: pointer; name, ExternalID, SystemID: xmlCharPtr); EXTDECL; external xml2lib;
+function getEntity(ctx: pointer; name: xmlCharPtr): xmlEntityPtr; EXTDECL; external xml2lib;
+function getParameterEntity(ctx: pointer; name: xmlCharPtr): xmlEntityPtr; EXTDECL; external xml2lib;
+function resolveEntity(ctx: pointer; publicId, systemId: xmlCharPtr): xmlParserInputPtr; EXTDECL; external xml2lib;
 
-procedure entityDecl(ctx: pointer; name: xmlCharPtr; _type: cint; content, ExternalID, SystemID: xmlCharPtr); XMLCALL; XMLPUBFUN;
-procedure attributeDecl(ctx: pointer; elem, fullname: xmlCharPtr; _type, def: cint; defaultValue: xmlCharPtr; tree: xmlEnumerationPtr); XMLCALL; XMLPUBFUN;
-procedure elementDecl(ctx: pointer; name: xmlCharPtr; _type: cint; content: xmlElementContentPtr); XMLCALL; XMLPUBFUN;
-procedure notationDecl(ctx: pointer; name, ExternalID, SystemID: xmlCharPtr); XMLCALL; XMLPUBFUN;
-procedure unparsedEntityDecl(ctx: pointer; name, publicId, systemId, notationName: xmlCharPtr); XMLCALL; XMLPUBFUN;
+procedure entityDecl(ctx: pointer; name: xmlCharPtr; _type: cint; content, ExternalID, SystemID: xmlCharPtr); EXTDECL; external xml2lib;
+procedure attributeDecl(ctx: pointer; elem, fullname: xmlCharPtr; _type, def: cint; defaultValue: xmlCharPtr; tree: xmlEnumerationPtr); EXTDECL; external xml2lib;
+procedure elementDecl(ctx: pointer; name: xmlCharPtr; _type: cint; content: xmlElementContentPtr); EXTDECL; external xml2lib;
+procedure notationDecl(ctx: pointer; name, ExternalID, SystemID: xmlCharPtr); EXTDECL; external xml2lib;
+procedure unparsedEntityDecl(ctx: pointer; name, publicId, systemId, notationName: xmlCharPtr); EXTDECL; external xml2lib;
 
-procedure startDocument(ctx: pointer); XMLCALL; XMLPUBFUN;
-procedure endDocument(ctx: pointer); XMLCALL; XMLPUBFUN;
-procedure attribute(ctx: pointer; fullname, value: xmlCharPtr); XMLCALL; XMLPUBFUN;
-procedure startElement(ctx: pointer; fullname: xmlCharPtr; atts: xmlCharPtrPtr); XMLCALL; XMLPUBFUN;
-procedure endElement(ctx: pointer; name: xmlCharPtr); XMLCALL; XMLPUBFUN;
-procedure reference(ctx: pointer; name: xmlCharPtr); XMLCALL; XMLPUBFUN;
-procedure characters(ctx: pointer; ch: xmlCharPtr; len: cint); XMLCALL; XMLPUBFUN;
-procedure ignorableWhitespace(ctx: pointer; ch: xmlCharPtr; len: cint); XMLCALL; XMLPUBFUN;
-procedure processingInstruction(ctx: pointer; target, data: xmlCharPtr); XMLCALL; XMLPUBFUN;
-procedure globalNamespace(ctx: pointer; href, prefix: xmlCharPtr); XMLCALL; XMLPUBFUN;
-procedure setNamespace(ctx: pointer; name: xmlCharPtr); XMLCALL; XMLPUBFUN;
-function getNamespace(ctx: pointer): xmlNsPtr; XMLCALL; XMLPUBFUN;
-function checkNamespace(ctx: pointer; nameSpace: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-procedure namespaceDecl(ctx: pointer; href, prefix: xmlCharPtr); XMLCALL; XMLPUBFUN;
-procedure comment(ctx: pointer; value: xmlCharPtr); XMLCALL; XMLPUBFUN;
-procedure cdataBlock(ctx: pointer; value: xmlCharPtr; len: cint); XMLCALL; XMLPUBFUN;
+procedure startDocument(ctx: pointer); EXTDECL; external xml2lib;
+procedure endDocument(ctx: pointer); EXTDECL; external xml2lib;
+procedure attribute(ctx: pointer; fullname, value: xmlCharPtr); EXTDECL; external xml2lib;
+procedure startElement(ctx: pointer; fullname: xmlCharPtr; atts: xmlCharPtrPtr); EXTDECL; external xml2lib;
+procedure endElement(ctx: pointer; name: xmlCharPtr); EXTDECL; external xml2lib;
+procedure reference(ctx: pointer; name: xmlCharPtr); EXTDECL; external xml2lib;
+procedure characters(ctx: pointer; ch: xmlCharPtr; len: cint); EXTDECL; external xml2lib;
+procedure ignorableWhitespace(ctx: pointer; ch: xmlCharPtr; len: cint); EXTDECL; external xml2lib;
+procedure processingInstruction(ctx: pointer; target, data: xmlCharPtr); EXTDECL; external xml2lib;
+procedure globalNamespace(ctx: pointer; href, prefix: xmlCharPtr); EXTDECL; external xml2lib;
+procedure setNamespace(ctx: pointer; name: xmlCharPtr); EXTDECL; external xml2lib;
+function getNamespace(ctx: pointer): xmlNsPtr; EXTDECL; external xml2lib;
+function checkNamespace(ctx: pointer; nameSpace: xmlCharPtr): cint; EXTDECL; external xml2lib;
+procedure namespaceDecl(ctx: pointer; href, prefix: xmlCharPtr); EXTDECL; external xml2lib;
+procedure comment(ctx: pointer; value: xmlCharPtr); EXTDECL; external xml2lib;
+procedure cdataBlock(ctx: pointer; value: xmlCharPtr; len: cint); EXTDECL; external xml2lib;
 
 {$IFDEF LIBXML_SAX1_ENABLED}
-procedure initxmlDefaultSAXHandler(hdlr: xmlSAXHandlerV1Ptr; warning: cint); XMLCALL; XMLPUBFUN;
+procedure initxmlDefaultSAXHandler(hdlr: xmlSAXHandlerV1Ptr; warning: cint); EXTDECL; external xml2lib;
 {$IFDEF LIBXML_HTML_ENABLED}
-procedure inithtmlDefaultSAXHandler(hdlr: xmlSAXHandlerV1Ptr); XMLCALL; XMLPUBFUN;
+procedure inithtmlDefaultSAXHandler(hdlr: xmlSAXHandlerV1Ptr); EXTDECL; external xml2lib;
 {$ENDIF}
 {$IFDEF LIBXML_DOCB_ENABLED}
-procedure initdocbDefaultSAXHandler(hdlr: xmlSAXHandlerV1Ptr); XMLCALL; XMLPUBFUN;
+procedure initdocbDefaultSAXHandler(hdlr: xmlSAXHandlerV1Ptr); EXTDECL; external xml2lib;
 {$ENDIF}
 {$ENDIF} (* LIBXML_SAX1_ENABLED *)
 {$ENDIF}

packages/libxml/src/SAX2.inc

@@ -9,58 +9,58 @@
  *)
 
 {$IFDEF FUNCTION}
-function xmlSAX2GetPublicId(ctx: pointer): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlSAX2GetSystemId(ctx: pointer): xmlCharPtr; XMLCALL; XMLPUBFUN;
-procedure xmlSAX2GetSystemId(ctx: pointer; loc: xmlSAXLocatorPtr); XMLCALL; XMLPUBFUN;
+function xmlSAX2GetPublicId(ctx: pointer): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlSAX2GetSystemId(ctx: pointer): xmlCharPtr; EXTDECL; external xml2lib;
+procedure xmlSAX2GetSystemId(ctx: pointer; loc: xmlSAXLocatorPtr); EXTDECL; external xml2lib;
 
-function xmlSAX2GetLineNumber(ctx: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlSAX2GetColumnNumber(ctx: pointer): cint; XMLCALL; XMLPUBFUN;
+function xmlSAX2GetLineNumber(ctx: pointer): cint; EXTDECL; external xml2lib;
+function xmlSAX2GetColumnNumber(ctx: pointer): cint; EXTDECL; external xml2lib;
 
-function xmlSAX2IsStandalone(ctx: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlSAX2HasInternalSubset(ctx: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlSAX2HasExternalSubset(ctx: pointer): cint; XMLCALL; XMLPUBFUN;
+function xmlSAX2IsStandalone(ctx: pointer): cint; EXTDECL; external xml2lib;
+function xmlSAX2HasInternalSubset(ctx: pointer): cint; EXTDECL; external xml2lib;
+function xmlSAX2HasExternalSubset(ctx: pointer): cint; EXTDECL; external xml2lib;
 
-procedure xmlSAX2InternalSubset(ctx: pointer; name, ExternalID, SystemID: xmlCharPtr); XMLCALL; XMLPUBFUN;
-procedure xmlSAX2ExternalSubset(ctx: pointer; name, ExternalID, SystemID: xmlCharPtr); XMLCALL; XMLPUBFUN;
-function xmlSAX2GetEntity(ctx: pointer; name: xmlCharPtr): xmlEntityPtr; XMLCALL; XMLPUBFUN;
-function xmlSAX2GetParameterEntity(ctx: pointer; name: xmlCharPtr): xmlEntityPtr; XMLCALL; XMLPUBFUN;
-function xmlSAX2ResolveEntity(ctx: pointer; publicId, systemId: xmlCharPtr): xmlParserInputPtr; XMLCALL; XMLPUBFUN;
+procedure xmlSAX2InternalSubset(ctx: pointer; name, ExternalID, SystemID: xmlCharPtr); EXTDECL; external xml2lib;
+procedure xmlSAX2ExternalSubset(ctx: pointer; name, ExternalID, SystemID: xmlCharPtr); EXTDECL; external xml2lib;
+function xmlSAX2GetEntity(ctx: pointer; name: xmlCharPtr): xmlEntityPtr; EXTDECL; external xml2lib;
+function xmlSAX2GetParameterEntity(ctx: pointer; name: xmlCharPtr): xmlEntityPtr; EXTDECL; external xml2lib;
+function xmlSAX2ResolveEntity(ctx: pointer; publicId, systemId: xmlCharPtr): xmlParserInputPtr; EXTDECL; external xml2lib;
 
-procedure xmlSAX2EntityDecl(ctx: pointer; name: xmlCharPtr; _type: cint; publicId, systemId, content: xmlCharPtr); XMLCALL; XMLPUBFUN;
-procedure xmlSAX2AttributeDecl(ctx: pointer; elem, fullname: xmlCharPtr; _type, def: cint; defaultValue: xmlCharPtr; tree: xmlEnumerationPtr); XMLCALL; XMLPUBFUN;
-procedure xmlSAX2ElementDecl(ctx: pointer; name: xmlCharPtr; _type: cint; content: xmlElementContentPtr); XMLCALL; XMLPUBFUN;
-procedure xmlSAX2NotationDecl(ctx: pointer; name, publicId, systemId: xmlCharPtr); XMLCALL; XMLPUBFUN;
-procedure xmlSAX2UnparsedEntityDecl(ctx: pointer; name, publicId, systemId, notationName: xmlCharPtr); XMLCALL; XMLPUBFUN;
+procedure xmlSAX2EntityDecl(ctx: pointer; name: xmlCharPtr; _type: cint; publicId, systemId, content: xmlCharPtr); EXTDECL; external xml2lib;
+procedure xmlSAX2AttributeDecl(ctx: pointer; elem, fullname: xmlCharPtr; _type, def: cint; defaultValue: xmlCharPtr; tree: xmlEnumerationPtr); EXTDECL; external xml2lib;
+procedure xmlSAX2ElementDecl(ctx: pointer; name: xmlCharPtr; _type: cint; content: xmlElementContentPtr); EXTDECL; external xml2lib;
+procedure xmlSAX2NotationDecl(ctx: pointer; name, publicId, systemId: xmlCharPtr); EXTDECL; external xml2lib;
+procedure xmlSAX2UnparsedEntityDecl(ctx: pointer; name, publicId, systemId, notationName: xmlCharPtr); EXTDECL; external xml2lib;
 
-procedure xmlSAX2StartDocument(ctx: pointer); XMLCALL; XMLPUBFUN;
-procedure xmlSAX2EndDocument(ctx: pointer); XMLCALL; XMLPUBFUN;
+procedure xmlSAX2StartDocument(ctx: pointer); EXTDECL; external xml2lib;
+procedure xmlSAX2EndDocument(ctx: pointer); EXTDECL; external xml2lib;
 
 {$IF defined(LIBXML_SAX1_ENABLED) or defined(LIBXML_HTML_ENABLED) or defined(LIBXML_WRITER_ENABLED) or defined(LIBXML_DOCB_ENABLED)}
-procedure xmlSAX2StartElement(ctx: pointer; filename: xmlCharPtr; atts: xmlCharPtrPtr); XMLCALL; XMLPUBFUN;
-procedure xmlSAX2EndElement(ctx: pointer; name: xmlCharPtr); XMLCALL; XMLPUBFUN;
+procedure xmlSAX2StartElement(ctx: pointer; filename: xmlCharPtr; atts: xmlCharPtrPtr); EXTDECL; external xml2lib;
+procedure xmlSAX2EndElement(ctx: pointer; name: xmlCharPtr); EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_SAX1_ENABLED or LIBXML_HTML_ENABLED *)
 procedure xmlSAX2StartElementNs(ctx: pointer; localname, prefix, URI: xmlCharPtr; nb_namespaces: cint; namespaces: xmlCharPtrPtr;
-  nb_attributes, nb_defaulted: cint; attributes: xmlCharPtrPtr); XMLCALL; XMLPUBFUN;
-procedure xmlSAX2EndElementNs(ctx: pointer; localname, prefix, URI: xmlCharPtr); XMLCALL; XMLPUBFUN;
-procedure xmlSAX2Reference(ctx: pointer; name: xmlCharPtr); XMLCALL; XMLPUBFUN;
-procedure xmlSAX2Characters(ctx: pointer; name: xmlCharPtr; len: cint); XMLCALL; XMLPUBFUN;
-procedure xmlSAX2IgnorableWhitespace(ctx: pointer; name: xmlCharPtr; len: cint); XMLCALL; XMLPUBFUN;
-procedure xmlSAX2ProcessingInstruction(ctx: pointer; target, data: xmlCharPtr); XMLCALL; XMLPUBFUN;
-procedure xmlSAX2Comment(ctx: pointer; value: xmlCharPtr); XMLCALL; XMLPUBFUN;
-procedure xmlSAX2CDataBlock(ctx: pointer; value: xmlCharPtr; len: cint); XMLCALL; XMLPUBFUN;
+  nb_attributes, nb_defaulted: cint; attributes: xmlCharPtrPtr); EXTDECL; external xml2lib;
+procedure xmlSAX2EndElementNs(ctx: pointer; localname, prefix, URI: xmlCharPtr); EXTDECL; external xml2lib;
+procedure xmlSAX2Reference(ctx: pointer; name: xmlCharPtr); EXTDECL; external xml2lib;
+procedure xmlSAX2Characters(ctx: pointer; name: xmlCharPtr; len: cint); EXTDECL; external xml2lib;
+procedure xmlSAX2IgnorableWhitespace(ctx: pointer; name: xmlCharPtr; len: cint); EXTDECL; external xml2lib;
+procedure xmlSAX2ProcessingInstruction(ctx: pointer; target, data: xmlCharPtr); EXTDECL; external xml2lib;
+procedure xmlSAX2Comment(ctx: pointer; value: xmlCharPtr); EXTDECL; external xml2lib;
+procedure xmlSAX2CDataBlock(ctx: pointer; value: xmlCharPtr; len: cint); EXTDECL; external xml2lib;
 {$IFDEF LIBXML_SAX1_ENABLED}
-function xmlSAXDefaultVersion(version: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlSAXDefaultVersion(version: cint): cint; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_SAX1_ENABLED *)
 
-function xmlSAXVersion(hdlr: xmlSAXHandlerPtr; version: cint): cint; XMLCALL; XMLPUBFUN;
-procedure xmlSAX2InitDefaultSAXHandler(hdlr: xmlSAXHandlerPtr; warning: cint); XMLCALL; XMLPUBFUN;
+function xmlSAXVersion(hdlr: xmlSAXHandlerPtr; version: cint): cint; EXTDECL; external xml2lib;
+procedure xmlSAX2InitDefaultSAXHandler(hdlr: xmlSAXHandlerPtr; warning: cint); EXTDECL; external xml2lib;
 {$IFDEF LIBXML_HTML_ENABLED}
-procedure xmlSAX2InitHtmlDefaultSAXHandler(hdlr: xmlSAXHandlerPtr); XMLCALL; XMLPUBFUN;
-procedure htmlDefaultSAXHandlerInit; XMLCALL; XMLPUBFUN;
+procedure xmlSAX2InitHtmlDefaultSAXHandler(hdlr: xmlSAXHandlerPtr); EXTDECL; external xml2lib;
+procedure htmlDefaultSAXHandlerInit; EXTDECL; external xml2lib;
 {$ENDIF}
 {$IFDEF LIBXML_DOCB_ENABLED}
-procedure xmlSAX2InitDocbDefaultSAXHandler(hdlr: xmlSAXHandlerPtr); XMLCALL; XMLPUBFUN;
-procedure docbDefaultSAXHandlerInit; XMLCALL; XMLPUBFUN;
+procedure xmlSAX2InitDocbDefaultSAXHandler(hdlr: xmlSAXHandlerPtr); EXTDECL; external xml2lib;
+procedure docbDefaultSAXHandlerInit; EXTDECL; external xml2lib;
 {$ENDIF}
-procedure xmlDefaultSAXHandlerInit; XMLCALL; XMLPUBFUN;
+procedure xmlDefaultSAXHandlerInit; EXTDECL; external xml2lib;
 {$ENDIF}

packages/libxml/src/c14n.inc

@@ -48,21 +48,21 @@
  * This is the core C14N function
  *)
 
-  xmlC14NIsVisibleCallback = function(user_data: pointer; node, parent: xmlNodePtr): cint; XMLCALL;
+  xmlC14NIsVisibleCallback = function(user_data: pointer; node, parent: xmlNodePtr): cint; EXTDECL;
 {$ENDIF}
 
 {$IFDEF FUNCTION}
 function xmlC14NDocSaveTo(doc: xmlDocPtr; nodes: xmlNodeSetPtr; exclusive: cint; inclusive_ns_prefixes: xmlCharPtrPtr;
-  with_comments: cint; buf: xmlOutputBufferPtr): cint; XMLCALL; XMLPUBFUN;
+  with_comments: cint; buf: xmlOutputBufferPtr): cint; EXTDECL; external xml2lib;
 
 function xmlC14NDocDumpMemory(doc: xmlDocPtr; nodes: xmlNodeSetPtr; exclusive: cint; inclusive_ns_prefixes: xmlCharPtrPtr;
-  with_comments: cint; doc_txt_ptr: xmlCharPtrPtr): cint; XMLCALL; XMLPUBFUN;
+  with_comments: cint; doc_txt_ptr: xmlCharPtrPtr): cint; EXTDECL; external xml2lib;
 
 function xmlC14NDocSave(doc: xmlDocPtr; nodes: xmlNodeSetPtr; exclusive: cint; inclusive_ns_prefixes: xmlCharPtrPtr;
-  with_comments: cint; filename: pchar; compression: cint): cint; XMLCALL; XMLPUBFUN;
+  with_comments: cint; filename: pchar; compression: cint): cint; EXTDECL; external xml2lib;
 
 function xmlC14NExecute(doc: xmlDocPtr; is_visible_callback: xmlC14NIsVisibleCallback; user_data: pointer;
-  exclusive: cint; inclusive_ns_prefixes: xmlCharPtrPtr; with_comments: cint; buf: xmlOutputBufferPtr): cint; XMLCALL; XMLPUBFUN;
+  exclusive: cint; inclusive_ns_prefixes: xmlCharPtrPtr; with_comments: cint; buf: xmlOutputBufferPtr): cint; EXTDECL; external xml2lib;
 {$ENDIF}
 
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)

packages/libxml/src/catalog.inc

@@ -62,56 +62,56 @@
 (*
  * Operations on a given catalog.
  *)
-function xmlNewCatalog(sgml: cint): xmlCatalogPtr; XMLCALL; XMLPUBFUN;
-function xmlLoadACatalog(filename: pchar): xmlCatalogPtr; XMLCALL; XMLPUBFUN;
-function xmlLoadSGMLSuperCatalog(filename: pchar): xmlCatalogPtr; XMLCALL; XMLPUBFUN;
-function xmlLoadACatalog(catal: xmlCatalogPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlACatalogAdd(catal: xmlCatalogPtr; _type, orig, replace: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlACatalogRemove(catal: xmlCatalogPtr; value: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlACatalogResolve(catal: xmlCatalogPtr; pubID, sysID: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlACatalogResolveSystem(catal: xmlCatalogPtr; sysID: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlACatalogResolvePublic(catal: xmlCatalogPtr; pubID: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlACatalogResolveURI(catal: xmlCatalogPtr; URI: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
+function xmlNewCatalog(sgml: cint): xmlCatalogPtr; EXTDECL; external xml2lib;
+function xmlLoadACatalog(filename: pchar): xmlCatalogPtr; EXTDECL; external xml2lib;
+function xmlLoadSGMLSuperCatalog(filename: pchar): xmlCatalogPtr; EXTDECL; external xml2lib;
+function xmlLoadACatalog(catal: xmlCatalogPtr): cint; EXTDECL; external xml2lib;
+function xmlACatalogAdd(catal: xmlCatalogPtr; _type, orig, replace: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlACatalogRemove(catal: xmlCatalogPtr; value: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlACatalogResolve(catal: xmlCatalogPtr; pubID, sysID: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlACatalogResolveSystem(catal: xmlCatalogPtr; sysID: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlACatalogResolvePublic(catal: xmlCatalogPtr; pubID: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlACatalogResolveURI(catal: xmlCatalogPtr; URI: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_OUTPUT_ENABLED}
-procedure xmlACatalogDump(catal: xmlCatalogPtr; _out: PFILE); XMLCALL; XMLPUBFUN;
+procedure xmlACatalogDump(catal: xmlCatalogPtr; _out: PFILE); EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
-procedure xmlFreeCatalog(catal: xmlCatalogPtr); XMLCALL; XMLPUBFUN;
-function xmlCatalogIsEmpty(catal: xmlCatalogPtr): cint; XMLCALL; XMLPUBFUN;
+procedure xmlFreeCatalog(catal: xmlCatalogPtr); EXTDECL; external xml2lib;
+function xmlCatalogIsEmpty(catal: xmlCatalogPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * Global operations.
  *)
-procedure xmlInitializeCatalog; XMLCALL; XMLPUBFUN;
-function xmlLoadCatalog(filename: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlLoadCatalogs(paths: pchar): cint; XMLCALL; XMLPUBFUN;
-procedure xmlCatalogCleanup; XMLCALL; XMLPUBFUN;
+procedure xmlInitializeCatalog; EXTDECL; external xml2lib;
+function xmlLoadCatalog(filename: pchar): cint; EXTDECL; external xml2lib;
+function xmlLoadCatalogs(paths: pchar): cint; EXTDECL; external xml2lib;
+procedure xmlCatalogCleanup; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_OUTPUT_ENABLED}
-procedure xmlCatalogDump(_out: PFILE); XMLCALL; XMLPUBFUN;
+procedure xmlCatalogDump(_out: PFILE); EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
-function xmlCatalogResolve(pubID, sysID: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlCatalogResolveSystem(sysID: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlCatalogResolvePublic(pubID: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlCatalogResolveURI(URI: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlCatalogAdd(_type, orig, replace: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlCatalogRemove(value: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlParseCatalogFile(filename: pchar): xmlDocPtr; XMLCALL; XMLPUBFUN;
-function xmlCatalogConvert: cint; XMLCALL; XMLPUBFUN;
+function xmlCatalogResolve(pubID, sysID: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlCatalogResolveSystem(sysID: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlCatalogResolvePublic(pubID: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlCatalogResolveURI(URI: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlCatalogAdd(_type, orig, replace: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlCatalogRemove(value: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlParseCatalogFile(filename: pchar): xmlDocPtr; EXTDECL; external xml2lib;
+function xmlCatalogConvert: cint; EXTDECL; external xml2lib;
 
 (*
  * Strictly minimal interfaces for per-document catalogs used
  * by the parser.
  *)
-procedure xmlCatalogFreeLocal(catalogs: pointer); XMLCALL; XMLPUBFUN;
-function xmlCatalogAddLocal(catalogs: pointer; URL: xmlCharPtr): pointer; XMLCALL; XMLPUBFUN;
-function xmlCatalogLocalResolve(catalogs: pointer; pubID, sysID: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlCatalogLocalResolveURI(catalogs: pointer; URI: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
+procedure xmlCatalogFreeLocal(catalogs: pointer); EXTDECL; external xml2lib;
+function xmlCatalogAddLocal(catalogs: pointer; URL: xmlCharPtr): pointer; EXTDECL; external xml2lib;
+function xmlCatalogLocalResolve(catalogs: pointer; pubID, sysID: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlCatalogLocalResolveURI(catalogs: pointer; URI: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
 
 (*
  * Preference settings.
  *)
-function xmlCatalogSetDebug(level: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlCatalogSetDefaultPrefer(prefer: xmlCatalogPrefer): cint; XMLCALL; XMLPUBFUN;
-procedure xmlCatalogSetDefaults(allow: xmlCatalogAllow); XMLCALL; XMLPUBFUN;
-function xmlCatalogGetDefaults: xmlCatalogAllow; XMLCALL; XMLPUBFUN;
+function xmlCatalogSetDebug(level: cint): cint; EXTDECL; external xml2lib;
+function xmlCatalogSetDefaultPrefer(prefer: xmlCatalogPrefer): cint; EXTDECL; external xml2lib;
+procedure xmlCatalogSetDefaults(allow: xmlCatalogAllow); EXTDECL; external xml2lib;
+function xmlCatalogGetDefaults: xmlCatalogAllow; EXTDECL; external xml2lib;
 {$ENDIF}
 {$ENDIF} (* LIBXML_CATALOG_ENABLED *)

packages/libxml/src/chvalid.inc

@@ -44,7 +44,7 @@
 (**
  * Range checking routine
  *)
-function xmlCharInRange(val: cint; group: xmlChRangeGroupPtr): cbool; XMLCALL; XMLPUBFUN;
+function xmlCharInRange(val: cint; group: xmlChRangeGroupPtr): cbool; EXTDECL; external xml2lib;
 
 (**
  * xmlIsBaseChar_ch:
@@ -64,7 +64,7 @@ function xmlIsBaseCharQ(c: cint): cbool;
 
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlIsBaseCharGroup: xmlChRangeGroup; XMLPUBVAR;
+  xmlIsBaseCharGroup: xmlChRangeGroup; cvar; external;
   __xmlIsBaseCharGroup: xmlChRangeGroupPtr = @xmlIsBaseCharGroup;
 {$ELSE}
 var
@@ -105,7 +105,7 @@ function xmlIsCharQ(c: cint): cbool;
 
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlIsCharGroup: xmlChRangeGroup; XMLPUBVAR;
+  xmlIsCharGroup: xmlChRangeGroup; cvar; external;
   __xmlIsCharGroup: xmlChRangeGroupPtr = @xmlIsCharGroup;
 {$ELSE}
 var
@@ -122,7 +122,7 @@ function xmlIsCombiningQ(c: cint): cbool;
 
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlIsCombiningGroup: xmlChRangeGroup; XMLPUBVAR;
+  xmlIsCombiningGroup: xmlChRangeGroup; cvar; external;
   __xmlIsCombiningGroup: xmlChRangeGroupPtr = @xmlIsCombiningGroup;
 {$ELSE}
 var
@@ -147,7 +147,7 @@ function xmlIsDigitQ(c: cint): cbool;
 
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlIsDigitGroup: xmlChRangeGroup; XMLPUBVAR;
+  xmlIsDigitGroup: xmlChRangeGroup; cvar; external;
   __xmlIsDigitGroup: xmlChRangeGroupPtr = @xmlIsDigitGroup;
 {$ELSE}
 var
@@ -172,7 +172,7 @@ function xmlIsExtenderQ(c: cint): cbool;
 
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlIsExtenderGroup: xmlChRangeGroup; XMLPUBVAR;
+  xmlIsExtenderGroup: xmlChRangeGroup; cvar; external;
   __xmlIsExtenderGroup: xmlChRangeGroupPtr = @xmlIsExtenderGroup;
 {$ELSE}
 var
@@ -193,10 +193,10 @@ type
 
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlIsIdeographicGroup: xmlChRangeGroup; XMLPUBVAR;
+  xmlIsIdeographicGroup: xmlChRangeGroup; cvar; external;
   __xmlIsIdeographicGroup: xmlChRangeGroupPtr = @xmlIsIdeographicGroup;
   
-  xmlIsPubidChar_tab: char_tab; XMLPUBVAR;
+  xmlIsPubidChar_tab: char_tab; cvar; external;
   __xmlIsPubidChar_tab: pchar_tab = @xmlIsPubidChar_tab;
 {$ELSE}
 var
@@ -220,12 +220,12 @@ function xmlIsPubidChar_ch(c: cint): cbool;
  *)
 function xmlIsPubidCharQ(c: cint): cbool;
 
-function xmlIsBaseChar(ch: cuint): cbool; XMLCALL; XMLPUBFUN;
-function xmlIsBlank(ch: cuint): cbool; XMLCALL; XMLPUBFUN;
-function xmlIsChar(ch: cuint): cbool; XMLCALL; XMLPUBFUN;
-function xmlIsCombining(ch: cuint): cbool; XMLCALL; XMLPUBFUN;
-function xmlIsDigit(ch: cuint): cbool; XMLCALL; XMLPUBFUN;
-function xmlIsExtender(ch: cuint): cbool; XMLCALL; XMLPUBFUN;
-function xmlIsIdeographic(ch: cuint): cbool; XMLCALL; XMLPUBFUN;
-function xmlIsPubidChar(ch: cuint): cbool; XMLCALL; XMLPUBFUN;
+function xmlIsBaseChar(ch: cuint): cbool; EXTDECL; external xml2lib;
+function xmlIsBlank(ch: cuint): cbool; EXTDECL; external xml2lib;
+function xmlIsChar(ch: cuint): cbool; EXTDECL; external xml2lib;
+function xmlIsCombining(ch: cuint): cbool; EXTDECL; external xml2lib;
+function xmlIsDigit(ch: cuint): cbool; EXTDECL; external xml2lib;
+function xmlIsExtender(ch: cuint): cbool; EXTDECL; external xml2lib;
+function xmlIsIdeographic(ch: cuint): cbool; EXTDECL; external xml2lib;
+function xmlIsPubidChar(ch: cuint): cbool; EXTDECL; external xml2lib;
 {$ENDIF}

packages/libxml/src/debugXML.inc

@@ -25,39 +25,39 @@ extern "C" {
 (*
  * The standard Dump routines.
  *)
-XMLPUBFUN void XMLCALL	
+external xml2lib void EXTDECL	
 	xmlDebugDumpString	(FILE *output,
 				 xmlChar *str);
-XMLPUBFUN void XMLCALL	
+external xml2lib void EXTDECL	
 	xmlDebugDumpAttr	(FILE *output,
 				 xmlAttrPtr attr,
 				 int depth);
-XMLPUBFUN void XMLCALL	
+external xml2lib void EXTDECL	
 	xmlDebugDumpAttrList	(FILE *output,
 				 xmlAttrPtr attr,
 				 int depth);
-XMLPUBFUN void XMLCALL	
+external xml2lib void EXTDECL	
 	xmlDebugDumpOneNode	(FILE *output,
 				 xmlNodePtr node,
 				 int depth);
-XMLPUBFUN void XMLCALL
+external xml2lib void EXTDECL
 	xmlDebugDumpNode	(FILE *output,
 				 xmlNodePtr node,
 				 int depth);
-XMLPUBFUN void XMLCALL
+external xml2lib void EXTDECL
 	xmlDebugDumpNodeList	(FILE *output,
 				 xmlNodePtr node,
 				 int depth);
-XMLPUBFUN void XMLCALL
+external xml2lib void EXTDECL
 	xmlDebugDumpDocumentHead(FILE *output,
 				 xmlDocPtr doc);
-XMLPUBFUN void XMLCALL
+external xml2lib void EXTDECL
 	xmlDebugDumpDocument	(FILE *output,
 				 xmlDocPtr doc);
-XMLPUBFUN void XMLCALL	
+external xml2lib void EXTDECL	
 	xmlDebugDumpDTD		(FILE *output,
 				 xmlDtdPtr dtd);
-XMLPUBFUN void XMLCALL	
+external xml2lib void EXTDECL	
 	xmlDebugDumpEntities	(FILE *output,
 				 xmlDocPtr doc);
 
@@ -67,7 +67,7 @@ XMLPUBFUN void XMLCALL
  *								*
  ****************************************************************)
 
-XMLPUBFUN int XMLCALL
+external xml2lib int EXTDECL
 	xmlDebugCheckDocument	(FILE * output,
 				 xmlDocPtr doc);
 
@@ -77,12 +77,12 @@ XMLPUBFUN int XMLCALL
  *								*
  ****************************************************************)
 
-XMLPUBFUN void XMLCALL	
+external xml2lib void EXTDECL	
 	xmlLsOneNode		(FILE *output, xmlNodePtr node);
-XMLPUBFUN int XMLCALL	
+external xml2lib int EXTDECL	
 	xmlLsCountNode		(xmlNodePtr node);
 
-XMLPUBFUN char * XMLCALL 
+external xml2lib char * EXTDECL 
 	xmlBoolToText		(int boolval);
 
 (****************************************************************
@@ -136,63 +136,63 @@ typedef int (* xmlShellCmd) (xmlShellCtxtPtr ctxt,
 			     xmlNodePtr node,
 			     xmlNodePtr node2);
 
-XMLPUBFUN void XMLCALL	
+external xml2lib void EXTDECL	
 	xmlShellPrintXPathError	(int errorType,
 				 char *arg);
-XMLPUBFUN void XMLCALL	
+external xml2lib void EXTDECL	
 	xmlShellPrintXPathResult(xmlXPathObjectPtr list);
-XMLPUBFUN int XMLCALL	
+external xml2lib int EXTDECL	
 	xmlShellList		(xmlShellCtxtPtr ctxt,
 				 char *arg,
 				 xmlNodePtr node,
 				 xmlNodePtr node2);
-XMLPUBFUN int XMLCALL	
+external xml2lib int EXTDECL	
 	xmlShellBase		(xmlShellCtxtPtr ctxt,
 				 char *arg,
 				 xmlNodePtr node,
 				 xmlNodePtr node2);
-XMLPUBFUN int XMLCALL	
+external xml2lib int EXTDECL	
 	xmlShellDir		(xmlShellCtxtPtr ctxt,
 				 char *arg,
 				 xmlNodePtr node,
 				 xmlNodePtr node2);
-XMLPUBFUN int XMLCALL	
+external xml2lib int EXTDECL	
 	xmlShellLoad		(xmlShellCtxtPtr ctxt,
 				 char *filename,
 				 xmlNodePtr node,
 				 xmlNodePtr node2);
 { LIBXML_OUTPUT_ENABLED
-XMLPUBFUN void XMLCALL	
+external xml2lib void EXTDECL	
 	xmlShellPrintNode	(xmlNodePtr node);
-XMLPUBFUN int XMLCALL	
+external xml2lib int EXTDECL	
 	xmlShellCat		(xmlShellCtxtPtr ctxt,
 				 char *arg,
 				 xmlNodePtr node,
 				 xmlNodePtr node2);
-XMLPUBFUN int XMLCALL	
+external xml2lib int EXTDECL	
 	xmlShellWrite		(xmlShellCtxtPtr ctxt,
 				 char *filename,
 				 xmlNodePtr node,
 				 xmlNodePtr node2);
-XMLPUBFUN int XMLCALL	
+external xml2lib int EXTDECL	
 	xmlShellSave		(xmlShellCtxtPtr ctxt,
 				 char *filename,
 				 xmlNodePtr node,
 				 xmlNodePtr node2);
 #endif (* LIBXML_OUTPUT_ENABLED *)
 { LIBXML_VALID_ENABLED
-XMLPUBFUN int XMLCALL	
+external xml2lib int EXTDECL	
 	xmlShellValidate	(xmlShellCtxtPtr ctxt,
 				 char *dtd,
 				 xmlNodePtr node,
 				 xmlNodePtr node2);
 #endif (* LIBXML_VALID_ENABLED *)
-XMLPUBFUN int XMLCALL	
+external xml2lib int EXTDECL	
 	xmlShellDu		(xmlShellCtxtPtr ctxt,
 				 char *arg,
 				 xmlNodePtr tree,
 				 xmlNodePtr node2);
-XMLPUBFUN int XMLCALL	
+external xml2lib int EXTDECL	
 	xmlShellPwd		(xmlShellCtxtPtr ctxt,
 				 char *buffer,
 				 xmlNodePtr node,
@@ -201,7 +201,7 @@ XMLPUBFUN int XMLCALL
 (*
  * The Shell interface.
  *)
-XMLPUBFUN void XMLCALL	
+external xml2lib void EXTDECL	
 	xmlShell		(xmlDocPtr doc,
 				 char *filename,
 				 xmlShellReadlineFunc input,

packages/libxml/src/dict.inc

@@ -23,22 +23,22 @@
 (*
  * Constructor and destructor.
  *)
-function xmlDictCreate: xmlDictPtr; XMLCALL; XMLPUBFUN;
-function xmlDictCreateSub(sub: xmlDictPtr): xmlDictPtr; XMLCALL; XMLPUBFUN;
-function xmlDictReference(dict: xmlDictPtr): cint; XMLCALL; XMLPUBFUN;
-procedure xmlDictFree(dict: xmlDictPtr); XMLCALL; XMLPUBFUN;
+function xmlDictCreate: xmlDictPtr; EXTDECL; external xml2lib;
+function xmlDictCreateSub(sub: xmlDictPtr): xmlDictPtr; EXTDECL; external xml2lib;
+function xmlDictReference(dict: xmlDictPtr): cint; EXTDECL; external xml2lib;
+procedure xmlDictFree(dict: xmlDictPtr); EXTDECL; external xml2lib;
 
 (*
  * Lookup of entry in the dictionnary.
  *)
-function xmlDictLookup(dict: xmlDictPtr; name: xmlCharPtr; len: cint): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlDictExists(dict: xmlDictPtr; name: xmlCharPtr; len: cint): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlDictQLookup(dict: xmlDictPtr; prefix, name: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlDictOwns(dict: xmlDictPtr; str: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlDictOwns(dict: xmlDictPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlDictLookup(dict: xmlDictPtr; name: xmlCharPtr; len: cint): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlDictExists(dict: xmlDictPtr; name: xmlCharPtr; len: cint): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlDictQLookup(dict: xmlDictPtr; prefix, name: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlDictOwns(dict: xmlDictPtr; str: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlDictOwns(dict: xmlDictPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * Cleanup function
  *)
-procedure xmlDictCleanup; XMLCALL; XMLPUBFUN;
+procedure xmlDictCleanup; EXTDECL; external xml2lib;
 {$ENDIF}

packages/libxml/src/encoding.inc

@@ -88,7 +88,7 @@
  *     if the return value is positive, else unpredictiable.
  * The value of @outlen after return is the number of octets consumed.
  *)
-  xmlCharEncodingInputFunc = function(_out: pchar; outlen: pcint; _in: pchar; inlen: pcint): cint; XMLCDECL;
+  xmlCharEncodingInputFunc = function(_out: pchar; outlen: pcint; _in: pchar; inlen: pcint): cint; cdecl;
 
 (**
  * xmlCharEncodingOutputFunc:
@@ -108,7 +108,7 @@
  *     if the return value is positive, else unpredictiable.
  * The value of @outlen after return is the number of octets produced.
  *)
-  xmlCharEncodingOutputFunc = function(_out: pchar; outlen: pcint; _in: pchar; inlen: pcint): cint; XMLCDECL;
+  xmlCharEncodingOutputFunc = function(_out: pchar; outlen: pcint; _in: pchar; inlen: pcint): cint; cdecl;
 
 (*
  * Block defining the handlers for non UTF-8 encodings.
@@ -129,37 +129,37 @@
 (*
  * Interfaces for encoding handlers.
  *)
-procedure xmlInitCharEncodingHandlers; XMLCALL; XMLPUBFUN;
-procedure xmlCleanupCharEncodingHandlers; XMLCALL; XMLPUBFUN;
-procedure xmlRegisterCharEncodingHandler(handler: xmlCharEncodingHandlerPtr); XMLCALL; XMLPUBFUN;
-function xmlGetCharEncodingHandler(enc: xmlCharEncoding): xmlCharEncodingHandlerPtr; XMLCALL; XMLPUBFUN;
-function xmlFindCharEncodingHandler(name: pchar): xmlCharEncodingHandlerPtr; XMLCALL; XMLPUBFUN;
-function xmlNewCharEncodingHandler(name: pchar; input: xmlCharEncodingInputFunc; output: xmlCharEncodingOutputFunc): xmlCharEncodingHandlerPtr; XMLCALL; XMLPUBFUN;
+procedure xmlInitCharEncodingHandlers; EXTDECL; external xml2lib;
+procedure xmlCleanupCharEncodingHandlers; EXTDECL; external xml2lib;
+procedure xmlRegisterCharEncodingHandler(handler: xmlCharEncodingHandlerPtr); EXTDECL; external xml2lib;
+function xmlGetCharEncodingHandler(enc: xmlCharEncoding): xmlCharEncodingHandlerPtr; EXTDECL; external xml2lib;
+function xmlFindCharEncodingHandler(name: pchar): xmlCharEncodingHandlerPtr; EXTDECL; external xml2lib;
+function xmlNewCharEncodingHandler(name: pchar; input: xmlCharEncodingInputFunc; output: xmlCharEncodingOutputFunc): xmlCharEncodingHandlerPtr; EXTDECL; external xml2lib;
 
 (*
  * Interfaces for encoding names and aliases.
  *)
-function xmlAddEncodingAlias(name: pchar; alias: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlDelEncodingAlias(alias: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlGetEncodingAlias(alias: pchar): pchar; XMLCALL; XMLPUBFUN;
-procedure xmlCleanupEncodingAliases; XMLCALL; XMLPUBFUN;
-function xmlParseCharEncoding(name: pchar): xmlCharEncoding; XMLCALL; XMLPUBFUN;
-function xmlGetCharEncodingName(enc: xmlCharEncoding): pchar; XMLCALL; XMLPUBFUN;
+function xmlAddEncodingAlias(name: pchar; alias: pchar): cint; EXTDECL; external xml2lib;
+function xmlDelEncodingAlias(alias: pchar): cint; EXTDECL; external xml2lib;
+function xmlGetEncodingAlias(alias: pchar): pchar; EXTDECL; external xml2lib;
+procedure xmlCleanupEncodingAliases; EXTDECL; external xml2lib;
+function xmlParseCharEncoding(name: pchar): xmlCharEncoding; EXTDECL; external xml2lib;
+function xmlGetCharEncodingName(enc: xmlCharEncoding): pchar; EXTDECL; external xml2lib;
 
 (*
  * Interfaces directly used by the parsers.
  *)
-function xmlDetectCharEncoding(_in: pchar; len: cint): xmlCharEncoding; XMLCALL; XMLPUBFUN;
-function xmlCharEncOutFunc(handler: xmlCharEncodingHandlerPtr; _out, _in: xmlBufferPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlCharEncInFunc(handler: xmlCharEncodingHandlerPtr; _out, _in: xmlBufferPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlCharEncFirstLine(handler: xmlCharEncodingHandlerPtr; _out, _in: xmlBufferPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlCharEncCloseFunc(handler: xmlCharEncodingHandlerPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlDetectCharEncoding(_in: pchar; len: cint): xmlCharEncoding; EXTDECL; external xml2lib;
+function xmlCharEncOutFunc(handler: xmlCharEncodingHandlerPtr; _out, _in: xmlBufferPtr): cint; EXTDECL; external xml2lib;
+function xmlCharEncInFunc(handler: xmlCharEncodingHandlerPtr; _out, _in: xmlBufferPtr): cint; EXTDECL; external xml2lib;
+function xmlCharEncFirstLine(handler: xmlCharEncodingHandlerPtr; _out, _in: xmlBufferPtr): cint; EXTDECL; external xml2lib;
+function xmlCharEncCloseFunc(handler: xmlCharEncodingHandlerPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * Export a few useful functions
  *)
 {$IFDEF LIBXML_OUTPUT_ENABLED}
-function UTF8Toisolat1(_out: pchar; outlen: pcint; _in: pchar; inlen: pcint): cint; XMLCALL; XMLPUBFUN;
+function UTF8Toisolat1(_out: pchar; outlen: pcint; _in: pchar; inlen: pcint): cint; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
-function isolat1ToUTF8(_out: pchar; outlen: pcint; _in: pchar; inlen: pcint): cint; XMLCALL; XMLPUBFUN;
+function isolat1ToUTF8(_out: pchar; outlen: pcint; _in: pchar; inlen: pcint): cint; EXTDECL; external xml2lib;
 {$ENDIF}

packages/libxml/src/entities.inc

@@ -67,29 +67,29 @@
  *)
 
 {$IFDEF LIBXML_LEGACY_ENABLED}
-procedure xmlInitializePredefinedEntities; XMLCALL; XMLPUBFUN;
+procedure xmlInitializePredefinedEntities; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_LEGACY_ENABLED *)
-function xmlAddDocEntity(doc: xmlDocPtr; name: xmlCharPtr; _type: cint; ExternalID, SystemID, content: xmlCharPtr): xmlEntityPtr; XMLCALL; XMLPUBFUN;
-function xmlAddDtdEntity(doc: xmlDocPtr; name: xmlCharPtr; _type: cint; ExternalID, SystemID, content: xmlCharPtr): xmlEntityPtr; XMLCALL; XMLPUBFUN;
-function xmlGetPredefinedEntity(name: xmlCharPtr): xmlEntityPtr; XMLCALL; XMLPUBFUN;
-function xmlGetDocEntity(doc: xmlDocPtr; name: xmlCharPtr): xmlEntityPtr; XMLCALL; XMLPUBFUN;
-function xmlGetDtdEntity(doc: xmlDocPtr; name: xmlCharPtr): xmlEntityPtr; XMLCALL; XMLPUBFUN;
-function xmlGetParameterEntity(doc: xmlDocPtr; name: xmlCharPtr): xmlEntityPtr; XMLCALL; XMLPUBFUN;
+function xmlAddDocEntity(doc: xmlDocPtr; name: xmlCharPtr; _type: cint; ExternalID, SystemID, content: xmlCharPtr): xmlEntityPtr; EXTDECL; external xml2lib;
+function xmlAddDtdEntity(doc: xmlDocPtr; name: xmlCharPtr; _type: cint; ExternalID, SystemID, content: xmlCharPtr): xmlEntityPtr; EXTDECL; external xml2lib;
+function xmlGetPredefinedEntity(name: xmlCharPtr): xmlEntityPtr; EXTDECL; external xml2lib;
+function xmlGetDocEntity(doc: xmlDocPtr; name: xmlCharPtr): xmlEntityPtr; EXTDECL; external xml2lib;
+function xmlGetDtdEntity(doc: xmlDocPtr; name: xmlCharPtr): xmlEntityPtr; EXTDECL; external xml2lib;
+function xmlGetParameterEntity(doc: xmlDocPtr; name: xmlCharPtr): xmlEntityPtr; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_LEGACY_ENABLED}
-function xmlEncodeEntities(doc: xmlDocPtr; input: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
+function xmlEncodeEntities(doc: xmlDocPtr; input: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_LEGACY_ENABLED *)
-function xmlEncodeEntitiesReentrant(doc: xmlDocPtr; input: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlEncodeSpecialChars(doc: xmlDocPtr; input: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlCreateEntitiesTable: xmlEntitiesTablePtr; XMLCALL; XMLPUBFUN;
+function xmlEncodeEntitiesReentrant(doc: xmlDocPtr; input: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlEncodeSpecialChars(doc: xmlDocPtr; input: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlCreateEntitiesTable: xmlEntitiesTablePtr; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_TREE_ENABLED}
-function xmlCopyEntitiesTable(table: xmlEntitiesTablePtr): xmlEntitiesTablePtr; XMLCALL; XMLPUBFUN;
+function xmlCopyEntitiesTable(table: xmlEntitiesTablePtr): xmlEntitiesTablePtr; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_TREE_ENABLED *)
-procedure xmlFreeEntitiesTable(table: xmlEntitiesTablePtr); XMLCALL; XMLPUBFUN;
+procedure xmlFreeEntitiesTable(table: xmlEntitiesTablePtr); EXTDECL; external xml2lib;
 {$IFDEF LIBXML_OUTPUT_ENABLED}
-procedure xmlDumpEntitiesTable(buf: xmlBufferPtr; table: xmlEntitiesTablePtr); XMLCALL; XMLPUBFUN;
-procedure xmlDumpEntityDecl(buf: xmlBufferPtr; ent: xmlEntityPtr); XMLCALL; XMLPUBFUN;
+procedure xmlDumpEntitiesTable(buf: xmlBufferPtr; table: xmlEntitiesTablePtr); EXTDECL; external xml2lib;
+procedure xmlDumpEntityDecl(buf: xmlBufferPtr; ent: xmlEntityPtr); EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
 {$IFDEF LIBXML_LEGACY_ENABLED}
-procedure xmlCleanupPredefinedEntities; XMLCALL; XMLPUBFUN;
+procedure xmlCleanupPredefinedEntities; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_LEGACY_ENABLED *)
 {$ENDIF}

packages/libxml/src/globals.inc

@@ -20,18 +20,18 @@
 {$ENDIF}
 
 {$IFDEF FUNCTION}
-procedure xmlInitGlobals; XMLCALL; XMLPUBFUN;
-procedure xmlCleanupGlobals; XMLCALL; XMLPUBFUN;
+procedure xmlInitGlobals; EXTDECL; external xml2lib;
+procedure xmlCleanupGlobals; EXTDECL; external xml2lib;
 {$ENDIF}
 
 {$IFDEF TYPE}
-  xmlParserInputBufferCreateFilenameFunc = function(URI: pchar; enc: xmlCharEncoding): xmlParserInputBufferPtr; XMLCALL;
-  xmlOutputBufferCreateFilenameFunc = function(URI: pchar; encoder: xmlCharEncodingHandlerPtr; compression: cint): xmlOutputBufferPtr; XMLCALL;
+  xmlParserInputBufferCreateFilenameFunc = function(URI: pchar; enc: xmlCharEncoding): xmlParserInputBufferPtr; EXTDECL;
+  xmlOutputBufferCreateFilenameFunc = function(URI: pchar; encoder: xmlCharEncodingHandlerPtr; compression: cint): xmlOutputBufferPtr; EXTDECL;
 {$ENDIF}
 
 {$IFDEF FUNCTION}
-function xmlParserInputBufferCreateFilenameDefault(func: xmlParserInputBufferCreateFilenameFunc): xmlParserInputBufferCreateFilenameFunc; XMLCALL; XMLPUBFUN;
-function xmlOutputBufferCreateFilenameDefault(func: xmlOutputBufferCreateFilenameFunc): xmlOutputBufferCreateFilenameFunc; XMLCALL; XMLPUBFUN;
+function xmlParserInputBufferCreateFilenameDefault(func: xmlParserInputBufferCreateFilenameFunc): xmlParserInputBufferCreateFilenameFunc; EXTDECL; external xml2lib;
+function xmlOutputBufferCreateFilenameDefault(func: xmlOutputBufferCreateFilenameFunc): xmlOutputBufferCreateFilenameFunc; EXTDECL; external xml2lib;
 {$ENDIF}
 
 (*
@@ -40,8 +40,8 @@ function xmlOutputBufferCreateFilenameDefault(func: xmlOutputBufferCreateFilenam
  *)
 
 {$IFDEF TYPE}
-  xmlRegisterNodeFunc = procedure(node: xmlNodePtr); XMLCALL;
-  xmlDeregisterNodeFunc = procedure(node: xmlNodePtr); XMLCALL;
+  xmlRegisterNodeFunc = procedure(node: xmlNodePtr); EXTDECL;
+  xmlDeregisterNodeFunc = procedure(node: xmlNodePtr); EXTDECL;
 
   xmlGlobalState = record
     xmlParserVersion                        : pchar;
@@ -90,17 +90,17 @@ function xmlOutputBufferCreateFilenameDefault(func: xmlOutputBufferCreateFilenam
 {$ENDIF}
 
 {$IFDEF FUNCTION}
-procedure xmlInitializeGlobalState(gs: xmlGlobalStatePtr); XMLCALL; XMLPUBFUN;
-procedure xmlThrDefSetGenericErrorFunc(ctx: pointer; handler: xmlGenericErrorFunc); XMLCALL; XMLPUBFUN;
-procedure xmlThrDefSetStructuredErrorFunc(ctx: pointer; handler: xmlStructuredErrorFunc); XMLCALL; XMLPUBFUN;
+procedure xmlInitializeGlobalState(gs: xmlGlobalStatePtr); EXTDECL; external xml2lib;
+procedure xmlThrDefSetGenericErrorFunc(ctx: pointer; handler: xmlGenericErrorFunc); EXTDECL; external xml2lib;
+procedure xmlThrDefSetStructuredErrorFunc(ctx: pointer; handler: xmlStructuredErrorFunc); EXTDECL; external xml2lib;
 
-function xmlRegisterNodeDefault(func: xmlRegisterNodeFunc): xmlRegisterNodeFunc; XMLCALL; XMLPUBFUN;
-function xmlThrDefRegisterNodeDefault(func: xmlRegisterNodeFunc): xmlRegisterNodeFunc; XMLCALL; XMLPUBFUN;
-function xmlDeregisterNodeDefault(func: xmlRegisterNodeFunc): xmlDeregisterNodeFunc; XMLCALL; XMLPUBFUN;
-function xmlThrDefDeregisterNodeDefault(func: xmlRegisterNodeFunc): xmlDeregisterNodeFunc; XMLCALL; XMLPUBFUN;
+function xmlRegisterNodeDefault(func: xmlRegisterNodeFunc): xmlRegisterNodeFunc; EXTDECL; external xml2lib;
+function xmlThrDefRegisterNodeDefault(func: xmlRegisterNodeFunc): xmlRegisterNodeFunc; EXTDECL; external xml2lib;
+function xmlDeregisterNodeDefault(func: xmlRegisterNodeFunc): xmlDeregisterNodeFunc; EXTDECL; external xml2lib;
+function xmlThrDefDeregisterNodeDefault(func: xmlRegisterNodeFunc): xmlDeregisterNodeFunc; EXTDECL; external xml2lib;
 
-function xmlDeregisterNodeDefault(func: xmlOutputBufferCreateFilenameFunc): xmlOutputBufferCreateFilenameFunc; XMLCALL; XMLPUBFUN;
-function xmlThrDefDeregisterNodeDefault(func: xmlParserInputBufferCreateFilenameFunc): xmlParserInputBufferCreateFilenameFunc; XMLCALL; XMLPUBFUN;
+function xmlDeregisterNodeDefault(func: xmlOutputBufferCreateFilenameFunc): xmlOutputBufferCreateFilenameFunc; EXTDECL; external xml2lib;
+function xmlThrDefDeregisterNodeDefault(func: xmlParserInputBufferCreateFilenameFunc): xmlParserInputBufferCreateFilenameFunc; EXTDECL; external xml2lib;
 
 (** DOC_DISABLE *)
 (*
@@ -115,85 +115,85 @@ function xmlThrDefDeregisterNodeDefault(func: xmlParserInputBufferCreateFilename
 
 {$IFDEF LIBXML_THREAD_ALLOC_ENABLED}
 {$IFDEF LIBXML_THREAD_ENABLED}
-function __xmlMalloc: xmlMallocFuncPtr; XMLCALL; XMLPUBFUN;
+function __xmlMalloc: xmlMallocFuncPtr; EXTDECL; external xml2lib;
 {$DEFINE xmlMalloc := __xmlMalloc()^ }
 {$ELSE}
 var
-  xmlMalloc: xmlMallocFunc; {$IFNDEF NO_EXTERNAL_VARS}XMLPUBVAR;{$ENDIF}
+  xmlMalloc: xmlMallocFunc; {$IFNDEF NO_EXTERNAL_VARS}cvar; external;{$ENDIF}
 {$ENDIF}
 
 {$IFDEF LIBXML_THREAD_ENABLED}
-function __xmlMallocAtomic: xmlMallocFuncPtr; XMLCALL; XMLPUBFUN;
+function __xmlMallocAtomic: xmlMallocFuncPtr; EXTDECL; external xml2lib;
 #define xmlMallocAtomic ( *(__xmlMallocAtomic()))
 {$ELSE}
 var
-  xmlMallocAtomic: xmlMallocFunc; {$IFNDEF NO_EXTERNAL_VARS}XMLPUBVAR;{$ENDIF}
+  xmlMallocAtomic: xmlMallocFunc; {$IFNDEF NO_EXTERNAL_VARS}cvar; external;{$ENDIF}
 {$ENDIF}
 
 {$IFDEF LIBXML_THREAD_ENABLED}
-function __xmlRealloc: xmlReallocFuncPtr; XMLCALL; XMLPUBFUN;
+function __xmlRealloc: xmlReallocFuncPtr; EXTDECL; external xml2lib;
 #define xmlRealloc ( *(__xmlRealloc()))
 {$ELSE}
 var
-  xmlRealloc: xmlReallocFunc; {$IFNDEF NO_EXTERNAL_VARS}XMLPUBVAR;{$ENDIF}
+  xmlRealloc: xmlReallocFunc; {$IFNDEF NO_EXTERNAL_VARS}cvar; external;{$ENDIF}
 {$ENDIF}
 
 {$IFDEF LIBXML_THREAD_ENABLED}
-function __xmlFree: xmlFreeFuncPtr; XMLCALL; XMLPUBFUN;
+function __xmlFree: xmlFreeFuncPtr; EXTDECL; external xml2lib;
 #define xmlFree ( *(__xmlFree()))
 {$ELSE}
 var
-  xmlFree: xmlFreeFunc; {$IFNDEF NO_EXTERNAL_VARS}XMLPUBVAR;{$ENDIF}
+  xmlFree: xmlFreeFunc; {$IFNDEF NO_EXTERNAL_VARS}cvar; external;{$ENDIF}
 {$ENDIF}
 
 {$IFDEF LIBXML_THREAD_ENABLED}
-function __xmlMemStrdup: xmlStrdupFuncPtr; XMLCALL; XMLPUBFUN;
+function __xmlMemStrdup: xmlStrdupFuncPtr; EXTDECL; external xml2lib;
 #define xmlMemStrdup ( *(__xmlMemStrdup()))
 {$ELSE}
 var
-  xmlMemStrdup: xmlStrdupFunc; {$IFNDEF NO_EXTERNAL_VARS}XMLPUBVAR;{$ENDIF}
+  xmlMemStrdup: xmlStrdupFunc; {$IFNDEF NO_EXTERNAL_VARS}cvar; external;{$ENDIF}
 {$ENDIF}
 
 {$ELSE} (* !LIBXML_THREAD_ALLOC_ENABLED *)
 var
-  xmlMalloc: xmlMallocFunc; {$IFNDEF NO_EXTERNAL_VARS}XMLPUBVAR;{$ENDIF}
-  xmlMallocAtomic: xmlMallocFunc; {$IFNDEF NO_EXTERNAL_VARS}XMLPUBVAR;{$ENDIF}
-  xmlRealloc: xmlReallocFunc; {$IFNDEF NO_EXTERNAL_VARS}XMLPUBVAR;{$ENDIF}
-  xmlFree: xmlFreeFunc; {$IFNDEF NO_EXTERNAL_VARS}XMLPUBVAR;{$ENDIF}
-  xmlMemStrdup: xmlStrdupFunc; {$IFNDEF NO_EXTERNAL_VARS}XMLPUBVAR;{$ENDIF}
+  xmlMalloc: xmlMallocFunc; {$IFNDEF NO_EXTERNAL_VARS}cvar; external;{$ENDIF}
+  xmlMallocAtomic: xmlMallocFunc; {$IFNDEF NO_EXTERNAL_VARS}cvar; external;{$ENDIF}
+  xmlRealloc: xmlReallocFunc; {$IFNDEF NO_EXTERNAL_VARS}cvar; external;{$ENDIF}
+  xmlFree: xmlFreeFunc; {$IFNDEF NO_EXTERNAL_VARS}cvar; external;{$ENDIF}
+  xmlMemStrdup: xmlStrdupFunc; {$IFNDEF NO_EXTERNAL_VARS}cvar; external;{$ENDIF}
 {$ENDIF} (* LIBXML_THREAD_ALLOC_ENABLED *)
 
 {$IFDEF LIBXML_DOCB_ENABLED}
-function __docbDefaultSAXHandler: xmlSAXHandlerV1Ptr; XMLCALL; XMLPUBFUN;
+function __docbDefaultSAXHandler: xmlSAXHandlerV1Ptr; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE docbDefaultSAXHandler := __docbDefaultSAXHandler()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  docbDefaultSAXHandler: xmlSAXHandlerV1; XMLPUBVAR;
+  docbDefaultSAXHandler: xmlSAXHandlerV1; cvar; external;
 {$ENDIF}
 {$ENDIF}
 {$ENDIF}
 
 {$IFDEF LIBXML_HTML_ENABLED}
-function __htmlDefaultSAXHandler: xmlSAXHandlerV1Ptr; XMLCALL; XMLPUBFUN;
+function __htmlDefaultSAXHandler: xmlSAXHandlerV1Ptr; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE htmlDefaultSAXHandler := __htmlDefaultSAXHandler()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  htmlDefaultSAXHandler: xmlSAXHandlerV1; XMLPUBVAR;
+  htmlDefaultSAXHandler: xmlSAXHandlerV1; cvar; external;
 {$ENDIF}
 {$ENDIF}
 {$ENDIF}
 
-function __xmlLastError: xmlErrorPtr; XMLCALL; XMLPUBFUN;
+function __xmlLastError: xmlErrorPtr; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlLastError := __xmlLastError()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlLastError: xmlError; XMLPUBVAR;
+  xmlLastError: xmlError; cvar; external;
 {$ENDIF}
 {$ENDIF}
 
@@ -203,256 +203,256 @@ var
  * Do not modify the previous line.
  *)
 
-function __oldXMLWDcompatibility: pcint; XMLCALL; XMLPUBFUN;
+function __oldXMLWDcompatibility: pcint; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE oldXMLWDcompatibility := __oldXMLWDcompatibility()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  oldXMLWDcompatibility: cint; XMLPUBVAR;
+  oldXMLWDcompatibility: cint; cvar; external;
   {$ENDIF}
 {$ENDIF}
 
-function __xmlBufferAllocScheme: xmlBufferAllocationSchemePtr; XMLCALL; XMLPUBFUN;
+function __xmlBufferAllocScheme: xmlBufferAllocationSchemePtr; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlBufferAllocScheme := __xmlBufferAllocScheme()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlBufferAllocScheme: xmlBufferAllocationScheme; XMLPUBVAR;
+  xmlBufferAllocScheme: xmlBufferAllocationScheme; cvar; external;
 {$ENDIF}
 {$ENDIF}
-function xmlThrDefBufferAllocScheme(v: xmlBufferAllocationScheme): xmlBufferAllocationScheme; XMLCALL; XMLPUBFUN;
+function xmlThrDefBufferAllocScheme(v: xmlBufferAllocationScheme): xmlBufferAllocationScheme; EXTDECL; external xml2lib;
 
-function __xmlDefaultBufferSize: pcint; XMLCALL; XMLPUBFUN;
+function __xmlDefaultBufferSize: pcint; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlDefaultBufferSize := __xmlDefaultBufferSize()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlDefaultBufferSize: cint; XMLPUBVAR;
+  xmlDefaultBufferSize: cint; cvar; external;
 {$ENDIF}
 {$ENDIF}
-function xmlThrDefDefaultBufferSize(v: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlThrDefDefaultBufferSize(v: cint): cint; EXTDECL; external xml2lib;
 
-function __xmlDefaultSAXHandler: xmlSAXHandlerV1Ptr; XMLCALL; XMLPUBFUN;
+function __xmlDefaultSAXHandler: xmlSAXHandlerV1Ptr; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlDefaultSAXHandler := __xmlDefaultSAXHandler()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlDefaultSAXHandler: xmlSAXHandlerV1; XMLPUBVAR;
+  xmlDefaultSAXHandler: xmlSAXHandlerV1; cvar; external;
 {$ENDIF}
 {$ENDIF}
 
-function __xmlDefaultSAXLocator: xmlSAXLocatorPtr; XMLCALL; XMLPUBFUN;
+function __xmlDefaultSAXLocator: xmlSAXLocatorPtr; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlDefaultSAXLocator := __xmlDefaultSAXLocator()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlDefaultSAXLocator: xmlSAXLocator; XMLPUBVAR;
+  xmlDefaultSAXLocator: xmlSAXLocator; cvar; external;
 {$ENDIF}
 {$ENDIF}
 
-function __xmlDoValidityCheckingDefaultValue: pcint; XMLCALL; XMLPUBFUN;
+function __xmlDoValidityCheckingDefaultValue: pcint; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlDoValidityCheckingDefaultValue := __xmlDoValidityCheckingDefaultValue()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlDoValidityCheckingDefaultValue: cint; XMLPUBVAR;
+  xmlDoValidityCheckingDefaultValue: cint; cvar; external;
 {$ENDIF}
 {$ENDIF}
-function xmlThrDefDoValidityCheckingDefaultValue(v: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlThrDefDoValidityCheckingDefaultValue(v: cint): cint; EXTDECL; external xml2lib;
 
-function __xmlGenericError: xmlGenericErrorFuncPtr; XMLCALL; XMLPUBFUN;
+function __xmlGenericError: xmlGenericErrorFuncPtr; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlGenericError := __xmlGenericError()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlGenericError: xmlGenericErrorFunc; XMLPUBVAR;
+  xmlGenericError: xmlGenericErrorFunc; cvar; external;
 {$ENDIF}
 {$ENDIF}
 
-function __xmlStructuredError: xmlStructuredErrorFuncPtr; XMLCALL; XMLPUBFUN;
+function __xmlStructuredError: xmlStructuredErrorFuncPtr; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlStructuredError := __xmlStructuredError()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlStructuredError: xmlStructuredErrorFunc; XMLPUBVAR;
+  xmlStructuredError: xmlStructuredErrorFunc; cvar; external;
 {$ENDIF}
 {$ENDIF}
 
-function __xmlGenericErrorContext: ppointer; XMLCALL; XMLPUBFUN;
+function __xmlGenericErrorContext: ppointer; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlGenericErrorContext := __xmlGenericErrorContext()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlGenericErrorContext: pointer; XMLPUBVAR;
+  xmlGenericErrorContext: pointer; cvar; external;
 {$ENDIF}
 {$ENDIF}
 
-function __xmlGetWarningsDefaultValue: pcint; XMLCALL; XMLPUBFUN;
+function __xmlGetWarningsDefaultValue: pcint; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlGetWarningsDefaultValue := __xmlGetWarningsDefaultValue()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlGetWarningsDefaultValue: cint; XMLPUBVAR;
+  xmlGetWarningsDefaultValue: cint; cvar; external;
 {$ENDIF}
 {$ENDIF}
-function xmlThrDefGetWarningsDefaultValue(v: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlThrDefGetWarningsDefaultValue(v: cint): cint; EXTDECL; external xml2lib;
 
-function __xmlIndentTreeOutput: pcint; XMLCALL; XMLPUBFUN;
+function __xmlIndentTreeOutput: pcint; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlIndentTreeOutput := __xmlIndentTreeOutput()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlIndentTreeOutput: cint; XMLPUBVAR;
+  xmlIndentTreeOutput: cint; cvar; external;
 {$ENDIF}
 {$ENDIF}
-function xmlThrDefIndentTreeOutput(v: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlThrDefIndentTreeOutput(v: cint): cint; EXTDECL; external xml2lib;
 
-function __xmlTreeIndentString: ppchar; XMLCALL; XMLPUBFUN;
+function __xmlTreeIndentString: ppchar; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlTreeIndentString := __xmlTreeIndentString()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlTreeIndentString: pchar; XMLPUBVAR;
+  xmlTreeIndentString: pchar; cvar; external;
 {$ENDIF}
 {$ENDIF}
-function xmlThrDefTreeIndentString(v: pchar): pchar; XMLCALL; XMLPUBFUN;
+function xmlThrDefTreeIndentString(v: pchar): pchar; EXTDECL; external xml2lib;
 
-function __xmlKeepBlanksDefaultValue: pcint; XMLCALL; XMLPUBFUN;
+function __xmlKeepBlanksDefaultValue: pcint; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlKeepBlanksDefaultValue := __xmlKeepBlanksDefaultValue()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlKeepBlanksDefaultValue: cint; XMLPUBVAR;
+  xmlKeepBlanksDefaultValue: cint; cvar; external;
 {$ENDIF}
 {$ENDIF}
-function xmlThrDefKeepBlanksDefaultValue(v: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlThrDefKeepBlanksDefaultValue(v: cint): cint; EXTDECL; external xml2lib;
 
-function __xmlLineNumbersDefaultValue: pcint; XMLCALL; XMLPUBFUN;
+function __xmlLineNumbersDefaultValue: pcint; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlLineNumbersDefaultValue := __xmlLineNumbersDefaultValue()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlLineNumbersDefaultValue: cint; XMLPUBVAR;
+  xmlLineNumbersDefaultValue: cint; cvar; external;
 {$ENDIF}
 {$ENDIF}
-function xmlThrDefLineNumbersDefaultValue(v: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlThrDefLineNumbersDefaultValue(v: cint): cint; EXTDECL; external xml2lib;
 
-function __xmlLoadExtDtdDefaultValue: pcint; XMLCALL; XMLPUBFUN;
+function __xmlLoadExtDtdDefaultValue: pcint; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlLoadExtDtdDefaultValue := __xmlLoadExtDtdDefaultValue()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlLoadExtDtdDefaultValue: cint; XMLPUBVAR;
+  xmlLoadExtDtdDefaultValue: cint; cvar; external;
 {$ENDIF}
 {$ENDIF}
-function xmlThrDefLoadExtDtdDefaultValue(v: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlThrDefLoadExtDtdDefaultValue(v: cint): cint; EXTDECL; external xml2lib;
 
-function __xmlParserDebugEntities: pcint; XMLCALL; XMLPUBFUN;
+function __xmlParserDebugEntities: pcint; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlParserDebugEntities := __xmlParserDebugEntities()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlParserDebugEntities: cint; XMLPUBVAR;
+  xmlParserDebugEntities: cint; cvar; external;
 {$ENDIF}
 {$ENDIF}
-function xmlThrDefParserDebugEntities(v: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlThrDefParserDebugEntities(v: cint): cint; EXTDECL; external xml2lib;
 
-function __xmlParserVersion: ppchar; XMLCALL; XMLPUBFUN;
+function __xmlParserVersion: ppchar; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlParserVersion := __xmlParserVersion()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlParserVersion: pchar; XMLPUBVAR;
+  xmlParserVersion: pchar; cvar; external;
 {$ENDIF}
 {$ENDIF}
 
-function __xmlPedanticParserDefaultValue: pcint; XMLCALL; XMLPUBFUN;
+function __xmlPedanticParserDefaultValue: pcint; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlPedanticParserDefaultValue := __xmlPedanticParserDefaultValue()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlPedanticParserDefaultValue: cint; XMLPUBVAR;
+  xmlPedanticParserDefaultValue: cint; cvar; external;
 {$ENDIF}
 {$ENDIF}
-function xmlThrDefPedanticParserDefaultValue(v: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlThrDefPedanticParserDefaultValue(v: cint): cint; EXTDECL; external xml2lib;
 
-function __xmlSaveNoEmptyTags: pcint; XMLCALL; XMLPUBFUN;
+function __xmlSaveNoEmptyTags: pcint; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlSaveNoEmptyTags := __xmlSaveNoEmptyTags()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlSaveNoEmptyTags: cint; XMLPUBVAR;
+  xmlSaveNoEmptyTags: cint; cvar; external;
 {$ENDIF}
 {$ENDIF}
-function xmlThrDefSaveNoEmptyTags(v: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlThrDefSaveNoEmptyTags(v: cint): cint; EXTDECL; external xml2lib;
 
-function __xmlSubstituteEntitiesDefaultValue: pcint; XMLCALL; XMLPUBFUN;
+function __xmlSubstituteEntitiesDefaultValue: pcint; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlSubstituteEntitiesDefaultValue := __xmlSubstituteEntitiesDefaultValue()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlSubstituteEntitiesDefaultValue: cint; XMLPUBVAR;
+  xmlSubstituteEntitiesDefaultValue: cint; cvar; external;
 {$ENDIF}
 {$ENDIF}
-function xmlThrDefSubstituteEntitiesDefaultValue(v: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlThrDefSubstituteEntitiesDefaultValue(v: cint): cint; EXTDECL; external xml2lib;
 
-function __xmlRegisterNodeDefaultValue: xmlRegisterNodeFuncPtr; XMLCALL; XMLPUBFUN;
+function __xmlRegisterNodeDefaultValue: xmlRegisterNodeFuncPtr; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlRegisterNodeDefaultValue := __xmlRegisterNodeDefaultValue()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlRegisterNodeDefaultValue: xmlRegisterNodeFunc; XMLPUBVAR;
+  xmlRegisterNodeDefaultValue: xmlRegisterNodeFunc; cvar; external;
 {$ENDIF}
 {$ENDIF}
 
-function __xmlDeregisterNodeDefaultValue: xmlDeregisterNodeFuncPtr; XMLCALL; XMLPUBFUN;
+function __xmlDeregisterNodeDefaultValue: xmlDeregisterNodeFuncPtr; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlDeregisterNodeDefaultValue := __xmlDeregisterNodeDefaultValue()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlDeregisterNodeDefaultValue: xmlDeregisterNodeFunc; XMLPUBVAR;
+  xmlDeregisterNodeDefaultValue: xmlDeregisterNodeFunc; cvar; external;
 {$ENDIF}
 {$ENDIF}
 
-function __xmlParserInputBufferCreateFilenameValue: xmlParserInputBufferCreateFilenameFuncPtr; XMLCALL; XMLPUBFUN;
+function __xmlParserInputBufferCreateFilenameValue: xmlParserInputBufferCreateFilenameFuncPtr; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlParserInputBufferCreateFilenameValue := __xmlParserInputBufferCreateFilenameValue()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlParserInputBufferCreateFilenameValue: xmlParserInputBufferCreateFilenameFunc; XMLPUBVAR;
+  xmlParserInputBufferCreateFilenameValue: xmlParserInputBufferCreateFilenameFunc; cvar; external;
 {$ENDIF}
 {$ENDIF}
 
-function __xmlOutputBufferCreateFilenameValue: xmlOutputBufferCreateFilenameFuncPtr; XMLCALL; XMLPUBFUN;
+function __xmlOutputBufferCreateFilenameValue: xmlOutputBufferCreateFilenameFuncPtr; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_THREAD_ENABLED}
 {$DEFINE xmlOutputBufferCreateFilenameValue := __xmlOutputBufferCreateFilenameValue()^ }
 {$ELSE}
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlOutputBufferCreateFilenameValue: xmlOutputBufferCreateFilenameFunc; XMLPUBVAR;
+  xmlOutputBufferCreateFilenameValue: xmlOutputBufferCreateFilenameFunc; cvar; external;
 {$ENDIF}
 {$ENDIF}
 

packages/libxml/src/hash.inc

@@ -36,7 +36,7 @@
  *
  * Callback to free data from a hash.
  *)
-  xmlHashDeallocator = procedure(payload: pointer; name: xmlCharPtr); XMLCALL;
+  xmlHashDeallocator = procedure(payload: pointer; name: xmlCharPtr); EXTDECL;
 
 (**
  * xmlHashCopier:
@@ -47,7 +47,7 @@
  *
  * Returns a copy of the data or NULL in case of error.
  *)
-  xmlHashCopier = function(payload: pointer; name: xmlCharPtr): pointer; XMLCALL;
+  xmlHashCopier = function(payload: pointer; name: xmlCharPtr): pointer; EXTDECL;
 
 (**
  * xmlHashScanner:
@@ -57,7 +57,7 @@
  *
  * Callback when scanning data in a hash with the simple scanner.
  *)
-  xmlHashScanner = procedure(payload: pointer; data: pointer; name: xmlCharPtr); XMLCALL;
+  xmlHashScanner = procedure(payload: pointer; data: pointer; name: xmlCharPtr); EXTDECL;
 
 (**
  * xmlHashScannerFull:
@@ -69,51 +69,51 @@
  *
  * Callback when scanning data in a hash with the full scanner.
  *)
-  xmlHashScannerFull = procedure(payload: pointer; data: pointer; name, name2, name3: xmlCharPtr); XMLCALL;
+  xmlHashScannerFull = procedure(payload: pointer; data: pointer; name, name2, name3: xmlCharPtr); EXTDECL;
 {$ENDIF}
 
 {$IFDEF FUNCTION}
 (*
  * Constructor and destructor.
  *)
-function xmlHashCreate(size: cint): xmlHashTablePtr; XMLCALL; XMLPUBFUN;
-function xmlHashCreateDict(size: cint; dict: xmlDictPtr): xmlHashTablePtr; XMLCALL; XMLPUBFUN;
-procedure xmlHashFree(table: xmlHashTablePtr; f: xmlHashDeallocator); XMLCALL; XMLPUBFUN;
+function xmlHashCreate(size: cint): xmlHashTablePtr; EXTDECL; external xml2lib;
+function xmlHashCreateDict(size: cint; dict: xmlDictPtr): xmlHashTablePtr; EXTDECL; external xml2lib;
+procedure xmlHashFree(table: xmlHashTablePtr; f: xmlHashDeallocator); EXTDECL; external xml2lib;
 
 (*
  * Add a new entry to the hash table.
  *)
-function xmlHashAddEntry(table: xmlHashTablePtr; name: xmlCharPtr; userdata: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlHashUpdateEntry(table: xmlHashTablePtr; name: xmlCharPtr; userdata: pointer; f: xmlHashDeallocator): cint; XMLCALL; XMLPUBFUN;
-function xmlHashAddEntry2(table: xmlHashTablePtr; name, name2: xmlCharPtr; userdata: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlHashUpdateEntry2(table: xmlHashTablePtr; name, name2: xmlCharPtr; userdata: pointer; f: xmlHashDeallocator): cint; XMLCALL; XMLPUBFUN;
-function xmlHashAddEntry3(table: xmlHashTablePtr; name, name2, name3: xmlCharPtr; userdata: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlHashUpdateEntry2(table: xmlHashTablePtr; name, name2, name3: xmlCharPtr; userdata: pointer; f: xmlHashDeallocator): cint; XMLCALL; XMLPUBFUN;
+function xmlHashAddEntry(table: xmlHashTablePtr; name: xmlCharPtr; userdata: pointer): cint; EXTDECL; external xml2lib;
+function xmlHashUpdateEntry(table: xmlHashTablePtr; name: xmlCharPtr; userdata: pointer; f: xmlHashDeallocator): cint; EXTDECL; external xml2lib;
+function xmlHashAddEntry2(table: xmlHashTablePtr; name, name2: xmlCharPtr; userdata: pointer): cint; EXTDECL; external xml2lib;
+function xmlHashUpdateEntry2(table: xmlHashTablePtr; name, name2: xmlCharPtr; userdata: pointer; f: xmlHashDeallocator): cint; EXTDECL; external xml2lib;
+function xmlHashAddEntry3(table: xmlHashTablePtr; name, name2, name3: xmlCharPtr; userdata: pointer): cint; EXTDECL; external xml2lib;
+function xmlHashUpdateEntry2(table: xmlHashTablePtr; name, name2, name3: xmlCharPtr; userdata: pointer; f: xmlHashDeallocator): cint; EXTDECL; external xml2lib;
 
 (*
  * Remove an entry from the hash table.
  *)
-function xmlHashRemoveEntry(table: xmlHashTablePtr; name: xmlCharPtr; f: xmlHashDeallocator): cint; XMLCALL; XMLPUBFUN;
-function xmlHashRemoveEntry2(table: xmlHashTablePtr; name, name2: xmlCharPtr; f: xmlHashDeallocator): cint; XMLCALL; XMLPUBFUN;
-function xmlHashRemoveEntry3(table: xmlHashTablePtr; name, name2, name3: xmlCharPtr; f: xmlHashDeallocator): cint; XMLCALL; XMLPUBFUN;
+function xmlHashRemoveEntry(table: xmlHashTablePtr; name: xmlCharPtr; f: xmlHashDeallocator): cint; EXTDECL; external xml2lib;
+function xmlHashRemoveEntry2(table: xmlHashTablePtr; name, name2: xmlCharPtr; f: xmlHashDeallocator): cint; EXTDECL; external xml2lib;
+function xmlHashRemoveEntry3(table: xmlHashTablePtr; name, name2, name3: xmlCharPtr; f: xmlHashDeallocator): cint; EXTDECL; external xml2lib;
 
 (*
  * Retrieve the userdata.
  *)
-function xmlHashRemoveEntry(table: xmlHashTablePtr; name: xmlCharPtr): pointer; XMLCALL; XMLPUBFUN;
-function xmlHashRemoveEntry2(table: xmlHashTablePtr; name, name2: xmlCharPtr): pointer; XMLCALL; XMLPUBFUN;
-function xmlHashRemoveEntry3(table: xmlHashTablePtr; name, name2, name3: xmlCharPtr): pointer; XMLCALL; XMLPUBFUN;
-function xmlHashQLookup(table: xmlHashTablePtr; name, prefix: xmlCharPtr): pointer; XMLCALL; XMLPUBFUN;
-function xmlHashQLookup2(table: xmlHashTablePtr; name, prefix, name2, prefix2: xmlCharPtr): pointer; XMLCALL; XMLPUBFUN;
-function xmlHashQLookup3(table: xmlHashTablePtr; name, prefix, name2, prefix2, name3, prefix3: xmlCharPtr): pointer; XMLCALL; XMLPUBFUN;
+function xmlHashRemoveEntry(table: xmlHashTablePtr; name: xmlCharPtr): pointer; EXTDECL; external xml2lib;
+function xmlHashRemoveEntry2(table: xmlHashTablePtr; name, name2: xmlCharPtr): pointer; EXTDECL; external xml2lib;
+function xmlHashRemoveEntry3(table: xmlHashTablePtr; name, name2, name3: xmlCharPtr): pointer; EXTDECL; external xml2lib;
+function xmlHashQLookup(table: xmlHashTablePtr; name, prefix: xmlCharPtr): pointer; EXTDECL; external xml2lib;
+function xmlHashQLookup2(table: xmlHashTablePtr; name, prefix, name2, prefix2: xmlCharPtr): pointer; EXTDECL; external xml2lib;
+function xmlHashQLookup3(table: xmlHashTablePtr; name, prefix, name2, prefix2, name3, prefix3: xmlCharPtr): pointer; EXTDECL; external xml2lib;
 
 (*
  * Helpers.
  *)
-function xmlHashCopy(table: xmlHashTablePtr; f: xmlHashCopier): xmlHashTablePtr; XMLCALL; XMLPUBFUN;
-function xmlHashSize(table: xmlHashTablePtr): cint; XMLCALL; XMLPUBFUN;
-procedure xmlHashScan(table: xmlHashTablePtr; f: xmlHashScanner; data: pointer); XMLCALL; XMLPUBFUN;
-procedure xmlHashScan(table: xmlHashTablePtr; name, name2, name3: xmlCharPtr; f: xmlHashScanner; data: pointer); XMLCALL; XMLPUBFUN;
-procedure xmlHashScanFull(table: xmlHashTablePtr; f: xmlHashScannerFull; data: pointer); XMLCALL; XMLPUBFUN;
-procedure xmlHashScanFull(table: xmlHashTablePtr; name, name2, name3: xmlCharPtr; f: xmlHashScannerFull; data: pointer); XMLCALL; XMLPUBFUN;
+function xmlHashCopy(table: xmlHashTablePtr; f: xmlHashCopier): xmlHashTablePtr; EXTDECL; external xml2lib;
+function xmlHashSize(table: xmlHashTablePtr): cint; EXTDECL; external xml2lib;
+procedure xmlHashScan(table: xmlHashTablePtr; f: xmlHashScanner; data: pointer); EXTDECL; external xml2lib;
+procedure xmlHashScan(table: xmlHashTablePtr; name, name2, name3: xmlCharPtr; f: xmlHashScanner; data: pointer); EXTDECL; external xml2lib;
+procedure xmlHashScanFull(table: xmlHashTablePtr; f: xmlHashScannerFull; data: pointer); EXTDECL; external xml2lib;
+procedure xmlHashScanFull(table: xmlHashTablePtr; name, name2, name3: xmlCharPtr; f: xmlHashScannerFull; data: pointer); EXTDECL; external xml2lib;
 {$ENDIF}

packages/libxml/src/list.inc

@@ -23,7 +23,7 @@
  *
  * Callback function used to free data from a list.
  *)
-  xmlListDeallocator = procedure(lk: xmlLinkPtr); XMLCALL;
+  xmlListDeallocator = procedure(lk: xmlLinkPtr); EXTDECL;
 
 (**
  * xmlListDataCompare:
@@ -34,7 +34,7 @@
  *
  * Returns 0 is equality, -1 or 1 otherwise depending on the ordering.
  *)
-  xmlListDataCompare = function(data0, data1: pointer): cint; XMLCALL;
+  xmlListDataCompare = function(data0, data1: pointer): cint; EXTDECL;
 
 (**
  * xmlListWalker:
@@ -45,41 +45,41 @@
  *
  * Returns 0 to stop walking the list, 1 otherwise.
  *)
-  xmlListWalker = function(data, user: pointer): cint; XMLCALL;
+  xmlListWalker = function(data, user: pointer): cint; EXTDECL;
 {$ENDIF}
 
 {$IFDEF FUNCTION}
 (* Creation/Deletion *)
-function xmlListCreate(deallocator: xmlListDeallocator; compare: xmlListDataCompare): xmlListPtr; XMLCALL; XMLPUBFUN;
-procedure xmlListDelete(l: xmlListPtr); XMLCALL; XMLPUBFUN;
+function xmlListCreate(deallocator: xmlListDeallocator; compare: xmlListDataCompare): xmlListPtr; EXTDECL; external xml2lib;
+procedure xmlListDelete(l: xmlListPtr); EXTDECL; external xml2lib;
 
 (* Basic Operators *)
-function xmlListSearch(l: xmlListPtr; data: pointer): pointer; XMLCALL; XMLPUBFUN;
-function xmlListReverseSearch(l: xmlListPtr; data: pointer): pointer; XMLCALL; XMLPUBFUN;
-function xmlListInsert(l: xmlListPtr; data: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlListAppend(l: xmlListPtr; data: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlListRemoveFirst(l: xmlListPtr; data: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlListRemoveLast(l: xmlListPtr; data: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlListRemoveAll(l: xmlListPtr; data: pointer): cint; XMLCALL; XMLPUBFUN;
-procedure xmlListClear(l: xmlListPtr); XMLCALL; XMLPUBFUN;
-function xmlListEmpty(l: xmlListPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlListFront(l: xmlListPtr): xmlLinkPtr; XMLCALL; XMLPUBFUN;
-function xmlListEnd(l: xmlListPtr): xmlLinkPtr; XMLCALL; XMLPUBFUN;
-function xmlListSize(l: xmlListPtr): cint; XMLCALL; XMLPUBFUN;
-procedure xmlListPopFront(l: xmlListPtr); XMLCALL; XMLPUBFUN;
-procedure xmlListPopBack(l: xmlListPtr); XMLCALL; XMLPUBFUN;
-function xmlListPushFront(l: xmlListPtr; data: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlListPushBack(l: xmlListPtr; data: pointer): cint; XMLCALL; XMLPUBFUN;
+function xmlListSearch(l: xmlListPtr; data: pointer): pointer; EXTDECL; external xml2lib;
+function xmlListReverseSearch(l: xmlListPtr; data: pointer): pointer; EXTDECL; external xml2lib;
+function xmlListInsert(l: xmlListPtr; data: pointer): cint; EXTDECL; external xml2lib;
+function xmlListAppend(l: xmlListPtr; data: pointer): cint; EXTDECL; external xml2lib;
+function xmlListRemoveFirst(l: xmlListPtr; data: pointer): cint; EXTDECL; external xml2lib;
+function xmlListRemoveLast(l: xmlListPtr; data: pointer): cint; EXTDECL; external xml2lib;
+function xmlListRemoveAll(l: xmlListPtr; data: pointer): cint; EXTDECL; external xml2lib;
+procedure xmlListClear(l: xmlListPtr); EXTDECL; external xml2lib;
+function xmlListEmpty(l: xmlListPtr): cint; EXTDECL; external xml2lib;
+function xmlListFront(l: xmlListPtr): xmlLinkPtr; EXTDECL; external xml2lib;
+function xmlListEnd(l: xmlListPtr): xmlLinkPtr; EXTDECL; external xml2lib;
+function xmlListSize(l: xmlListPtr): cint; EXTDECL; external xml2lib;
+procedure xmlListPopFront(l: xmlListPtr); EXTDECL; external xml2lib;
+procedure xmlListPopBack(l: xmlListPtr); EXTDECL; external xml2lib;
+function xmlListPushFront(l: xmlListPtr; data: pointer): cint; EXTDECL; external xml2lib;
+function xmlListPushBack(l: xmlListPtr; data: pointer): cint; EXTDECL; external xml2lib;
 
 (* Advanced Operators *)
-procedure xmlListReverse(l: xmlListPtr); XMLCALL; XMLPUBFUN;
-procedure xmlListSort(l: xmlListPtr); XMLCALL; XMLPUBFUN;
-procedure xmlListWalk(l: xmlListPtr; walker: xmlListWalker; user: pointer); XMLCALL; XMLPUBFUN;
-procedure xmlListReverseWalk(l: xmlListPtr; walker: xmlListWalker; user: pointer); XMLCALL; XMLPUBFUN;
-procedure xmlListMerge(l1, l2: xmlListPtr); XMLCALL; XMLPUBFUN;
-function xmlListDup(old: xmlListPtr): xmlListPtr; XMLCALL; XMLPUBFUN;
-function xmlListDup(cur, old: xmlListPtr): cint; XMLCALL; XMLPUBFUN;
+procedure xmlListReverse(l: xmlListPtr); EXTDECL; external xml2lib;
+procedure xmlListSort(l: xmlListPtr); EXTDECL; external xml2lib;
+procedure xmlListWalk(l: xmlListPtr; walker: xmlListWalker; user: pointer); EXTDECL; external xml2lib;
+procedure xmlListReverseWalk(l: xmlListPtr; walker: xmlListWalker; user: pointer); EXTDECL; external xml2lib;
+procedure xmlListMerge(l1, l2: xmlListPtr); EXTDECL; external xml2lib;
+function xmlListDup(old: xmlListPtr): xmlListPtr; EXTDECL; external xml2lib;
+function xmlListDup(cur, old: xmlListPtr): cint; EXTDECL; external xml2lib;
 
 (* Link operators *)
-function xmlLinkGetData(lk: xmlLinkPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlLinkGetData(lk: xmlLinkPtr): cint; EXTDECL; external xml2lib;
 {$ENDIF}

packages/libxml/src/nanoftp.inc

@@ -29,7 +29,7 @@
  * A callback for the xmlNanoFTPList command.
  * Note that only one of year and day:minute are specified.
  *)
-  ftpListCallback = procedure(userData: pointer; filename, attrib, owner, group: pchar; size: culong; links, year: cint; month: pchar; day, hour, minute: cint); XMLCALL;
+  ftpListCallback = procedure(userData: pointer; filename, attrib, owner, group: pchar; size: culong; links, year: cint; month: pchar; day, hour, minute: cint); EXTDECL;
 
 (**
  * ftpDataCallback: 
@@ -39,51 +39,51 @@
  *
  * A callback for the xmlNanoFTPGet command.
  *)
-  ftpDataCallback = procedure(userData: pointer; data: pchar; len: cint); XMLCALL;
+  ftpDataCallback = procedure(userData: pointer; data: pchar; len: cint); EXTDECL;
 {$ENDIF}
 
 {$IFDEF FUNCTION}
 (*
  * Init
  *)
-procedure xmlNanoFTPInit; XMLCALL; XMLPUBFUN;
-procedure xmlNanoFTPCleanup; XMLCALL; XMLPUBFUN;
+procedure xmlNanoFTPInit; EXTDECL; external xml2lib;
+procedure xmlNanoFTPCleanup; EXTDECL; external xml2lib;
 
 (*
  * Creating/freeing contexts.
  *)
-function xmlNanoFTPNewCtxt(URL: pchar): pointer; XMLCALL; XMLPUBFUN;
-procedure xmlNanoFTPFreeCtxt(ctx: pointer); XMLCALL; XMLPUBFUN;
-function xmlNanoFTPConnectTo(server: pchar; port: cint): pointer; XMLCALL; XMLPUBFUN;
+function xmlNanoFTPNewCtxt(URL: pchar): pointer; EXTDECL; external xml2lib;
+procedure xmlNanoFTPFreeCtxt(ctx: pointer); EXTDECL; external xml2lib;
+function xmlNanoFTPConnectTo(server: pchar; port: cint): pointer; EXTDECL; external xml2lib;
 
 (*
  * Opening/closing session connections.
  *)
-function xmlNanoFTPOpen(URL: pchar): pointer; XMLCALL; XMLPUBFUN;
-function xmlNanoFTPConnect(ctx: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlNanoFTPClose(ctx: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlNanoFTPQuit(ctx: pointer): cint; XMLCALL; XMLPUBFUN;
-procedure xmlNanoFTPScanProxy(URL: pchar); XMLCALL; XMLPUBFUN;
-procedure xmlNanoFTPProxy(host: pchar; port: cint; user, passwd: pchar; _type: cint); XMLCALL; XMLPUBFUN;
-function xmlNanoFTPUpdateURL(ctx: pointer; URL: pchar): cint; XMLCALL; XMLPUBFUN;
+function xmlNanoFTPOpen(URL: pchar): pointer; EXTDECL; external xml2lib;
+function xmlNanoFTPConnect(ctx: pointer): cint; EXTDECL; external xml2lib;
+function xmlNanoFTPClose(ctx: pointer): cint; EXTDECL; external xml2lib;
+function xmlNanoFTPQuit(ctx: pointer): cint; EXTDECL; external xml2lib;
+procedure xmlNanoFTPScanProxy(URL: pchar); EXTDECL; external xml2lib;
+procedure xmlNanoFTPProxy(host: pchar; port: cint; user, passwd: pchar; _type: cint); EXTDECL; external xml2lib;
+function xmlNanoFTPUpdateURL(ctx: pointer; URL: pchar): cint; EXTDECL; external xml2lib;
 
 (*
  * Rather internal commands.
  *)
-function xmlNanoFTPGetResponse(ctx: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlNanoFTPCheckResponse(ctx: pointer): cint; XMLCALL; XMLPUBFUN;
+function xmlNanoFTPGetResponse(ctx: pointer): cint; EXTDECL; external xml2lib;
+function xmlNanoFTPCheckResponse(ctx: pointer): cint; EXTDECL; external xml2lib;
 
 (*
  * CD/DIR/GET handlers.
  *)
-function xmlNanoFTPCwd(ctx: pointer; directory: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlNanoFTPGetResponse(ctx: pointer; _file: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlNanoFTPGetConnection(ctx: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlNanoFTPCloseConnection(ctx: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlNanoFTPList(ctx: pointer; callback: ftpListCallback; userData: pointer; filename: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlNanoFTPGetSocket(ctx: pointer; filename: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlNanoFTPGet(ctx: pointer; callback: ftpDataCallback; userData: pointer; filename: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlNanoFTPRead(ctx: pointer; dest: pointer; len: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlNanoFTPCwd(ctx: pointer; directory: pchar): cint; EXTDECL; external xml2lib;
+function xmlNanoFTPGetResponse(ctx: pointer; _file: pchar): cint; EXTDECL; external xml2lib;
+function xmlNanoFTPGetConnection(ctx: pointer): cint; EXTDECL; external xml2lib;
+function xmlNanoFTPCloseConnection(ctx: pointer): cint; EXTDECL; external xml2lib;
+function xmlNanoFTPList(ctx: pointer; callback: ftpListCallback; userData: pointer; filename: pchar): cint; EXTDECL; external xml2lib;
+function xmlNanoFTPGetSocket(ctx: pointer; filename: pchar): cint; EXTDECL; external xml2lib;
+function xmlNanoFTPGet(ctx: pointer; callback: ftpDataCallback; userData: pointer; filename: pchar): cint; EXTDECL; external xml2lib;
+function xmlNanoFTPRead(ctx: pointer; dest: pointer; len: cint): cint; EXTDECL; external xml2lib;
 
 {$ENDIF}
 {$ENDIF} (* LIBXML_FTP_ENABLED *)

packages/libxml/src/nanohttp.inc

@@ -11,25 +11,25 @@
 {$IFDEF LIBXML_HTTP_ENABLED}
 
 {$IFDEF FUNCTION}
-procedure xmlNanoHTTPInit; XMLCALL; XMLPUBFUN;
-procedure xmlNanoHTTPCleanup; XMLCALL; XMLPUBFUN;
-procedure xmlNanoHTTPScanProxy(URL: pchar); XMLCALL; XMLPUBFUN;
-function xmlNanoHTTPCleanup(URL, filename: pchar; contentType: ppchar): cint; XMLCALL; XMLPUBFUN;
-function xmlNanoHTTPMethod(URL, method, input: pchar; contentType: ppchar; headers: pchar; ilen: cint): pointer; XMLCALL; XMLPUBFUN;
-function xmlNanoHTTPMethodRedir(URL, method, input: pchar; contentType, redir: ppchar; headers: pchar; ilen: cint): pointer; XMLCALL; XMLPUBFUN;
-function xmlNanoHTTPOpen(URL: pchar; contentType: ppchar): pointer; XMLCALL; XMLPUBFUN;
-function xmlNanoHTTPOpenRedir(URL: pchar; contentType, redir: ppchar): pointer; XMLCALL; XMLPUBFUN;
-function xmlNanoHTTPReturnCode(ctx: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlNanoHTTPAuthHeader(ctx: pointer): pchar; XMLCALL; XMLPUBFUN;
-function xmlNanoHTTPRedir(ctx: pointer): pchar; XMLCALL; XMLPUBFUN;
-function xmlNanoHTTPContentLength(ctx: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlNanoHTTPEncoding(ctx: pointer): pchar; XMLCALL; XMLPUBFUN;
-function xmlNanoHTTPMimeType(ctx: pointer): pchar; XMLCALL; XMLPUBFUN;
-function xmlNanoHTTPRead(ctx: pointer; dest: pointer; len: cint): cint; XMLCALL; XMLPUBFUN;
+procedure xmlNanoHTTPInit; EXTDECL; external xml2lib;
+procedure xmlNanoHTTPCleanup; EXTDECL; external xml2lib;
+procedure xmlNanoHTTPScanProxy(URL: pchar); EXTDECL; external xml2lib;
+function xmlNanoHTTPCleanup(URL, filename: pchar; contentType: ppchar): cint; EXTDECL; external xml2lib;
+function xmlNanoHTTPMethod(URL, method, input: pchar; contentType: ppchar; headers: pchar; ilen: cint): pointer; EXTDECL; external xml2lib;
+function xmlNanoHTTPMethodRedir(URL, method, input: pchar; contentType, redir: ppchar; headers: pchar; ilen: cint): pointer; EXTDECL; external xml2lib;
+function xmlNanoHTTPOpen(URL: pchar; contentType: ppchar): pointer; EXTDECL; external xml2lib;
+function xmlNanoHTTPOpenRedir(URL: pchar; contentType, redir: ppchar): pointer; EXTDECL; external xml2lib;
+function xmlNanoHTTPReturnCode(ctx: pointer): cint; EXTDECL; external xml2lib;
+function xmlNanoHTTPAuthHeader(ctx: pointer): pchar; EXTDECL; external xml2lib;
+function xmlNanoHTTPRedir(ctx: pointer): pchar; EXTDECL; external xml2lib;
+function xmlNanoHTTPContentLength(ctx: pointer): cint; EXTDECL; external xml2lib;
+function xmlNanoHTTPEncoding(ctx: pointer): pchar; EXTDECL; external xml2lib;
+function xmlNanoHTTPMimeType(ctx: pointer): pchar; EXTDECL; external xml2lib;
+function xmlNanoHTTPRead(ctx: pointer; dest: pointer; len: cint): cint; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_OUTPUT_ENABLED}
-function xmlNanoHTTPSave(ctx: pointer; filename: pchar): cint; XMLCALL; XMLPUBFUN;
+function xmlNanoHTTPSave(ctx: pointer; filename: pchar): cint; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
-procedure xmlNanoHTTPClose(ctx: pointer); XMLCALL; XMLPUBFUN;
+procedure xmlNanoHTTPClose(ctx: pointer); EXTDECL; external xml2lib;
 {$ENDIF}
 
 {$ENDIF} (* LIBXML_HTTP_ENABLED *)

packages/libxml/src/parser.inc

@@ -45,7 +45,7 @@
  *
  * Callback for freeing some parser input allocations.
  *)
-  xmlParserInputDeallocate = procedure(str: xmlCharPtr); XMLCALL;
+  xmlParserInputDeallocate = procedure(str: xmlCharPtr); EXTDECL;
 
   xmlParserInput = record
     (* Input buffer *)
@@ -299,10 +299,10 @@
  *
  * A SAX Locator.
  *)
-  getPublicIdFunc = function(ctx: pointer): xmlCharPtr; XMLCALL;
-  getSystemIdFunc = function(ctx: pointer): xmlCharPtr; XMLCALL;
-  getLineNumberFunc = function(ctx: pointer): cint; XMLCALL;
-  getColumnNumberFunc = function(ctx: pointer): cint; XMLCALL;
+  getPublicIdFunc = function(ctx: pointer): xmlCharPtr; EXTDECL;
+  getSystemIdFunc = function(ctx: pointer): xmlCharPtr; EXTDECL;
+  getLineNumberFunc = function(ctx: pointer): cint; EXTDECL;
+  getColumnNumberFunc = function(ctx: pointer): cint; EXTDECL;
 
   xmlSAXLocator = record
     getPublicId     : getPublicIdFunc;
@@ -333,7 +333,7 @@
  *
  * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
  *)
-  resolveEntitySAXFunc = function(ctx: pointer; publicID, systemID: xmlCharPtr): xmlParserInputPtr; XMLCALL;
+  resolveEntitySAXFunc = function(ctx: pointer; publicID, systemID: xmlCharPtr): xmlParserInputPtr; EXTDECL;
 
 (**
  * internalSubsetSAXFunc:
@@ -344,7 +344,7 @@
  *
  * Callback on internal subset declaration.
  *)
-  internalSubsetSAXFunc = procedure(ctx: pointer; name, ExternalID, SystemID: xmlCharPtr); XMLCALL;
+  internalSubsetSAXFunc = procedure(ctx: pointer; name, ExternalID, SystemID: xmlCharPtr); EXTDECL;
 
 (**
  * externalSubsetSAXFunc:
@@ -355,7 +355,7 @@
  *
  * Callback on external subset declaration.
  *)
-  externalSubsetSAXFunc = procedure(ctx: pointer; name, ExternalID, SystemID: xmlCharPtr); XMLCALL;
+  externalSubsetSAXFunc = procedure(ctx: pointer; name, ExternalID, SystemID: xmlCharPtr); EXTDECL;
 
 (**
  * getEntitySAXFunc:
@@ -366,7 +366,7 @@
  *
  * Returns the xmlEntityPtr if found.
  *)
-  getEntitySAXFunc = function(ctx: pointer; name: xmlCharPtr): xmlEntityPtr; XMLCALL;
+  getEntitySAXFunc = function(ctx: pointer; name: xmlCharPtr): xmlEntityPtr; EXTDECL;
 
 (**
  * getParameterEntitySAXFunc:
@@ -377,7 +377,7 @@
  *
  * Returns the xmlEntityPtr if found.
  *)
-  getParameterEntitySAXFunc = function(ctx: pointer; name: xmlCharPtr): xmlEntityPtr; XMLCALL;
+  getParameterEntitySAXFunc = function(ctx: pointer; name: xmlCharPtr): xmlEntityPtr; EXTDECL;
 
 (**
  * entityDeclSAXFunc:
@@ -390,7 +390,7 @@
  *
  * An entity definition has been parsed.
  *)
-  entityDeclSAXFunc = procedure(ctx: pointer; name: xmlCharPtr; _type: cint; publicId, systemId, content: xmlCharPtr); XMLCALL;
+  entityDeclSAXFunc = procedure(ctx: pointer; name: xmlCharPtr; _type: cint; publicId, systemId, content: xmlCharPtr); EXTDECL;
 
 (**
  * notationDeclSAXFunc:
@@ -401,7 +401,7 @@
  *
  * What to do when a notation declaration has been parsed.
  *)
-  notationDeclSAXFunc = procedure(ctx: pointer; name, publicId, systemId: xmlCharPtr); XMLCALL;
+  notationDeclSAXFunc = procedure(ctx: pointer; name, publicId, systemId: xmlCharPtr); EXTDECL;
 
 (**
  * attributeDeclSAXFunc:
@@ -415,7 +415,7 @@
  *
  * An attribute definition has been parsed.
  *)
-  attributeDeclSAXFunc = procedure(ctx: pointer; elem, fullname: xmlCharPtr; _type, def: cint; defaultValue: xmlCharPtr; tree: xmlEnumerationPtr); XMLCALL;
+  attributeDeclSAXFunc = procedure(ctx: pointer; elem, fullname: xmlCharPtr; _type, def: cint; defaultValue: xmlCharPtr; tree: xmlEnumerationPtr); EXTDECL;
 
 (**
  * elementDeclSAXFunc:
@@ -426,7 +426,7 @@
  *
  * An element definition has been parsed.
  *)
-  elementDeclSAXFunc = procedure(ctx: pointer; name: xmlCharPtr; _type: cint; content: xmlElementContentPtr); XMLCALL;
+  elementDeclSAXFunc = procedure(ctx: pointer; name: xmlCharPtr; _type: cint; content: xmlElementContentPtr); EXTDECL;
 
 (**
  * unparsedEntityDeclSAXFunc:
@@ -438,7 +438,7 @@
  *
  * What to do when an unparsed entity declaration is parsed.
  *)
-  unparsedEntityDeclSAXFunc = procedure(ctx: pointer; name, publicId, systemId, notationName: xmlCharPtr); XMLCALL;
+  unparsedEntityDeclSAXFunc = procedure(ctx: pointer; name, publicId, systemId, notationName: xmlCharPtr); EXTDECL;
 
 (**
  * setDocumentLocatorSAXFunc:
@@ -448,7 +448,7 @@
  * Receive the document locator at startup, actually xmlDefaultSAXLocator.
  * Everything is available on the context, so this is useless in our case.
  *)
-  setDocumentLocatorSAXFunc = procedure(ctx: pointer; loc: xmlSAXLocatorPtr); XMLCALL;
+  setDocumentLocatorSAXFunc = procedure(ctx: pointer; loc: xmlSAXLocatorPtr); EXTDECL;
 
 (**
  * startDocumentSAXFunc:
@@ -456,7 +456,7 @@
  *
  * Called when the document start being processed.
  *)
-  startDocumentSAXFunc = procedure(ctx: pointer); XMLCALL;
+  startDocumentSAXFunc = procedure(ctx: pointer); EXTDECL;
 
 (**
  * endDocumentSAXFunc:
@@ -464,7 +464,7 @@
  *
  * Called when the document end has been detected.
  *)
-  endDocumentSAXFunc = procedure(ctx: pointer); XMLCALL;
+  endDocumentSAXFunc = procedure(ctx: pointer); EXTDECL;
 
 (**
  * startElementSAXFunc:
@@ -474,7 +474,7 @@
  *
  * Called when an opening tag has been processed.
  *)
-  startElementSAXFunc = procedure(ctx: pointer; name: xmlCharPtr; atts: xmlCharPtrPtr); XMLCALL;
+  startElementSAXFunc = procedure(ctx: pointer; name: xmlCharPtr; atts: xmlCharPtrPtr); EXTDECL;
 
 (**
  * endElementSAXFunc:
@@ -483,7 +483,7 @@
  *
  * Called when the end of an element has been detected.
  *)
-  endElementSAXFunc = procedure(ctx: pointer; name: xmlCharPtr); XMLCALL;
+  endElementSAXFunc = procedure(ctx: pointer; name: xmlCharPtr); EXTDECL;
 
 (**
  * attributeSAXFunc:
@@ -496,7 +496,7 @@
  * DOM subtree and past it in a new xmlAttr element added to
  * the element.
  *)
-  attributeSAXFunc = procedure(ctx: pointer; name, value: xmlCharPtr); XMLCALL;
+  attributeSAXFunc = procedure(ctx: pointer; name, value: xmlCharPtr); EXTDECL;
 
 (**
  * referenceSAXFunc:
@@ -505,7 +505,7 @@
  *
  * Called when an entity reference is detected.
  *)
-  referenceSAXFunc = procedure(ctx: pointer; name: xmlCharPtr); XMLCALL;
+  referenceSAXFunc = procedure(ctx: pointer; name: xmlCharPtr); EXTDECL;
 
 (**
  * charactersSAXFunc:
@@ -515,7 +515,7 @@
  *
  * Receiving some chars from the parser.
  *)
-  charactersSAXFunc = procedure(ctx: pointer; ch: xmlCharPtr; len: cint); XMLCALL;
+  charactersSAXFunc = procedure(ctx: pointer; ch: xmlCharPtr; len: cint); EXTDECL;
 
 (**
  * ignorableWhitespaceSAXFunc:
@@ -526,7 +526,7 @@
  * Receiving some ignorable whitespaces from the parser.
  * UNUSED: by default the DOM building will use characters.
  *)
-  ignorableWhitespaceSAXFunc = procedure(ctx: pointer; ch: xmlCharPtr; len: cint); XMLCALL;
+  ignorableWhitespaceSAXFunc = procedure(ctx: pointer; ch: xmlCharPtr; len: cint); EXTDECL;
 
 (**
  * processingInstructionSAXFunc:
@@ -536,7 +536,7 @@
  *
  * A processing instruction has been parsed.
  *)
-  processingInstructionSAXFunc = procedure(ctx: pointer; target, data: xmlCharPtr); XMLCALL;
+  processingInstructionSAXFunc = procedure(ctx: pointer; target, data: xmlCharPtr); EXTDECL;
 
 (**
  * commentSAXFunc:
@@ -545,7 +545,7 @@
  *
  * A comment has been parsed.
  *)
-  commentSAXFunc = procedure(ctx: pointer; value: xmlCharPtr); XMLCALL;
+  commentSAXFunc = procedure(ctx: pointer; value: xmlCharPtr); EXTDECL;
 
 (**
  * cdataBlockSAXFunc:
@@ -555,7 +555,7 @@
  *
  * Called when a pcdata block has been parsed.
  *)
-  cdataBlockSAXFunc = procedure(ctx: pointer; value: xmlCharPtr; len: cint); XMLCALL;
+  cdataBlockSAXFunc = procedure(ctx: pointer; value: xmlCharPtr; len: cint); EXTDECL;
 
 (**
  * warningSAXFunc:
@@ -565,7 +565,7 @@
  *
  * Display and format a warning messages, callback.
  *)
-  warningSAXFunc = procedure(ctx: pointer; msg: pchar); XMLCDECL; varargs;
+  warningSAXFunc = procedure(ctx: pointer; msg: pchar); cdecl; varargs;
 
 (**
  * errorSAXFunc:
@@ -575,7 +575,7 @@
  *
  * Display and format an error messages, callback.
  *)
-  errorSAXFunc = procedure(ctx: pointer; msg: pchar); XMLCDECL; varargs;
+  errorSAXFunc = procedure(ctx: pointer; msg: pchar); cdecl; varargs;
 
 (**
  * fatalErrorSAXFunc:
@@ -587,7 +587,7 @@
  * Note: so far fatalError() SAX callbacks are not used, error()
  *       get all the callbacks for errors.
  *)
-  fatalErrorSAXFunc = procedure(ctx: pointer; msg: pchar); XMLCDECL; varargs;
+  fatalErrorSAXFunc = procedure(ctx: pointer; msg: pchar); cdecl; varargs;
 
 (**
  * isStandaloneSAXFunc:
@@ -597,7 +597,7 @@
  *
  * Returns 1 if true
  *)
-  isStandaloneSAXFunc = function(ctx: pointer): cint; XMLCALL;
+  isStandaloneSAXFunc = function(ctx: pointer): cint; EXTDECL;
 
 (**
  * hasInternalSubsetSAXFunc:
@@ -607,7 +607,7 @@
  *
  * Returns 1 if true
  *)
-  hasInternalSubsetSAXFunc = function(ctx: pointer): cint; XMLCALL;
+  hasInternalSubsetSAXFunc = function(ctx: pointer): cint; EXTDECL;
 
 (**
  * hasExternalSubsetSAXFunc:
@@ -617,7 +617,7 @@
  *
  * Returns 1 if true
  *)
-  hasExternalSubsetSAXFunc = function(ctx: pointer): cint; XMLCALL;
+  hasExternalSubsetSAXFunc = function(ctx: pointer): cint; EXTDECL;
 
 
 (************************************************************************
@@ -651,7 +651,7 @@
  * the new namespace declarations on the element.
  *)
   startElementNsSAX2Func = procedure(ctx: pointer; localname, prefix, URI: xmlCharPtr; nb_namespaces: cint;
-    namespaces: xmlCharPtrPtr; nb_attributes, nb_defaulted: cint; attributes: xmlCharPtrPtr); XMLCALL;
+    namespaces: xmlCharPtrPtr; nb_attributes, nb_defaulted: cint; attributes: xmlCharPtrPtr); EXTDECL;
 
 (**
  * endElementNsSAX2Func:
@@ -663,7 +663,7 @@
  * SAX2 callback when an element end has been detected by the parser.
  * It provides the namespace informations for the element.
  *)
-  endElementNsSAX2Func = procedure(ctx: pointer; localname, prefix, URI: xmlCharPtr); XMLCALL;
+  endElementNsSAX2Func = procedure(ctx: pointer; localname, prefix, URI: xmlCharPtr); EXTDECL;
 
   xmlSAXHandler = record
     internalSubset: internalSubsetSAXFunc;
@@ -746,7 +746,7 @@
  *
  * Returns the entity input parser.
  *)
-  xmlExternalEntityLoader = function(URL, ID: pchar; context: xmlParserCtxtPtr): xmlParserInputPtr; XMLCALL;
+  xmlExternalEntityLoader = function(URL, ID: pchar; context: xmlParserCtxtPtr): xmlParserInputPtr; EXTDECL;
 
 (**
  * xmlParserOption:
@@ -820,146 +820,146 @@
 (*
  * Init/Cleanup
  *)
-procedure xmlInitParser; XMLCALL; XMLPUBFUN;
-procedure xmlCleanupParser; XMLCALL; XMLPUBFUN;
+procedure xmlInitParser; EXTDECL; external xml2lib;
+procedure xmlCleanupParser; EXTDECL; external xml2lib;
 
 (*
  * Input functions
  *)
-function xmlParserInputRead(_in: xmlParserInputPtr; len: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlParserInputGrow(_in: xmlParserInputPtr; len: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlParserInputRead(_in: xmlParserInputPtr; len: cint): cint; EXTDECL; external xml2lib;
+function xmlParserInputGrow(_in: xmlParserInputPtr; len: cint): cint; EXTDECL; external xml2lib;
 
 (*
  * Basic parsing Interfaces
  *)
 {$IFDEF LIBXML_SAX1_ENABLED}
-function xmlParseDoc(cur: xmlCharPtr): xmlDocPtr; XMLCALL; XMLPUBFUN;
-function xmlParseFile(filename: pchar): xmlDocPtr; XMLCALL; XMLPUBFUN;
-function xmlParseMemory(buffer: pchar; size: cint): xmlDocPtr; XMLCALL; XMLPUBFUN;
+function xmlParseDoc(cur: xmlCharPtr): xmlDocPtr; EXTDECL; external xml2lib;
+function xmlParseFile(filename: pchar): xmlDocPtr; EXTDECL; external xml2lib;
+function xmlParseMemory(buffer: pchar; size: cint): xmlDocPtr; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_SAX1_ENABLED *)
-function xmlSubstituteEntitiesDefault(val: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlKeepBlanksDefault(val: cint): cint; XMLCALL; XMLPUBFUN;
-procedure xmlStopParser(ctxt: xmlParserCtxtPtr); XMLCALL; XMLPUBFUN;
-function xmlPedanticParserDefault(val: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlLineNumbersDefault(val: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlSubstituteEntitiesDefault(val: cint): cint; EXTDECL; external xml2lib;
+function xmlKeepBlanksDefault(val: cint): cint; EXTDECL; external xml2lib;
+procedure xmlStopParser(ctxt: xmlParserCtxtPtr); EXTDECL; external xml2lib;
+function xmlPedanticParserDefault(val: cint): cint; EXTDECL; external xml2lib;
+function xmlLineNumbersDefault(val: cint): cint; EXTDECL; external xml2lib;
 
 {$IFDEF LIBXML_SAX1_ENABLED}
 (*
  * Recovery mode
  *)
-function xmlRecoverDoc(cur: xmlCharPtr): xmlDocPtr; XMLCALL; XMLPUBFUN;
-function xmlRecoverMemory(buffer: pchar; size: cint): xmlDocPtr; XMLCALL; XMLPUBFUN;
-function xmlRecoverFile(filename: pchar): xmlDocPtr; XMLCALL; XMLPUBFUN;
+function xmlRecoverDoc(cur: xmlCharPtr): xmlDocPtr; EXTDECL; external xml2lib;
+function xmlRecoverMemory(buffer: pchar; size: cint): xmlDocPtr; EXTDECL; external xml2lib;
+function xmlRecoverFile(filename: pchar): xmlDocPtr; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_SAX1_ENABLED *)
 
 (*
  * Less common routines and SAX interfaces
  *)
-function xmlParseDocument(ctxt: xmlParserCtxtPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlParseExtParsedEnt(ctxt: xmlParserCtxtPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlParseDocument(ctxt: xmlParserCtxtPtr): cint; EXTDECL; external xml2lib;
+function xmlParseExtParsedEnt(ctxt: xmlParserCtxtPtr): cint; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_SAX1_ENABLED}
-function xmlSAXUserParseFile(sax: xmlSAXHandlerPtr; user_data: pointer; filename: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlSAXUserParseMemory(sax: xmlSAXHandlerPtr; user_data: pointer; buffer: pchar; size: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlSAXParseDoc(sax: xmlSAXHandlerPtr; cur: xmlCharPtr; recovery: cint): xmlDocPtr; XMLCALL; XMLPUBFUN;
-function xmlSAXParseMemory(sax: xmlSAXHandlerPtr; buffer: pchar; size: cint; recovery: cint): xmlDocPtr; XMLCALL; XMLPUBFUN;
-function xmlSAXParseMemoryWithData(sax: xmlSAXHandlerPtr; buffer: pchar; size: cint; recovery: cint; data: pointer): xmlDocPtr; XMLCALL; XMLPUBFUN;
-function xmlSAXParseFile(sax: xmlSAXHandlerPtr; filename: pchar; recovery: cint): xmlDocPtr; XMLCALL; XMLPUBFUN;
-function xmlSAXParseFileWithData(sax: xmlSAXHandlerPtr; filename: pchar; recovery: cint; data: pointer): xmlDocPtr; XMLCALL; XMLPUBFUN;
-function xmlSAXParseEntity(sax: xmlSAXHandlerPtr; filename: pchar): xmlDocPtr; XMLCALL; XMLPUBFUN;
-function xmlParseEntity(filename: pchar): xmlDocPtr; XMLCALL; XMLPUBFUN;
+function xmlSAXUserParseFile(sax: xmlSAXHandlerPtr; user_data: pointer; filename: pchar): cint; EXTDECL; external xml2lib;
+function xmlSAXUserParseMemory(sax: xmlSAXHandlerPtr; user_data: pointer; buffer: pchar; size: cint): cint; EXTDECL; external xml2lib;
+function xmlSAXParseDoc(sax: xmlSAXHandlerPtr; cur: xmlCharPtr; recovery: cint): xmlDocPtr; EXTDECL; external xml2lib;
+function xmlSAXParseMemory(sax: xmlSAXHandlerPtr; buffer: pchar; size: cint; recovery: cint): xmlDocPtr; EXTDECL; external xml2lib;
+function xmlSAXParseMemoryWithData(sax: xmlSAXHandlerPtr; buffer: pchar; size: cint; recovery: cint; data: pointer): xmlDocPtr; EXTDECL; external xml2lib;
+function xmlSAXParseFile(sax: xmlSAXHandlerPtr; filename: pchar; recovery: cint): xmlDocPtr; EXTDECL; external xml2lib;
+function xmlSAXParseFileWithData(sax: xmlSAXHandlerPtr; filename: pchar; recovery: cint; data: pointer): xmlDocPtr; EXTDECL; external xml2lib;
+function xmlSAXParseEntity(sax: xmlSAXHandlerPtr; filename: pchar): xmlDocPtr; EXTDECL; external xml2lib;
+function xmlParseEntity(filename: pchar): xmlDocPtr; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_SAX1_ENABLED *)
 
 {$IFDEF LIBXML_VALID_ENABLED}
-function xmlSAXParseDTD(sax: xmlSAXHandlerPtr; ExternalID, SystemID: xmlCharPtr): xmlDtdPtr; XMLCALL; XMLPUBFUN;
-function xmlParseDTD(ExternalID, SystemID: xmlCharPtr): xmlDtdPtr; XMLCALL; XMLPUBFUN;
-function xmlIOParseDTD(sax: xmlSAXHandlerPtr; input: xmlParserInputBufferPtr; enc: xmlCharEncoding): xmlDtdPtr; XMLCALL; XMLPUBFUN;
+function xmlSAXParseDTD(sax: xmlSAXHandlerPtr; ExternalID, SystemID: xmlCharPtr): xmlDtdPtr; EXTDECL; external xml2lib;
+function xmlParseDTD(ExternalID, SystemID: xmlCharPtr): xmlDtdPtr; EXTDECL; external xml2lib;
+function xmlIOParseDTD(sax: xmlSAXHandlerPtr; input: xmlParserInputBufferPtr; enc: xmlCharEncoding): xmlDtdPtr; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_VALID_ENABLE *)
 {$IFDEF LIBXML_SAX1_ENABLED}
-function xmlParseBalancedChunkMemory(doc: xmlDocPtr; sax: xmlSAXHandlerPtr; user_data: pointer; depth: cint; _string: xmlCharPtr; lst: xmlNodePtrPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlParseBalancedChunkMemory(doc: xmlDocPtr; sax: xmlSAXHandlerPtr; user_data: pointer; depth: cint; _string: xmlCharPtr; lst: xmlNodePtrPtr): cint; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_SAX1_ENABLED *)
-function xmlParseInNodeContext(node: xmlNodePtr; data: pchar; datalen, options: cint; lst: xmlNodePtrPtr): xmlParserErrors; XMLCALL; XMLPUBFUN;
+function xmlParseInNodeContext(node: xmlNodePtr; data: pchar; datalen, options: cint; lst: xmlNodePtrPtr): xmlParserErrors; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_SAX1_ENABLED}
 function xmlParseBalancedChunkMemoryRecover(doc: xmlDocPtr; sax: xmlSAXHandlerPtr; user_data: pointer;
-  depth: cint; _string: xmlCharPtr; lst: xmlNodePtrPtr; recover: cint): cint; XMLCALL; XMLPUBFUN;
+  depth: cint; _string: xmlCharPtr; lst: xmlNodePtrPtr; recover: cint): cint; EXTDECL; external xml2lib;
 function xmlParseExternalEntity(doc: xmlDocPtr; sax: xmlSAXHandlerPtr; user_data: pointer;
-  depth: cint; URL, ID: xmlCharPtr; lst: xmlNodePtrPtr): cint; XMLCALL; XMLPUBFUN;
+  depth: cint; URL, ID: xmlCharPtr; lst: xmlNodePtrPtr): cint; EXTDECL; external xml2lib;
 
 {$ENDIF} (* LIBXML_SAX1_ENABLED *)
-function xmlParseCtxtExternalEntity(ctx: xmlParserCtxtPtr; URL, ID: xmlCharPtr; lst: xmlNodePtrPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlParseCtxtExternalEntity(ctx: xmlParserCtxtPtr; URL, ID: xmlCharPtr; lst: xmlNodePtrPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * Parser contexts handling.
  *)
-function xmlNewParserCtxt: xmlParserCtxtPtr; XMLCALL; XMLPUBFUN;
-function xmlInitParserCtxt(ctxt: xmlParserCtxtPtr): cint; XMLCALL; XMLPUBFUN;
-procedure xmlClearParserCtxt(ctxt: xmlParserCtxtPtr); XMLCALL; XMLPUBFUN;
-procedure xmlFreeParserCtxt(ctxt: xmlParserCtxtPtr); XMLCALL; XMLPUBFUN;
+function xmlNewParserCtxt: xmlParserCtxtPtr; EXTDECL; external xml2lib;
+function xmlInitParserCtxt(ctxt: xmlParserCtxtPtr): cint; EXTDECL; external xml2lib;
+procedure xmlClearParserCtxt(ctxt: xmlParserCtxtPtr); EXTDECL; external xml2lib;
+procedure xmlFreeParserCtxt(ctxt: xmlParserCtxtPtr); EXTDECL; external xml2lib;
 {$IFDEF LIBXML_SAX1_ENABLED}
-procedure xmlSetupParserForBuffer(ctxt: xmlParserCtxtPtr; buffer: xmlCharPtr; filename: pchar); XMLCALL; XMLPUBFUN;
+procedure xmlSetupParserForBuffer(ctxt: xmlParserCtxtPtr; buffer: xmlCharPtr; filename: pchar); EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_SAX1_ENABLED *)
-function xmlCreateDocParserCtxt(cur: xmlCharPtr): xmlParserCtxtPtr; XMLCALL; XMLPUBFUN;
+function xmlCreateDocParserCtxt(cur: xmlCharPtr): xmlParserCtxtPtr; EXTDECL; external xml2lib;
 
 {$IFDEF LIBXML_LEGACY_ENABLED}
 (*
  * Reading/setting optional parsing features.
  *)
-function xmlGetFeaturesList(var len: cint; var result: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlGetFeature(ctxt: xmlParserCtxtPtr; name: pchar; result: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlSetFeature(ctxt: xmlParserCtxtPtr; name: pchar; value: pointer): cint; XMLCALL; XMLPUBFUN;
+function xmlGetFeaturesList(var len: cint; var result: pchar): cint; EXTDECL; external xml2lib;
+function xmlGetFeature(ctxt: xmlParserCtxtPtr; name: pchar; result: pointer): cint; EXTDECL; external xml2lib;
+function xmlSetFeature(ctxt: xmlParserCtxtPtr; name: pchar; value: pointer): cint; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_LEGACY_ENABLED *)
 
 {$IFDEF LIBXML_PUSH_ENABLED}
 (*
  * Interfaces for the Push mode.
  *)
-function xmlCreatePushParserCtxt(sax: xmlSAXHandlerPtr; user_data: pointer; chunk: pchar; size: cint; filename: pchar): xmlParserCtxtPtr; XMLCALL; XMLPUBFUN;
-function xmlParseChunk(ctxt: xmlParserCtxtPtr; chunk: pchar; size, terminate: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlCreatePushParserCtxt(sax: xmlSAXHandlerPtr; user_data: pointer; chunk: pchar; size: cint; filename: pchar): xmlParserCtxtPtr; EXTDECL; external xml2lib;
+function xmlParseChunk(ctxt: xmlParserCtxtPtr; chunk: pchar; size, terminate: cint): cint; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_PUSH_ENABLED *)
 
 (*
  * Special I/O mode.
  *)
 function xmlCreateIOParserCtxt(sax: xmlSAXHandlerPtr; user_data: pointer; ioread: xmlInputReadCallback;
-  ioclose: xmlInputCloseCallback; ioctx: pointer; enc: xmlCharEncoding): xmlParserCtxtPtr; XMLCALL; XMLPUBFUN;
-function xmlNewIOInputStream(ctxt: xmlParserCtxtPtr; input: xmlParserInputBufferPtr; enc: xmlCharEncoding): xmlParserInputPtr; XMLCALL; XMLPUBFUN;
+  ioclose: xmlInputCloseCallback; ioctx: pointer; enc: xmlCharEncoding): xmlParserCtxtPtr; EXTDECL; external xml2lib;
+function xmlNewIOInputStream(ctxt: xmlParserCtxtPtr; input: xmlParserInputBufferPtr; enc: xmlCharEncoding): xmlParserInputPtr; EXTDECL; external xml2lib;
 
 (*
  * Node infos.
  *)
-function xmlParserFindNodeInfo(ctxt: xmlParserCtxtPtr; node: xmlNodePtr): xmlParserNodeInfoPtr; XMLCALL; XMLPUBFUN;
-procedure xmlInitNodeInfoSeq(seq: xmlParserNodeInfoSeqPtr); XMLCALL; XMLPUBFUN;
-procedure xmlClearNodeInfoSeq(seq: xmlParserNodeInfoSeqPtr); XMLCALL; XMLPUBFUN;
-function xmlParserFindNodeInfoIndex(seq: xmlParserNodeInfoSeqPtr; node: xmlNodePtr): culong; XMLCALL; XMLPUBFUN;
-procedure xmlParserAddNodeInfo(ctxt: xmlParserCtxtPtr; info: xmlParserNodeInfoPtr); XMLCALL; XMLPUBFUN;
+function xmlParserFindNodeInfo(ctxt: xmlParserCtxtPtr; node: xmlNodePtr): xmlParserNodeInfoPtr; EXTDECL; external xml2lib;
+procedure xmlInitNodeInfoSeq(seq: xmlParserNodeInfoSeqPtr); EXTDECL; external xml2lib;
+procedure xmlClearNodeInfoSeq(seq: xmlParserNodeInfoSeqPtr); EXTDECL; external xml2lib;
+function xmlParserFindNodeInfoIndex(seq: xmlParserNodeInfoSeqPtr; node: xmlNodePtr): culong; EXTDECL; external xml2lib;
+procedure xmlParserAddNodeInfo(ctxt: xmlParserCtxtPtr; info: xmlParserNodeInfoPtr); EXTDECL; external xml2lib;
 
 (*
  * External entities handling actually implemented in xmlIO.
  *)
-procedure xmlSetExternalEntityLoader(f: xmlExternalEntityLoader); XMLCALL; XMLPUBFUN;
-function xmlGetExternalEntityLoader(): xmlExternalEntityLoader; XMLCALL; XMLPUBFUN;
-function xmlLoadExternalEntity(URL, ID: pchar; ctxt: xmlParserCtxtPtr): xmlParserInputPtr; XMLCALL; XMLPUBFUN;
+procedure xmlSetExternalEntityLoader(f: xmlExternalEntityLoader); EXTDECL; external xml2lib;
+function xmlGetExternalEntityLoader(): xmlExternalEntityLoader; EXTDECL; external xml2lib;
+function xmlLoadExternalEntity(URL, ID: pchar; ctxt: xmlParserCtxtPtr): xmlParserInputPtr; EXTDECL; external xml2lib;
 
 (*
  * Index lookup, actually implemented in the encoding module
  *)
-function xmlByteConsumed(ctxt: xmlParserCtxtPtr): culong; XMLCALL; XMLPUBFUN;
+function xmlByteConsumed(ctxt: xmlParserCtxtPtr): culong; EXTDECL; external xml2lib;
 
 (*
  * New set of simpler/more flexible APIs
  *)
-procedure xmlCtxtReset(ctxt: xmlParserCtxtPtr); XMLCALL; XMLPUBFUN;
-function xmlCtxtResetPush(ctxt: xmlParserCtxtPtr; chunk: pchar; size: cint; filename, encoding: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlCtxtUseOptions(ctxt: xmlParserCtxtPtr; options: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlReadDoc(cur: xmlCharPtr; URL, encoding: pchar; options: cint): xmlDocPtr; XMLCALL; XMLPUBFUN;
-function xmlReadFile(filename, encoding: pchar; options: cint): xmlDocPtr; XMLCALL; XMLPUBFUN;
-function xmlReadMemory(buffer: pchar; size: cint; URL, encoding: pchar; options: cint): xmlDocPtr; XMLCALL; XMLPUBFUN;
-function xmlReadFd(fd: cint; URL, encoding: pchar; options: cint): xmlDocPtr; XMLCALL; XMLPUBFUN;
-function xmlReadIO(ioread: xmlInputReadCallback; ioclose: xmlInputCloseCallback; ioctx: pchar; URL, encoding: pchar; options: cint): xmlDocPtr; XMLCALL; XMLPUBFUN;
-function xmlCtxtReadDoc(ctxt: xmlParserCtxtPtr; cur: xmlCharPtr; URL, encoding: pchar; options: cint): xmlDocPtr; XMLCALL; XMLPUBFUN;
-function xmlCtxtReadFile(ctxt: xmlParserCtxtPtr; filename, encoding: pchar; options: cint): xmlDocPtr; XMLCALL; XMLPUBFUN;
-function xmlCtxtReadMemory(ctxt: xmlParserCtxtPtr; buffer: pchar; size: cint; URL, encoding: pchar; options: cint): xmlDocPtr; XMLCALL; XMLPUBFUN;
-function xmlCtxtReadFd(ctxt: xmlParserCtxtPtr; fd: cint; URL, encoding: pchar; options: cint): xmlDocPtr; XMLCALL; XMLPUBFUN;
-function xmlCtxtReadIO(ctxt: xmlParserCtxtPtr; ioread: xmlInputReadCallback; ioclose: xmlInputCloseCallback; ioctx: pchar; URL, encoding: pchar; options: cint): xmlDocPtr; XMLCALL; XMLPUBFUN;
+procedure xmlCtxtReset(ctxt: xmlParserCtxtPtr); EXTDECL; external xml2lib;
+function xmlCtxtResetPush(ctxt: xmlParserCtxtPtr; chunk: pchar; size: cint; filename, encoding: pchar): cint; EXTDECL; external xml2lib;
+function xmlCtxtUseOptions(ctxt: xmlParserCtxtPtr; options: cint): cint; EXTDECL; external xml2lib;
+function xmlReadDoc(cur: xmlCharPtr; URL, encoding: pchar; options: cint): xmlDocPtr; EXTDECL; external xml2lib;
+function xmlReadFile(filename, encoding: pchar; options: cint): xmlDocPtr; EXTDECL; external xml2lib;
+function xmlReadMemory(buffer: pchar; size: cint; URL, encoding: pchar; options: cint): xmlDocPtr; EXTDECL; external xml2lib;
+function xmlReadFd(fd: cint; URL, encoding: pchar; options: cint): xmlDocPtr; EXTDECL; external xml2lib;
+function xmlReadIO(ioread: xmlInputReadCallback; ioclose: xmlInputCloseCallback; ioctx: pchar; URL, encoding: pchar; options: cint): xmlDocPtr; EXTDECL; external xml2lib;
+function xmlCtxtReadDoc(ctxt: xmlParserCtxtPtr; cur: xmlCharPtr; URL, encoding: pchar; options: cint): xmlDocPtr; EXTDECL; external xml2lib;
+function xmlCtxtReadFile(ctxt: xmlParserCtxtPtr; filename, encoding: pchar; options: cint): xmlDocPtr; EXTDECL; external xml2lib;
+function xmlCtxtReadMemory(ctxt: xmlParserCtxtPtr; buffer: pchar; size: cint; URL, encoding: pchar; options: cint): xmlDocPtr; EXTDECL; external xml2lib;
+function xmlCtxtReadFd(ctxt: xmlParserCtxtPtr; fd: cint; URL, encoding: pchar; options: cint): xmlDocPtr; EXTDECL; external xml2lib;
+function xmlCtxtReadIO(ctxt: xmlParserCtxtPtr; ioread: xmlInputReadCallback; ioclose: xmlInputCloseCallback; ioctx: pchar; URL, encoding: pchar; options: cint): xmlDocPtr; EXTDECL; external xml2lib;
 
 (*
  * Library wide options
@@ -971,6 +971,6 @@ function xmlCtxtReadIO(ctxt: xmlParserCtxtPtr; ioread: xmlInputReadCallback; ioc
  * or disabled at compile-time.
  * They used to be called XML_FEATURE_xxx but this clashed with Expat
  *)
-function xmlHasFeature(feature: xmlFeature): cint; XMLCALL; XMLPUBFUN;
+function xmlHasFeature(feature: xmlFeature): cint; EXTDECL; external xml2lib;
 {$ENDIF}
 

packages/libxml/src/parserInternals.inc

@@ -19,7 +19,7 @@
  *)
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlParserMaxDepth: cuint; XMLPUBVAR;
+  xmlParserMaxDepth: cuint; cvar; external;
 {$ENDIF}
 {$ENDIF}
 
@@ -263,44 +263,44 @@ var
 (**
  * Global variables used for predefined strings.
  *)
-XMLPUBVAR xmlChar xmlStringText[];
-XMLPUBVAR xmlChar xmlStringTextNoenc[];
-XMLPUBVAR xmlChar xmlStringComment[];
+cvar; external xmlChar xmlStringText[];
+cvar; external xmlChar xmlStringTextNoenc[];
+cvar; external xmlChar xmlStringComment[];
 
 (*
  * Function to finish the work of the macros where needed.
  *)
-XMLPUBFUN int XMLCALL                   xmlIsLetter     (int c);
+external xml2lib int EXTDECL                   xmlIsLetter     (int c);
 
 (**
  * Parser context.
  *)
-XMLPUBFUN xmlParserCtxtPtr XMLCALL	
+external xml2lib xmlParserCtxtPtr EXTDECL	
 			xmlCreateFileParserCtxt	(char *filename);
-XMLPUBFUN xmlParserCtxtPtr XMLCALL	
+external xml2lib xmlParserCtxtPtr EXTDECL	
 			xmlCreateURLParserCtxt	(char *filename,
 						 int options);
-XMLPUBFUN xmlParserCtxtPtr XMLCALL	
+external xml2lib xmlParserCtxtPtr EXTDECL	
 			xmlCreateMemoryParserCtxt(char *buffer,
 						 int size);
-XMLPUBFUN xmlParserCtxtPtr XMLCALL	
+external xml2lib xmlParserCtxtPtr EXTDECL	
 			xmlCreateEntityParserCtxt(xmlChar *URL,
 						 xmlChar *ID,
 						 xmlChar *base);
-XMLPUBFUN int XMLCALL			
+external xml2lib int EXTDECL			
 			xmlSwitchEncoding	(xmlParserCtxtPtr ctxt,
 						 xmlCharEncoding enc);
-XMLPUBFUN int XMLCALL			
+external xml2lib int EXTDECL			
 			xmlSwitchToEncoding	(xmlParserCtxtPtr ctxt,
 					 xmlCharEncodingHandlerPtr handler);
-XMLPUBFUN int XMLCALL			
+external xml2lib int EXTDECL			
 			xmlSwitchInputEncoding	(xmlParserCtxtPtr ctxt,
 						 xmlParserInputPtr input,
 					 xmlCharEncodingHandlerPtr handler);
 
 {$IFDEF IN_LIBXML}
 (* internal error reporting *)
-XMLPUBFUN void XMLCALL
+external xml2lib void EXTDECL
 			__xmlErrEncoding	(xmlParserCtxtPtr ctxt,
 						 xmlParserErrors xmlerr,
 						 char *msg,
@@ -311,29 +311,29 @@ XMLPUBFUN void XMLCALL
 (**
  * Input Streams.
  *)
-XMLPUBFUN xmlParserInputPtr XMLCALL	
+external xml2lib xmlParserInputPtr EXTDECL	
 			xmlNewStringInputStream	(xmlParserCtxtPtr ctxt,
 						 xmlChar *buffer);
-XMLPUBFUN xmlParserInputPtr XMLCALL	
+external xml2lib xmlParserInputPtr EXTDECL	
 			xmlNewEntityInputStream	(xmlParserCtxtPtr ctxt,
 						 xmlEntityPtr entity);
-XMLPUBFUN void XMLCALL			
+external xml2lib void EXTDECL			
 			xmlPushInput		(xmlParserCtxtPtr ctxt,
 						 xmlParserInputPtr input);
-XMLPUBFUN xmlChar XMLCALL			
+external xml2lib xmlChar EXTDECL			
 			xmlPopInput		(xmlParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL			
+external xml2lib void EXTDECL			
 			xmlFreeInputStream	(xmlParserInputPtr input);
-XMLPUBFUN xmlParserInputPtr XMLCALL	
+external xml2lib xmlParserInputPtr EXTDECL	
 			xmlNewInputFromFile	(xmlParserCtxtPtr ctxt,
 						 char *filename);
-XMLPUBFUN xmlParserInputPtr XMLCALL	
+external xml2lib xmlParserInputPtr EXTDECL	
 			xmlNewInputStream	(xmlParserCtxtPtr ctxt);
 
 (**
  * Namespaces.
  *)
-XMLPUBFUN xmlChar * XMLCALL		
+external xml2lib xmlChar * EXTDECL		
 			xmlSplitQName		(xmlParserCtxtPtr ctxt,
 						 xmlChar *name,
 						 xmlChar **prefix);
@@ -341,109 +341,109 @@ XMLPUBFUN xmlChar * XMLCALL
 (**
  * Generic production rules.
  *)
-XMLPUBFUN xmlChar * XMLCALL		
+external xml2lib xmlChar * EXTDECL		
 			xmlParseName		(xmlParserCtxtPtr ctxt);
-XMLPUBFUN xmlChar * XMLCALL		
+external xml2lib xmlChar * EXTDECL		
 			xmlParseNmtoken		(xmlParserCtxtPtr ctxt);
-XMLPUBFUN xmlChar * XMLCALL		
+external xml2lib xmlChar * EXTDECL		
 			xmlParseEntityValue	(xmlParserCtxtPtr ctxt,
 						 xmlChar **orig);
-XMLPUBFUN xmlChar * XMLCALL		
+external xml2lib xmlChar * EXTDECL		
 			xmlParseAttValue	(xmlParserCtxtPtr ctxt);
-XMLPUBFUN xmlChar * XMLCALL		
+external xml2lib xmlChar * EXTDECL		
 			xmlParseSystemLiteral	(xmlParserCtxtPtr ctxt);
-XMLPUBFUN xmlChar * XMLCALL		
+external xml2lib xmlChar * EXTDECL		
 			xmlParsePubidLiteral	(xmlParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL			
+external xml2lib void EXTDECL			
 			xmlParseCharData	(xmlParserCtxtPtr ctxt,
 						 int cdata);
-XMLPUBFUN xmlChar * XMLCALL		
+external xml2lib xmlChar * EXTDECL		
 			xmlParseExternalID	(xmlParserCtxtPtr ctxt,
 						 xmlChar **publicID,
 						 int strict);
-XMLPUBFUN void XMLCALL			
+external xml2lib void EXTDECL			
 			xmlParseComment		(xmlParserCtxtPtr ctxt);
-XMLPUBFUN xmlChar * XMLCALL		
+external xml2lib xmlChar * EXTDECL		
 			xmlParsePITarget	(xmlParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL			
+external xml2lib void EXTDECL			
 			xmlParsePI		(xmlParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL			
+external xml2lib void EXTDECL			
 			xmlParseNotationDecl	(xmlParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL			
+external xml2lib void EXTDECL			
 			xmlParseEntityDecl	(xmlParserCtxtPtr ctxt);
-XMLPUBFUN int XMLCALL			
+external xml2lib int EXTDECL			
 			xmlParseDefaultDecl	(xmlParserCtxtPtr ctxt,
 						 xmlChar **value);
-XMLPUBFUN xmlEnumerationPtr XMLCALL	
+external xml2lib xmlEnumerationPtr EXTDECL	
 			xmlParseNotationType	(xmlParserCtxtPtr ctxt);
-XMLPUBFUN xmlEnumerationPtr XMLCALL	
+external xml2lib xmlEnumerationPtr EXTDECL	
 			xmlParseEnumerationType	(xmlParserCtxtPtr ctxt);
-XMLPUBFUN int XMLCALL			
+external xml2lib int EXTDECL			
 			xmlParseEnumeratedType	(xmlParserCtxtPtr ctxt,
 						 xmlEnumerationPtr *tree);
-XMLPUBFUN int XMLCALL			
+external xml2lib int EXTDECL			
 			xmlParseAttributeType	(xmlParserCtxtPtr ctxt,
 						 xmlEnumerationPtr *tree);
-XMLPUBFUN void XMLCALL			
+external xml2lib void EXTDECL			
 			xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt);
-XMLPUBFUN xmlElementContentPtr XMLCALL	
+external xml2lib xmlElementContentPtr EXTDECL	
 			xmlParseElementMixedContentDecl
 						(xmlParserCtxtPtr ctxt,
 						 int inputchk);
-XMLPUBFUN xmlElementContentPtr XMLCALL	
+external xml2lib xmlElementContentPtr EXTDECL	
 			xmlParseElementChildrenContentDecl
 						(xmlParserCtxtPtr ctxt,
 						 int inputchk);
-XMLPUBFUN int XMLCALL			
+external xml2lib int EXTDECL			
 			xmlParseElementContentDecl(xmlParserCtxtPtr ctxt,
 						 xmlChar *name,
 						 xmlElementContentPtr *result);
-XMLPUBFUN int XMLCALL			
+external xml2lib int EXTDECL			
 			xmlParseElementDecl	(xmlParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL			
+external xml2lib void EXTDECL			
 			xmlParseMarkupDecl	(xmlParserCtxtPtr ctxt);
-XMLPUBFUN int XMLCALL			
+external xml2lib int EXTDECL			
 			xmlParseCharRef		(xmlParserCtxtPtr ctxt);
-XMLPUBFUN xmlEntityPtr XMLCALL		
+external xml2lib xmlEntityPtr EXTDECL		
 			xmlParseEntityRef	(xmlParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL			
+external xml2lib void EXTDECL			
 			xmlParseReference	(xmlParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL			
+external xml2lib void EXTDECL			
 			xmlParsePEReference	(xmlParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL			
+external xml2lib void EXTDECL			
 			xmlParseDocTypeDecl	(xmlParserCtxtPtr ctxt);
 {$IFDEF LIBXML_SAX1_ENABLED}
-XMLPUBFUN xmlChar * XMLCALL		
+external xml2lib xmlChar * EXTDECL		
 			xmlParseAttribute	(xmlParserCtxtPtr ctxt,
 						 xmlChar **value);
-XMLPUBFUN xmlChar * XMLCALL		
+external xml2lib xmlChar * EXTDECL		
 			xmlParseStartTag	(xmlParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL			
+external xml2lib void EXTDECL			
 			xmlParseEndTag		(xmlParserCtxtPtr ctxt);
 {$ENDIF} (* LIBXML_SAX1_ENABLED *)
-XMLPUBFUN void XMLCALL			
+external xml2lib void EXTDECL			
 			xmlParseCDSect		(xmlParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL			
+external xml2lib void EXTDECL			
 			xmlParseContent		(xmlParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL			
+external xml2lib void EXTDECL			
 			xmlParseElement		(xmlParserCtxtPtr ctxt);
-XMLPUBFUN xmlChar * XMLCALL		
+external xml2lib xmlChar * EXTDECL		
 			xmlParseVersionNum	(xmlParserCtxtPtr ctxt);
-XMLPUBFUN xmlChar * XMLCALL		
+external xml2lib xmlChar * EXTDECL		
 			xmlParseVersionInfo	(xmlParserCtxtPtr ctxt);
-XMLPUBFUN xmlChar * XMLCALL		
+external xml2lib xmlChar * EXTDECL		
 			xmlParseEncName		(xmlParserCtxtPtr ctxt);
-XMLPUBFUN xmlChar * XMLCALL		
+external xml2lib xmlChar * EXTDECL		
 			xmlParseEncodingDecl	(xmlParserCtxtPtr ctxt);
-XMLPUBFUN int XMLCALL			
+external xml2lib int EXTDECL			
 			xmlParseSDDecl		(xmlParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL			
+external xml2lib void EXTDECL			
 			xmlParseXMLDecl		(xmlParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL			
+external xml2lib void EXTDECL			
 			xmlParseTextDecl	(xmlParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL			
+external xml2lib void EXTDECL			
 			xmlParseMisc		(xmlParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL			
+external xml2lib void EXTDECL			
 			xmlParseExternalSubset	(xmlParserCtxtPtr ctxt,
 						 xmlChar *ExternalID,
 						 xmlChar *SystemID);
@@ -480,14 +480,14 @@ XMLPUBFUN void XMLCALL
 {$ENDIF}
 
 {$IFDEF FUNCTION_}
-XMLPUBFUN xmlChar * XMLCALL
+external xml2lib xmlChar * EXTDECL
 		xmlStringDecodeEntities		(xmlParserCtxtPtr ctxt,
 						 xmlChar *str,
 						 int what,
 						 xmlChar end,
 						 xmlChar  end2,
 						 xmlChar end3);
-XMLPUBFUN xmlChar * XMLCALL
+external xml2lib xmlChar * EXTDECL
 		xmlStringLenDecodeEntities	(xmlParserCtxtPtr ctxt,
 						 xmlChar *str,
 						 int len,
@@ -499,45 +499,45 @@ XMLPUBFUN xmlChar * XMLCALL
 (*
  * Generated by MACROS on top of parser.c c.f. PUSH_AND_POP.
  *)
-XMLPUBFUN int XMLCALL			nodePush		(xmlParserCtxtPtr ctxt,
+external xml2lib int EXTDECL			nodePush		(xmlParserCtxtPtr ctxt,
 						 xmlNodePtr value);
-XMLPUBFUN xmlNodePtr XMLCALL		nodePop			(xmlParserCtxtPtr ctxt);
-XMLPUBFUN int XMLCALL			inputPush		(xmlParserCtxtPtr ctxt,
+external xml2lib xmlNodePtr EXTDECL		nodePop			(xmlParserCtxtPtr ctxt);
+external xml2lib int EXTDECL			inputPush		(xmlParserCtxtPtr ctxt,
 						 xmlParserInputPtr value);
-XMLPUBFUN xmlParserInputPtr XMLCALL	inputPop		(xmlParserCtxtPtr ctxt);
-XMLPUBFUN xmlChar * XMLCALL	namePop			(xmlParserCtxtPtr ctxt);
-XMLPUBFUN int XMLCALL			namePush		(xmlParserCtxtPtr ctxt,
+external xml2lib xmlParserInputPtr EXTDECL	inputPop		(xmlParserCtxtPtr ctxt);
+external xml2lib xmlChar * EXTDECL	namePop			(xmlParserCtxtPtr ctxt);
+external xml2lib int EXTDECL			namePush		(xmlParserCtxtPtr ctxt,
 						 xmlChar *value);
 
 (*
  * other commodities shared between parser.c and parserInternals.
  *)
-XMLPUBFUN int XMLCALL			xmlSkipBlankChars	(xmlParserCtxtPtr ctxt);
-XMLPUBFUN int XMLCALL			xmlStringCurrentChar	(xmlParserCtxtPtr ctxt,
+external xml2lib int EXTDECL			xmlSkipBlankChars	(xmlParserCtxtPtr ctxt);
+external xml2lib int EXTDECL			xmlStringCurrentChar	(xmlParserCtxtPtr ctxt,
 						 xmlChar *cur,
 						 int *len);
-XMLPUBFUN void XMLCALL			xmlParserHandlePEReference(xmlParserCtxtPtr ctxt);
-XMLPUBFUN int XMLCALL			xmlCheckLanguageID	(xmlChar *lang);
+external xml2lib void EXTDECL			xmlParserHandlePEReference(xmlParserCtxtPtr ctxt);
+external xml2lib int EXTDECL			xmlCheckLanguageID	(xmlChar *lang);
 
 (*
  * Really core function shared with HTML parser.
  *)
-XMLPUBFUN int XMLCALL			xmlCurrentChar		(xmlParserCtxtPtr ctxt,
+external xml2lib int EXTDECL			xmlCurrentChar		(xmlParserCtxtPtr ctxt,
 						 int *len);
-XMLPUBFUN int XMLCALL		xmlCopyCharMultiByte	(xmlChar *out,
+external xml2lib int EXTDECL		xmlCopyCharMultiByte	(xmlChar *out,
 						 int val);
-XMLPUBFUN int XMLCALL			xmlCopyChar		(int len,
+external xml2lib int EXTDECL			xmlCopyChar		(int len,
 						 xmlChar *out,
 						 int val);
-XMLPUBFUN void XMLCALL			xmlNextChar		(xmlParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL			xmlParserInputShrink	(xmlParserInputPtr in);
+external xml2lib void EXTDECL			xmlNextChar		(xmlParserCtxtPtr ctxt);
+external xml2lib void EXTDECL			xmlParserInputShrink	(xmlParserInputPtr in);
 
 {$IFDEF LIBXML_HTML_ENABLED}
 (*
  * Actually comes from the HTML parser but launched from the init stuff.
  *)
-XMLPUBFUN void XMLCALL			htmlInitAutoClose	(void);
-XMLPUBFUN htmlParserCtxtPtr XMLCALL	htmlCreateFileParserCtxt(char *filename,
+external xml2lib void EXTDECL			htmlInitAutoClose	(void);
+external xml2lib htmlParserCtxtPtr EXTDECL	htmlCreateFileParserCtxt(char *filename,
 	                                         char *encoding);
 {$ENDIF}
 
@@ -559,34 +559,34 @@ typedef	void	(xmlEntityReferenceFunc)	(xmlEntityPtr ent,
 						 xmlNodePtr firstNode,
 						 xmlNodePtr lastNode);
   
-XMLPUBFUN void XMLCALL		xmlSetEntityReferenceFunc	(xmlEntityReferenceFunc func);
+external xml2lib void EXTDECL		xmlSetEntityReferenceFunc	(xmlEntityReferenceFunc func);
 
-XMLPUBFUN xmlChar * XMLCALL		
+external xml2lib xmlChar * EXTDECL		
 			xmlParseQuotedString	(xmlParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL
+external xml2lib void EXTDECL
                         xmlParseNamespace       (xmlParserCtxtPtr ctxt);
-XMLPUBFUN xmlChar * XMLCALL		
+external xml2lib xmlChar * EXTDECL		
 			xmlNamespaceParseNSDef	(xmlParserCtxtPtr ctxt);
-XMLPUBFUN xmlChar * XMLCALL		
+external xml2lib xmlChar * EXTDECL		
 			xmlScanName		(xmlParserCtxtPtr ctxt);
-XMLPUBFUN xmlChar * XMLCALL		
+external xml2lib xmlChar * EXTDECL		
 			xmlNamespaceParseNCName	(xmlParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL	xmlParserHandleReference(xmlParserCtxtPtr ctxt);
-XMLPUBFUN xmlChar * XMLCALL		
+external xml2lib void EXTDECL	xmlParserHandleReference(xmlParserCtxtPtr ctxt);
+external xml2lib xmlChar * EXTDECL		
 			xmlNamespaceParseQName	(xmlParserCtxtPtr ctxt,
 						 xmlChar **prefix);
 
 (**
  * Entities
  *)
-XMLPUBFUN xmlChar * XMLCALL
+external xml2lib xmlChar * EXTDECL
 		xmlDecodeEntities		(xmlParserCtxtPtr ctxt,
 						 int len,
 						 int what,
 						 xmlChar end,
 						 xmlChar  end2,
 						 xmlChar end3);
-XMLPUBFUN void XMLCALL			
+external xml2lib void EXTDECL			
 			xmlHandleEntity		(xmlParserCtxtPtr ctxt,
 						 xmlEntityPtr entity);
 
@@ -596,7 +596,7 @@ XMLPUBFUN void XMLCALL
 (*
  * internal only
  *)
-XMLPUBFUN void XMLCALL
+external xml2lib void EXTDECL
 	xmlErrMemory		(xmlParserCtxtPtr ctxt,
 				 char *extra);
 {$ENDIF}

packages/libxml/src/pattern.inc

@@ -43,23 +43,23 @@
 {$ENDIF}
 
 {$IFDEF FUNCTION}
-procedure xmlFreePattern(comp: xmlPatternPtr); XMLCALL; XMLPUBFUN;
-procedure xmlFreePatternList(comp: xmlPatternPtr); XMLCALL; XMLPUBFUN;
-function xmlPatterncompile(pattern: xmlCharPtr; dict: xmlDictPtr; flags: cint; namespaces: xmlCharPtrPtr): xmlPatternPtr; XMLCALL; XMLPUBFUN;
-function xmlPatternMatch(comp: xmlPatternPtr; node: xmlNodePtr): cint; XMLCALL; XMLPUBFUN;
+procedure xmlFreePattern(comp: xmlPatternPtr); EXTDECL; external xml2lib;
+procedure xmlFreePatternList(comp: xmlPatternPtr); EXTDECL; external xml2lib;
+function xmlPatterncompile(pattern: xmlCharPtr; dict: xmlDictPtr; flags: cint; namespaces: xmlCharPtrPtr): xmlPatternPtr; EXTDECL; external xml2lib;
+function xmlPatternMatch(comp: xmlPatternPtr; node: xmlNodePtr): cint; EXTDECL; external xml2lib;
 
 (* streaming interfaces *)
-function xmlPatternStreamable(comp: xmlPatternPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlPatternMaxDepth(comp: xmlPatternPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlPatternMinDepth(comp: xmlPatternPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlPatternFromRoot(comp: xmlPatternPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlPatternGetStreamCtxt(comp: xmlPatternPtr): xmlStreamCtxtPtr; XMLCALL; XMLPUBFUN;
-procedure xmlFreeStreamCtxt(stream: xmlStreamCtxtPtr); XMLCALL; XMLPUBFUN;
-function xmlStreamPushNode(stream: xmlStreamCtxtPtr; name, ns: xmlCharPtr; nodeType: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlStreamPush(stream: xmlStreamCtxtPtr; name, ns: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlStreamPushAttr(stream: xmlStreamCtxtPtr; name, ns: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlStreamPop(stream: xmlStreamCtxtPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlStreamWantsAnyNode(stream: xmlStreamCtxtPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlPatternStreamable(comp: xmlPatternPtr): cint; EXTDECL; external xml2lib;
+function xmlPatternMaxDepth(comp: xmlPatternPtr): cint; EXTDECL; external xml2lib;
+function xmlPatternMinDepth(comp: xmlPatternPtr): cint; EXTDECL; external xml2lib;
+function xmlPatternFromRoot(comp: xmlPatternPtr): cint; EXTDECL; external xml2lib;
+function xmlPatternGetStreamCtxt(comp: xmlPatternPtr): xmlStreamCtxtPtr; EXTDECL; external xml2lib;
+procedure xmlFreeStreamCtxt(stream: xmlStreamCtxtPtr); EXTDECL; external xml2lib;
+function xmlStreamPushNode(stream: xmlStreamCtxtPtr; name, ns: xmlCharPtr; nodeType: cint): cint; EXTDECL; external xml2lib;
+function xmlStreamPush(stream: xmlStreamCtxtPtr; name, ns: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlStreamPushAttr(stream: xmlStreamCtxtPtr; name, ns: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlStreamPop(stream: xmlStreamCtxtPtr): cint; EXTDECL; external xml2lib;
+function xmlStreamWantsAnyNode(stream: xmlStreamCtxtPtr): cint; EXTDECL; external xml2lib;
 {$ENDIF}
 
 {$ENDIF} (* LIBXML_PATTERN_ENABLED *)

packages/libxml/src/relaxng.inc

@@ -22,8 +22,8 @@
 (**
  * A schemas validation context
  *)
-  xmlRelaxNGValidityErrorFunc = procedure(ctx: pointer; msg: pchar); XMLCDECL; varargs;
-  xmlRelaxNGValidityWarningFunc = procedure(ctx: pointer; msg: pchar); XMLCDECL; varargs;
+  xmlRelaxNGValidityErrorFunc = procedure(ctx: pointer; msg: pchar); cdecl; varargs;
+  xmlRelaxNGValidityWarningFunc = procedure(ctx: pointer; msg: pchar); cdecl; varargs;
 
   xmlRelaxNGParserCtxt = record end;
 
@@ -91,44 +91,44 @@
 {$ENDIF}
 
 {$IFDEF FUNCTION}
-function xmlRelaxNGInitTypes: cint; XMLCALL; XMLPUBFUN;
-function xmlRelaxNGCleanupTypes: cint; XMLCALL; XMLPUBFUN;
+function xmlRelaxNGInitTypes: cint; EXTDECL; external xml2lib;
+function xmlRelaxNGCleanupTypes: cint; EXTDECL; external xml2lib;
 
 (*
  * Interfaces for parsing.
  *)
-function xmlRelaxNGNewParserCtxt(URL: pchar): xmlRelaxNGParserCtxtPtr; XMLCALL; XMLPUBFUN;
-function xmlRelaxNGNewMemParserCtxt(buffer: pchar; size: cint): xmlRelaxNGParserCtxtPtr; XMLCALL; XMLPUBFUN;
-function xmlRelaxNGNewDocParserCtxt(doc: xmlDocPtr): xmlRelaxNGParserCtxtPtr; XMLCALL; XMLPUBFUN;
-function xmlRelaxParserSetFlag(ctxt: xmlRelaxNGParserCtxtPtr; flag: cint; doc: xmlDocPtr): cint; XMLCALL; XMLPUBFUN;
-procedure xmlRelaxNGFreeParserCtxt(ctxt: xmlRelaxNGParserCtxtPtr); XMLCALL; XMLPUBFUN;
-procedure xmlRelaxNGSetParserErrors(ctxt: xmlRelaxNGParserCtxtPtr; err: xmlRelaxNGValidityErrorFunc; warn: xmlRelaxNGValidityWarningFunc; ctx: pointer); XMLCALL; XMLPUBFUN;
-function xmlRelaxNGGetParserErrors(ctxt: xmlRelaxNGParserCtxtPtr; var err: xmlRelaxNGValidityErrorFunc; var warn: xmlRelaxNGValidityWarningFunc; var ctx: pointer): cint; XMLCALL; XMLPUBFUN;
-procedure xmlRelaxNGSetParserStructuredErrors(ctxt: xmlRelaxNGParserCtxtPtr; serror: xmlStructuredErrorFunc; ctx: pointer); XMLCALL; XMLPUBFUN;
-function xmlRelaxNGParse(ctxt: xmlRelaxNGParserCtxtPtr): xmlRelaxNGPtr; XMLCALL; XMLPUBFUN;
-procedure xmlRelaxNGFree(schema: xmlRelaxNGPtr); XMLCALL; XMLPUBFUN;
+function xmlRelaxNGNewParserCtxt(URL: pchar): xmlRelaxNGParserCtxtPtr; EXTDECL; external xml2lib;
+function xmlRelaxNGNewMemParserCtxt(buffer: pchar; size: cint): xmlRelaxNGParserCtxtPtr; EXTDECL; external xml2lib;
+function xmlRelaxNGNewDocParserCtxt(doc: xmlDocPtr): xmlRelaxNGParserCtxtPtr; EXTDECL; external xml2lib;
+function xmlRelaxParserSetFlag(ctxt: xmlRelaxNGParserCtxtPtr; flag: cint; doc: xmlDocPtr): cint; EXTDECL; external xml2lib;
+procedure xmlRelaxNGFreeParserCtxt(ctxt: xmlRelaxNGParserCtxtPtr); EXTDECL; external xml2lib;
+procedure xmlRelaxNGSetParserErrors(ctxt: xmlRelaxNGParserCtxtPtr; err: xmlRelaxNGValidityErrorFunc; warn: xmlRelaxNGValidityWarningFunc; ctx: pointer); EXTDECL; external xml2lib;
+function xmlRelaxNGGetParserErrors(ctxt: xmlRelaxNGParserCtxtPtr; var err: xmlRelaxNGValidityErrorFunc; var warn: xmlRelaxNGValidityWarningFunc; var ctx: pointer): cint; EXTDECL; external xml2lib;
+procedure xmlRelaxNGSetParserStructuredErrors(ctxt: xmlRelaxNGParserCtxtPtr; serror: xmlStructuredErrorFunc; ctx: pointer); EXTDECL; external xml2lib;
+function xmlRelaxNGParse(ctxt: xmlRelaxNGParserCtxtPtr): xmlRelaxNGPtr; EXTDECL; external xml2lib;
+procedure xmlRelaxNGFree(schema: xmlRelaxNGPtr); EXTDECL; external xml2lib;
 {$IFDEF LIBXML_OUTPUT_ENABLED}
-procedure xmlRelaxNGDump(output: PFILE; schema: xmlRelaxNGPtr); XMLCALL; XMLPUBFUN;
-procedure xmlRelaxNGDumpTree(output: PFILE; schema: xmlRelaxNGPtr); XMLCALL; XMLPUBFUN;
+procedure xmlRelaxNGDump(output: PFILE; schema: xmlRelaxNGPtr); EXTDECL; external xml2lib;
+procedure xmlRelaxNGDumpTree(output: PFILE; schema: xmlRelaxNGPtr); EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
 
 (*
  * Interfaces for validating
  *)
-procedure xmlRelaxNGSetValidErrors(ctxt: xmlRelaxNGValidCtxtPtr; err: xmlRelaxNGValidityErrorFunc; warn: xmlRelaxNGValidityWarningFunc; ctx: pointer); XMLCALL; XMLPUBFUN;
-function xmlRelaxNGGetValidErrors(ctxt: xmlRelaxNGValidCtxtPtr; var err: xmlRelaxNGValidityErrorFunc; var warn: xmlRelaxNGValidityWarningFunc; var ctx: pointer): cint; XMLCALL; XMLPUBFUN;
-procedure xmlRelaxNGSetValidErrors(ctxt: xmlRelaxNGValidCtxtPtr; serror: xmlStructuredErrorFunc; ctx: pointer); XMLCALL; XMLPUBFUN;
-function xmlRelaxNGNewValidCtxt(schema: xmlRelaxNGPtr): xmlRelaxNGValidCtxtPtr; XMLCALL; XMLPUBFUN;
-procedure xmlRelaxNGFreeValidCtxt(ctxt: xmlRelaxNGValidCtxtPtr); XMLCALL; XMLPUBFUN;
-function xmlRelaxNGValidateDoc(ctxt: xmlRelaxNGValidCtxtPtr; doc: xmlDocPtr): cint; XMLCALL; XMLPUBFUN;
+procedure xmlRelaxNGSetValidErrors(ctxt: xmlRelaxNGValidCtxtPtr; err: xmlRelaxNGValidityErrorFunc; warn: xmlRelaxNGValidityWarningFunc; ctx: pointer); EXTDECL; external xml2lib;
+function xmlRelaxNGGetValidErrors(ctxt: xmlRelaxNGValidCtxtPtr; var err: xmlRelaxNGValidityErrorFunc; var warn: xmlRelaxNGValidityWarningFunc; var ctx: pointer): cint; EXTDECL; external xml2lib;
+procedure xmlRelaxNGSetValidErrors(ctxt: xmlRelaxNGValidCtxtPtr; serror: xmlStructuredErrorFunc; ctx: pointer); EXTDECL; external xml2lib;
+function xmlRelaxNGNewValidCtxt(schema: xmlRelaxNGPtr): xmlRelaxNGValidCtxtPtr; EXTDECL; external xml2lib;
+procedure xmlRelaxNGFreeValidCtxt(ctxt: xmlRelaxNGValidCtxtPtr); EXTDECL; external xml2lib;
+function xmlRelaxNGValidateDoc(ctxt: xmlRelaxNGValidCtxtPtr; doc: xmlDocPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * Interfaces for progressive validation when possible
  *)
-function xmlRelaxNGValidatePushElement(ctxt: xmlRelaxNGValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr): cint; XMLCALL; XMLPUBFUN;
-function xmlRelaxNGValidatePushCData(ctxt: xmlRelaxNGValidCtxtPtr; data: xmlCharPtr; len: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlRelaxNGValidatePopElement(ctxt: xmlRelaxNGValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr): cint; XMLCALL; XMLPUBFUN;
-function xmlRelaxNGValidateFullElement(ctxt: xmlRelaxNGValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr): cint; XMLCALL; XMLPUBFUN;
+function xmlRelaxNGValidatePushElement(ctxt: xmlRelaxNGValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr): cint; EXTDECL; external xml2lib;
+function xmlRelaxNGValidatePushCData(ctxt: xmlRelaxNGValidCtxtPtr; data: xmlCharPtr; len: cint): cint; EXTDECL; external xml2lib;
+function xmlRelaxNGValidatePopElement(ctxt: xmlRelaxNGValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr): cint; EXTDECL; external xml2lib;
+function xmlRelaxNGValidateFullElement(ctxt: xmlRelaxNGValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr): cint; EXTDECL; external xml2lib;
 {$ENDIF}
 {$ENDIF} (* LIBXML_SCHEMAS_ENABLED *)
 

packages/libxml/src/schemasInternals.inc

@@ -913,8 +913,8 @@
 {$ENDIF}
 
 {$IFDEF FUNCTION}
-procedure xmlSchemaFreeType(_type: xmlSchemaTypePtr); XMLCALL; XMLPUBFUN;
-procedure xmlSchemaFreeWildcard(wildcard: xmlSchemaWildcardPtr); XMLCALL; XMLPUBFUN;
+procedure xmlSchemaFreeType(_type: xmlSchemaTypePtr); EXTDECL; external xml2lib;
+procedure xmlSchemaFreeWildcard(wildcard: xmlSchemaWildcardPtr); EXTDECL; external xml2lib;
 {$ENDIF}
 
 {$ENDIF} (* LIBXML_SCHEMAS_ENABLED *)

packages/libxml/src/schematron.inc

@@ -36,8 +36,8 @@
 (**
  * A schemas validation context
  *)
-  xmlSchematronValidityErrorFunc = procedure(ctx: pointer; msg: pchar); XMLCDECL; varargs;
-  xmlSchematronValidityWarningFunc = procedure(ctx: pointer; msg: pchar); XMLCDECL; varargs;
+  xmlSchematronValidityErrorFunc = procedure(ctx: pointer; msg: pchar); cdecl; varargs;
+  xmlSchematronValidityWarningFunc = procedure(ctx: pointer; msg: pchar); cdecl; varargs;
 
   xmlSchematronParserCtxt = record end;
 
@@ -48,54 +48,54 @@
 (*
  * Interfaces for parsing.
  *)
-function xmlSchematronNewParserCtxt(URL: pchar): xmlSchematronParserCtxtPtr; XMLCALL; XMLPUBFUN;
-function xmlSchematronNewMemParserCtxt(buffer: pchar; size: cint): xmlSchematronParserCtxtPtr; XMLCALL; XMLPUBFUN;
-function xmlSchematronNewDocParserCtxt(doc: xmlDocPtr): xmlSchematronParserCtxtPtr; XMLCALL; XMLPUBFUN;
-procedure xmlSchematronFreeParserCtxt(ctxt: xmlSchematronParserCtxtPtr); XMLCALL; XMLPUBFUN;
+function xmlSchematronNewParserCtxt(URL: pchar): xmlSchematronParserCtxtPtr; EXTDECL; external xml2lib;
+function xmlSchematronNewMemParserCtxt(buffer: pchar; size: cint): xmlSchematronParserCtxtPtr; EXTDECL; external xml2lib;
+function xmlSchematronNewDocParserCtxt(doc: xmlDocPtr): xmlSchematronParserCtxtPtr; EXTDECL; external xml2lib;
+procedure xmlSchematronFreeParserCtxt(ctxt: xmlSchematronParserCtxtPtr); EXTDECL; external xml2lib;
 (*****
-XMLPUBFUN void XMLCALL		
+external xml2lib void EXTDECL		
 	    xmlSchematronSetParserErrors(xmlSchematronParserCtxtPtr ctxt,
 					 xmlSchematronValidityErrorFunc err,
 					 xmlSchematronValidityWarningFunc warn,
 					 void *ctx);
-XMLPUBFUN int XMLCALL
+external xml2lib int EXTDECL
 		xmlSchematronGetParserErrors(xmlSchematronParserCtxtPtr ctxt,
 					xmlSchematronValidityErrorFunc * err,
 					xmlSchematronValidityWarningFunc * warn,
 					void **ctx);
-XMLPUBFUN int XMLCALL
+external xml2lib int EXTDECL
 		xmlSchematronIsValid	(xmlSchematronValidCtxtPtr ctxt);
  *****)
-function xmlSchematronParse(ctxt: xmlSchematronParserCtxtPtr): xmlSchematronPtr; XMLCALL; XMLPUBFUN;
-procedure xmlSchematronFree(schema: xmlSchematronPtr); XMLCALL; XMLPUBFUN;
+function xmlSchematronParse(ctxt: xmlSchematronParserCtxtPtr): xmlSchematronPtr; EXTDECL; external xml2lib;
+procedure xmlSchematronFree(schema: xmlSchematronPtr); EXTDECL; external xml2lib;
 
 (*
  * Interfaces for validating
  *)
-procedure xmlSchematronSetValidStructuredErrors(ctxt: xmlSchematronValidCtxtPtr; serror: xmlStructuredErrorFunc; ctx: pointer); XMLCALL; XMLPUBFUN;
+procedure xmlSchematronSetValidStructuredErrors(ctxt: xmlSchematronValidCtxtPtr; serror: xmlStructuredErrorFunc; ctx: pointer); EXTDECL; external xml2lib;
 (******
-XMLPUBFUN void XMLCALL		
+external xml2lib void EXTDECL		
 	    xmlSchematronSetValidErrors	(xmlSchematronValidCtxtPtr ctxt,
 					 xmlSchematronValidityErrorFunc err,
 					 xmlSchematronValidityWarningFunc warn,
 					 void *ctx);
-XMLPUBFUN int XMLCALL
+external xml2lib int EXTDECL
 	    xmlSchematronGetValidErrors	(xmlSchematronValidCtxtPtr ctxt,
 					 xmlSchematronValidityErrorFunc *err,
 					 xmlSchematronValidityWarningFunc *warn,
 					 void **ctx);
-XMLPUBFUN int XMLCALL
+external xml2lib int EXTDECL
 	    xmlSchematronSetValidOptions(xmlSchematronValidCtxtPtr ctxt,
 					 int options);
-XMLPUBFUN int XMLCALL
+external xml2lib int EXTDECL
 	    xmlSchematronValidCtxtGetOptions(xmlSchematronValidCtxtPtr ctxt);
-XMLPUBFUN int XMLCALL
+external xml2lib int EXTDECL
             xmlSchematronValidateOneElement (xmlSchematronValidCtxtPtr ctxt,
 			                 xmlNodePtr elem);
  *******)
-function xmlSchematronNewValidCtxt(schema: xmlSchematronPtr; options: cint): xmlSchematronValidCtxtPtr; XMLCALL; XMLPUBFUN;
-procedure xmlSchematronFreeValidCtxt(ctxt: xmlSchematronValidCtxtPtr); XMLCALL; XMLPUBFUN;
-function xmlSchematronValidateDoc(ctxt: xmlSchematronValidCtxtPtr; instance: xmlDocPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlSchematronNewValidCtxt(schema: xmlSchematronPtr; options: cint): xmlSchematronValidCtxtPtr; EXTDECL; external xml2lib;
+procedure xmlSchematronFreeValidCtxt(ctxt: xmlSchematronValidCtxtPtr); EXTDECL; external xml2lib;
+function xmlSchematronValidateDoc(ctxt: xmlSchematronValidCtxtPtr; instance: xmlDocPtr): cint; EXTDECL; external xml2lib;
 
 {$ENDIF}
 {$ENDIF} (* LIBXML_SCHEMATRON_ENABLED *)

packages/libxml/src/threads.inc

@@ -26,30 +26,30 @@
 {$ENDIF}
 
 {$IFDEF FUNCTION}
-function xmlNewMutex: xmlMutexPtr; XMLCALL; XMLPUBFUN;
-procedure xmlMutexLock(tok: xmlMutexPtr); XMLCALL; XMLPUBFUN;
-procedure xmlMutexUnlock(tok: xmlMutexPtr); XMLCALL; XMLPUBFUN;
-procedure xmlFreeMutex(tok: xmlMutexPtr); XMLCALL; XMLPUBFUN;
+function xmlNewMutex: xmlMutexPtr; EXTDECL; external xml2lib;
+procedure xmlMutexLock(tok: xmlMutexPtr); EXTDECL; external xml2lib;
+procedure xmlMutexUnlock(tok: xmlMutexPtr); EXTDECL; external xml2lib;
+procedure xmlFreeMutex(tok: xmlMutexPtr); EXTDECL; external xml2lib;
 
-function xmlNewRMutex: xmlRMutexPtr; XMLCALL; XMLPUBFUN;
-procedure xmlRMutexLock(tok: xmlRMutexPtr); XMLCALL; XMLPUBFUN;
-procedure xmlRMutexUnlock(tok: xmlRMutexPtr); XMLCALL; XMLPUBFUN;
-procedure xmlFreeRMutex(tok: xmlRMutexPtr); XMLCALL; XMLPUBFUN;
+function xmlNewRMutex: xmlRMutexPtr; EXTDECL; external xml2lib;
+procedure xmlRMutexLock(tok: xmlRMutexPtr); EXTDECL; external xml2lib;
+procedure xmlRMutexUnlock(tok: xmlRMutexPtr); EXTDECL; external xml2lib;
+procedure xmlFreeRMutex(tok: xmlRMutexPtr); EXTDECL; external xml2lib;
 
 (*
  * Library wide APIs.
  *)
-procedure xmlInitThreads; XMLCALL; XMLPUBFUN;
-procedure xmlLockLibrary; XMLCALL; XMLPUBFUN;
-procedure xmlUnlockLibrary; XMLCALL; XMLPUBFUN;
+procedure xmlInitThreads; EXTDECL; external xml2lib;
+procedure xmlLockLibrary; EXTDECL; external xml2lib;
+procedure xmlUnlockLibrary; EXTDECL; external xml2lib;
 
-function xmlGetThreadId: cint; XMLCALL; XMLPUBFUN;
-function xmlIsMainThread: cint; XMLCALL; XMLPUBFUN;
-procedure xmlCleanupThreads; XMLCALL; XMLPUBFUN;
-function xmlGetGlobalState: xmlGlobalStatePtr; XMLCALL; XMLPUBFUN;
+function xmlGetThreadId: cint; EXTDECL; external xml2lib;
+function xmlIsMainThread: cint; EXTDECL; external xml2lib;
+procedure xmlCleanupThreads; EXTDECL; external xml2lib;
+function xmlGetGlobalState: xmlGlobalStatePtr; EXTDECL; external xml2lib;
 
 {$IF defined(HAVE_WIN32_THREADS) and not defined(HAVE_COMPILER_TLS) and defined(LIBXML_STATIC_FOR_DLL)}
-//int XMLCALL xmlDllMain(void *hinstDLL, unsigned long fdwReason, void *lpvReserved);
+//int EXTDECL xmlDllMain(void *hinstDLL, unsigned long fdwReason, void *lpvReserved);
 {$ENDIF}
 
 {$ENDIF}

packages/libxml/src/tree.inc

@@ -486,7 +486,7 @@ function XML_GET_CONTENT(n: pointer): xmlCharPtr;
  *
  * Returns an xmlNsPtr or NULL in case of an error.
  *)
-  xmlDOMWrapAcquireNsFunction = function (ctxt: xmlDOMWrapCtxtPtr; node: xmlNodePtr; nsName, nsPrefix: xmlCharPtr): xmlNsPtr; XMLCALL;
+  xmlDOMWrapAcquireNsFunction = function (ctxt: xmlDOMWrapCtxtPtr; node: xmlNodePtr; nsName, nsPrefix: xmlCharPtr): xmlNsPtr; EXTDECL;
 
 (**
  * xmlDOMWrapCtxt:
@@ -542,218 +542,218 @@ function XML_GET_CONTENT(n: pointer): xmlCharPtr;
 {$IF defined(LIBXML_TREE_ENABLED) or defined(LIBXML_XPATH_ENABLED) or defined(LIBXML_SCHEMAS_ENABLED) or
   defined(LIBXML_DEBUG_ENABLED) or defined (LIBXML_HTML_ENABLED) or defined(LIBXML_SAX1_ENABLED) or
   defined(LIBXML_HTML_ENABLED) or defined(LIBXML_WRITER_ENABLED) or defined(LIBXML_DOCB_ENABLED)}
-function xmlValidateNCName(value: xmlCharPtr; space: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlValidateNCName(value: xmlCharPtr; space: cint): cint; EXTDECL; external xml2lib;
 {$ENDIF}
 
 {$IF defined(LIBXML_TREE_ENABLED) or defined(LIBXML_SCHEMAS_ENABLED)}
-function xmlValidateQName(value: xmlCharPtr; space: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlValidateName(value: xmlCharPtr; space: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlValidateNMToken(value: xmlCharPtr; space: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlValidateQName(value: xmlCharPtr; space: cint): cint; EXTDECL; external xml2lib;
+function xmlValidateName(value: xmlCharPtr; space: cint): cint; EXTDECL; external xml2lib;
+function xmlValidateNMToken(value: xmlCharPtr; space: cint): cint; EXTDECL; external xml2lib;
 {$ENDIF}
 
-function xmlValidateQName(ncname, prefix, memory: xmlCharPtr; len: cint): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlSplitQName2(name: xmlCharPtr; var prefix: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlSplitQName3(name: xmlCharPtr; var prefix: xmlCharPtr; var len: cint): xmlCharPtr; XMLCALL; XMLPUBFUN;
+function xmlValidateQName(ncname, prefix, memory: xmlCharPtr; len: cint): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlSplitQName2(name: xmlCharPtr; var prefix: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlSplitQName3(name: xmlCharPtr; var prefix: xmlCharPtr; var len: cint): xmlCharPtr; EXTDECL; external xml2lib;
 
 (*
  * Handling Buffers.
  *)
-procedure xmlSetBufferAllocationScheme(scheme: xmlBufferAllocationScheme); XMLCALL; XMLPUBFUN;
-function xmlGetBufferAllocationScheme: xmlBufferAllocationScheme; XMLCALL; XMLPUBFUN;
-
-function xmlBufferCreate: xmlBufferPtr; XMLCALL; XMLPUBFUN;
-function xmlBufferCreateSize(size: csize_t): xmlBufferPtr; XMLCALL; XMLPUBFUN;
-function xmlBufferCreateStatic(mem: pointer; size: csize_t): xmlBufferPtr; XMLCALL; XMLPUBFUN;
-function xmlBufferResize(buf: xmlBufferPtr; size: cuint): cint; XMLCALL; XMLPUBFUN;
-procedure xmlBufferFree(buf: xmlBufferPtr); XMLCALL; XMLPUBFUN;
-procedure xmlBufferDump(fp: PFILE; buf: xmlBufferPtr); XMLCALL; XMLPUBFUN;
-function xmlBufferAdd(buf: xmlBufferPtr; str: xmlCharPtr; len: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlBufferAddHead(buf: xmlBufferPtr; str: xmlCharPtr; len: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlBufferCat(buf: xmlBufferPtr; str: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlBufferCCat(buf: xmlBufferPtr; str: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlBufferShrink(buf: xmlBufferPtr; len: cuint): cint; XMLCALL; XMLPUBFUN;
-function xmlBufferGrow(buf: xmlBufferPtr; len: cuint): cint; XMLCALL; XMLPUBFUN;
-procedure xmlBufferEmpty(buf: xmlBufferPtr); XMLCALL; XMLPUBFUN;
-function xmlBufferContent(buf: xmlBufferPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-procedure xmlBufferSetAllocationScheme(buf: xmlBufferPtr; scheme: xmlBufferAllocationScheme); XMLCALL; XMLPUBFUN;
-function xmlBufferLength(buf: xmlBufferPtr): cint; XMLCALL; XMLPUBFUN;
+procedure xmlSetBufferAllocationScheme(scheme: xmlBufferAllocationScheme); EXTDECL; external xml2lib;
+function xmlGetBufferAllocationScheme: xmlBufferAllocationScheme; EXTDECL; external xml2lib;
+
+function xmlBufferCreate: xmlBufferPtr; EXTDECL; external xml2lib;
+function xmlBufferCreateSize(size: csize_t): xmlBufferPtr; EXTDECL; external xml2lib;
+function xmlBufferCreateStatic(mem: pointer; size: csize_t): xmlBufferPtr; EXTDECL; external xml2lib;
+function xmlBufferResize(buf: xmlBufferPtr; size: cuint): cint; EXTDECL; external xml2lib;
+procedure xmlBufferFree(buf: xmlBufferPtr); EXTDECL; external xml2lib;
+procedure xmlBufferDump(fp: PFILE; buf: xmlBufferPtr); EXTDECL; external xml2lib;
+function xmlBufferAdd(buf: xmlBufferPtr; str: xmlCharPtr; len: cint): cint; EXTDECL; external xml2lib;
+function xmlBufferAddHead(buf: xmlBufferPtr; str: xmlCharPtr; len: cint): cint; EXTDECL; external xml2lib;
+function xmlBufferCat(buf: xmlBufferPtr; str: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlBufferCCat(buf: xmlBufferPtr; str: pchar): cint; EXTDECL; external xml2lib;
+function xmlBufferShrink(buf: xmlBufferPtr; len: cuint): cint; EXTDECL; external xml2lib;
+function xmlBufferGrow(buf: xmlBufferPtr; len: cuint): cint; EXTDECL; external xml2lib;
+procedure xmlBufferEmpty(buf: xmlBufferPtr); EXTDECL; external xml2lib;
+function xmlBufferContent(buf: xmlBufferPtr): xmlCharPtr; EXTDECL; external xml2lib;
+procedure xmlBufferSetAllocationScheme(buf: xmlBufferPtr; scheme: xmlBufferAllocationScheme); EXTDECL; external xml2lib;
+function xmlBufferLength(buf: xmlBufferPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * Creating/freeing new structures.
  *)
-function xmlCreateIntSubset(doc: xmlDocPtr; name, ExternalID, SystemID: xmlCharPtr): xmlDtdPtr; XMLCALL; XMLPUBFUN;
-function xmlNewDtd(doc: xmlDocPtr; name, ExternalID, SystemID: xmlCharPtr): xmlDtdPtr; XMLCALL; XMLPUBFUN;
-function xmlGetIntSubset(doc: xmlDocPtr): xmlDtdPtr; XMLCALL; XMLPUBFUN;
-procedure xmlFreeDtd(cur: xmlDtdPtr); XMLCALL; XMLPUBFUN;
+function xmlCreateIntSubset(doc: xmlDocPtr; name, ExternalID, SystemID: xmlCharPtr): xmlDtdPtr; EXTDECL; external xml2lib;
+function xmlNewDtd(doc: xmlDocPtr; name, ExternalID, SystemID: xmlCharPtr): xmlDtdPtr; EXTDECL; external xml2lib;
+function xmlGetIntSubset(doc: xmlDocPtr): xmlDtdPtr; EXTDECL; external xml2lib;
+procedure xmlFreeDtd(cur: xmlDtdPtr); EXTDECL; external xml2lib;
 {$IFDEF LIBXML_LEGACY_ENABLED}
-function xmlNewGlobalNs(doc: xmlDocPtr; href, prefix: xmlCharPtr): xmlNsPtr; XMLCALL; XMLPUBFUN;
+function xmlNewGlobalNs(doc: xmlDocPtr; href, prefix: xmlCharPtr): xmlNsPtr; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_LEGACY_ENABLED *)
-function xmlNewNs(node: xmlNodePtr; href, prefix: xmlCharPtr): xmlNsPtr; XMLCALL; XMLPUBFUN;
-procedure xmlFreeNs(cur: xmlNsPtr); XMLCALL; XMLPUBFUN;
-procedure xmlFreeNsList(cur: xmlNsPtr); XMLCALL; XMLPUBFUN;
-function xmlNewDoc(version: xmlCharPtr): xmlDocPtr; XMLCALL; XMLPUBFUN;
-procedure xmlFreeDoc(cur: xmlDocPtr); XMLCALL; XMLPUBFUN;
-function xmlNewDocProp(doc: xmlDocPtr; name, value: xmlCharPtr): xmlAttrPtr; XMLCALL; XMLPUBFUN;
+function xmlNewNs(node: xmlNodePtr; href, prefix: xmlCharPtr): xmlNsPtr; EXTDECL; external xml2lib;
+procedure xmlFreeNs(cur: xmlNsPtr); EXTDECL; external xml2lib;
+procedure xmlFreeNsList(cur: xmlNsPtr); EXTDECL; external xml2lib;
+function xmlNewDoc(version: xmlCharPtr): xmlDocPtr; EXTDECL; external xml2lib;
+procedure xmlFreeDoc(cur: xmlDocPtr); EXTDECL; external xml2lib;
+function xmlNewDocProp(doc: xmlDocPtr; name, value: xmlCharPtr): xmlAttrPtr; EXTDECL; external xml2lib;
 {$IF defined(LIBXML_TREE_ENABLED) or defined(LIBXML_HTML_ENABLED) or defined(LIBXML_SCHEMAS_ENABLED)}
-function xmlNewProp(node: xmlNodePtr; name, value: xmlCharPtr): xmlAttrPtr; XMLCALL; XMLPUBFUN;
+function xmlNewProp(node: xmlNodePtr; name, value: xmlCharPtr): xmlAttrPtr; EXTDECL; external xml2lib;
 {$ENDIF}
-function xmlNewNsProp(node: xmlNodePtr; ns: xmlNsPtr; name, value: xmlCharPtr): xmlAttrPtr; XMLCALL; XMLPUBFUN;
-function xmlNewNsPropEatName(node: xmlNodePtr; ns: xmlNsPtr; name, value: xmlCharPtr): xmlAttrPtr; XMLCALL; XMLPUBFUN;
-procedure xmlFreePropList(cur: xmlAttrPtr); XMLCALL; XMLPUBFUN;
-procedure xmlFreeProp(cur: xmlAttrPtr); XMLCALL; XMLPUBFUN;
-function xmlCopyProp(target: xmlNodePtr; cur: xmlAttrPtr): xmlAttrPtr; XMLCALL; XMLPUBFUN;
-function xmlCopyPropList(target: xmlNodePtr; cur: xmlAttrPtr): xmlAttrPtr; XMLCALL; XMLPUBFUN;
+function xmlNewNsProp(node: xmlNodePtr; ns: xmlNsPtr; name, value: xmlCharPtr): xmlAttrPtr; EXTDECL; external xml2lib;
+function xmlNewNsPropEatName(node: xmlNodePtr; ns: xmlNsPtr; name, value: xmlCharPtr): xmlAttrPtr; EXTDECL; external xml2lib;
+procedure xmlFreePropList(cur: xmlAttrPtr); EXTDECL; external xml2lib;
+procedure xmlFreeProp(cur: xmlAttrPtr); EXTDECL; external xml2lib;
+function xmlCopyProp(target: xmlNodePtr; cur: xmlAttrPtr): xmlAttrPtr; EXTDECL; external xml2lib;
+function xmlCopyPropList(target: xmlNodePtr; cur: xmlAttrPtr): xmlAttrPtr; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_TREE_ENABLED}
-function xmlCopyDtd(dtd: xmlDtdPtr): xmlDtdPtr; XMLCALL; XMLPUBFUN;
+function xmlCopyDtd(dtd: xmlDtdPtr): xmlDtdPtr; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_TREE_ENABLED *)
 {$IF defined(LIBXML_TREE_ENABLED) or defined(LIBXML_SCHEMAS_ENABLED)}
-function xmlCopyDoc(doc: xmlDocPtr; recursive: cint): xmlDocPtr; XMLCALL; XMLPUBFUN;
+function xmlCopyDoc(doc: xmlDocPtr; recursive: cint): xmlDocPtr; EXTDECL; external xml2lib;
 {$ENDIF} (* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) *)
 
 (*
  * Creating new nodes.
  *)
-function xmlNewDocNode(doc: xmlDocPtr; ns: xmlNsPtr; name, content: xmlCharPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlNewDocNodeEatName(doc: xmlDocPtr; ns: xmlNsPtr; name, content: xmlCharPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlNewNode(ns: xmlNsPtr; name: xmlCharPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlNewNodeEatName(ns: xmlNsPtr; name: xmlCharPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
+function xmlNewDocNode(doc: xmlDocPtr; ns: xmlNsPtr; name, content: xmlCharPtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlNewDocNodeEatName(doc: xmlDocPtr; ns: xmlNsPtr; name, content: xmlCharPtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlNewNode(ns: xmlNsPtr; name: xmlCharPtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlNewNodeEatName(ns: xmlNsPtr; name: xmlCharPtr): xmlNodePtr; EXTDECL; external xml2lib;
 {$IF defined(LIBXML_TREE_ENABLED) or defined(LIBXML_SCHEMAS_ENABLED)}
-function xmlNewChild(parent: xmlNodePtr; ns: xmlNsPtr; name, content: xmlCharPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
+function xmlNewChild(parent: xmlNodePtr; ns: xmlNsPtr; name, content: xmlCharPtr): xmlNodePtr; EXTDECL; external xml2lib;
 {$ENDIF}
 
-function xmlNewDocText(doc: xmlDocPtr; content: xmlCharPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlNewText(content: xmlCharPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlNewDocPI(doc: xmlDocPtr; name, content: xmlCharPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlNewPI(name, content: xmlCharPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlNewDocTextLen(doc: xmlDocPtr; content: xmlCharPtr; len: cint): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlNewTextLen(content: xmlCharPtr; len: cint): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlNewDocComment(doc: xmlDocPtr; content: xmlCharPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlNewComment(content: xmlCharPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlNewCDataBlock(doc: xmlDocPtr; content: xmlCharPtr; len: cint): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlNewCharRef(doc: xmlDocPtr; name: xmlCharPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlNewReference(doc: xmlDocPtr; name: xmlCharPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlCopyNode(node: xmlNodePtr; recursive: cint): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlDocCopyNode(node: xmlNodePtr; doc: xmlDocPtr; recursive: cint): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlDocCopyNodeList(doc: xmlDocPtr; node: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlCopyNodeList(node: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
+function xmlNewDocText(doc: xmlDocPtr; content: xmlCharPtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlNewText(content: xmlCharPtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlNewDocPI(doc: xmlDocPtr; name, content: xmlCharPtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlNewPI(name, content: xmlCharPtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlNewDocTextLen(doc: xmlDocPtr; content: xmlCharPtr; len: cint): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlNewTextLen(content: xmlCharPtr; len: cint): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlNewDocComment(doc: xmlDocPtr; content: xmlCharPtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlNewComment(content: xmlCharPtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlNewCDataBlock(doc: xmlDocPtr; content: xmlCharPtr; len: cint): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlNewCharRef(doc: xmlDocPtr; name: xmlCharPtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlNewReference(doc: xmlDocPtr; name: xmlCharPtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlCopyNode(node: xmlNodePtr; recursive: cint): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlDocCopyNode(node: xmlNodePtr; doc: xmlDocPtr; recursive: cint): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlDocCopyNodeList(doc: xmlDocPtr; node: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlCopyNodeList(node: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_TREE_ENABLED}
-function xmlNewTextChild(parent: xmlNodePtr; ns: xmlNsPtr; name, content: xmlCharPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlNewDocRawNode(doc: xmlDocPtr; ns: xmlNsPtr; name, content: xmlCharPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlNewDocFragment(doc: xmlDocPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
+function xmlNewTextChild(parent: xmlNodePtr; ns: xmlNsPtr; name, content: xmlCharPtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlNewDocRawNode(doc: xmlDocPtr; ns: xmlNsPtr; name, content: xmlCharPtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlNewDocFragment(doc: xmlDocPtr): xmlNodePtr; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_TREE_ENABLED *)
 
 (*
  * Navigating.
  *)
-function xmlGetLineNo(node: xmlNodePtr): clong; XMLCALL; XMLPUBFUN;
+function xmlGetLineNo(node: xmlNodePtr): clong; EXTDECL; external xml2lib;
 {$IF defined(LIBXML_TREE_ENABLED) or defined(LIBXML_DEBUG_ENABLED)}
-function xmlGetNodePath(node: xmlNodePtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
+function xmlGetNodePath(node: xmlNodePtr): xmlCharPtr; EXTDECL; external xml2lib;
 {$ENDIF} (* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) *)
-function xmlDocGetRootElement(doc: xmlDocPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlGetLastChild(parent: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlNodeIsText(node: xmlNodePtr): cint; XMLCALL; XMLPUBFUN;
-function xmlIsBlankNode(node: xmlNodePtr): cint; XMLCALL; XMLPUBFUN;
+function xmlDocGetRootElement(doc: xmlDocPtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlGetLastChild(parent: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlNodeIsText(node: xmlNodePtr): cint; EXTDECL; external xml2lib;
+function xmlIsBlankNode(node: xmlNodePtr): cint; EXTDECL; external xml2lib;
 
 (*
  * Changing the structure.
  *)
 {$IF defined(LIBXML_TREE_ENABLED) or defined(LIBXML_WRITER_ENABLED)}
-function xmlDocSetRootElement(doc: xmlDocPtr; root: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
+function xmlDocSetRootElement(doc: xmlDocPtr; root: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
 {$ENDIF} (* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) *)
 {$IFDEF LIBXML_TREE_ENABLED}
-procedure xmlNodeSetName(cur: xmlNodePtr; name: xmlCharPtr); XMLCALL; XMLPUBFUN;
+procedure xmlNodeSetName(cur: xmlNodePtr; name: xmlCharPtr); EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_TREE_ENABLED *)
-function xmlAddChild(parent, cur: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlAddChildList(parent, cur: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
+function xmlAddChild(parent, cur: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlAddChildList(parent, cur: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
 {$IF defined(LIBXML_TREE_ENABLED) or defined(LIBXML_WRITER_ENABLED)}
-function xmlReplaceNode(old, cur: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
+function xmlReplaceNode(old, cur: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
 {$ENDIF} (* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) *)
 {$IF defined(LIBXML_TREE_ENABLED) or defined(LIBXML_HTML_ENABLED) or defined(LIBXML_SCHEMAS_ENABLED)}
-function xmlAddPrevSibling(cur, elem: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
+function xmlAddPrevSibling(cur, elem: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_TREE_ENABLED || LIBXML_HTML_ENABLED || LIBXML_SCHEMAS_ENABLED *)
-function xmlAddSibling(cur, elem: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlAddNextSibling(cur, elem: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-procedure xmlUnlinkNode(cur: xmlNodePtr); XMLCALL; XMLPUBFUN;
-function xmlTextMerge(first, second: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlTextConcat(node: xmlNodePtr; name: xmlCharPtr; len: cint): cint; XMLCALL; XMLPUBFUN;
-procedure xmlFreeNodeList(cur: xmlNodePtr); XMLCALL; XMLPUBFUN;
-procedure xmlFreeNode(cur: xmlNodePtr); XMLCALL; XMLPUBFUN;
-procedure xmlSetTreeDoc(tree: xmlNodePtr; doc: xmlDocPtr); XMLCALL; XMLPUBFUN;
-procedure xmlSetListDoc(list: xmlNodePtr; doc: xmlDocPtr); XMLCALL; XMLPUBFUN;
+function xmlAddSibling(cur, elem: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlAddNextSibling(cur, elem: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
+procedure xmlUnlinkNode(cur: xmlNodePtr); EXTDECL; external xml2lib;
+function xmlTextMerge(first, second: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlTextConcat(node: xmlNodePtr; name: xmlCharPtr; len: cint): cint; EXTDECL; external xml2lib;
+procedure xmlFreeNodeList(cur: xmlNodePtr); EXTDECL; external xml2lib;
+procedure xmlFreeNode(cur: xmlNodePtr); EXTDECL; external xml2lib;
+procedure xmlSetTreeDoc(tree: xmlNodePtr; doc: xmlDocPtr); EXTDECL; external xml2lib;
+procedure xmlSetListDoc(list: xmlNodePtr; doc: xmlDocPtr); EXTDECL; external xml2lib;
 
 (*
  * Namespaces.
  *)
-function xmlSearchNs(doc: xmlDocPtr; node: xmlNodePtr; nameSpace: xmlCharPtr): xmlNsPtr; XMLCALL; XMLPUBFUN;
-function xmlSearchNsByHref(doc: xmlDocPtr; node: xmlNodePtr; href: xmlCharPtr): xmlNsPtr; XMLCALL; XMLPUBFUN;
+function xmlSearchNs(doc: xmlDocPtr; node: xmlNodePtr; nameSpace: xmlCharPtr): xmlNsPtr; EXTDECL; external xml2lib;
+function xmlSearchNsByHref(doc: xmlDocPtr; node: xmlNodePtr; href: xmlCharPtr): xmlNsPtr; EXTDECL; external xml2lib;
 {$IF defined(LIBXML_TREE_ENABLED) or defined(LIBXML_XPATH_ENABLED) or defined(LIBXML_SCHEMAS_ENABLED)}
-function xmlGetNsList(doc: xmlDocPtr; node: xmlNodePtr): xmlNsPtr; XMLCALL; XMLPUBFUN;
+function xmlGetNsList(doc: xmlDocPtr; node: xmlNodePtr): xmlNsPtr; EXTDECL; external xml2lib;
 {$ENDIF} (* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) *)
-procedure xmlSetNs(node: xmlNodePtr; ns: xmlNsPtr); XMLCALL; XMLPUBFUN;
-function xmlCopyNamespace(cur: xmlNsPtr): xmlNsPtr; XMLCALL; XMLPUBFUN;
-function xmlCopyNamespaceList(cur: xmlNsPtr): xmlNsPtr; XMLCALL; XMLPUBFUN;
+procedure xmlSetNs(node: xmlNodePtr; ns: xmlNsPtr); EXTDECL; external xml2lib;
+function xmlCopyNamespace(cur: xmlNsPtr): xmlNsPtr; EXTDECL; external xml2lib;
+function xmlCopyNamespaceList(cur: xmlNsPtr): xmlNsPtr; EXTDECL; external xml2lib;
 
 (*
  * Changing the content.
  *)
 {$IF defined(LIBXML_TREE_ENABLED) or defined(LIBXML_XINCLUDE_ENABLED) or defined(LIBXML_SCHEMAS_ENABLED) or defined(LIBXML_HTML_ENABLED)}
-function xmlSetProp(node: xmlNodePtr; name, value: xmlCharPtr): xmlAttrPtr; XMLCALL; XMLPUBFUN;
-function xmlSetNsProp(node: xmlNodePtr; ns: xmlNsPtr; name, value: xmlCharPtr): xmlAttrPtr; XMLCALL; XMLPUBFUN;
+function xmlSetProp(node: xmlNodePtr; name, value: xmlCharPtr): xmlAttrPtr; EXTDECL; external xml2lib;
+function xmlSetNsProp(node: xmlNodePtr; ns: xmlNsPtr; name, value: xmlCharPtr): xmlAttrPtr; EXTDECL; external xml2lib;
 {$ENDIF} (* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) *)
-function xmlGetNoNsProp(node: xmlNodePtr; name: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlGetProp(node: xmlNodePtr; name: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlHasProp(node: xmlNodePtr; name: xmlCharPtr): xmlAttrPtr; XMLCALL; XMLPUBFUN;
-function xmlHasNsProp(node: xmlNodePtr; name, nameSpace: xmlCharPtr): xmlAttrPtr; XMLCALL; XMLPUBFUN;
-function xmlGetNsProp(node: xmlNodePtr; name, nameSpace: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlStringGetNodeList(doc: xmlDocPtr; value: xmlCharPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlStringLenGetNodeList(doc: xmlDocPtr; value: xmlCharPtr; len: cint): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlNodeListGetString(doc: xmlDocPtr; list: xmlNodePtr; inLine: cint): xmlCharPtr; XMLCALL; XMLPUBFUN;
+function xmlGetNoNsProp(node: xmlNodePtr; name: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlGetProp(node: xmlNodePtr; name: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlHasProp(node: xmlNodePtr; name: xmlCharPtr): xmlAttrPtr; EXTDECL; external xml2lib;
+function xmlHasNsProp(node: xmlNodePtr; name, nameSpace: xmlCharPtr): xmlAttrPtr; EXTDECL; external xml2lib;
+function xmlGetNsProp(node: xmlNodePtr; name, nameSpace: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlStringGetNodeList(doc: xmlDocPtr; value: xmlCharPtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlStringLenGetNodeList(doc: xmlDocPtr; value: xmlCharPtr; len: cint): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlNodeListGetString(doc: xmlDocPtr; list: xmlNodePtr; _inLine: cint): xmlCharPtr; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_TREE_ENABLED}
-function xmlNodeListGetRawString(doc: xmlDocPtr; list: xmlNodePtr; inLine: cint): xmlCharPtr; XMLCALL; XMLPUBFUN;
+function xmlNodeListGetRawString(doc: xmlDocPtr; list: xmlNodePtr; _inLine: cint): xmlCharPtr; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_TREE_ENABLED *)
-procedure xmlNodeSetContent(node: xmlNodePtr; content: xmlCharPtr); XMLCALL; XMLPUBFUN;
+procedure xmlNodeSetContent(node: xmlNodePtr; content: xmlCharPtr); EXTDECL; external xml2lib;
 {$IFDEF LIBXML_TREE_ENABLED}
-procedure xmlNodeSetContentLen(node: xmlNodePtr; content: xmlCharPtr; len: cint); XMLCALL; XMLPUBFUN;
+procedure xmlNodeSetContentLen(node: xmlNodePtr; content: xmlCharPtr; len: cint); EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_TREE_ENABLED *)
-procedure xmlNodeAddContent(cur: xmlNodePtr; content: xmlCharPtr); XMLCALL; XMLPUBFUN;
-procedure xmlNodeAddContentLen(cur: xmlNodePtr; content: xmlCharPtr; len: cint); XMLCALL; XMLPUBFUN;
-function xmlNodeGetContent(cur: xmlNodePtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlNodeBufGetContent(buffer: xmlBufferPtr; cur: xmlNodePtr): cint; XMLCALL; XMLPUBFUN;
-function xmlNodeGetLang(cur: xmlNodePtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlNodeGetSpacePreserve(cur: xmlNodePtr): cint; XMLCALL; XMLPUBFUN;
+procedure xmlNodeAddContent(cur: xmlNodePtr; content: xmlCharPtr); EXTDECL; external xml2lib;
+procedure xmlNodeAddContentLen(cur: xmlNodePtr; content: xmlCharPtr; len: cint); EXTDECL; external xml2lib;
+function xmlNodeGetContent(cur: xmlNodePtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlNodeBufGetContent(buffer: xmlBufferPtr; cur: xmlNodePtr): cint; EXTDECL; external xml2lib;
+function xmlNodeGetLang(cur: xmlNodePtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlNodeGetSpacePreserve(cur: xmlNodePtr): cint; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_TREE_ENABLED}
-procedure xmlNodeSetLang(cur: xmlNodePtr; lang: xmlCharPtr); XMLCALL; XMLPUBFUN;
-procedure xmlNodeSetSpacePreserve(cur: xmlNodePtr; val: cint); XMLCALL; XMLPUBFUN;
+procedure xmlNodeSetLang(cur: xmlNodePtr; lang: xmlCharPtr); EXTDECL; external xml2lib;
+procedure xmlNodeSetSpacePreserve(cur: xmlNodePtr; val: cint); EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_TREE_ENABLED *)
-function xmlNodeGetBase(doc: xmlDocPtr; cur: xmlNodePtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
+function xmlNodeGetBase(doc: xmlDocPtr; cur: xmlNodePtr): xmlCharPtr; EXTDECL; external xml2lib;
 {$IF defined(LIBXML_TREE_ENABLED) or defined(LIBXML_XINCLUDE_ENABLED)}
-procedure xmlNodeSetBase(cur: xmlNodePtr; uri: xmlCharPtr); XMLCALL; XMLPUBFUN;
+procedure xmlNodeSetBase(cur: xmlNodePtr; uri: xmlCharPtr); EXTDECL; external xml2lib;
 {$ENDIF}
 
 (*
  * Removing content.
  *)
-function xmlRemoveProp(cur: xmlAttrPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlRemoveProp(cur: xmlAttrPtr): cint; EXTDECL; external xml2lib;
 {$IF defined(LIBXML_TREE_ENABLED) or defined(LIBXML_SCHEMAS_ENABLED)}
-function xmlUnsetNsProp(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlUnsetProp(node: xmlNodePtr; name: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlUnsetNsProp(node: xmlNodePtr; ns: xmlNsPtr; name: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlUnsetProp(node: xmlNodePtr; name: xmlCharPtr): cint; EXTDECL; external xml2lib;
 {$ENDIF} (* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) *)
 
 (*
  * Internal, don't use.
  *)
-{XMLPUBFUN void XMLCALL
+{external xml2lib void EXTDECL
 		xmlBufferWriteCHAR	(xmlBufferPtr buf,
 					 xmlChar *string);
-XMLPUBFUN void XMLCALL
+external xml2lib void EXTDECL
 		xmlBufferWriteChar	(xmlBufferPtr buf,
 					 char *string);
-XMLPUBFUN void XMLCALL
+external xml2lib void EXTDECL
 		xmlBufferWriteQuotedString(xmlBufferPtr buf,
 					 xmlChar *string);
 }
 {$IFDEF LIBXML_OUTPUT_ENABLED}
-{XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBufferPtr buf,
+{external xml2lib void xmlAttrSerializeTxtContent(xmlBufferPtr buf,
 					 xmlDocPtr doc,
 					 xmlAttrPtr attr,
 					 xmlChar *string);}
@@ -763,50 +763,50 @@ XMLPUBFUN void XMLCALL
 (*
  * Namespace handling.
  *)
-function xmlReconciliateNs(doc: xmlDocPtr; tree: xmlNodePtr): cint; XMLCALL; XMLPUBFUN;
+function xmlReconciliateNs(doc: xmlDocPtr; tree: xmlNodePtr): cint; EXTDECL; external xml2lib;
 {$ENDIF}
 
 {$IFDEF LIBXML_OUTPUT_ENABLED}
 (*
  * Saving.
  *)
-procedure xmlDocDumpFormatMemory(cur: xmlDocPtr; var mem: xmlCharPtr; var size: cint; format: cint); XMLCALL; XMLPUBFUN;
-procedure xmlDocDumpMemory(cur: xmlDocPtr; var mem: xmlCharPtr; var size: cint); XMLCALL; XMLPUBFUN;
-procedure xmlDocDumpMemoryEnc(out_doc: xmlDocPtr; var doc_txt_ptr: xmlCharPtr; var doc_txt_len: cint; txt_encoding: pchar); XMLCALL; XMLPUBFUN;
-procedure xmlDocDumpFormatMemoryEnc(out_doc: xmlDocPtr; var doc_txt_ptr: xmlCharPtr; var doc_txt_len: cint; txt_encoding: pchar; format: cint); XMLCALL; XMLPUBFUN;
-function xmlDocFormatDump(f: PFILE; cur: xmlDocPtr; format: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlDocDump(f: PFILE; cur: xmlDocPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlElemDump(f: PFILE; doc: xmlDocPtr; cur: xmlNodePtr): cint; XMLCALL; XMLPUBFUN;
-function xmlSaveFormatFile(filename: pchar; cur: xmlDocPtr; format: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlSaveFile(filename: pchar; cur: xmlDocPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlNodeDump(buf: xmlBufferPtr; doc: xmlDocPtr; cur: xmlNodePtr; level, format: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlSaveFileTo(buf: xmlOutputBufferPtr; cur: xmlDocPtr; encoding: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlSaveFormatFileTo(buf: xmlOutputBufferPtr; cur: xmlDocPtr; encoding: pchar; format: cint): cint; XMLCALL; XMLPUBFUN;
-procedure xmlNodeDumpOutput(buf: xmlBufferPtr; doc: xmlDocPtr; cur: xmlNodePtr; level, format: cint; encoding: pchar); XMLCALL; XMLPUBFUN;
-function xmlSaveFormatFileEnc(filename: pchar; cur: xmlDocPtr; encoding: pchar; format: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlSaveFileEnc(filename: pchar; cur: xmlDocPtr; encoding: pchar): cint; XMLCALL; XMLPUBFUN;
+procedure xmlDocDumpFormatMemory(cur: xmlDocPtr; var mem: xmlCharPtr; var size: cint; format: cint); EXTDECL; external xml2lib;
+procedure xmlDocDumpMemory(cur: xmlDocPtr; var mem: xmlCharPtr; var size: cint); EXTDECL; external xml2lib;
+procedure xmlDocDumpMemoryEnc(out_doc: xmlDocPtr; var doc_txt_ptr: xmlCharPtr; var doc_txt_len: cint; txt_encoding: pchar); EXTDECL; external xml2lib;
+procedure xmlDocDumpFormatMemoryEnc(out_doc: xmlDocPtr; var doc_txt_ptr: xmlCharPtr; var doc_txt_len: cint; txt_encoding: pchar; format: cint); EXTDECL; external xml2lib;
+function xmlDocFormatDump(f: PFILE; cur: xmlDocPtr; format: cint): cint; EXTDECL; external xml2lib;
+function xmlDocDump(f: PFILE; cur: xmlDocPtr): cint; EXTDECL; external xml2lib;
+function xmlElemDump(f: PFILE; doc: xmlDocPtr; cur: xmlNodePtr): cint; EXTDECL; external xml2lib;
+function xmlSaveFormatFile(filename: pchar; cur: xmlDocPtr; format: cint): cint; EXTDECL; external xml2lib;
+function xmlSaveFile(filename: pchar; cur: xmlDocPtr): cint; EXTDECL; external xml2lib;
+function xmlNodeDump(buf: xmlBufferPtr; doc: xmlDocPtr; cur: xmlNodePtr; level, format: cint): cint; EXTDECL; external xml2lib;
+function xmlSaveFileTo(buf: xmlOutputBufferPtr; cur: xmlDocPtr; encoding: pchar): cint; EXTDECL; external xml2lib;
+function xmlSaveFormatFileTo(buf: xmlOutputBufferPtr; cur: xmlDocPtr; encoding: pchar; format: cint): cint; EXTDECL; external xml2lib;
+procedure xmlNodeDumpOutput(buf: xmlBufferPtr; doc: xmlDocPtr; cur: xmlNodePtr; level, format: cint; encoding: pchar); EXTDECL; external xml2lib;
+function xmlSaveFormatFileEnc(filename: pchar; cur: xmlDocPtr; encoding: pchar; format: cint): cint; EXTDECL; external xml2lib;
+function xmlSaveFileEnc(filename: pchar; cur: xmlDocPtr; encoding: pchar): cint; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
 
 (*
  * XHTML
  *)
-function xmlIsXHTML(systemID, publicID: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlIsXHTML(systemID, publicID: xmlCharPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * Compression.
  *)
-function xmlGetDocCompressMode(doc: xmlDocPtr): cint; XMLCALL; XMLPUBFUN;
-procedure xmlSetDocCompressMode(ctxt: xmlDOMWrapCtxtPtr; mode: cint); XMLCALL; XMLPUBFUN;
-function xmlGetCompressMode: cint; XMLCALL; XMLPUBFUN;
-procedure xmlSetCompressMode(mode: cint); XMLCALL; XMLPUBFUN;
+function xmlGetDocCompressMode(doc: xmlDocPtr): cint; EXTDECL; external xml2lib;
+procedure xmlSetDocCompressMode(ctxt: xmlDOMWrapCtxtPtr; mode: cint); EXTDECL; external xml2lib;
+function xmlGetCompressMode: cint; EXTDECL; external xml2lib;
+procedure xmlSetCompressMode(mode: cint); EXTDECL; external xml2lib;
 
 (*
 * DOM-wrapper helper functions.
 *)
-function xmlDOMWrapNewCtxt: xmlDOMWrapCtxtPtr; XMLCALL; XMLPUBFUN;
-procedure xmlDOMWrapNewCtxt(ctxt: xmlDOMWrapCtxtPtr); XMLCALL; XMLPUBFUN;
-function xmlDOMWrapReconcileNamespaces(ctxt: xmlDOMWrapCtxtPtr; elem: xmlNodePtr; options: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlDOMWrapAdoptNode(ctxt: xmlDOMWrapCtxtPtr; sourceDoc: xmlDocPtr; node: xmlNodePtr; destDoc: xmlDocPtr; destParent: xmlNodePtr; options: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlDOMWrapRemoveNode(ctxt: xmlDOMWrapCtxtPtr; doc: xmlDocPtr; node: xmlNodePtr; options: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlDOMWrapCloneNode(ctxt: xmlDOMWrapCtxtPtr; sourceDoc: xmlDocPtr; node: xmlNodePtr; var clonedNode: xmlNodePtr; destDoc: xmlDocPtr; destParent: xmlNodePtr; deep, options: cint): cint; XMLCALL; XMLPUBFUN;
-{$ENDIF}
+function xmlDOMWrapNewCtxt: xmlDOMWrapCtxtPtr; EXTDECL; external xml2lib;
+procedure xmlDOMWrapNewCtxt(ctxt: xmlDOMWrapCtxtPtr); EXTDECL; external xml2lib;
+function xmlDOMWrapReconcileNamespaces(ctxt: xmlDOMWrapCtxtPtr; elem: xmlNodePtr; options: cint): cint; EXTDECL; external xml2lib;
+function xmlDOMWrapAdoptNode(ctxt: xmlDOMWrapCtxtPtr; sourceDoc: xmlDocPtr; node: xmlNodePtr; destDoc: xmlDocPtr; destParent: xmlNodePtr; options: cint): cint; EXTDECL; external xml2lib;
+function xmlDOMWrapRemoveNode(ctxt: xmlDOMWrapCtxtPtr; doc: xmlDocPtr; node: xmlNodePtr; options: cint): cint; EXTDECL; external xml2lib;
+function xmlDOMWrapCloneNode(ctxt: xmlDOMWrapCtxtPtr; sourceDoc: xmlDocPtr; node: xmlNodePtr; var clonedNode: xmlNodePtr; destDoc: xmlDocPtr; destParent: xmlNodePtr; deep, options: cint): cint; EXTDECL; external xml2lib;
+{$ENDIF}

packages/libxml/src/uri.inc

@@ -44,19 +44,19 @@
  * xmlChar *	xmlNodeGetBase	(xmlDocPtr doc,
  *                               xmlNodePtr cur);
  *)
-function xmlCreateURI(): xmlURIPtr; XMLCALL; XMLPUBFUN;
-function xmlBuildURI(URI: xmlCharPtr; base: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlBuildRelativeURI(URI: xmlCharPtr; base: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlParseURI(str: pchar): xmlURIPtr; XMLCALL; XMLPUBFUN;
-function xmlParseURI(str: pchar; raw: cint): xmlURIPtr; XMLCALL; XMLPUBFUN;
-function xmlParseURIReference(uri: xmlURIPtr; str: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlSaveUri(uri: xmlURIPtr): pchar; XMLCALL; XMLPUBFUN;
-procedure xmlPrintURI(stream: PFILE; uri: xmlURIPtr); XMLCALL; XMLPUBFUN;
-function xmlURIEscapeStr(str: xmlCharPtr; list: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlURIUnescapeString(str: pchar; len: cint; target: pchar): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlNormalizeURIPath(path: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlURIEscape(str: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-procedure xmlPrintURI(uri: xmlURIPtr); XMLCALL; XMLPUBFUN;
-function xmlCanonicPath(path: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlPathToURI(path: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
+function xmlCreateURI(): xmlURIPtr; EXTDECL; external xml2lib;
+function xmlBuildURI(URI: xmlCharPtr; base: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlBuildRelativeURI(URI: xmlCharPtr; base: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlParseURI(str: pchar): xmlURIPtr; EXTDECL; external xml2lib;
+function xmlParseURI(str: pchar; raw: cint): xmlURIPtr; EXTDECL; external xml2lib;
+function xmlParseURIReference(uri: xmlURIPtr; str: pchar): cint; EXTDECL; external xml2lib;
+function xmlSaveUri(uri: xmlURIPtr): pchar; EXTDECL; external xml2lib;
+procedure xmlPrintURI(stream: PFILE; uri: xmlURIPtr); EXTDECL; external xml2lib;
+function xmlURIEscapeStr(str: xmlCharPtr; list: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlURIUnescapeString(str: pchar; len: cint; target: pchar): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlNormalizeURIPath(path: pchar): cint; EXTDECL; external xml2lib;
+function xmlURIEscape(str: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+procedure xmlPrintURI(uri: xmlURIPtr); EXTDECL; external xml2lib;
+function xmlCanonicPath(path: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlPathToURI(path: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
 {$ENDIF}

packages/libxml/src/valid.inc

@@ -34,7 +34,7 @@
  * Callback called when a validity error is found. This is a message
  * oriented function similar to an *printf function.
  *)
-  xmlValidityErrorFunc = procedure(ctx: pointer; msg: pchar); XMLCDECL; varargs;
+  xmlValidityErrorFunc = procedure(ctx: pointer; msg: pchar); cdecl; varargs;
 
 (**
  * xmlValidityWarningFunc:
@@ -47,7 +47,7 @@
  * Callback called when a validity warning is found. This is a message
  * oriented function similar to an *printf function.
  *)
-  xmlValidityWarningFunc = procedure(ctx: pointer; msg: pchar); XMLCDECL; varargs;
+  xmlValidityWarningFunc = procedure(ctx: pointer; msg: pchar); cdecl; varargs;
 
 (*
  * xmlValidCtxt:
@@ -117,118 +117,118 @@
 
 {$IFDEF FUNCTION}
 (* Notation *)
-function xmlAddNotationDecl(ctxt: xmlValidCtxtPtr; dtd: xmlDtdPtr; name, PublicID, SystemID: xmlCharPtr): xmlNotationPtr; XMLCALL; XMLPUBFUN;
+function xmlAddNotationDecl(ctxt: xmlValidCtxtPtr; dtd: xmlDtdPtr; name, PublicID, SystemID: xmlCharPtr): xmlNotationPtr; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_TREE_ENABLED}
-function xmlCopyNotationTable(table: xmlNotationTablePtr): xmlNotationTablePtr; XMLCALL; XMLPUBFUN;
+function xmlCopyNotationTable(table: xmlNotationTablePtr): xmlNotationTablePtr; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_TREE_ENABLED *)
-procedure xmlFreeNotationTable(table: xmlNotationTablePtr); XMLCALL; XMLPUBFUN;
+procedure xmlFreeNotationTable(table: xmlNotationTablePtr); EXTDECL; external xml2lib;
 {$IFDEF LIBXML_OUTPUT_ENABLED}
-procedure xmlDumpNotationDecl(buf: xmlBufferPtr; nota: xmlNotationPtr); XMLCALL; XMLPUBFUN;
-procedure xmlDumpNotationTable(buf: xmlBufferPtr; table: xmlNotationTablePtr); XMLCALL; XMLPUBFUN;
+procedure xmlDumpNotationDecl(buf: xmlBufferPtr; nota: xmlNotationPtr); EXTDECL; external xml2lib;
+procedure xmlDumpNotationTable(buf: xmlBufferPtr; table: xmlNotationTablePtr); EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
 
 (* Element Content *)
-function xmlNewDocElementContent(doc: xmlDocPtr; name: xmlCharPtr; _type: xmlElementContentType): xmlElementContentPtr; XMLCALL; XMLPUBFUN;
-function xmlCopyDocElementContent(doc: xmlDocPtr; content: xmlElementContentPtr): xmlElementContentPtr; XMLCALL; XMLPUBFUN;
-procedure xmlFreeDocElementContent(doc: xmlDocPtr; cur: xmlElementContentPtr); XMLCALL; XMLPUBFUN;
-procedure xmlSnprintfElementContent(buf: pchar; size: cint; content: xmlElementContentPtr; englob: cint); XMLCALL; XMLPUBFUN;
+function xmlNewDocElementContent(doc: xmlDocPtr; name: xmlCharPtr; _type: xmlElementContentType): xmlElementContentPtr; EXTDECL; external xml2lib;
+function xmlCopyDocElementContent(doc: xmlDocPtr; content: xmlElementContentPtr): xmlElementContentPtr; EXTDECL; external xml2lib;
+procedure xmlFreeDocElementContent(doc: xmlDocPtr; cur: xmlElementContentPtr); EXTDECL; external xml2lib;
+procedure xmlSnprintfElementContent(buf: pchar; size: cint; content: xmlElementContentPtr; englob: cint); EXTDECL; external xml2lib;
 
 (* Element *)
-function xmlAddElementDecl(ctxt: xmlValidCtxtPtr; dtd: xmlDtdPtr; name: xmlCharPtr; _type: xmlElementTypeVal; content: xmlElementContentPtr): xmlElementPtr; XMLCALL; XMLPUBFUN;
+function xmlAddElementDecl(ctxt: xmlValidCtxtPtr; dtd: xmlDtdPtr; name: xmlCharPtr; _type: xmlElementTypeVal; content: xmlElementContentPtr): xmlElementPtr; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_TREE_ENABLED}
-function xmlCopyElementTable(table: xmlElementTablePtr): xmlElementTablePtr; XMLCALL; XMLPUBFUN;
+function xmlCopyElementTable(table: xmlElementTablePtr): xmlElementTablePtr; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_TREE_ENABLED *)
-procedure xmlFreeElementTable(table: xmlElementTablePtr); XMLCALL; XMLPUBFUN;
+procedure xmlFreeElementTable(table: xmlElementTablePtr); EXTDECL; external xml2lib;
 {$IFDEF LIBXML_OUTPUT_ENABLED}
-procedure xmlDumpElementTable(buf: xmlBufferPtr; table: xmlElementTablePtr); XMLCALL; XMLPUBFUN;
-procedure xmlDumpElementDecl(buf: xmlBufferPtr; elem: xmlElementPtr); XMLCALL; XMLPUBFUN;
+procedure xmlDumpElementTable(buf: xmlBufferPtr; table: xmlElementTablePtr); EXTDECL; external xml2lib;
+procedure xmlDumpElementDecl(buf: xmlBufferPtr; elem: xmlElementPtr); EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
 
 (* Enumeration *)
-function xmlCreateEnumeration(name: xmlCharPtr): xmlEnumerationPtr; XMLCALL; XMLPUBFUN;
-procedure xmlFreeEnumeration(cur: xmlEnumerationPtr); XMLCALL; XMLPUBFUN;
+function xmlCreateEnumeration(name: xmlCharPtr): xmlEnumerationPtr; EXTDECL; external xml2lib;
+procedure xmlFreeEnumeration(cur: xmlEnumerationPtr); EXTDECL; external xml2lib;
 {$IFDEF LIBXML_TREE_ENABLED}
-function xmlCopyEnumeration(cur: xmlEnumerationPtr): xmlEnumerationPtr; XMLCALL; XMLPUBFUN;
+function xmlCopyEnumeration(cur: xmlEnumerationPtr): xmlEnumerationPtr; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_TREE_ENABLED *)
 
 (* Attribute *)
 function xmlAddAttributeDecl(ctxt: xmlValidCtxtPtr; dtd: xmlDtdPtr; elem, name, ns: xmlCharPtr; _type: xmlAttributeType;
-  def: xmlAttributeDefault; defaultValue: xmlCharPtr; tree: xmlEnumerationPtr): xmlAttributePtr; XMLCALL; XMLPUBFUN;
+  def: xmlAttributeDefault; defaultValue: xmlCharPtr; tree: xmlEnumerationPtr): xmlAttributePtr; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_TREE_ENABLED}
-function xmlCopyAttributeTable(table: xmlAttributeTablePtr): xmlAttributeTablePtr; XMLCALL; XMLPUBFUN;
+function xmlCopyAttributeTable(table: xmlAttributeTablePtr): xmlAttributeTablePtr; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_TREE_ENABLED *)
-procedure xmlFreeAttributeTable(table: xmlAttributeTablePtr); XMLCALL; XMLPUBFUN;
+procedure xmlFreeAttributeTable(table: xmlAttributeTablePtr); EXTDECL; external xml2lib;
 {$IFDEF LIBXML_OUTPUT_ENABLED}
-procedure xmlDumpAttributeTable(buf: xmlBufferPtr; table: xmlAttributeTablePtr); XMLCALL; XMLPUBFUN;
-procedure xmlDumpAttributeDecl(buf: xmlBufferPtr; attr: xmlAttributePtr); XMLCALL; XMLPUBFUN;
+procedure xmlDumpAttributeTable(buf: xmlBufferPtr; table: xmlAttributeTablePtr); EXTDECL; external xml2lib;
+procedure xmlDumpAttributeDecl(buf: xmlBufferPtr; attr: xmlAttributePtr); EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
 
 (* IDs *)
-function xmlAddID(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; value: xmlCharPtr; attr: xmlAttrPtr): xmlIDPtr; XMLCALL; XMLPUBFUN;
-procedure xmlFreeIDTable(table: xmlIDTablePtr); XMLCALL; XMLPUBFUN;
-function xmlGetID(doc: xmlDocPtr; ID: xmlCharPtr): xmlAttrPtr; XMLCALL; XMLPUBFUN;
-function xmlIsID(doc: xmlDocPtr; elem: xmlNodePtr; attr: xmlAttrPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlRemoveID(doc: xmlDocPtr; attr: xmlAttrPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlAddID(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; value: xmlCharPtr; attr: xmlAttrPtr): xmlIDPtr; EXTDECL; external xml2lib;
+procedure xmlFreeIDTable(table: xmlIDTablePtr); EXTDECL; external xml2lib;
+function xmlGetID(doc: xmlDocPtr; ID: xmlCharPtr): xmlAttrPtr; EXTDECL; external xml2lib;
+function xmlIsID(doc: xmlDocPtr; elem: xmlNodePtr; attr: xmlAttrPtr): cint; EXTDECL; external xml2lib;
+function xmlRemoveID(doc: xmlDocPtr; attr: xmlAttrPtr): cint; EXTDECL; external xml2lib;
 
 (* IDREFs *)
-function xmlAddRef(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; value: xmlCharPtr; attr: xmlAttrPtr): xmlRefPtr; XMLCALL; XMLPUBFUN;
-procedure xmlFreeRefTable(table: xmlRefTablePtr); XMLCALL; XMLPUBFUN;
-function xmlIsRef(doc: xmlDocPtr; elem: xmlNodePtr; attr: xmlAttrPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlRemoveRef(doc: xmlDocPtr; attr: xmlAttrPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlGetRefs(doc: xmlDocPtr; ID: xmlCharPtr): xmlListPtr; XMLCALL; XMLPUBFUN;
+function xmlAddRef(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; value: xmlCharPtr; attr: xmlAttrPtr): xmlRefPtr; EXTDECL; external xml2lib;
+procedure xmlFreeRefTable(table: xmlRefTablePtr); EXTDECL; external xml2lib;
+function xmlIsRef(doc: xmlDocPtr; elem: xmlNodePtr; attr: xmlAttrPtr): cint; EXTDECL; external xml2lib;
+function xmlRemoveRef(doc: xmlDocPtr; attr: xmlAttrPtr): cint; EXTDECL; external xml2lib;
+function xmlGetRefs(doc: xmlDocPtr; ID: xmlCharPtr): xmlListPtr; EXTDECL; external xml2lib;
 
 (**
  * The public function calls related to validity checking.
  *)
 {$IFDEF LIBXML_VALID_ENABLED}
 (* Allocate/Release Validation Contexts *)
-function xmlNewValidCtxt: xmlValidCtxtPtr; XMLCALL; XMLPUBFUN;
-procedure xmlFreeValidCtxt(table: xmlValidCtxtPtr); XMLCALL; XMLPUBFUN;
-function xmlValidateRoot(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlValidateElementDecl(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; elem: xmlElementPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlValidNormalizeAttributeValue(doc: xmlDocPtr; elem: xmlNodePtr; name, value: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlValidCtxtNormalizeAttributeValue(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr; name, value: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlValidateAttributeDecl(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; attr: xmlAttributePtr): cint; XMLCALL; XMLPUBFUN;
-function xmlValidateAttributeValue(_type: xmlAttributeType; value: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlValidateNotationDecl(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; nota: xmlNotationPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlValidateDtd(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; dtd: xmlDtdPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlValidateDtdFinal(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlValidateDocument(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlValidateElement(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr): cint; XMLCALL; XMLPUBFUN;
-function xmlValidateOneElement(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr): cint; XMLCALL; XMLPUBFUN;
-function xmlValidateOneAttribute(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr; attr: xmlAttrPtr; value: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlValidateOneNamespace(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr; prefix: xmlCharPtr; ns: xmlNsPtr; value: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlValidateDocumentFinal(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlNewValidCtxt: xmlValidCtxtPtr; EXTDECL; external xml2lib;
+procedure xmlFreeValidCtxt(table: xmlValidCtxtPtr); EXTDECL; external xml2lib;
+function xmlValidateRoot(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr): cint; EXTDECL; external xml2lib;
+function xmlValidateElementDecl(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; elem: xmlElementPtr): cint; EXTDECL; external xml2lib;
+function xmlValidNormalizeAttributeValue(doc: xmlDocPtr; elem: xmlNodePtr; name, value: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlValidCtxtNormalizeAttributeValue(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr; name, value: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlValidateAttributeDecl(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; attr: xmlAttributePtr): cint; EXTDECL; external xml2lib;
+function xmlValidateAttributeValue(_type: xmlAttributeType; value: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlValidateNotationDecl(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; nota: xmlNotationPtr): cint; EXTDECL; external xml2lib;
+function xmlValidateDtd(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; dtd: xmlDtdPtr): cint; EXTDECL; external xml2lib;
+function xmlValidateDtdFinal(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr): cint; EXTDECL; external xml2lib;
+function xmlValidateDocument(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr): cint; EXTDECL; external xml2lib;
+function xmlValidateElement(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr): cint; EXTDECL; external xml2lib;
+function xmlValidateOneElement(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr): cint; EXTDECL; external xml2lib;
+function xmlValidateOneAttribute(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr; attr: xmlAttrPtr; value: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlValidateOneNamespace(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr; prefix: xmlCharPtr; ns: xmlNsPtr; value: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlValidateDocumentFinal(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr): cint; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_VALID_ENABLED *)
 
 {$IF defined(LIBXML_VALID_ENABLED) or defined(LIBXML_SCHEMAS_ENABLED)}
-function xmlValidateNotationUse(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; notationName: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlValidateNotationUse(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; notationName: xmlCharPtr): cint; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_VALID_ENABLED or LIBXML_SCHEMAS_ENABLED *)
 
-function xmlIsMixedElement(doc: xmlDocPtr; name: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlGetDtdAttrDesc(dtd: xmlDtdPtr; elem, name: xmlCharPtr): xmlAttributePtr; XMLCALL; XMLPUBFUN;
-function xmlGetDtdQAttrDesc(dtd: xmlDtdPtr; elem, name, prefix: xmlCharPtr): xmlAttributePtr; XMLCALL; XMLPUBFUN;
-function xmlGetDtdNotationDesc(dtd: xmlDtdPtr; name: xmlCharPtr): xmlNotationPtr; XMLCALL; XMLPUBFUN;
-function xmlGetDtdQElementDesc(dtd: xmlDtdPtr; name, prefix: xmlCharPtr): xmlElementPtr; XMLCALL; XMLPUBFUN;
-function xmlGetDtdElementDesc(dtd: xmlDtdPtr; name: xmlCharPtr): xmlElementPtr; XMLCALL; XMLPUBFUN;
+function xmlIsMixedElement(doc: xmlDocPtr; name: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlGetDtdAttrDesc(dtd: xmlDtdPtr; elem, name: xmlCharPtr): xmlAttributePtr; EXTDECL; external xml2lib;
+function xmlGetDtdQAttrDesc(dtd: xmlDtdPtr; elem, name, prefix: xmlCharPtr): xmlAttributePtr; EXTDECL; external xml2lib;
+function xmlGetDtdNotationDesc(dtd: xmlDtdPtr; name: xmlCharPtr): xmlNotationPtr; EXTDECL; external xml2lib;
+function xmlGetDtdQElementDesc(dtd: xmlDtdPtr; name, prefix: xmlCharPtr): xmlElementPtr; EXTDECL; external xml2lib;
+function xmlGetDtdElementDesc(dtd: xmlDtdPtr; name: xmlCharPtr): xmlElementPtr; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_VALID_ENABLED}
 
-function xmlGetDtdElementDesc(ctree: xmlElementContentPtr; var names: xmlCharPtr; var len: cint; max: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlValidGetValidElements(prev, next: xmlNodePtr; var names: xmlCharPtr; max: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlValidateNameValue(value: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlValidateNamesValue(value: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlValidateNmtokenValue(value: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlValidateNmtokensValue(value: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlGetDtdElementDesc(ctree: xmlElementContentPtr; var names: xmlCharPtr; var len: cint; max: cint): cint; EXTDECL; external xml2lib;
+function xmlValidGetValidElements(prev, next: xmlNodePtr; var names: xmlCharPtr; max: cint): cint; EXTDECL; external xml2lib;
+function xmlValidateNameValue(value: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlValidateNamesValue(value: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlValidateNmtokenValue(value: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlValidateNmtokensValue(value: xmlCharPtr): cint; EXTDECL; external xml2lib;
 
 
 {$IFDEF LIBXML_REGEXP_ENABLED}
 (*
  * Validation based on the regexp support
  *)
-function xmlValidBuildContentModel(ctxt: xmlValidCtxtPtr; elem: xmlElementPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlValidatePushElement(ctxt: xmlValidCtxtPtr; doc: xmlNodePtr; elem: xmlElementPtr; qname: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlValidatePushCData(ctxt: xmlValidCtxtPtr; data: xmlCharPtr; len: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlValidatePopElement(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr; qname: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlValidBuildContentModel(ctxt: xmlValidCtxtPtr; elem: xmlElementPtr): cint; EXTDECL; external xml2lib;
+function xmlValidatePushElement(ctxt: xmlValidCtxtPtr; doc: xmlNodePtr; elem: xmlElementPtr; qname: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlValidatePushCData(ctxt: xmlValidCtxtPtr; data: xmlCharPtr; len: cint): cint; EXTDECL; external xml2lib;
+function xmlValidatePopElement(ctxt: xmlValidCtxtPtr; doc: xmlDocPtr; elem: xmlNodePtr; qname: xmlCharPtr): cint; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_REGEXP_ENABLED *)
 {$ENDIF} (* LIBXML_VALID_ENABLED *)
 {$ENDIF}

packages/libxml/src/xinclude.inc

@@ -97,19 +97,19 @@
 (*
  * standalone processing
  *)
-function xmlXIncludeProcess(doc: xmlDocPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlXIncludeProcessFlags(doc: xmlDocPtr; flags: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlXIncludeProcessFlagsData(doc: xmlDocPtr; flags: cint; data: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlXIncludeProcessTree(tree: xmlNodePtr): cint; XMLCALL; XMLPUBFUN;
-function xmlXIncludeProcessTreeFlags(tree: xmlNodePtr; flags: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlXIncludeProcess(doc: xmlDocPtr): cint; EXTDECL; external xml2lib;
+function xmlXIncludeProcessFlags(doc: xmlDocPtr; flags: cint): cint; EXTDECL; external xml2lib;
+function xmlXIncludeProcessFlagsData(doc: xmlDocPtr; flags: cint; data: pointer): cint; EXTDECL; external xml2lib;
+function xmlXIncludeProcessTree(tree: xmlNodePtr): cint; EXTDECL; external xml2lib;
+function xmlXIncludeProcessTreeFlags(tree: xmlNodePtr; flags: cint): cint; EXTDECL; external xml2lib;
 
 (*
  * contextual processing
  *)
-function xmlXIncludeNewContext(doc: xmlDocPtr): xmlXIncludeCtxtPtr; XMLCALL; XMLPUBFUN;
-function xmlXIncludeProcessFlags(ctxt: xmlXIncludeCtxtPtr; flags: cint): cint; XMLCALL; XMLPUBFUN;
-procedure xmlXIncludeProcess(ctxt: xmlXIncludeCtxtPtr); XMLCALL; XMLPUBFUN;
-function xmlXIncludeProcessNode(ctxt: xmlXIncludeCtxtPtr; tree: xmlNodePtr): cint; XMLCALL; XMLPUBFUN;
+function xmlXIncludeNewContext(doc: xmlDocPtr): xmlXIncludeCtxtPtr; EXTDECL; external xml2lib;
+function xmlXIncludeProcessFlags(ctxt: xmlXIncludeCtxtPtr; flags: cint): cint; EXTDECL; external xml2lib;
+procedure xmlXIncludeProcess(ctxt: xmlXIncludeCtxtPtr); EXTDECL; external xml2lib;
+function xmlXIncludeProcessNode(ctxt: xmlXIncludeCtxtPtr; tree: xmlNodePtr): cint; EXTDECL; external xml2lib;
 {$ENDIF}
 
 {$ENDIF} (* LIBXML_XINCLUDE_ENABLED *)

packages/libxml/src/xlink.inc

@@ -61,7 +61,7 @@
  * This is the prototype for the link detection routine.
  * It calls the default link detection callbacks upon link detection.
  *)
-  xlinkNodeDetectFunc = procedure(ctx: pointer; node: xmlNodePtr); XMLCALL;
+  xlinkNodeDetectFunc = procedure(ctx: pointer; node: xmlNodePtr); EXTDECL;
 
 (*
  * The link detection module interact with the upper layers using
@@ -78,7 +78,7 @@
  *
  * This is the prototype for a simple link detection callback.
  *)
-  xlinkSimpleLinkFunk = procedure(ctx: pointer; node: xmlNodePtr; href: xlinkHRef; role: xlinkRole; title: xlinkTitle); XMLCALL;
+  xlinkSimpleLinkFunk = procedure(ctx: pointer; node: xmlNodePtr; href: xlinkHRef; role: xlinkRole; title: xlinkTitle); EXTDECL;
 
 (**
  * xlinkExtendedLinkFunk:
@@ -99,7 +99,7 @@
  * This is the prototype for a extended link detection callback.
  *)
   xlinkExtendedLinkFunk = procedure(ctx: pointer; node: xmlNodePtr; nbLocators: cint; hrefs: xlinkHRefPtr; roles: xlinkRolePtr;
-    nbArcs: cint; from, _to: xlinkRolePtr; show: xlinkShowPtr; actuate: xlinkActuatePtr; nbTitles: cint; titles: xlinkTitlePtr; langs: xmlCharPtrPtr); XMLCALL;
+    nbArcs: cint; from, _to: xlinkRolePtr; show: xlinkShowPtr; actuate: xlinkActuatePtr; nbTitles: cint; titles: xlinkTitlePtr; langs: xmlCharPtrPtr); EXTDECL;
 
 (**
  * xlinkExtendedLinkSetFunk:
@@ -115,7 +115,7 @@
  * This is the prototype for a extended link set detection callback.
  *)
   xlinkExtendedLinkSetFunk = procedure(ctx: pointer; node: xmlNodePtr; nbLocators: cint; hrefs: xlinkHRefPtr; roles: xlinkRolePtr;
-    nbTitles: cint; titles: xlinkTitlePtr; langs: xmlCharPtrPtr); XMLCALL;
+    nbTitles: cint; titles: xlinkTitlePtr; langs: xmlCharPtrPtr); EXTDECL;
 
 (**
  * This is the structure containing a set of Links detection callbacks.
@@ -135,19 +135,19 @@
  * The default detection routine, can be overridden, they call the default
  * detection callbacks. 
  *)
-function xlinkGetDefaultDetect: xlinkNodeDetectFunc; XMLCALL; XMLPUBFUN;
-procedure xlinkSetDefaultDetect(func: xlinkNodeDetectFunc); XMLCALL; XMLPUBFUN;
+function xlinkGetDefaultDetect: xlinkNodeDetectFunc; EXTDECL; external xml2lib;
+procedure xlinkSetDefaultDetect(func: xlinkNodeDetectFunc); EXTDECL; external xml2lib;
 
 (*
  * Routines to set/get the default handlers.
  *)
-function xlinkGetDefaultHandler: xlinkHandlerPtr; XMLCALL; XMLPUBFUN;
-procedure xlinkSetDefaultHandler(handler: xlinkHandlerPtr); XMLCALL; XMLPUBFUN;
+function xlinkGetDefaultHandler: xlinkHandlerPtr; EXTDECL; external xml2lib;
+procedure xlinkSetDefaultHandler(handler: xlinkHandlerPtr); EXTDECL; external xml2lib;
 
 (*
  * Link detection module itself.
  *)
-function xlinkIsLink(doc: xmlDocPtr; node: xmlNodePtr): xlinkType; XMLCALL; XMLPUBFUN;
+function xlinkIsLink(doc: xmlDocPtr; node: xmlNodePtr): xlinkType; EXTDECL; external xml2lib;
 {$ENDIF}
 
 {$ENDIF} (* LIBXML_XPTR_ENABLED *)

packages/libxml/src/xml2.inc

@@ -0,0 +1,204 @@
+{$i xmlversion.inc}
+
+type
+  PFILE = pointer;
+  va_list = pointer;
+  iconv_t = pointer;
+
+(*
+  include pointers (forwarding)
+*)
+{$DEFINE POINTER}
+  {$i catalog.inc}
+  {$i chvalid.inc}
+  {$i dict.inc}
+  {$i encoding.inc}
+  {$i tree.inc}
+  {$i list.inc}
+  {$i entities.inc}
+  {$i xmlerror.inc}
+  {$i xmlmemory.inc}
+  {$i hash.inc}
+  {$i pattern.inc}
+  {$i schemasInternals.inc}
+  {$i valid.inc}
+  {$i parser.inc}
+  {$i parserInternals.inc}
+  {$i schematron.inc}
+  {$i threads.inc}
+  {$i uri.inc}
+  {$i relaxng.inc}
+  {$i globals.inc}
+  {$i nanoftp.inc}
+  {$i nanohttp.inc}
+  {$i SAX.inc}
+  {$i SAX2.inc}
+  {$i HTMLtree.inc}
+  {$i HTMLparser.inc}
+  {$i xmlautomata.inc}
+  {$i xmlIO.inc}
+  {$i xmlmodule.inc}
+  {$i xmlreader.inc}
+  {$i xmlregexp.inc}
+  {$i xmlsave.inc}
+  {$i xmlschemas.inc}
+  {$i xmlschemastypes.inc}
+  {$i xmlstring.inc}
+  {$i xmlunicode.inc}
+  {$i xmlwriter.inc}
+  {$i c14n.inc}
+  {$i xpath.inc}
+  {$i xpathInternals.inc}
+  {$i xlink.inc}
+  {$i xinclude.inc}
+  {$i xpointer.inc}
+{$UNDEF POINTER}
+
+(*
+  include types
+*)
+{$DEFINE TYPE}
+  {$i catalog.inc}
+  {$i chvalid.inc}
+  {$i dict.inc}
+  {$i encoding.inc}
+  {$i tree.inc}
+  {$i list.inc}
+  {$i entities.inc}
+  {$i xmlerror.inc}
+  {$i xmlmemory.inc}
+  {$i hash.inc}
+  {$i pattern.inc}
+  {$i schemasInternals.inc}
+  {$i valid.inc}
+  {$i parser.inc}
+  {$i parserInternals.inc}
+  {$i schematron.inc}
+  {$i threads.inc}
+  {$i uri.inc}
+  {$i relaxng.inc}
+  {$i globals.inc}
+  {$i nanoftp.inc}
+  {$i nanohttp.inc}
+  {$i SAX.inc}
+  {$i SAX2.inc}
+  {$i HTMLtree.inc}
+  {$i HTMLparser.inc}
+  {$i xmlautomata.inc}
+  {$i xmlIO.inc}
+  {$i xmlmodule.inc}
+  {$i xmlreader.inc}
+  {$i xmlregexp.inc}
+  {$i xmlsave.inc}
+  {$i xmlschemas.inc}
+  {$i xmlschemastypes.inc}
+  {$i xmlstring.inc}
+  {$i xmlunicode.inc}
+  {$i xmlwriter.inc}
+  {$i c14n.inc}
+  {$i xpath.inc}
+  {$i xpathInternals.inc}
+  {$i xlink.inc}
+  {$i xinclude.inc}
+  {$i xpointer.inc}
+{$UNDEF TYPE}
+
+(*
+  include constants
+*)
+{$DEFINE CONST}
+const
+  {$i catalog.inc}
+  {$i chvalid.inc}
+  {$i dict.inc}
+  {$i encoding.inc}
+  {$i tree.inc}
+  {$i list.inc}
+  {$i entities.inc}
+  {$i xmlerror.inc}
+  {$i xmlmemory.inc}
+  {$i pattern.inc}
+  {$i schemasInternals.inc}
+  {$i hash.inc}
+  {$i valid.inc}
+  {$i parser.inc}
+  {$i parserInternals.inc}
+  {$i schematron.inc}
+  {$i threads.inc}
+  {$i uri.inc}
+  {$i relaxng.inc}
+  {$i globals.inc}
+  {$i nanoftp.inc}
+  {$i nanohttp.inc}
+  {$i SAX.inc}
+  {$i SAX2.inc}
+  {$i HTMLtree.inc}
+  {$i HTMLparser.inc}
+  {$i xmlautomata.inc}
+  {$i xmlIO.inc}
+  {$i xmlmodule.inc}
+  {$i xmlreader.inc}
+  {$i xmlregexp.inc}
+  {$i xmlsave.inc}
+  {$i xmlschemas.inc}
+  {$i xmlschemastypes.inc}
+  {$i xmlstring.inc}
+  {$i xmlunicode.inc}
+  {$i xmlwriter.inc}
+  {$i c14n.inc}
+  {$i xpath.inc}
+  {$i xpathInternals.inc}
+  {$i xlink.inc}
+  {$i xinclude.inc}
+  {$i xpointer.inc}
+{$UNDEF CONST}
+
+(*
+  include functions
+*)
+{$DEFINE FUNCTION}
+  {$i catalog.inc}
+  {$i chvalid.inc}
+  {$i dict.inc}
+  {$i encoding.inc}
+  {$i tree.inc}
+  {$i list.inc}
+  {$i entities.inc}
+  {$i xmlerror.inc}
+  {$i xmlmemory.inc}
+  {$i pattern.inc}
+  {$i schemasInternals.inc}
+  {$i hash.inc}
+  {$i valid.inc}
+  {$i parser.inc}
+  {$i parserInternals.inc}
+  {$i schematron.inc}
+  {$i threads.inc}
+  {$i uri.inc}
+  {$i relaxng.inc}
+  {$i globals.inc}
+  {$i nanoftp.inc}
+  {$i nanohttp.inc}
+  {$i SAX.inc}
+  {$i SAX2.inc}
+  {$i HTMLtree.inc}
+  {$i HTMLparser.inc}
+  {$i xmlautomata.inc}
+  {$i xmlIO.inc}
+  {$i xmlmodule.inc}
+  {$i xmlreader.inc}
+  {$i xmlregexp.inc}
+  {$i xmlsave.inc}
+  {$i xmlschemas.inc}
+  {$i xmlschemastypes.inc}
+  {$i xmlstring.inc}
+  {$i xmlunicode.inc}
+  {$i xmlwriter.inc}
+  {$i c14n.inc}
+  {$i xpath.inc}
+  {$i xpathInternals.inc}
+  {$i xlink.inc}
+  {$i xinclude.inc}
+  {$i xpointer.inc}
+{$UNDEF FUNCTION}
+

packages/libxml/src/xml2.pas

@@ -16,10 +16,10 @@ interface
 
 uses
 {$IFDEF WINDOWS}
-  windows,
+  //windows,
 {$ENDIF}
 {$IFDEF UNIX}
-  unixtype,
+  //unixtype,
 {$ENDIF}
   ctypes;
 
@@ -27,250 +27,41 @@ uses
 // {$ERROR 'cbool size mismatch!'}
 //{$ENDIF}
 
-{$IFDEF WINDOWS}
-  {$DEFINE DYNLINK}
-{$ENDIF}
-
-{$IFDEF DYNLINK}
 const
 {$IF Defined(WINDOWS)}
-  libxml2lib = 'libxml2.dll';
+  xml2lib = 'libxml2.dll';
+  {$DEFINE EXTDECL := cdecl}
 {$ELSEIF Defined(UNIX)}
-  libxml2lib = 'libxml2.so';
+  xml2lib = 'libxml2.so';
+  {$DEFINE EXTDECL := cdecl}
 {$ELSE}
   {$MESSAGE ERROR 'DYNLINK not supported'}
 {$IFEND}
-{$ELSE}
-  {$LINKLIB xml2}
-{$ENDIF}
-
-{$i xmlexports.inc}
-{$i xmlversion.inc}
 
-type
-  PFILE = pointer;
-  va_list = pointer;
-  iconv_t = pointer;
-
-(*
-  include pointers (forwarding)
-*)
-{$DEFINE POINTER}
-  {$i catalog.inc}
-  {$i chvalid.inc}
-  {$i dict.inc}
-  {$i encoding.inc}
-  {$i tree.inc}
-  {$i list.inc}
-  {$i entities.inc}
-  {$i xmlerror.inc}
-  {$i xmlmemory.inc}
-  {$i hash.inc}
-  {$i pattern.inc}
-  {$i schemasInternals.inc}
-  {$i valid.inc}
-  {$i parser.inc}
-  {$i parserInternals.inc}
-  {$i schematron.inc}
-  {$i threads.inc}
-  {$i uri.inc}
-  {$i relaxng.inc}
-  {$i globals.inc}
-  {$i nanoftp.inc}
-  {$i nanohttp.inc}
-  {$i SAX.inc}
-  {$i SAX2.inc}
-  {$i HTMLtree.inc}
-  {$i HTMLparser.inc}
-  {$i xmlautomata.inc}
-  {$i xmlIO.inc}
-  {$i xmlmodule.inc}
-  {$i xmlreader.inc}
-  {$i xmlregexp.inc}
-  {$i xmlsave.inc}
-  {$i xmlschemas.inc}
-  {$i xmlschemastypes.inc}
-  {$i xmlstring.inc}
-  {$i xmlunicode.inc}
-  {$i xmlwriter.inc}
-  {$i c14n.inc}
-  {$i xpath.inc}
-  {$i xpathInternals.inc}
-  {$i xlink.inc}
-  {$i xinclude.inc}
-  {$i xpointer.inc}
-{$UNDEF POINTER}
-
-(*
-  include types
-*)
-{$DEFINE TYPE}
-  {$i catalog.inc}
-  {$i chvalid.inc}
-  {$i dict.inc}
-  {$i encoding.inc}
-  {$i tree.inc}
-  {$i list.inc}
-  {$i entities.inc}
-  {$i xmlerror.inc}
-  {$i xmlmemory.inc}
-  {$i hash.inc}
-  {$i pattern.inc}
-  {$i schemasInternals.inc}
-  {$i valid.inc}
-  {$i parser.inc}
-  {$i parserInternals.inc}
-  {$i schematron.inc}
-  {$i threads.inc}
-  {$i uri.inc}
-  {$i relaxng.inc}
-  {$i globals.inc}
-  {$i nanoftp.inc}
-  {$i nanohttp.inc}
-  {$i SAX.inc}
-  {$i SAX2.inc}
-  {$i HTMLtree.inc}
-  {$i HTMLparser.inc}
-  {$i xmlautomata.inc}
-  {$i xmlIO.inc}
-  {$i xmlmodule.inc}
-  {$i xmlreader.inc}
-  {$i xmlregexp.inc}
-  {$i xmlsave.inc}
-  {$i xmlschemas.inc}
-  {$i xmlschemastypes.inc}
-  {$i xmlstring.inc}
-  {$i xmlunicode.inc}
-  {$i xmlwriter.inc}
-  {$i c14n.inc}
-  {$i xpath.inc}
-  {$i xpathInternals.inc}
-  {$i xlink.inc}
-  {$i xinclude.inc}
-  {$i xpointer.inc}
-{$UNDEF TYPE}
-
-(*
-  include constants
-*)
-{$DEFINE CONST}
-const
-  {$i catalog.inc}
-  {$i chvalid.inc}
-  {$i dict.inc}
-  {$i encoding.inc}
-  {$i tree.inc}
-  {$i list.inc}
-  {$i entities.inc}
-  {$i xmlerror.inc}
-  {$i xmlmemory.inc}
-  {$i pattern.inc}
-  {$i schemasInternals.inc}
-  {$i hash.inc}
-  {$i valid.inc}
-  {$i parser.inc}
-  {$i parserInternals.inc}
-  {$i schematron.inc}
-  {$i threads.inc}
-  {$i uri.inc}
-  {$i relaxng.inc}
-  {$i globals.inc}
-  {$i nanoftp.inc}
-  {$i nanohttp.inc}
-  {$i SAX.inc}
-  {$i SAX2.inc}
-  {$i HTMLtree.inc}
-  {$i HTMLparser.inc}
-  {$i xmlautomata.inc}
-  {$i xmlIO.inc}
-  {$i xmlmodule.inc}
-  {$i xmlreader.inc}
-  {$i xmlregexp.inc}
-  {$i xmlsave.inc}
-  {$i xmlschemas.inc}
-  {$i xmlschemastypes.inc}
-  {$i xmlstring.inc}
-  {$i xmlunicode.inc}
-  {$i xmlwriter.inc}
-  {$i c14n.inc}
-  {$i xpath.inc}
-  {$i xpathInternals.inc}
-  {$i xlink.inc}
-  {$i xinclude.inc}
-  {$i xpointer.inc}
-{$UNDEF CONST}
-
-(*
-  include functions
-*)
-{$DEFINE FUNCTION}
-  {$i catalog.inc}
-  {$i chvalid.inc}
-  {$i dict.inc}
-  {$i encoding.inc}
-  {$i tree.inc}
-  {$i list.inc}
-  {$i entities.inc}
-  {$i xmlerror.inc}
-  {$i xmlmemory.inc}
-  {$i pattern.inc}
-  {$i schemasInternals.inc}
-  {$i hash.inc}
-  {$i valid.inc}
-  {$i parser.inc}
-  {$i parserInternals.inc}
-  {$i schematron.inc}
-  {$i threads.inc}
-  {$i uri.inc}
-  {$i relaxng.inc}
-  {$i globals.inc}
-  {$i nanoftp.inc}
-  {$i nanohttp.inc}
-  {$i SAX.inc}
-  {$i SAX2.inc}
-  {$i HTMLtree.inc}
-  {$i HTMLparser.inc}
-  {$i xmlautomata.inc}
-  {$i xmlIO.inc}
-  {$i xmlmodule.inc}
-  {$i xmlreader.inc}
-  {$i xmlregexp.inc}
-  {$i xmlsave.inc}
-  {$i xmlschemas.inc}
-  {$i xmlschemastypes.inc}
-  {$i xmlstring.inc}
-  {$i xmlunicode.inc}
-  {$i xmlwriter.inc}
-  {$i c14n.inc}
-  {$i xpath.inc}
-  {$i xpathInternals.inc}
-  {$i xlink.inc}
-  {$i xinclude.inc}
-  {$i xpointer.inc}
-{$UNDEF FUNCTION}
+{$i xml2.inc}
 
 operator := (const S: String): xmlCharPtr; inline;
 //operator := (const C: AnsiChar): xmlCharPtr; inline;
 
 implementation
 
-procedure fpcxmlFree(mem: pointer); XMLCALL;
+procedure fpcxmlFree(mem: pointer); EXTDECL;
 begin
   FreeMem(mem);
 end;
 
-function fpcxmlMalloc(size: size_t): pointer; XMLCALL;
+function fpcxmlMalloc(size: csize_t): pointer; EXTDECL;
 begin
   GetMem(Result, size);
 end;
 
-function fpcxmlRealloc(mem: pointer; size: size_t): pointer; XMLCALL;
+function fpcxmlRealloc(mem: pointer; size: csize_t): pointer; EXTDECL;
 begin
   Result := mem;
   ReallocMem(Result, size);
 end;
 
-procedure fpcxmlStructuredErrorHandler(userData: pointer; error: xmlErrorPtr); XMLCALL;
+procedure fpcxmlStructuredErrorHandler(userData: pointer; error: xmlErrorPtr); EXTDECL;
 begin
   writeln('struct error');
 end;

packages/libxml/src/xmlIO.inc

@@ -27,7 +27,7 @@
  *
  * Returns 1 if yes and 0 if another Input module should be used
  *)
-  xmlInputMatchCallback = function(filename: pchar): cint; XMLCALL;
+  xmlInputMatchCallback = function(filename: pchar): cint; EXTDECL;
 
 (**
  * xmlInputOpenCallback:
@@ -37,7 +37,7 @@
  *
  * Returns an Input context or NULL in case or error
  *)
-  xmlInputOpenCallback = function(filename: pchar): pointer; XMLCALL;
+  xmlInputOpenCallback = function(filename: pchar): pointer; EXTDECL;
 
 (**
  * xmlInputReadCallback:
@@ -49,7 +49,7 @@
  *
  * Returns the number of bytes read or -1 in case of error
  *)
-  xmlInputReadCallback = function(context: pointer; buffer: pchar; len: cint): cint; XMLCALL;
+  xmlInputReadCallback = function(context: pointer; buffer: pchar; len: cint): cint; EXTDECL;
 
 (**
  * xmlInputCloseCallback:
@@ -59,7 +59,7 @@
  *
  * Returns 0 or -1 in case of error
  *)
-  xmlInputCloseCallback = function(context: pointer): cint; XMLCALL;
+  xmlInputCloseCallback = function(context: pointer): cint; EXTDECL;
 
 {$IFDEF LIBXML_OUTPUT_ENABLED}
 (*
@@ -76,7 +76,7 @@
  *
  * Returns 1 if yes and 0 if another Output module should be used
  *)
-  xmlOutputMatchCallback = function(filename: pchar): cint; XMLCALL;
+  xmlOutputMatchCallback = function(filename: pchar): cint; EXTDECL;
 
 (**
  * xmlOutputOpenCallback:
@@ -86,7 +86,7 @@
  *
  * Returns an Output context or NULL in case or error
  *)
-  xmlOutputOpenCallback = function(filename: pchar): pointer; XMLCALL;
+  xmlOutputOpenCallback = function(filename: pchar): pointer; EXTDECL;
 
 (**
  * xmlOutputWriteCallback:
@@ -98,7 +98,7 @@
  *
  * Returns the number of bytes written or -1 in case of error
  *)
-  xmlOutputWriteCallback = function(context: pointer; buffer: pchar; len: cint): cint; XMLCALL;
+  xmlOutputWriteCallback = function(context: pointer; buffer: pchar; len: cint): cint; EXTDECL;
 
 (**
  * xmlOutputCloseCallback:
@@ -108,7 +108,7 @@
  *
  * Returns 0 or -1 in case of error
  *)
-  xmlOutputCloseCallback = function(context: pointer): cint; XMLCALL;
+  xmlOutputCloseCallback = function(context: pointer): cint; EXTDECL;
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
 
   xmlParserInputBuffer = record
@@ -141,92 +141,92 @@
 (*
  * Interfaces for input
  *)
-procedure xmlCleanupInputCallbacks; XMLCALL; XMLPUBFUN;
-function xmlPopInputCallbacks: cint; XMLCALL; XMLPUBFUN;
-procedure xmlRegisterDefaultInputCallbacks; XMLCALL; XMLPUBFUN;
-function xmlAllocParserInputBuffer(enc: xmlCharEncoding): xmlParserInputBufferPtr; XMLCALL; XMLPUBFUN;
-function xmlParserInputBufferCreateFilename(URI: pchar; enc: xmlCharEncoding): xmlParserInputBufferPtr; XMLCALL; XMLPUBFUN;
-function xmlParserInputBufferCreateFile(fp: PFILE; enc: xmlCharEncoding): xmlParserInputBufferPtr; XMLCALL; XMLPUBFUN;
-function xmlParserInputBufferCreateFd(fd: cint; enc: xmlCharEncoding): xmlParserInputBufferPtr; XMLCALL; XMLPUBFUN;
-function xmlParserInputBufferCreateMem(mem: pchar; size: cint; enc: xmlCharEncoding): xmlParserInputBufferPtr; XMLCALL; XMLPUBFUN;
-function xmlParserInputBufferCreateStatic(mem: pchar; size: cint; enc: xmlCharEncoding): xmlParserInputBufferPtr; XMLCALL; XMLPUBFUN;
-
-function xmlParserInputBufferCreateIO(ioread: xmlInputReadCallback; ioclose: xmlInputCloseCallback; ioctx: pointer; enc: xmlCharEncoding): xmlParserInputBufferPtr; XMLCALL; XMLPUBFUN;
-function xmlParserInputBufferRead(_in: xmlParserInputBufferPtr; len: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlParserInputBufferGrow(_in: xmlParserInputBufferPtr; len: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlParserInputBufferPush(_in: xmlParserInputBufferPtr; len: cint; buf: pchar): cint; XMLCALL; XMLPUBFUN;
-procedure xmlFreeParserInputBuffer(_in: xmlParserInputBufferPtr); XMLCALL; XMLPUBFUN;
-function xmlParserGetDirectory(filename: pchar): pchar; XMLCALL; XMLPUBFUN;
-function xmlRegisterInputCallbacks(matchFunc: xmlInputMatchCallback; openFunc: xmlInputOpenCallback; readFunc: xmlInputReadCallback; closeFunc: xmlInputCloseCallback): cint; XMLCALL; XMLPUBFUN;
-function __xmlParserInputBufferCreateFilename(URI: pchar; enc: xmlCharEncoding): xmlParserInputBufferPtr; XMLCALL; XMLPUBFUN;
+procedure xmlCleanupInputCallbacks; EXTDECL; external xml2lib;
+function xmlPopInputCallbacks: cint; EXTDECL; external xml2lib;
+procedure xmlRegisterDefaultInputCallbacks; EXTDECL; external xml2lib;
+function xmlAllocParserInputBuffer(enc: xmlCharEncoding): xmlParserInputBufferPtr; EXTDECL; external xml2lib;
+function xmlParserInputBufferCreateFilename(URI: pchar; enc: xmlCharEncoding): xmlParserInputBufferPtr; EXTDECL; external xml2lib;
+function xmlParserInputBufferCreateFile(fp: PFILE; enc: xmlCharEncoding): xmlParserInputBufferPtr; EXTDECL; external xml2lib;
+function xmlParserInputBufferCreateFd(fd: cint; enc: xmlCharEncoding): xmlParserInputBufferPtr; EXTDECL; external xml2lib;
+function xmlParserInputBufferCreateMem(mem: pchar; size: cint; enc: xmlCharEncoding): xmlParserInputBufferPtr; EXTDECL; external xml2lib;
+function xmlParserInputBufferCreateStatic(mem: pchar; size: cint; enc: xmlCharEncoding): xmlParserInputBufferPtr; EXTDECL; external xml2lib;
+
+function xmlParserInputBufferCreateIO(ioread: xmlInputReadCallback; ioclose: xmlInputCloseCallback; ioctx: pointer; enc: xmlCharEncoding): xmlParserInputBufferPtr; EXTDECL; external xml2lib;
+function xmlParserInputBufferRead(_in: xmlParserInputBufferPtr; len: cint): cint; EXTDECL; external xml2lib;
+function xmlParserInputBufferGrow(_in: xmlParserInputBufferPtr; len: cint): cint; EXTDECL; external xml2lib;
+function xmlParserInputBufferPush(_in: xmlParserInputBufferPtr; len: cint; buf: pchar): cint; EXTDECL; external xml2lib;
+procedure xmlFreeParserInputBuffer(_in: xmlParserInputBufferPtr); EXTDECL; external xml2lib;
+function xmlParserGetDirectory(filename: pchar): pchar; EXTDECL; external xml2lib;
+function xmlRegisterInputCallbacks(matchFunc: xmlInputMatchCallback; openFunc: xmlInputOpenCallback; readFunc: xmlInputReadCallback; closeFunc: xmlInputCloseCallback): cint; EXTDECL; external xml2lib;
+function __xmlParserInputBufferCreateFilename(URI: pchar; enc: xmlCharEncoding): xmlParserInputBufferPtr; EXTDECL; external xml2lib;
 
 {$IFDEF LIBXML_OUTPUT_ENABLED}
 (*
  * Interfaces for output
  *)
-procedure xmlCleanupOutputCallbacks; XMLCALL; XMLPUBFUN;
-procedure xmlRegisterDefaultOutputCallbacks; XMLCALL; XMLPUBFUN;
-function xmlAllocOutputBuffer(encoder: xmlCharEncodingHandlerPtr): xmlOutputBufferPtr; XMLCALL; XMLPUBFUN;
-
-function xmlOutputBufferCreateFilename(URI: pchar; encoder: xmlCharEncodingHandlerPtr; compression: cint): xmlOutputBufferPtr; XMLCALL; XMLPUBFUN;
-function xmlOutputBufferCreateFile(fp: PFILE; encoder: xmlCharEncodingHandlerPtr): xmlOutputBufferPtr; XMLCALL; XMLPUBFUN;
-function xmlOutputBufferCreateBuffer(buffer: xmlBufferPtr; encoder: xmlCharEncodingHandlerPtr): xmlOutputBufferPtr; XMLCALL; XMLPUBFUN;
-function xmlOutputBufferCreateFd(fd: cint; encoder: xmlCharEncodingHandlerPtr): xmlOutputBufferPtr; XMLCALL; XMLPUBFUN;
-function xmlOutputBufferCreateIO(iowrite: xmlOutputWriteCallback; ioclose: xmlOutputCloseCallback; ioctx: pointer; encoder: xmlCharEncodingHandlerPtr): xmlOutputBufferPtr; XMLCALL; XMLPUBFUN;
-function xmlOutputBufferWrite(_out: xmlOutputBufferPtr; len: cint; buf: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlOutputBufferWriteString(_out: xmlOutputBufferPtr; str: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlOutputBufferWriteEscape(_out: xmlOutputBufferPtr; str: xmlCharPtr; escaping: xmlCharEncodingOutputFunc): cint; XMLCALL; XMLPUBFUN;
-function xmlOutputBufferFlush(_out: xmlOutputBufferPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlOutputBufferClose(_out: xmlOutputBufferPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlRegisterOutputCallbacks(matchFunc: xmlOutputMatchCallback; openFunc: xmlOutputOpenCallback; writeFunc: xmlOutputWriteCallback; closeFunc: xmlOutputCloseCallback): cint; XMLCALL; XMLPUBFUN;
-function __xmlOutputBufferCreateFilename(URI: pchar; encoder: xmlCharEncodingHandlerPtr; compression: cint): xmlOutputBufferPtr; XMLCALL; XMLPUBFUN;
+procedure xmlCleanupOutputCallbacks; EXTDECL; external xml2lib;
+procedure xmlRegisterDefaultOutputCallbacks; EXTDECL; external xml2lib;
+function xmlAllocOutputBuffer(encoder: xmlCharEncodingHandlerPtr): xmlOutputBufferPtr; EXTDECL; external xml2lib;
+
+function xmlOutputBufferCreateFilename(URI: pchar; encoder: xmlCharEncodingHandlerPtr; compression: cint): xmlOutputBufferPtr; EXTDECL; external xml2lib;
+function xmlOutputBufferCreateFile(fp: PFILE; encoder: xmlCharEncodingHandlerPtr): xmlOutputBufferPtr; EXTDECL; external xml2lib;
+function xmlOutputBufferCreateBuffer(buffer: xmlBufferPtr; encoder: xmlCharEncodingHandlerPtr): xmlOutputBufferPtr; EXTDECL; external xml2lib;
+function xmlOutputBufferCreateFd(fd: cint; encoder: xmlCharEncodingHandlerPtr): xmlOutputBufferPtr; EXTDECL; external xml2lib;
+function xmlOutputBufferCreateIO(iowrite: xmlOutputWriteCallback; ioclose: xmlOutputCloseCallback; ioctx: pointer; encoder: xmlCharEncodingHandlerPtr): xmlOutputBufferPtr; EXTDECL; external xml2lib;
+function xmlOutputBufferWrite(_out: xmlOutputBufferPtr; len: cint; buf: pchar): cint; EXTDECL; external xml2lib;
+function xmlOutputBufferWriteString(_out: xmlOutputBufferPtr; str: pchar): cint; EXTDECL; external xml2lib;
+function xmlOutputBufferWriteEscape(_out: xmlOutputBufferPtr; str: xmlCharPtr; escaping: xmlCharEncodingOutputFunc): cint; EXTDECL; external xml2lib;
+function xmlOutputBufferFlush(_out: xmlOutputBufferPtr): cint; EXTDECL; external xml2lib;
+function xmlOutputBufferClose(_out: xmlOutputBufferPtr): cint; EXTDECL; external xml2lib;
+function xmlRegisterOutputCallbacks(matchFunc: xmlOutputMatchCallback; openFunc: xmlOutputOpenCallback; writeFunc: xmlOutputWriteCallback; closeFunc: xmlOutputCloseCallback): cint; EXTDECL; external xml2lib;
+function __xmlOutputBufferCreateFilename(URI: pchar; encoder: xmlCharEncodingHandlerPtr; compression: cint): xmlOutputBufferPtr; EXTDECL; external xml2lib;
 
 {$IFDEF LIBXML_HTTP_ENABLED}
 (*  This function only exists if HTTP support built into the library  *)
-procedure xmlRegisterHTTPPostCallbacks; XMLCALL; XMLPUBFUN;
+procedure xmlRegisterHTTPPostCallbacks; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_HTTP_ENABLED *)
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
 
-function xmlCheckHTTPInput(ctxt: xmlParserCtxtPtr; ret: xmlParserInputPtr): xmlParserInputPtr; XMLCALL; XMLPUBFUN;
+function xmlCheckHTTPInput(ctxt: xmlParserCtxtPtr; ret: xmlParserInputPtr): xmlParserInputPtr; EXTDECL; external xml2lib;
 
 (*
  * A predefined entity loader disabling network accesses
  *)
-function xmlNoNetExternalEntityLoader(URL: pchar; ID: pchar; ctxt: xmlParserCtxtPtr): xmlParserInputPtr; XMLCALL; XMLPUBFUN;
+function xmlNoNetExternalEntityLoader(URL: pchar; ID: pchar; ctxt: xmlParserCtxtPtr): xmlParserInputPtr; EXTDECL; external xml2lib;
 
 (*
  * Check xmlCanonicPath in uri.h for a better alternative.
  *)
-function xmlCheckFilename(path: pchar): cint; XMLCALL; XMLPUBFUN;
+function xmlCheckFilename(path: pchar): cint; EXTDECL; external xml2lib;
 
 (**
  * Default 'file://' protocol callbacks
  *)
-function xmlFileMatch(filename: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlFileOpen(filename: pchar): pointer; XMLCALL; XMLPUBFUN;
-function xmlFileRead(context: pointer; buffer: pchar; len: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlFileClose(context: pointer): cint; XMLCALL; XMLPUBFUN;
+function xmlFileMatch(filename: pchar): cint; EXTDECL; external xml2lib;
+function xmlFileOpen(filename: pchar): pointer; EXTDECL; external xml2lib;
+function xmlFileRead(context: pointer; buffer: pchar; len: cint): cint; EXTDECL; external xml2lib;
+function xmlFileClose(context: pointer): cint; EXTDECL; external xml2lib;
 
 (**
  * Default 'http://' protocol callbacks
  *)
 {$IFDEF LIBXML_HTTP_ENABLED}
-function xmlIOHTTPMatch(filename: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlIOHTTPOpen(filename: pchar): pointer; XMLCALL; XMLPUBFUN;
+function xmlIOHTTPMatch(filename: pchar): cint; EXTDECL; external xml2lib;
+function xmlIOHTTPOpen(filename: pchar): pointer; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_OUTPUT_ENABLED}
-function xmlIOHTTPOpenW(post_uri: pchar; compression: cint): pointer; XMLCALL; XMLPUBFUN;
+function xmlIOHTTPOpenW(post_uri: pchar; compression: cint): pointer; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
-function xmlIOHTTPRead(context: pointer; buffer: pchar; len: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlIOHTTPClose(context: pointer): cint; XMLCALL; XMLPUBFUN;
+function xmlIOHTTPRead(context: pointer; buffer: pchar; len: cint): cint; EXTDECL; external xml2lib;
+function xmlIOHTTPClose(context: pointer): cint; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_HTTP_ENABLED *)
 
 (**
  * Default 'ftp://' protocol callbacks
  *)
 {$IFDEF LIBXML_FTP_ENABLED}
-function xmlIOFTPMatch(filename: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlIOFTPOpen(filename: pchar): pointer; XMLCALL; XMLPUBFUN;
-function xmlIOFTPRead(context: pointer; buffer: pchar; len: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlIOFTPClose(context: pointer): cint; XMLCALL; XMLPUBFUN;
+function xmlIOFTPMatch(filename: pchar): cint; EXTDECL; external xml2lib;
+function xmlIOFTPOpen(filename: pchar): pointer; EXTDECL; external xml2lib;
+function xmlIOFTPRead(context: pointer; buffer: pchar; len: cint): cint; EXTDECL; external xml2lib;
+function xmlIOFTPClose(context: pointer): cint; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_FTP_ENABLED *)
 {$ENDIF}

packages/libxml/src/xmlautomata.inc

@@ -36,25 +36,25 @@
 (*
  * Building API
  *)
-function xmlNewAutomata: xmlAutomataPtr; XMLCALL; XMLPUBFUN;
-procedure xmlFreeAutomata(am: xmlAutomataPtr); XMLCALL; XMLPUBFUN;
-function xmlAutomataGetInitState(am: xmlAutomataPtr): xmlAutomataStatePtr; XMLCALL; XMLPUBFUN;
-function xmlAutomataSetFinalState(am: xmlAutomataPtr; state: xmlAutomataStatePtr): cint; XMLCALL; XMLPUBFUN;
-function xmlAutomataNewState(am: xmlAutomataPtr): xmlAutomataStatePtr; XMLCALL; XMLPUBFUN;
-function xmlAutomataNewTransition(am: xmlAutomataPtr; from, _to: xmlAutomataStatePtr; token: xmlCharPtr; data: pointer): xmlAutomataStatePtr; XMLCALL; XMLPUBFUN;
-function xmlAutomataNewTransition2(am: xmlAutomataPtr; from, _to: xmlAutomataStatePtr; token, token2: xmlCharPtr; data: pointer): xmlAutomataStatePtr; XMLCALL; XMLPUBFUN;
-function xmlAutomataNewNegTrans(am: xmlAutomataPtr; from, _to: xmlAutomataStatePtr; token, token2: xmlCharPtr; data: pointer): xmlAutomataStatePtr; XMLCALL; XMLPUBFUN;
-function xmlAutomataNewCountTrans(am: xmlAutomataPtr; from, _to: xmlAutomataStatePtr; token: xmlCharPtr; min, max: cint; data: pointer): xmlAutomataStatePtr; XMLCALL; XMLPUBFUN;
-function xmlAutomataNewCountTrans2(am: xmlAutomataPtr; from, _to: xmlAutomataStatePtr; token, token2: xmlCharPtr; min, max: cint; data: pointer): xmlAutomataStatePtr; XMLCALL; XMLPUBFUN;
-function xmlAutomataNewOnceTrans(am: xmlAutomataPtr; from, _to: xmlAutomataStatePtr; token: xmlCharPtr; min, max: cint; data: pointer): xmlAutomataStatePtr; XMLCALL; XMLPUBFUN;
-function xmlAutomataNewOnceTrans2(am: xmlAutomataPtr; from, _to: xmlAutomataStatePtr; token, token2: xmlCharPtr; min, max: cint; data: pointer): xmlAutomataStatePtr; XMLCALL; XMLPUBFUN;
-function xmlAutomataNewAllTrans(am: xmlAutomataPtr; from, _to: xmlAutomataStatePtr; lax: cint): xmlAutomataStatePtr; XMLCALL; XMLPUBFUN;
-function xmlAutomataNewEpsilon(am: xmlAutomataPtr; from, _to: xmlAutomataStatePtr): xmlAutomataStatePtr; XMLCALL; XMLPUBFUN;
-function xmlAutomataNewCountedTrans(am: xmlAutomataPtr; from, _to: xmlAutomataStatePtr; counter: cint): xmlAutomataStatePtr; XMLCALL; XMLPUBFUN;
-function xmlAutomataNewCounterTrans(am: xmlAutomataPtr; from, _to: xmlAutomataStatePtr; counter: cint): xmlAutomataStatePtr; XMLCALL; XMLPUBFUN;
-function xmlAutomataNewCounter(am: xmlAutomataPtr; min, max: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlAutomataCompile(am: xmlAutomataPtr): xmlRegexpPtr; XMLCALL; XMLPUBFUN;
-function xmlAutomataIsDeterminist(am: xmlAutomataPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlNewAutomata: xmlAutomataPtr; EXTDECL; external xml2lib;
+procedure xmlFreeAutomata(am: xmlAutomataPtr); EXTDECL; external xml2lib;
+function xmlAutomataGetInitState(am: xmlAutomataPtr): xmlAutomataStatePtr; EXTDECL; external xml2lib;
+function xmlAutomataSetFinalState(am: xmlAutomataPtr; state: xmlAutomataStatePtr): cint; EXTDECL; external xml2lib;
+function xmlAutomataNewState(am: xmlAutomataPtr): xmlAutomataStatePtr; EXTDECL; external xml2lib;
+function xmlAutomataNewTransition(am: xmlAutomataPtr; from, _to: xmlAutomataStatePtr; token: xmlCharPtr; data: pointer): xmlAutomataStatePtr; EXTDECL; external xml2lib;
+function xmlAutomataNewTransition2(am: xmlAutomataPtr; from, _to: xmlAutomataStatePtr; token, token2: xmlCharPtr; data: pointer): xmlAutomataStatePtr; EXTDECL; external xml2lib;
+function xmlAutomataNewNegTrans(am: xmlAutomataPtr; from, _to: xmlAutomataStatePtr; token, token2: xmlCharPtr; data: pointer): xmlAutomataStatePtr; EXTDECL; external xml2lib;
+function xmlAutomataNewCountTrans(am: xmlAutomataPtr; from, _to: xmlAutomataStatePtr; token: xmlCharPtr; min, max: cint; data: pointer): xmlAutomataStatePtr; EXTDECL; external xml2lib;
+function xmlAutomataNewCountTrans2(am: xmlAutomataPtr; from, _to: xmlAutomataStatePtr; token, token2: xmlCharPtr; min, max: cint; data: pointer): xmlAutomataStatePtr; EXTDECL; external xml2lib;
+function xmlAutomataNewOnceTrans(am: xmlAutomataPtr; from, _to: xmlAutomataStatePtr; token: xmlCharPtr; min, max: cint; data: pointer): xmlAutomataStatePtr; EXTDECL; external xml2lib;
+function xmlAutomataNewOnceTrans2(am: xmlAutomataPtr; from, _to: xmlAutomataStatePtr; token, token2: xmlCharPtr; min, max: cint; data: pointer): xmlAutomataStatePtr; EXTDECL; external xml2lib;
+function xmlAutomataNewAllTrans(am: xmlAutomataPtr; from, _to: xmlAutomataStatePtr; lax: cint): xmlAutomataStatePtr; EXTDECL; external xml2lib;
+function xmlAutomataNewEpsilon(am: xmlAutomataPtr; from, _to: xmlAutomataStatePtr): xmlAutomataStatePtr; EXTDECL; external xml2lib;
+function xmlAutomataNewCountedTrans(am: xmlAutomataPtr; from, _to: xmlAutomataStatePtr; counter: cint): xmlAutomataStatePtr; EXTDECL; external xml2lib;
+function xmlAutomataNewCounterTrans(am: xmlAutomataPtr; from, _to: xmlAutomataStatePtr; counter: cint): xmlAutomataStatePtr; EXTDECL; external xml2lib;
+function xmlAutomataNewCounter(am: xmlAutomataPtr; min, max: cint): cint; EXTDECL; external xml2lib;
+function xmlAutomataCompile(am: xmlAutomataPtr): xmlRegexpPtr; EXTDECL; external xml2lib;
+function xmlAutomataIsDeterminist(am: xmlAutomataPtr): cint; EXTDECL; external xml2lib;
 {$ENDIF}
 
 {$ENDIF} (* LIBXML_AUTOMATA_ENABLED *)

packages/libxml/src/xmlerror.inc

@@ -829,7 +829,7 @@
  * Signature of the function to use when there is an error and
  * no parsing or validity context available .
  *)
-  xmlGenericErrorFunc = procedure(ctx: pointer; msg: pchar); XMLCDECL; varargs;
+  xmlGenericErrorFunc = procedure(ctx: pointer; msg: pchar); cdecl; varargs;
 
 (**
  * xmlStructuredErrorFunc:
@@ -839,7 +839,7 @@
  * Signature of the function to use when there is an error and
  * the module handles the new error reporting mechanism.
  *)
-  xmlStructuredErrorFunc = procedure(userData: pointer; error: xmlErrorPtr); XMLCALL;
+  xmlStructuredErrorFunc = procedure(userData: pointer; error: xmlErrorPtr); EXTDECL;
 
 (*
  * Use the following function to reset the two global variables
@@ -848,30 +848,30 @@
 {$ENDIF}
 
 {$IFDEF FUNCTION}
-procedure xmlSetGenericErrorFunc(ctx: pointer; handler: xmlGenericErrorFunc); XMLCALL; XMLPUBFUN;
-procedure initGenericErrorDefaultFunc(var handler: xmlGenericErrorFunc); XMLCALL; XMLPUBFUN;
-procedure xmlSetStructuredErrorFunc(ctx: pointer; handler: xmlStructuredErrorFunc); XMLCALL; XMLPUBFUN;
+procedure xmlSetGenericErrorFunc(ctx: pointer; handler: xmlGenericErrorFunc); EXTDECL; external xml2lib;
+procedure initGenericErrorDefaultFunc(var handler: xmlGenericErrorFunc); EXTDECL; external xml2lib;
+procedure xmlSetStructuredErrorFunc(ctx: pointer; handler: xmlStructuredErrorFunc); EXTDECL; external xml2lib;
 
 (*
  * Default message routines used by SAX and Valid context for error
  * and warning reporting.
  *)
-procedure xmlParserError(ctx: pointer; msg: pchar; args: array of const); XMLCALL; XMLPUBFUN;
-procedure xmlParserWarning(ctx: pointer; msg: pchar; args: array of const); XMLCALL; XMLPUBFUN;
-procedure xmlParserValidityError(ctx: pointer; msg: pchar; args: array of const); XMLCALL; XMLPUBFUN;
-procedure xmlParserValidityWarning(ctx: pointer; msg: pchar; args: array of const); XMLCALL; XMLPUBFUN;
-procedure xmlParserPrintFileInfo(input: xmlParserInputPtr); XMLCALL; XMLPUBFUN;
-procedure xmlParserPrintFileContext(input: xmlParserInputPtr); XMLCALL; XMLPUBFUN;
+procedure xmlParserError(ctx: pointer; msg: pchar; args: array of const); EXTDECL; external xml2lib;
+procedure xmlParserWarning(ctx: pointer; msg: pchar; args: array of const); EXTDECL; external xml2lib;
+procedure xmlParserValidityError(ctx: pointer; msg: pchar; args: array of const); EXTDECL; external xml2lib;
+procedure xmlParserValidityWarning(ctx: pointer; msg: pchar; args: array of const); EXTDECL; external xml2lib;
+procedure xmlParserPrintFileInfo(input: xmlParserInputPtr); EXTDECL; external xml2lib;
+procedure xmlParserPrintFileContext(input: xmlParserInputPtr); EXTDECL; external xml2lib;
 
 (*
  * Extended error information routines
  *)
-function xmlGetLastError: xmlErrorPtr; XMLCALL; XMLPUBFUN;
-procedure xmlResetLastError; XMLCALL; XMLPUBFUN;
-function xmlCtxtGetLastError(ctx: pointer): xmlErrorPtr; XMLCALL; XMLPUBFUN;
-procedure xmlCtxtResetLastError(ctx: pointer); XMLCALL; XMLPUBFUN;
-procedure xmlResetError(err: xmlErrorPtr); XMLCALL; XMLPUBFUN;
-function xmlResetError(from, _to: xmlErrorPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlGetLastError: xmlErrorPtr; EXTDECL; external xml2lib;
+procedure xmlResetLastError; EXTDECL; external xml2lib;
+function xmlCtxtGetLastError(ctx: pointer): xmlErrorPtr; EXTDECL; external xml2lib;
+procedure xmlCtxtResetLastError(ctx: pointer); EXTDECL; external xml2lib;
+procedure xmlResetError(err: xmlErrorPtr); EXTDECL; external xml2lib;
+function xmlResetError(from, _to: xmlErrorPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * Internal callback reporting routine
@@ -894,7 +894,7 @@ procedure __xmlRaiseError(
   col: cint;
   msg: pchar;
   args: array of const
-); XMLCALL; XMLPUBFUN;
+); EXTDECL; external xml2lib;
 
 procedure __xmlSimpleError(
   domain: cint;
@@ -902,5 +902,5 @@ procedure __xmlSimpleError(
   node: xmlNodePtr;
   msg: pchar;
   extra: pchar
-); XMLCALL; XMLPUBFUN;
+); EXTDECL; external xml2lib;
 {$ENDIF}

packages/libxml/src/xmlexports.inc

@@ -1,158 +0,0 @@
-(*
- * Summary: macros for marking symbols as exportable/importable.
- * Description: macros for marking symbols as exportable/importable.
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Igor Zlatovic <[email protected]>
- *)
-
-(**
- * 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 { lines. This helps
- * readability as well as the fact that different compilers on the same
- * platform might need different definitions.
- *)
-
-(**
- * XMLPUBFUN:
- *
- * Macros which declare an exportable function
- *)
-{$DEFINE XMLPUBFUN := external {$IFDEF DYNLINK}libxml2lib{$ENDIF}}
-
-(**
- * XMLPUBVAR:
- *
- * Macros which declare an exportable variable
- *)
-{$IFDEF UNIX}
-{$DEFINE XMLPUBVAR := cvar; external}
-{$ELSE}
-{$DEFINE XMLPUBVAR := not_supported}
-{$DEFINE NO_EXTERNAL_VARS}
-{$ENDIF}
-
-(**
- * XMLCALL:
- *
- * Macros which declare the called convention for exported functions
- *)
-{$DEFINE XMLCALL := cdecl}
-
-(**
- * XMLCDECL:
- *
- * Macro which declares the calling convention for exported functions that
- * use '...'.
- *)
-{$DEFINE XMLCDECL := cdecl}
-
-(** DOC_DISABLE *)
-
-(* Windows platform with MS compiler *)
-{#if defined(_WIN32) && defined(_MSC_VER)
-  #undef XMLPUBFUN
-  #undef XMLPUBVAR
-  #undef XMLCALL
-  #undef XMLCDECL
-  #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 extern
-    #endif
-  #endif
-  #if defined(LIBXML_FASTCALL)
-    #define XMLCALL __fastcall
-  #else
-    #define XMLCALL __cdecl
-  #endif
-  #define XMLCDECL __cdecl
-  #if !defined _REENTRANT
-    #define _REENTRANT
-  #endif
-#endif}
-
-(* Windows platform with Borland compiler *)
-{#if defined(_WIN32) && defined(__BORLANDC__)
-  #undef XMLPUBFUN
-  #undef XMLPUBVAR
-  #undef XMLCALL
-  #undef XMLCDECL
-  #if defined(IN_LIBXML) && !defined(LIBXML_STATIC)
-    #define XMLPUBFUN __declspec(dllexport)
-    #define XMLPUBVAR __declspec(dllexport) extern
-  #else
-    #define XMLPUBFUN
-    #if !defined(LIBXML_STATIC)
-      #define XMLPUBVAR __declspec(dllimport) extern
-    #else
-      #define XMLPUBVAR extern
-    #endif
-  #endif
-  #define XMLCALL __cdecl
-  #define XMLCDECL __cdecl
-  #if !defined _REENTRANT
-    #define _REENTRANT
-  #endif
-#endif}
-
-(* Windows platform with GNU compiler (Mingw) *)
-{#if defined(_WIN32) && defined(__MINGW32__)
-  #undef XMLPUBFUN
-  #undef XMLPUBVAR
-  #undef XMLCALL
-  #undef XMLCDECL
-  #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 extern
-    #endif
-  #endif
-  #define XMLCALL __cdecl
-  #define XMLCDECL __cdecl
-  #if !defined _REENTRANT
-    #define _REENTRANT
-  #endif
-#endif}
-
-(* Cygwin platform, GNU compiler *)
-{#if defined(_WIN32) && defined(__CYGWIN__)
-  #undef XMLPUBFUN
-  #undef XMLPUBVAR
-  #undef XMLCALL
-  #undef XMLCDECL
-  #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
-  #define XMLCDECL __cdecl
-#endif}
-
-(* Compatibility *)
-{#if !defined(LIBXML_DLL_IMPORT)
-#define LIBXML_DLL_IMPORT XMLPUBVAR
-#endif}

packages/libxml/src/xmlmemory.inc

@@ -44,7 +44,7 @@
  *
  * Signature for a free() implementation.
  *)
-  xmlFreeFunc = procedure(mem: pointer); XMLCALL;
+  xmlFreeFunc = procedure(mem: pointer); EXTDECL;
 
 (**
  * xmlMallocFunc:
@@ -54,7 +54,7 @@
  *
  * Returns a pointer to the newly allocated block or NULL in case of error.
  *)
-  xmlMallocFunc = function(size: csize_t): pointer; XMLCALL;
+  xmlMallocFunc = function(size: csize_t): pointer; EXTDECL;
 
 (**
  * xmlReallocFunc:
@@ -65,7 +65,7 @@
  *
  * Returns a pointer to the newly reallocated block or NULL in case of error.
  *)
-  xmlReallocFunc = function(mem: pointer; size: csize_t): pointer; XMLCALL;
+  xmlReallocFunc = function(mem: pointer; size: csize_t): pointer; EXTDECL;
 
 (**
  * xmlStrdupFunc:
@@ -75,7 +75,7 @@
  *
  * Returns the copy of the string or NULL in case of error.
  *)
-  xmlStrdupFunc = function(str: pchar): pchar; XMLCALL;
+  xmlStrdupFunc = function(str: pchar): pchar; EXTDECL;
 
 (*
  * The 4 interfaces used for all memory handling within libxml.
@@ -93,38 +93,38 @@ LIBXML_DLL_IMPORT extern xmlStrdupFunc xmlMemStrdup;
  * The xmlGc function have an extra entry for atomic block
  * allocations useful for garbage collected memory allocators
  *)
-function xmlMemSetup(freeFunc: xmlFreeFunc; mallocFunc: xmlMallocFunc; reallocFunc: xmlReallocFunc; strdupFunc: xmlStrdupFunc): cint; XMLCALL; XMLPUBFUN;
-function xmlMemGet(var freeFunc: xmlFreeFunc; var mallocFunc: xmlMallocFunc; var reallocFunc: xmlReallocFunc; var strdupFunc: xmlStrdupFunc): cint; XMLCALL; XMLPUBFUN;
-function xmlGcMemSetup(freeFunc: xmlFreeFunc; mallocFunc: xmlMallocFunc; mallocAtomicFunc: xmlMallocFunc; reallocFunc: xmlReallocFunc; strdupFunc: xmlStrdupFunc): cint; XMLCALL; XMLPUBFUN;
-function xmlGcMemGet(var freeFunc: xmlFreeFunc; var mallocFunc: xmlMallocFunc; var mallocAtomicFunc: xmlMallocFunc; var reallocFunc: xmlReallocFunc; var strdupFunc: xmlStrdupFunc): cint; XMLCALL; XMLPUBFUN;
+function xmlMemSetup(freeFunc: xmlFreeFunc; mallocFunc: xmlMallocFunc; reallocFunc: xmlReallocFunc; strdupFunc: xmlStrdupFunc): cint; EXTDECL; external xml2lib;
+function xmlMemGet(var freeFunc: xmlFreeFunc; var mallocFunc: xmlMallocFunc; var reallocFunc: xmlReallocFunc; var strdupFunc: xmlStrdupFunc): cint; EXTDECL; external xml2lib;
+function xmlGcMemSetup(freeFunc: xmlFreeFunc; mallocFunc: xmlMallocFunc; mallocAtomicFunc: xmlMallocFunc; reallocFunc: xmlReallocFunc; strdupFunc: xmlStrdupFunc): cint; EXTDECL; external xml2lib;
+function xmlGcMemGet(var freeFunc: xmlFreeFunc; var mallocFunc: xmlMallocFunc; var mallocAtomicFunc: xmlMallocFunc; var reallocFunc: xmlReallocFunc; var strdupFunc: xmlStrdupFunc): cint; EXTDECL; external xml2lib;
 
 (*
  * Initialization of the memory layer.
  *)
-function xmlInitMemory(): cint; XMLCALL; XMLPUBFUN;
+function xmlInitMemory(): cint; EXTDECL; external xml2lib;
 
 (*
  * Cleanup of the memory layer.
  *)
-procedure xmlCleanupMemory(); XMLCALL; XMLPUBFUN;
+procedure xmlCleanupMemory(); EXTDECL; external xml2lib;
 
 (*
  * These are specific to the XML debug memory wrapper.
  *)
-function xmlMemUsed(): cint; XMLCALL; XMLPUBFUN;
-function xmlMemBlocks(): cint; XMLCALL; XMLPUBFUN;
-procedure xmlMemDisplay(fp: PFILE); XMLCALL; XMLPUBFUN;
-procedure xmlMemShow(fp: PFILE; nr: cint); XMLCALL; XMLPUBFUN;
-procedure xmlMemoryDump(); XMLCALL; XMLPUBFUN;
-function xmlMemMalloc(size: csize_t): pointer; XMLCALL; XMLPUBFUN;
-function xmlMemRealloc(ptr: pointer; size: csize_t): pointer; XMLCALL; XMLPUBFUN;
-procedure xmlMemFree(ptr: pointer); XMLCALL; XMLPUBFUN;
-function xmlMemoryStrdup(str: pchar): pchar; XMLCALL; XMLPUBFUN;
-
-function xmlMallocLoc(size: csize_t; _file: pchar; line: cint): pointer; XMLCALL; XMLPUBFUN;
-function xmlReallocLoc(ptr: pointer; size: csize_t; _file: pchar; line: cint): pointer; XMLCALL; XMLPUBFUN;
-function xmlMallocAtomicLoc(size: csize_t; _file: pchar; line: cint): pointer; XMLCALL; XMLPUBFUN;
-function xmlMemStrdupLoc(str: pchar; _file: pchar; line: cint): pchar; XMLCALL; XMLPUBFUN;
+function xmlMemUsed(): cint; EXTDECL; external xml2lib;
+function xmlMemBlocks(): cint; EXTDECL; external xml2lib;
+procedure xmlMemDisplay(fp: PFILE); EXTDECL; external xml2lib;
+procedure xmlMemShow(fp: PFILE; nr: cint); EXTDECL; external xml2lib;
+procedure xmlMemoryDump(); EXTDECL; external xml2lib;
+function xmlMemMalloc(size: csize_t): pointer; EXTDECL; external xml2lib;
+function xmlMemRealloc(ptr: pointer; size: csize_t): pointer; EXTDECL; external xml2lib;
+procedure xmlMemFree(ptr: pointer); EXTDECL; external xml2lib;
+function xmlMemoryStrdup(str: pchar): pchar; EXTDECL; external xml2lib;
+
+function xmlMallocLoc(size: csize_t; _file: pchar; line: cint): pointer; EXTDECL; external xml2lib;
+function xmlReallocLoc(ptr: pointer; size: csize_t; _file: pchar; line: cint): pointer; EXTDECL; external xml2lib;
+function xmlMallocAtomicLoc(size: csize_t; _file: pchar; line: cint): pointer; EXTDECL; external xml2lib;
+function xmlMemStrdupLoc(str: pchar; _file: pchar; line: cint): pchar; EXTDECL; external xml2lib;
 
 {$IFDEF DEBUG_MEMORY_LOCATION}
 (**

packages/libxml/src/xmlmodule.inc

@@ -34,10 +34,10 @@
 {$ENDIF}
 
 {$IFDEF FUNCTION}
-function xmlModuleOpen(filename: char; options: cint): xmlModulePtr; XMLCALL; XMLPUBFUN;
-function xmlModuleSymbol(module: xmlModulePtr; name: pchar; var result: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlModuleClose(module: xmlModulePtr): cint; XMLCALL; XMLPUBFUN;
-function xmlModuleFree(module: xmlModulePtr): cint; XMLCALL; XMLPUBFUN;
+function xmlModuleOpen(filename: char; options: cint): xmlModulePtr; EXTDECL; external xml2lib;
+function xmlModuleSymbol(module: xmlModulePtr; name: pchar; var result: pointer): cint; EXTDECL; external xml2lib;
+function xmlModuleClose(module: xmlModulePtr): cint; EXTDECL; external xml2lib;
+function xmlModuleFree(module: xmlModulePtr): cint; EXTDECL; external xml2lib;
 {$ENDIF}
 
 {$ENDIF} (* LIBXML_MODULES_ENABLED *)

packages/libxml/src/xmlreader.inc

@@ -91,140 +91,140 @@
 
   xmlTextReaderLocatorPtr = pointer;
 
-  xmlTextReaderErrorFunc = procedure(arg: pointer; msg: pchar; severity: xmlParserSeverities; locator: xmlTextReaderLocatorPtr); XMLCALL;
+  xmlTextReaderErrorFunc = procedure(arg: pointer; msg: pchar; severity: xmlParserSeverities; locator: xmlTextReaderLocatorPtr); EXTDECL;
 {$ENDIF}
 
 {$IFDEF FUNCTION}
 (*
  * Constructors & Destructor
  *)
-function xmlNewTextReader(input: xmlParserInputBufferPtr; URI: pchar): xmlTextReaderPtr; XMLCALL; XMLPUBFUN;
-function xmlNewTextReaderFilename(URI: pchar): xmlTextReaderPtr; XMLCALL; XMLPUBFUN;
-procedure xmlFreeTextReader(reader: xmlTextReaderPtr); XMLCALL; XMLPUBFUN;
-function xmlTextReaderSetup(reader: xmlTextReaderPtr; input: xmlParserInputBufferPtr; URL, encoding: pchar; options: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlNewTextReader(input: xmlParserInputBufferPtr; URI: pchar): xmlTextReaderPtr; EXTDECL; external xml2lib;
+function xmlNewTextReaderFilename(URI: pchar): xmlTextReaderPtr; EXTDECL; external xml2lib;
+procedure xmlFreeTextReader(reader: xmlTextReaderPtr); EXTDECL; external xml2lib;
+function xmlTextReaderSetup(reader: xmlTextReaderPtr; input: xmlParserInputBufferPtr; URL, encoding: pchar; options: cint): cint; EXTDECL; external xml2lib;
 
 (*
  * Iterators
  *)
-function xmlTextReaderRead(reader: xmlTextReaderPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextReaderRead(reader: xmlTextReaderPtr): cint; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_WRITER_ENABLED}
-function xmlTextReaderReadInnerXml(reader: xmlTextReaderPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderReadOuterXml(reader: xmlTextReaderPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
+function xmlTextReaderReadInnerXml(reader: xmlTextReaderPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlTextReaderReadOuterXml(reader: xmlTextReaderPtr): xmlCharPtr; EXTDECL; external xml2lib;
 {$ENDIF}
-function xmlTextReaderReadString(reader: xmlTextReaderPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderReadAttributeValue(reader: xmlTextReaderPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextReaderReadString(reader: xmlTextReaderPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlTextReaderReadAttributeValue(reader: xmlTextReaderPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * Attributes of the node
  *)
-function xmlTextReaderAttributeCount(reader: xmlTextReaderPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderDepth(reader: xmlTextReaderPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderHasAttributes(reader: xmlTextReaderPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderHasValue(reader: xmlTextReaderPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderIsDefault(reader: xmlTextReaderPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderIsEmptyElement(reader: xmlTextReaderPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderNodeType(reader: xmlTextReaderPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderQuoteChar(reader: xmlTextReaderPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderReadState(reader: xmlTextReaderPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderIsNamespaceDecl(reader: xmlTextReaderPtr): cint; XMLCALL; XMLPUBFUN;
-
-function xmlTextReaderConstBaseUri(reader: xmlTextReaderPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderConstLocalName(reader: xmlTextReaderPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderConstName(reader: xmlTextReaderPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderConstNamespaceUri(reader: xmlTextReaderPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderConstPrefix(reader: xmlTextReaderPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderConstXmlLang(reader: xmlTextReaderPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderConstString(reader: xmlTextReaderPtr; str: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderConstValue(reader: xmlTextReaderPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
+function xmlTextReaderAttributeCount(reader: xmlTextReaderPtr): cint; EXTDECL; external xml2lib;
+function xmlTextReaderDepth(reader: xmlTextReaderPtr): cint; EXTDECL; external xml2lib;
+function xmlTextReaderHasAttributes(reader: xmlTextReaderPtr): cint; EXTDECL; external xml2lib;
+function xmlTextReaderHasValue(reader: xmlTextReaderPtr): cint; EXTDECL; external xml2lib;
+function xmlTextReaderIsDefault(reader: xmlTextReaderPtr): cint; EXTDECL; external xml2lib;
+function xmlTextReaderIsEmptyElement(reader: xmlTextReaderPtr): cint; EXTDECL; external xml2lib;
+function xmlTextReaderNodeType(reader: xmlTextReaderPtr): cint; EXTDECL; external xml2lib;
+function xmlTextReaderQuoteChar(reader: xmlTextReaderPtr): cint; EXTDECL; external xml2lib;
+function xmlTextReaderReadState(reader: xmlTextReaderPtr): cint; EXTDECL; external xml2lib;
+function xmlTextReaderIsNamespaceDecl(reader: xmlTextReaderPtr): cint; EXTDECL; external xml2lib;
+
+function xmlTextReaderConstBaseUri(reader: xmlTextReaderPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlTextReaderConstLocalName(reader: xmlTextReaderPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlTextReaderConstName(reader: xmlTextReaderPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlTextReaderConstNamespaceUri(reader: xmlTextReaderPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlTextReaderConstPrefix(reader: xmlTextReaderPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlTextReaderConstXmlLang(reader: xmlTextReaderPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlTextReaderConstString(reader: xmlTextReaderPtr; str: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlTextReaderConstValue(reader: xmlTextReaderPtr): xmlCharPtr; EXTDECL; external xml2lib;
 
 (*
  * use the Const version of the routine for
  * better performance and simpler code
  *)
-function xmlTextReaderBaseUri(reader: xmlTextReaderPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderLocalName(reader: xmlTextReaderPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderName(reader: xmlTextReaderPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderNamespaceUri(reader: xmlTextReaderPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderPrefix(reader: xmlTextReaderPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderXmlLang(reader: xmlTextReaderPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderValue(reader: xmlTextReaderPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
+function xmlTextReaderBaseUri(reader: xmlTextReaderPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlTextReaderLocalName(reader: xmlTextReaderPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlTextReaderName(reader: xmlTextReaderPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlTextReaderNamespaceUri(reader: xmlTextReaderPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlTextReaderPrefix(reader: xmlTextReaderPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlTextReaderXmlLang(reader: xmlTextReaderPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlTextReaderValue(reader: xmlTextReaderPtr): xmlCharPtr; EXTDECL; external xml2lib;
 
 (*
  * Methods of the XmlTextReader
  *)
-function xmlTextReaderClose(reader: xmlTextReaderPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderGetAttributeNo(reader: xmlTextReaderPtr; no: cint): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderGetAttribute(reader: xmlTextReaderPtr; name: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderGetAttributeNs(reader: xmlTextReaderPtr; localName, namespaceURI: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderGetRemainder(reader: xmlTextReaderPtr): xmlParserInputBufferPtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderLookupNamespace(reader: xmlTextReaderPtr; prefix: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderMoveToAttributeNo(reader: xmlTextReaderPtr; no: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderMoveToAttribute(reader: xmlTextReaderPtr; name: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderMoveToAttributeNs(reader: xmlTextReaderPtr; localName, namespaceURI: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderMoveToFirstAttribute(reader: xmlTextReaderPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderMoveToNextAttribute(reader: xmlTextReaderPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderMoveToElement(reader: xmlTextReaderPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderNormalization(reader: xmlTextReaderPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderConstEncoding(reader: xmlTextReaderPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
+function xmlTextReaderClose(reader: xmlTextReaderPtr): cint; EXTDECL; external xml2lib;
+function xmlTextReaderGetAttributeNo(reader: xmlTextReaderPtr; no: cint): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlTextReaderGetAttribute(reader: xmlTextReaderPtr; name: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlTextReaderGetAttributeNs(reader: xmlTextReaderPtr; localName, namespaceURI: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlTextReaderGetRemainder(reader: xmlTextReaderPtr): xmlParserInputBufferPtr; EXTDECL; external xml2lib;
+function xmlTextReaderLookupNamespace(reader: xmlTextReaderPtr; prefix: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlTextReaderMoveToAttributeNo(reader: xmlTextReaderPtr; no: cint): cint; EXTDECL; external xml2lib;
+function xmlTextReaderMoveToAttribute(reader: xmlTextReaderPtr; name: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlTextReaderMoveToAttributeNs(reader: xmlTextReaderPtr; localName, namespaceURI: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlTextReaderMoveToFirstAttribute(reader: xmlTextReaderPtr): cint; EXTDECL; external xml2lib;
+function xmlTextReaderMoveToNextAttribute(reader: xmlTextReaderPtr): cint; EXTDECL; external xml2lib;
+function xmlTextReaderMoveToElement(reader: xmlTextReaderPtr): cint; EXTDECL; external xml2lib;
+function xmlTextReaderNormalization(reader: xmlTextReaderPtr): cint; EXTDECL; external xml2lib;
+function xmlTextReaderConstEncoding(reader: xmlTextReaderPtr): xmlCharPtr; EXTDECL; external xml2lib;
 
 (*
  * Extensions
  *)
-function xmlTextReaderSetParserProp(reader: xmlTextReaderPtr; prop, value: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderGetParserProp(reader: xmlTextReaderPtr; prop: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderCurrentNode(reader: xmlTextReaderPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderGetParserLineNumber(reader: xmlTextReaderPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderGetParserColumnNumber(reader: xmlTextReaderPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderPreserve(reader: xmlTextReaderPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
+function xmlTextReaderSetParserProp(reader: xmlTextReaderPtr; prop, value: cint): cint; EXTDECL; external xml2lib;
+function xmlTextReaderGetParserProp(reader: xmlTextReaderPtr; prop: cint): cint; EXTDECL; external xml2lib;
+function xmlTextReaderCurrentNode(reader: xmlTextReaderPtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlTextReaderGetParserLineNumber(reader: xmlTextReaderPtr): cint; EXTDECL; external xml2lib;
+function xmlTextReaderGetParserColumnNumber(reader: xmlTextReaderPtr): cint; EXTDECL; external xml2lib;
+function xmlTextReaderPreserve(reader: xmlTextReaderPtr): xmlNodePtr; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_PATTERN_ENABLED}
-function xmlTextReaderPreservePattern(reader: xmlTextReaderPtr; pattern: xmlCharPtr; namespaces: xmlCharPtrPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextReaderPreservePattern(reader: xmlTextReaderPtr; pattern: xmlCharPtr; namespaces: xmlCharPtrPtr): cint; EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_PATTERN_ENABLED *)
-function xmlTextReaderCurrentDoc(reader: xmlTextReaderPtr): xmlDocPtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderExpand(reader: xmlTextReaderPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderNext(reader: xmlTextReaderPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderNextSibling(reader: xmlTextReaderPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderIsValid(reader: xmlTextReaderPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextReaderCurrentDoc(reader: xmlTextReaderPtr): xmlDocPtr; EXTDECL; external xml2lib;
+function xmlTextReaderExpand(reader: xmlTextReaderPtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlTextReaderNext(reader: xmlTextReaderPtr): cint; EXTDECL; external xml2lib;
+function xmlTextReaderNextSibling(reader: xmlTextReaderPtr): cint; EXTDECL; external xml2lib;
+function xmlTextReaderIsValid(reader: xmlTextReaderPtr): cint; EXTDECL; external xml2lib;
 {$IFDEF LIBXML_SCHEMAS_ENABLED}
 
-function xmlTextReaderRelaxNGValidate(reader: xmlTextReaderPtr; rng: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderRelaxNGSetSchema(reader: xmlTextReaderPtr; schema: xmlRelaxNGPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderSchemaValidate(reader: xmlTextReaderPtr; xsd: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderSchemaValidateCtxt(reader: xmlTextReaderPtr; ctxt: xmlSchemaValidCtxtPtr; options: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderSetSchema(reader: xmlTextReaderPtr; schema: xmlSchemaPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextReaderRelaxNGValidate(reader: xmlTextReaderPtr; rng: pchar): cint; EXTDECL; external xml2lib;
+function xmlTextReaderRelaxNGSetSchema(reader: xmlTextReaderPtr; schema: xmlRelaxNGPtr): cint; EXTDECL; external xml2lib;
+function xmlTextReaderSchemaValidate(reader: xmlTextReaderPtr; xsd: pchar): cint; EXTDECL; external xml2lib;
+function xmlTextReaderSchemaValidateCtxt(reader: xmlTextReaderPtr; ctxt: xmlSchemaValidCtxtPtr; options: cint): cint; EXTDECL; external xml2lib;
+function xmlTextReaderSetSchema(reader: xmlTextReaderPtr; schema: xmlSchemaPtr): cint; EXTDECL; external xml2lib;
 {$ENDIF}
-function xmlTextReaderConstXmlVersion(reader: xmlTextReaderPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlTextReaderStandalone(reader: xmlTextReaderPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextReaderConstXmlVersion(reader: xmlTextReaderPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlTextReaderStandalone(reader: xmlTextReaderPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * Index lookup
  *)
-function xmlTextReaderByteConsumed(reader: xmlTextReaderPtr): clong; XMLCALL; XMLPUBFUN;
+function xmlTextReaderByteConsumed(reader: xmlTextReaderPtr): clong; EXTDECL; external xml2lib;
 
 (*
  * New more complete APIs for simpler creation and reuse of readers
  *)
-function xmlReaderWalker(doc: xmlDocPtr): xmlTextReaderPtr; XMLCALL; XMLPUBFUN;
-function xmlReaderForDoc(cur: xmlCharPtr; URL, encoding: pchar; options: cint): xmlTextReaderPtr; XMLCALL; XMLPUBFUN;
-function xmlReaderForFile(filename, encoding: pchar; options: cint): xmlTextReaderPtr; XMLCALL; XMLPUBFUN;
-function xmlReaderForMemory(buffer: pchar; size: cint; URL, encoding: pchar; options: cint): xmlTextReaderPtr; XMLCALL; XMLPUBFUN;
-function xmlReaderForFd(fd: cint; URL, encoding: pchar; options: cint): xmlTextReaderPtr; XMLCALL; XMLPUBFUN;
-function xmlReaderForIO(ioread: xmlInputReadCallback; ioclose: xmlInputCloseCallback; ioctx: pointer; URL, encoding: pchar; options: cint): xmlTextReaderPtr; XMLCALL; XMLPUBFUN;
-
-function xmlReaderNewWalker(reader: xmlTextReaderPtr; doc: xmlDocPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlReaderNewDoc(reader: xmlTextReaderPtr; cur: xmlCharPtr; URL, encoding: pchar; options: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlReaderNewFile(reader: xmlTextReaderPtr; filename, encoding: pchar; options: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlReaderNewMemory(reader: xmlTextReaderPtr; buffer: pchar; size: cint; URL, encoding: pchar; options: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlReaderNewFd(reader: xmlTextReaderPtr; fd: cint; URL, encoding: pchar; options: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlReaderNewIO(reader: xmlTextReaderPtr; ioread: xmlInputReadCallback; ioclose: xmlInputCloseCallback; ioctx: pointer; URL, encoding: pchar; options: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlReaderWalker(doc: xmlDocPtr): xmlTextReaderPtr; EXTDECL; external xml2lib;
+function xmlReaderForDoc(cur: xmlCharPtr; URL, encoding: pchar; options: cint): xmlTextReaderPtr; EXTDECL; external xml2lib;
+function xmlReaderForFile(filename, encoding: pchar; options: cint): xmlTextReaderPtr; EXTDECL; external xml2lib;
+function xmlReaderForMemory(buffer: pchar; size: cint; URL, encoding: pchar; options: cint): xmlTextReaderPtr; EXTDECL; external xml2lib;
+function xmlReaderForFd(fd: cint; URL, encoding: pchar; options: cint): xmlTextReaderPtr; EXTDECL; external xml2lib;
+function xmlReaderForIO(ioread: xmlInputReadCallback; ioclose: xmlInputCloseCallback; ioctx: pointer; URL, encoding: pchar; options: cint): xmlTextReaderPtr; EXTDECL; external xml2lib;
+
+function xmlReaderNewWalker(reader: xmlTextReaderPtr; doc: xmlDocPtr): cint; EXTDECL; external xml2lib;
+function xmlReaderNewDoc(reader: xmlTextReaderPtr; cur: xmlCharPtr; URL, encoding: pchar; options: cint): cint; EXTDECL; external xml2lib;
+function xmlReaderNewFile(reader: xmlTextReaderPtr; filename, encoding: pchar; options: cint): cint; EXTDECL; external xml2lib;
+function xmlReaderNewMemory(reader: xmlTextReaderPtr; buffer: pchar; size: cint; URL, encoding: pchar; options: cint): cint; EXTDECL; external xml2lib;
+function xmlReaderNewFd(reader: xmlTextReaderPtr; fd: cint; URL, encoding: pchar; options: cint): cint; EXTDECL; external xml2lib;
+function xmlReaderNewIO(reader: xmlTextReaderPtr; ioread: xmlInputReadCallback; ioclose: xmlInputCloseCallback; ioctx: pointer; URL, encoding: pchar; options: cint): cint; EXTDECL; external xml2lib;
 
 (*
  * Error handling extensions
  *)
-function xmlTextReaderLocatorLineNumber(locator: xmlTextReaderLocatorPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextReaderLocatorBaseURI(locator: xmlTextReaderLocatorPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-procedure xmlTextReaderSetErrorHandler(reader: xmlTextReaderPtr; f: xmlTextReaderErrorFunc; arg: pointer); XMLCALL; XMLPUBFUN;
-procedure xmlTextReaderSetStructuredErrorHandler(reader: xmlTextReaderPtr; f: xmlTextReaderErrorFunc; arg: pointer); XMLCALL; XMLPUBFUN;
-procedure xmlTextReaderGetErrorHandler(reader: xmlTextReaderPtr; var f: xmlTextReaderErrorFunc; var arg: pointer); XMLCALL; XMLPUBFUN;
+function xmlTextReaderLocatorLineNumber(locator: xmlTextReaderLocatorPtr): cint; EXTDECL; external xml2lib;
+function xmlTextReaderLocatorBaseURI(locator: xmlTextReaderLocatorPtr): xmlCharPtr; EXTDECL; external xml2lib;
+procedure xmlTextReaderSetErrorHandler(reader: xmlTextReaderPtr; f: xmlTextReaderErrorFunc; arg: pointer); EXTDECL; external xml2lib;
+procedure xmlTextReaderSetStructuredErrorHandler(reader: xmlTextReaderPtr; f: xmlTextReaderErrorFunc; arg: pointer); EXTDECL; external xml2lib;
+procedure xmlTextReaderGetErrorHandler(reader: xmlTextReaderPtr; var f: xmlTextReaderErrorFunc; var arg: pointer); EXTDECL; external xml2lib;
 {$ENDIF}
 
 {$ENDIF} (* LIBXML_READER_ENABLED *)

packages/libxml/src/xmlregexp.inc

@@ -37,28 +37,28 @@
 (*
  * Callback function when doing a transition in the automata
  *)
-  xmlRegExecCallbacks = procedure(exec: xmlRegExecCtxtPtr; token: xmlCharPtr; transdata, inputdata: pointer); XMLCALL;
+  xmlRegExecCallbacks = procedure(exec: xmlRegExecCtxtPtr; token: xmlCharPtr; transdata, inputdata: pointer); EXTDECL;
 {$ENDIF}
 
 {$IFDEF FUNCTION}
 (*
  * The POSIX like API
  *)
-function xmlRegexpCompile(regexp: xmlCharPtr): xmlRegexpPtr; XMLCALL; XMLPUBFUN;
-procedure xmlRegFreeRegexp(regexp: xmlRegexpPtr); XMLCALL; XMLPUBFUN;
-function xmlRegexpExec(comp: xmlRegexpPtr; value: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-procedure xmlRegexpPrint(output: PFILE; regexp: xmlRegexpPtr); XMLCALL; XMLPUBFUN;
-function xmlRegexpIsDeterminist(comp: xmlRegexpPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlRegexpCompile(regexp: xmlCharPtr): xmlRegexpPtr; EXTDECL; external xml2lib;
+procedure xmlRegFreeRegexp(regexp: xmlRegexpPtr); EXTDECL; external xml2lib;
+function xmlRegexpExec(comp: xmlRegexpPtr; value: xmlCharPtr): cint; EXTDECL; external xml2lib;
+procedure xmlRegexpPrint(output: PFILE; regexp: xmlRegexpPtr); EXTDECL; external xml2lib;
+function xmlRegexpIsDeterminist(comp: xmlRegexpPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * The progressive API
  *)
-function xmlRegNewExecCtxt(comp: xmlRegexpPtr; callback: xmlRegExecCallbacks; data: pointer): xmlRegExecCtxtPtr; XMLCALL; XMLPUBFUN;
-procedure xmlRegFreeExecCtxt(exec: xmlRegExecCtxtPtr); XMLCALL; XMLPUBFUN;
-function xmlRegExecPushString(exec: xmlRegExecCtxtPtr; value: xmlCharPtr; data: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlRegExecPushString2(exec: xmlRegExecCtxtPtr; value, value2: xmlCharPtr; data: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlRegExecNextValues(exec: xmlRegExecCtxtPtr; nbval, nbneg: pcint; values: xmlCharPtrPtr; terminal: pcint): cint; XMLCALL; XMLPUBFUN;
-function xmlRegExecErrInfo(exec: xmlRegExecCtxtPtr; _string: xmlCharPtrPtr; nbval, nbneg: pcint; values: xmlCharPtrPtr; terminal: pcint): cint; XMLCALL; XMLPUBFUN;
+function xmlRegNewExecCtxt(comp: xmlRegexpPtr; callback: xmlRegExecCallbacks; data: pointer): xmlRegExecCtxtPtr; EXTDECL; external xml2lib;
+procedure xmlRegFreeExecCtxt(exec: xmlRegExecCtxtPtr); EXTDECL; external xml2lib;
+function xmlRegExecPushString(exec: xmlRegExecCtxtPtr; value: xmlCharPtr; data: pointer): cint; EXTDECL; external xml2lib;
+function xmlRegExecPushString2(exec: xmlRegExecCtxtPtr; value, value2: xmlCharPtr; data: pointer): cint; EXTDECL; external xml2lib;
+function xmlRegExecNextValues(exec: xmlRegExecCtxtPtr; nbval, nbneg: pcint; values: xmlCharPtrPtr; terminal: pcint): cint; EXTDECL; external xml2lib;
+function xmlRegExecErrInfo(exec: xmlRegExecCtxtPtr; _string: xmlCharPtrPtr; nbval, nbneg: pcint; values: xmlCharPtrPtr; terminal: pcint): cint; EXTDECL; external xml2lib;
 {$ENDIF}
 
 {$IFDEF LIBXML_EXPR_ENABLED}
@@ -85,10 +85,10 @@ function xmlRegExecErrInfo(exec: xmlRegExecCtxtPtr; _string: xmlCharPtrPtr; nbva
 {$ENDIF}
 
 {$IFDEF FUNCTION}
-procedure xmlRegFreeExecCtxt(ctxt: xmlExpCtxtPtr); XMLCALL; XMLPUBFUN;
-function xmlExpNewCtxt(maxNodes: cint; dict: xmlDictPtr): xmlExpCtxtPtr; XMLCALL; XMLPUBFUN;
-function xmlExpCtxtNbNodes(ctxt: xmlExpCtxtPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlExpCtxtNbCons(ctxt: xmlExpCtxtPtr): cint; XMLCALL; XMLPUBFUN;
+procedure xmlRegFreeExecCtxt(ctxt: xmlExpCtxtPtr); EXTDECL; external xml2lib;
+function xmlExpNewCtxt(maxNodes: cint; dict: xmlDictPtr): xmlExpCtxtPtr; EXTDECL; external xml2lib;
+function xmlExpCtxtNbNodes(ctxt: xmlExpCtxtPtr): cint; EXTDECL; external xml2lib;
+function xmlExpCtxtNbCons(ctxt: xmlExpCtxtPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * 2 core expressions shared by all for the empty language set
@@ -96,36 +96,36 @@ function xmlExpCtxtNbCons(ctxt: xmlExpCtxtPtr): cint; XMLCALL; XMLPUBFUN;
  *)
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  forbiddenExp: xmlExpNodePtr; XMLPUBVAR;
-  emptyExp: xmlExpNodePtr; XMLPUBVAR;
+  forbiddenExp: xmlExpNodePtr; cvar; external;
+  emptyExp: xmlExpNodePtr; cvar; external;
 {$ENDIF}
 
 (*
  * Expressions are reference counted internally
  *)
-procedure xmlExpFree(ctxt: xmlExpCtxtPtr; expr: xmlExpNodePtr); XMLCALL; XMLPUBFUN;
-procedure xmlExpRef(expr: xmlExpNodePtr); XMLCALL; XMLPUBFUN;
+procedure xmlExpFree(ctxt: xmlExpCtxtPtr; expr: xmlExpNodePtr); EXTDECL; external xml2lib;
+procedure xmlExpRef(expr: xmlExpNodePtr); EXTDECL; external xml2lib;
 
 (*
  * constructors can be either manual or from a string
  *)
-function xmlExpParse(ctxt: xmlExpCtxtPtr; expr: pchar): xmlExpNodePtr; XMLCALL; XMLPUBFUN;
-function xmlExpNewAtom(ctxt: xmlExpCtxtPtr; name: xmlCharPtr; len: cint): xmlExpNodePtr; XMLCALL; XMLPUBFUN;
-function xmlExpNewOr(ctxt: xmlExpCtxtPtr; left, right: xmlExpNodePtr): xmlExpNodePtr; XMLCALL; XMLPUBFUN;
-function xmlExpNewSeq(ctxt: xmlExpCtxtPtr; left, right: xmlExpNodePtr): xmlExpNodePtr; XMLCALL; XMLPUBFUN;
-function xmlExpNewRange(ctxt: xmlExpCtxtPtr; subset: xmlExpNodePtr; min, max: cint): xmlExpNodePtr; XMLCALL; XMLPUBFUN;
+function xmlExpParse(ctxt: xmlExpCtxtPtr; expr: pchar): xmlExpNodePtr; EXTDECL; external xml2lib;
+function xmlExpNewAtom(ctxt: xmlExpCtxtPtr; name: xmlCharPtr; len: cint): xmlExpNodePtr; EXTDECL; external xml2lib;
+function xmlExpNewOr(ctxt: xmlExpCtxtPtr; left, right: xmlExpNodePtr): xmlExpNodePtr; EXTDECL; external xml2lib;
+function xmlExpNewSeq(ctxt: xmlExpCtxtPtr; left, right: xmlExpNodePtr): xmlExpNodePtr; EXTDECL; external xml2lib;
+function xmlExpNewRange(ctxt: xmlExpCtxtPtr; subset: xmlExpNodePtr; min, max: cint): xmlExpNodePtr; EXTDECL; external xml2lib;
 
 (*
  * The really interesting APIs
  *)
-function xmlExpIsNillable(expr: xmlExpNodePtr): cint; XMLCALL; XMLPUBFUN;
-function xmlExpMaxToken(expr: xmlExpNodePtr): cint; XMLCALL; XMLPUBFUN;
-function xmlExpGetLanguage(ctxt: xmlExpCtxtPtr; expr: xmlExpNodePtr; langList: xmlCharPtrPtr; len: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlExpGetStart(ctxt: xmlExpCtxtPtr; expr: xmlExpNodePtr; tokList: xmlCharPtrPtr; len: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlExpStringDerive(ctxt: xmlExpCtxtPtr; expr: xmlExpNodePtr; str: xmlCharPtr; len: cint): xmlExpNodePtr; XMLCALL; XMLPUBFUN;
-function xmlExpExpDerive(ctxt: xmlExpCtxtPtr; expr, sub: xmlExpNodePtr): xmlExpNodePtr; XMLCALL; XMLPUBFUN;
-function xmlExpSubsume(ctxt: xmlExpCtxtPtr; expr, sub: xmlExpNodePtr): cint; XMLCALL; XMLPUBFUN;
-procedure xmlExpDump(buf: xmlBufferPtr; expr: xmlExpNodePtr); XMLCALL; XMLPUBFUN;
+function xmlExpIsNillable(expr: xmlExpNodePtr): cint; EXTDECL; external xml2lib;
+function xmlExpMaxToken(expr: xmlExpNodePtr): cint; EXTDECL; external xml2lib;
+function xmlExpGetLanguage(ctxt: xmlExpCtxtPtr; expr: xmlExpNodePtr; langList: xmlCharPtrPtr; len: cint): cint; EXTDECL; external xml2lib;
+function xmlExpGetStart(ctxt: xmlExpCtxtPtr; expr: xmlExpNodePtr; tokList: xmlCharPtrPtr; len: cint): cint; EXTDECL; external xml2lib;
+function xmlExpStringDerive(ctxt: xmlExpCtxtPtr; expr: xmlExpNodePtr; str: xmlCharPtr; len: cint): xmlExpNodePtr; EXTDECL; external xml2lib;
+function xmlExpExpDerive(ctxt: xmlExpCtxtPtr; expr, sub: xmlExpNodePtr): xmlExpNodePtr; EXTDECL; external xml2lib;
+function xmlExpSubsume(ctxt: xmlExpCtxtPtr; expr, sub: xmlExpNodePtr): cint; EXTDECL; external xml2lib;
+procedure xmlExpDump(buf: xmlBufferPtr; expr: xmlExpNodePtr); EXTDECL; external xml2lib;
 {$ENDIF}
 {$ENDIF} (* LIBXML_EXPR_ENABLED *)
 {$ENDIF} (* LIBXML_REGEXP_ENABLED *)

packages/libxml/src/xmlsave.inc

@@ -33,17 +33,17 @@
 {$ENDIF}
 
 {$IFDEF FUNCTION}
-function xmlSaveToFd(fd: cint; encoding: pchar; options: cint): xmlSaveCtxtPtr; XMLCALL; XMLPUBFUN;
-function xmlSaveToFilename(filename: pchar; encoding: pchar; options: cint): xmlSaveCtxtPtr; XMLCALL; XMLPUBFUN;
-function xmlSaveToBuffer(buffer: xmlBufferPtr; encoding: pchar; options: cint): xmlSaveCtxtPtr; XMLCALL; XMLPUBFUN;
-function xmlSaveToIO(iowrite: xmlOutputWriteCallback; ioclose: xmlOutputCloseCallback; ioctx: pointer; encoding: pchar; options: cint): xmlSaveCtxtPtr; XMLCALL; XMLPUBFUN;
-
-function xmlSaveDoc(ctxt: xmlSaveCtxtPtr; doc: xmlDocPtr): clong; XMLCALL; XMLPUBFUN;
-function xmlSaveTree(ctxt: xmlSaveCtxtPtr; node: xmlNodePtr): clong; XMLCALL; XMLPUBFUN;
-function xmlSaveFlush(ctxt: xmlSaveCtxtPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlSaveClose(ctxt: xmlSaveCtxtPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlSaveSetEscape(ctxt: xmlSaveCtxtPtr; escape: xmlCharEncodingOutputFunc): cint; XMLCALL; XMLPUBFUN;
-function xmlSaveSetAttrEscape(ctxt: xmlSaveCtxtPtr; escape: xmlCharEncodingOutputFunc): cint; XMLCALL; XMLPUBFUN;
+function xmlSaveToFd(fd: cint; encoding: pchar; options: cint): xmlSaveCtxtPtr; EXTDECL; external xml2lib;
+function xmlSaveToFilename(filename: pchar; encoding: pchar; options: cint): xmlSaveCtxtPtr; EXTDECL; external xml2lib;
+function xmlSaveToBuffer(buffer: xmlBufferPtr; encoding: pchar; options: cint): xmlSaveCtxtPtr; EXTDECL; external xml2lib;
+function xmlSaveToIO(iowrite: xmlOutputWriteCallback; ioclose: xmlOutputCloseCallback; ioctx: pointer; encoding: pchar; options: cint): xmlSaveCtxtPtr; EXTDECL; external xml2lib;
+
+function xmlSaveDoc(ctxt: xmlSaveCtxtPtr; doc: xmlDocPtr): clong; EXTDECL; external xml2lib;
+function xmlSaveTree(ctxt: xmlSaveCtxtPtr; node: xmlNodePtr): clong; EXTDECL; external xml2lib;
+function xmlSaveFlush(ctxt: xmlSaveCtxtPtr): cint; EXTDECL; external xml2lib;
+function xmlSaveClose(ctxt: xmlSaveCtxtPtr): cint; EXTDECL; external xml2lib;
+function xmlSaveSetEscape(ctxt: xmlSaveCtxtPtr; escape: xmlCharEncodingOutputFunc): cint; EXTDECL; external xml2lib;
+function xmlSaveSetAttrEscape(ctxt: xmlSaveCtxtPtr; escape: xmlCharEncodingOutputFunc): cint; EXTDECL; external xml2lib;
 {$ENDIF}
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
 

packages/libxml/src/xmlschemas.inc

@@ -86,8 +86,8 @@
 (**
  * A schemas validation context
  *)
-  xmlSchemaValidityErrorFunc = procedure(ctx: pointer; msg: pchar); XMLCDECL; varargs;
-  xmlSchemaValidityWarningFunc = procedure(ctx: pointer; msg: pchar); XMLCDECL; varargs;
+  xmlSchemaValidityErrorFunc = procedure(ctx: pointer; msg: pchar); cdecl; varargs;
+  xmlSchemaValidityWarningFunc = procedure(ctx: pointer; msg: pchar); cdecl; varargs;
 
   xmlSchemaParserCtxt = record end;
 
@@ -100,40 +100,40 @@
 (*
  * Interfaces for parsing.
  *)
-function xmlSchemaNewParserCtxt(URL: pchar): xmlSchemaParserCtxtPtr; XMLCALL; XMLPUBFUN;
-function xmlSchemaNewMemParserCtxt(buffer: pchar; size: cint): xmlSchemaParserCtxtPtr; XMLCALL; XMLPUBFUN;
-function xmlSchemaNewDocParserCtxt(doc: xmlDocPtr): xmlSchemaParserCtxtPtr; XMLCALL; XMLPUBFUN;
-procedure xmlSchemaFreeParserCtxt(ctxt: xmlSchemaParserCtxtPtr); XMLCALL; XMLPUBFUN;
-procedure xmlSchemaSetParserErrors(ctxt: xmlSchemaParserCtxtPtr; err: xmlSchemaValidityErrorFunc; warn: xmlSchemaValidityWarningFunc; ctx: pointer); XMLCALL; XMLPUBFUN;
-procedure xmlSchemaSetParserStructuredErrors(ctxt: xmlSchemaParserCtxtPtr; serror: xmlStructuredErrorFunc; ctx: pointer); XMLCALL; XMLPUBFUN;
-function xmlSchemaSetParserErrors(ctxt: xmlSchemaParserCtxtPtr; var err: xmlSchemaValidityErrorFunc; var warn: xmlSchemaValidityWarningFunc; var ctx: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlSchemaIsValid(ctxt: xmlSchemaValidCtxtPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlSchemaParse(ctxt: xmlSchemaParserCtxtPtr): xmlSchemaPtr; XMLCALL; XMLPUBFUN;
-procedure xmlSchemaFree(schema: xmlSchemaPtr); XMLCALL; XMLPUBFUN;
+function xmlSchemaNewParserCtxt(URL: pchar): xmlSchemaParserCtxtPtr; EXTDECL; external xml2lib;
+function xmlSchemaNewMemParserCtxt(buffer: pchar; size: cint): xmlSchemaParserCtxtPtr; EXTDECL; external xml2lib;
+function xmlSchemaNewDocParserCtxt(doc: xmlDocPtr): xmlSchemaParserCtxtPtr; EXTDECL; external xml2lib;
+procedure xmlSchemaFreeParserCtxt(ctxt: xmlSchemaParserCtxtPtr); EXTDECL; external xml2lib;
+procedure xmlSchemaSetParserErrors(ctxt: xmlSchemaParserCtxtPtr; err: xmlSchemaValidityErrorFunc; warn: xmlSchemaValidityWarningFunc; ctx: pointer); EXTDECL; external xml2lib;
+procedure xmlSchemaSetParserStructuredErrors(ctxt: xmlSchemaParserCtxtPtr; serror: xmlStructuredErrorFunc; ctx: pointer); EXTDECL; external xml2lib;
+function xmlSchemaSetParserErrors(ctxt: xmlSchemaParserCtxtPtr; var err: xmlSchemaValidityErrorFunc; var warn: xmlSchemaValidityWarningFunc; var ctx: pointer): cint; EXTDECL; external xml2lib;
+function xmlSchemaIsValid(ctxt: xmlSchemaValidCtxtPtr): cint; EXTDECL; external xml2lib;
+function xmlSchemaParse(ctxt: xmlSchemaParserCtxtPtr): xmlSchemaPtr; EXTDECL; external xml2lib;
+procedure xmlSchemaFree(schema: xmlSchemaPtr); EXTDECL; external xml2lib;
 {$IFDEF LIBXML_OUTPUT_ENABLED}
-procedure xmlSchemaDump(output: PFILE; schema: xmlSchemaPtr); XMLCALL; XMLPUBFUN;
+procedure xmlSchemaDump(output: PFILE; schema: xmlSchemaPtr); EXTDECL; external xml2lib;
 {$ENDIF} (* LIBXML_OUTPUT_ENABLED *)
 
 (*
  * Interfaces for validating
  *)
-procedure xmlSchemaSetValidErrors(ctxt: xmlSchemaParserCtxtPtr; err: xmlSchemaValidityErrorFunc; warn: xmlSchemaValidityWarningFunc; ctx: pointer); XMLCALL; XMLPUBFUN;
-procedure xmlSchemaSetValidStructuredErrors(ctxt: xmlSchemaParserCtxtPtr; serror: xmlStructuredErrorFunc; ctx: pointer); XMLCALL; XMLPUBFUN;
-function xmlSchemaGetValidErrors(ctxt: xmlSchemaParserCtxtPtr; var err: xmlSchemaValidityErrorFunc; var warn: xmlSchemaValidityWarningFunc; var ctx: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlSchemaSetValidOptions(ctxt: xmlSchemaValidCtxtPtr; options: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlSchemaValidCtxtGetOptions(ctxt: xmlSchemaValidCtxtPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlSchemaNewValidCtxt(schema: xmlSchemaPtr): xmlSchemaValidCtxtPtr; XMLCALL; XMLPUBFUN;
-procedure xmlSchemaFreeValidCtxt(ctxt: xmlSchemaValidCtxtPtr); XMLCALL; XMLPUBFUN;
-function xmlSchemaNewValidCtxt(ctxt: xmlSchemaValidCtxtPtr; instance: xmlDocPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlSchemaValidateOneElement(ctxt: xmlSchemaValidCtxtPtr; elem: xmlNodePtr): cint; XMLCALL; XMLPUBFUN;
-function xmlSchemaValidateStream(ctxt: xmlSchemaValidCtxtPtr; input: xmlParserInputBufferPtr; enc: xmlCharEncoding; sax: xmlSAXHandlerPtr; user_data: pointer): cint; XMLCALL; XMLPUBFUN;
-function xmlSchemaValidateFile(ctxt: xmlSchemaValidCtxtPtr; filename: pchar; options: cint): cint; XMLCALL; XMLPUBFUN;
+procedure xmlSchemaSetValidErrors(ctxt: xmlSchemaParserCtxtPtr; err: xmlSchemaValidityErrorFunc; warn: xmlSchemaValidityWarningFunc; ctx: pointer); EXTDECL; external xml2lib;
+procedure xmlSchemaSetValidStructuredErrors(ctxt: xmlSchemaParserCtxtPtr; serror: xmlStructuredErrorFunc; ctx: pointer); EXTDECL; external xml2lib;
+function xmlSchemaGetValidErrors(ctxt: xmlSchemaParserCtxtPtr; var err: xmlSchemaValidityErrorFunc; var warn: xmlSchemaValidityWarningFunc; var ctx: pointer): cint; EXTDECL; external xml2lib;
+function xmlSchemaSetValidOptions(ctxt: xmlSchemaValidCtxtPtr; options: cint): cint; EXTDECL; external xml2lib;
+function xmlSchemaValidCtxtGetOptions(ctxt: xmlSchemaValidCtxtPtr): cint; EXTDECL; external xml2lib;
+function xmlSchemaNewValidCtxt(schema: xmlSchemaPtr): xmlSchemaValidCtxtPtr; EXTDECL; external xml2lib;
+procedure xmlSchemaFreeValidCtxt(ctxt: xmlSchemaValidCtxtPtr); EXTDECL; external xml2lib;
+function xmlSchemaNewValidCtxt(ctxt: xmlSchemaValidCtxtPtr; instance: xmlDocPtr): cint; EXTDECL; external xml2lib;
+function xmlSchemaValidateOneElement(ctxt: xmlSchemaValidCtxtPtr; elem: xmlNodePtr): cint; EXTDECL; external xml2lib;
+function xmlSchemaValidateStream(ctxt: xmlSchemaValidCtxtPtr; input: xmlParserInputBufferPtr; enc: xmlCharEncoding; sax: xmlSAXHandlerPtr; user_data: pointer): cint; EXTDECL; external xml2lib;
+function xmlSchemaValidateFile(ctxt: xmlSchemaValidCtxtPtr; filename: pchar; options: cint): cint; EXTDECL; external xml2lib;
 
 (*
  * Interface to insert Schemas SAX velidation in a SAX stream
  *)
-function xmlSchemaSAXPlug(ctxt: xmlSchemaValidCtxtPtr; var sax: xmlSchemaSAXPlugPtr; var user_data: pointer): xmlSchemaSAXPlugPtr; XMLCALL; XMLPUBFUN;
-function xmlSchemaSAXUnplug(plug: xmlSchemaSAXPlugPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlSchemaSAXPlug(ctxt: xmlSchemaValidCtxtPtr; var sax: xmlSchemaSAXPlugPtr; var user_data: pointer): xmlSchemaSAXPlugPtr; EXTDECL; external xml2lib;
+function xmlSchemaSAXUnplug(plug: xmlSchemaSAXPlugPtr): cint; EXTDECL; external xml2lib;
 {$ENDIF}
 
 {$ENDIF} (* LIBXML_SCHEMAS_ENABLED *)

packages/libxml/src/xmlschemastypes.inc

@@ -20,41 +20,41 @@
 {$ENDIF}
 
 {$IFDEF FUNCTION}
-procedure xmlSchemaInitTypes; XMLCALL; XMLPUBFUN;
-procedure xmlSchemaCleanupTypes; XMLCALL; XMLPUBFUN;
-function xmlSchemaGetPredefinedType(name, ns: xmlCharPtr): xmlSchemaTypePtr; XMLCALL; XMLPUBFUN;
-function xmlSchemaValidatePredefinedType(_type: xmlSchemaTypePtr; value: xmlCharPtr; var val: xmlSchemaValPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlSchemaValPredefTypeNode(_type: xmlSchemaTypePtr; value: xmlCharPtr; var val: xmlSchemaValPtr; node: xmlNodePtr): cint; XMLCALL; XMLPUBFUN;
-function xmlSchemaValidateFacet(base: xmlSchemaTypePtr; facet: xmlSchemaFacetPtr; value: xmlCharPtr; val: xmlSchemaValPtr): cint; XMLCALL; XMLPUBFUN;
+procedure xmlSchemaInitTypes; EXTDECL; external xml2lib;
+procedure xmlSchemaCleanupTypes; EXTDECL; external xml2lib;
+function xmlSchemaGetPredefinedType(name, ns: xmlCharPtr): xmlSchemaTypePtr; EXTDECL; external xml2lib;
+function xmlSchemaValidatePredefinedType(_type: xmlSchemaTypePtr; value: xmlCharPtr; var val: xmlSchemaValPtr): cint; EXTDECL; external xml2lib;
+function xmlSchemaValPredefTypeNode(_type: xmlSchemaTypePtr; value: xmlCharPtr; var val: xmlSchemaValPtr; node: xmlNodePtr): cint; EXTDECL; external xml2lib;
+function xmlSchemaValidateFacet(base: xmlSchemaTypePtr; facet: xmlSchemaFacetPtr; value: xmlCharPtr; val: xmlSchemaValPtr): cint; EXTDECL; external xml2lib;
 function xmlSchemaValidateFacetWhtsp(facet: xmlSchemaFacetPtr; fws: xmlSchemaWhitespaceValueType; valType: xmlSchemaValType;
-  value: xmlCharPtr; val: xmlSchemaValPtr; ws: xmlSchemaWhitespaceValueType): cint; XMLCALL; XMLPUBFUN;
-procedure xmlSchemaFreeValue(val: xmlSchemaValPtr); XMLCALL; XMLPUBFUN;
-function xmlSchemaNewFacet: xmlSchemaFacetPtr; XMLCALL; XMLPUBFUN;
-function xmlSchemaCheckFacet(facet: xmlSchemaFacetPtr; typeDecl: xmlSchemaTypePtr; ctxt: xmlSchemaParserCtxtPtr; name: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-procedure xmlSchemaFreeFacet(facet: xmlSchemaFacetPtr); XMLCALL; XMLPUBFUN;
-function xmlSchemaCompareValues(x, y: xmlSchemaValPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlSchemaGetBuiltInListSimpleTypeItemType(_type: xmlSchemaTypePtr): xmlSchemaTypePtr; XMLCALL; XMLPUBFUN;
-function xmlSchemaValidateListSimpleTypeFacet(facet: xmlSchemaFacetPtr; value: xmlCharPtr; actualLen: culong; expectedLen: pculong): cint; XMLCALL; XMLPUBFUN;
-function xmlSchemaGetBuiltInType(_type: xmlSchemaValType): xmlSchemaTypePtr; XMLCALL; XMLPUBFUN;
-function xmlSchemaIsBuiltInTypeFacet(_type: xmlSchemaTypePtr; faceType: cint): xmlSchemaTypePtr; XMLCALL; XMLPUBFUN;
-function xmlSchemaCollapseString(value: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlSchemaWhiteSpaceReplace(value: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlSchemaGetFacetValueAsULong(facet: xmlSchemaFacetPtr): culong; XMLCALL; XMLPUBFUN;
-function xmlSchemaValidateLengthFacet(_type: xmlSchemaTypePtr; facet: xmlSchemaFacetPtr; value: xmlCharPtr; val: xmlSchemaValPtr; length: pculong): cint; XMLCALL; XMLPUBFUN;
-function xmlSchemaValidateLengthFacetWhtsp(facet: xmlSchemaFacetPtr; valType: xmlSchemaValType; value: xmlCharPtr; val: xmlSchemaValPtr; length: pculong; ws: xmlSchemaWhitespaceValueType): cint; XMLCALL; XMLPUBFUN;
-function xmlSchemaValPredefTypeNodeNoNorm(_type: xmlSchemaTypePtr; value: xmlCharPtr; val: xmlSchemaValPtrPtr; node: xmlNodePtr): cint; XMLCALL; XMLPUBFUN;
-function xmlSchemaGetCanonValue(val: xmlSchemaValPtr; var retValue: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlSchemaGetCanonValueWhtsp(val: xmlSchemaValPtr; var retValue: xmlCharPtr; ws: xmlSchemaWhitespaceValueType): cint; XMLCALL; XMLPUBFUN;
-function xmlSchemaValueAppend(prev, cur: xmlSchemaValPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlSchemaValueGetNext(cur: xmlSchemaValPtr): xmlSchemaValPtr; XMLCALL; XMLPUBFUN;
-function xmlSchemaValueGetAsString(val: xmlSchemaValPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlSchemaValueGetAsBoolean(val: xmlSchemaValPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlSchemaNewStringValue(_type: xmlSchemaValType; value: xmlCharPtr): xmlSchemaValPtr; XMLCALL; XMLPUBFUN;
-function xmlSchemaNewNOTATIONValue(name, ns: xmlCharPtr): xmlSchemaValPtr; XMLCALL; XMLPUBFUN;
-function xmlSchemaNewQNameValue(namespaceName, localName: xmlCharPtr): xmlSchemaValPtr; XMLCALL; XMLPUBFUN;
-function xmlSchemaCompareValuesWhtsp(x: xmlSchemaValPtr; xws: xmlSchemaWhitespaceValueType; y: xmlSchemaValPtr; yws: xmlSchemaWhitespaceValueType): cint; XMLCALL; XMLPUBFUN;
-function xmlSchemaCopyValue(val: xmlSchemaValPtr): xmlSchemaValPtr; XMLCALL; XMLPUBFUN;
-function xmlSchemaGetValType(val: xmlSchemaValPtr): xmlSchemaValType; XMLCALL; XMLPUBFUN;
+  value: xmlCharPtr; val: xmlSchemaValPtr; ws: xmlSchemaWhitespaceValueType): cint; EXTDECL; external xml2lib;
+procedure xmlSchemaFreeValue(val: xmlSchemaValPtr); EXTDECL; external xml2lib;
+function xmlSchemaNewFacet: xmlSchemaFacetPtr; EXTDECL; external xml2lib;
+function xmlSchemaCheckFacet(facet: xmlSchemaFacetPtr; typeDecl: xmlSchemaTypePtr; ctxt: xmlSchemaParserCtxtPtr; name: xmlCharPtr): cint; EXTDECL; external xml2lib;
+procedure xmlSchemaFreeFacet(facet: xmlSchemaFacetPtr); EXTDECL; external xml2lib;
+function xmlSchemaCompareValues(x, y: xmlSchemaValPtr): cint; EXTDECL; external xml2lib;
+function xmlSchemaGetBuiltInListSimpleTypeItemType(_type: xmlSchemaTypePtr): xmlSchemaTypePtr; EXTDECL; external xml2lib;
+function xmlSchemaValidateListSimpleTypeFacet(facet: xmlSchemaFacetPtr; value: xmlCharPtr; actualLen: culong; expectedLen: pculong): cint; EXTDECL; external xml2lib;
+function xmlSchemaGetBuiltInType(_type: xmlSchemaValType): xmlSchemaTypePtr; EXTDECL; external xml2lib;
+function xmlSchemaIsBuiltInTypeFacet(_type: xmlSchemaTypePtr; faceType: cint): xmlSchemaTypePtr; EXTDECL; external xml2lib;
+function xmlSchemaCollapseString(value: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlSchemaWhiteSpaceReplace(value: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlSchemaGetFacetValueAsULong(facet: xmlSchemaFacetPtr): culong; EXTDECL; external xml2lib;
+function xmlSchemaValidateLengthFacet(_type: xmlSchemaTypePtr; facet: xmlSchemaFacetPtr; value: xmlCharPtr; val: xmlSchemaValPtr; length: pculong): cint; EXTDECL; external xml2lib;
+function xmlSchemaValidateLengthFacetWhtsp(facet: xmlSchemaFacetPtr; valType: xmlSchemaValType; value: xmlCharPtr; val: xmlSchemaValPtr; length: pculong; ws: xmlSchemaWhitespaceValueType): cint; EXTDECL; external xml2lib;
+function xmlSchemaValPredefTypeNodeNoNorm(_type: xmlSchemaTypePtr; value: xmlCharPtr; val: xmlSchemaValPtrPtr; node: xmlNodePtr): cint; EXTDECL; external xml2lib;
+function xmlSchemaGetCanonValue(val: xmlSchemaValPtr; var retValue: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlSchemaGetCanonValueWhtsp(val: xmlSchemaValPtr; var retValue: xmlCharPtr; ws: xmlSchemaWhitespaceValueType): cint; EXTDECL; external xml2lib;
+function xmlSchemaValueAppend(prev, cur: xmlSchemaValPtr): cint; EXTDECL; external xml2lib;
+function xmlSchemaValueGetNext(cur: xmlSchemaValPtr): xmlSchemaValPtr; EXTDECL; external xml2lib;
+function xmlSchemaValueGetAsString(val: xmlSchemaValPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlSchemaValueGetAsBoolean(val: xmlSchemaValPtr): cint; EXTDECL; external xml2lib;
+function xmlSchemaNewStringValue(_type: xmlSchemaValType; value: xmlCharPtr): xmlSchemaValPtr; EXTDECL; external xml2lib;
+function xmlSchemaNewNOTATIONValue(name, ns: xmlCharPtr): xmlSchemaValPtr; EXTDECL; external xml2lib;
+function xmlSchemaNewQNameValue(namespaceName, localName: xmlCharPtr): xmlSchemaValPtr; EXTDECL; external xml2lib;
+function xmlSchemaCompareValuesWhtsp(x: xmlSchemaValPtr; xws: xmlSchemaWhitespaceValueType; y: xmlSchemaValPtr; yws: xmlSchemaWhitespaceValueType): cint; EXTDECL; external xml2lib;
+function xmlSchemaCopyValue(val: xmlSchemaValPtr): xmlSchemaValPtr; EXTDECL; external xml2lib;
+function xmlSchemaGetValType(val: xmlSchemaValPtr): xmlSchemaValType; EXTDECL; external xml2lib;
 {$ENDIF}
 
 {$ENDIF} (* LIBXML_SCHEMAS_ENABLED *)

packages/libxml/src/xmlstring.inc

@@ -36,34 +36,34 @@ function BAD_CAST(str: string): xmlCharPtr; inline;
 (*
  * xmlChar handling
  *)
-function xmlStrdup(cur: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlStrndup(cur: xmlCharPtr; len: cint): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlCharStrndup(cur: pchar; len: cint): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlCharStrdup(cur: pchar): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlStrsub(str: xmlCharPtr; start: cint; len: cint): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlStrchr(str: xmlCharPtr; val: xmlChar): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlStrstr(str: xmlCharPtr; val: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlStrcasestr(str: xmlCharPtr; val: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlStrcmp(str1: xmlCharPtr; str2: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlStrncmp(str1: xmlCharPtr; str2: xmlCharPtr; len: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlStrcasecmp(str1: xmlCharPtr; str2: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlStrncasecmp(str1: xmlCharPtr; str2: xmlCharPtr; len: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlStrEqual(str1: xmlCharPtr; str2: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlStrQEqual(pref: xmlCharPtr; name: xmlCharPtr; str: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlStrlen(str: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlStrcat(cur: xmlCharPtr; add: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlStrncat(cur: xmlCharPtr; add: xmlCharPtr; len: cint): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlStrncatNew(str1: xmlCharPtr; str2: xmlCharPtr; len: cint): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlStrPrintf(buf: xmlCharPtr; len: cint; msg: xmlCharPtr; args: array of const): cint; XMLCDECL; XMLPUBFUN;
-function xmlStrVPrintf(buf: xmlCharPtr; len: cint; msg: xmlCharPtr; ap: va_list): cint; XMLCALL; XMLPUBFUN;
-function xmlGetUTF8Char(utf: pchar; len: pcint): cint; XMLCALL; XMLPUBFUN;
-function xmlCheckUTF8(utf: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlUTF8Strsize(utf: xmlCharPtr; len: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUTF8Strndup(utf: xmlCharPtr; len: cint): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlUTF8Strpos(utf: xmlCharPtr; pos: cint): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlUTF8Strloc(utf: xmlCharPtr; utfchar: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlUTF8Strsub(str: xmlCharPtr; start: cint; len: cint): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlUTF8Strlen(utf: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlUTF8Size(utf: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlUTF8Charcmp(utf1: xmlCharPtr; utf2: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlStrdup(cur: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlStrndup(cur: xmlCharPtr; len: cint): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlCharStrndup(cur: pchar; len: cint): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlCharStrdup(cur: pchar): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlStrsub(str: xmlCharPtr; start: cint; len: cint): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlStrchr(str: xmlCharPtr; val: xmlChar): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlStrstr(str: xmlCharPtr; val: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlStrcasestr(str: xmlCharPtr; val: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlStrcmp(str1: xmlCharPtr; str2: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlStrncmp(str1: xmlCharPtr; str2: xmlCharPtr; len: cint): cint; EXTDECL; external xml2lib;
+function xmlStrcasecmp(str1: xmlCharPtr; str2: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlStrncasecmp(str1: xmlCharPtr; str2: xmlCharPtr; len: cint): cint; EXTDECL; external xml2lib;
+function xmlStrEqual(str1: xmlCharPtr; str2: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlStrQEqual(pref: xmlCharPtr; name: xmlCharPtr; str: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlStrlen(str: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlStrcat(cur: xmlCharPtr; add: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlStrncat(cur: xmlCharPtr; add: xmlCharPtr; len: cint): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlStrncatNew(str1: xmlCharPtr; str2: xmlCharPtr; len: cint): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlStrPrintf(buf: xmlCharPtr; len: cint; msg: xmlCharPtr; args: array of const): cint; cdecl; external xml2lib;
+function xmlStrVPrintf(buf: xmlCharPtr; len: cint; msg: xmlCharPtr; ap: va_list): cint; EXTDECL; external xml2lib;
+function xmlGetUTF8Char(utf: pchar; len: pcint): cint; EXTDECL; external xml2lib;
+function xmlCheckUTF8(utf: pchar): cint; EXTDECL; external xml2lib;
+function xmlUTF8Strsize(utf: xmlCharPtr; len: cint): cint; EXTDECL; external xml2lib;
+function xmlUTF8Strndup(utf: xmlCharPtr; len: cint): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlUTF8Strpos(utf: xmlCharPtr; pos: cint): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlUTF8Strloc(utf: xmlCharPtr; utfchar: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlUTF8Strsub(str: xmlCharPtr; start: cint; len: cint): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlUTF8Strlen(utf: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlUTF8Size(utf: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlUTF8Charcmp(utf1: xmlCharPtr; utf2: xmlCharPtr): cint; EXTDECL; external xml2lib;
 {$ENDIF}

packages/libxml/src/xmlunicode.inc

@@ -15,175 +15,175 @@
 {$IFDEF LIBXML_UNICODE_ENABLED}
 
 {$IFDEF FUNCTION}
-function xmlUCSIsAegeanNumbers	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsAlphabeticPresentationForms	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsArabic	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsArabicPresentationFormsA	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsArabicPresentationFormsB	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsArmenian	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsArrows	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsBasicLatin	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsBengali	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsBlockElements	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsBopomofo	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsBopomofoExtended	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsBoxDrawing	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsBraillePatterns	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsBuhid	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsByzantineMusicalSymbols	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCJKCompatibility	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCJKCompatibilityForms	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCJKCompatibilityIdeographs	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCJKCompatibilityIdeographsSupplement	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCJKRadicalsSupplement	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCJKSymbolsandPunctuation	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCJKUnifiedIdeographs	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCJKUnifiedIdeographsExtensionA	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCJKUnifiedIdeographsExtensionB	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCherokee	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCombiningDiacriticalMarks	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCombiningDiacriticalMarksforSymbols	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCombiningHalfMarks	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCombiningMarksforSymbols	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsControlPictures	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCurrencySymbols	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCypriotSyllabary	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCyrillic	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCyrillicSupplement	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsDeseret	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsDevanagari	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsDingbats	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsEnclosedAlphanumerics	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsEnclosedCJKLettersandMonths	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsEthiopic	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsGeneralPunctuation	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsGeometricShapes	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsGeorgian	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsGothic	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsGreek	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsGreekExtended	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsGreekandCoptic	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsGujarati	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsGurmukhi	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsHalfwidthandFullwidthForms	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsHangulCompatibilityJamo	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsHangulJamo	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsHangulSyllables	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsHanunoo	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsHebrew	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsHighPrivateUseSurrogates	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsHighSurrogates	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsHiragana	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsIPAExtensions	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsIdeographicDescriptionCharacters	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsKanbun	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsKangxiRadicals	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsKannada	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsKatakana	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsKatakanaPhoneticExtensions	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsKhmer	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsKhmerSymbols	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsLao	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsLatin1Supplement	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsLatinExtendedA	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsLatinExtendedB	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsLatinExtendedAdditional	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsLetterlikeSymbols	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsLimbu	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsLinearBIdeograms	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsLinearBSyllabary	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsLowSurrogates	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsMalayalam	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsMathematicalAlphanumericSymbols	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsMathematicalOperators	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsMiscellaneousMathematicalSymbolsA	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsMiscellaneousMathematicalSymbolsB	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsMiscellaneousSymbols	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsMiscellaneousSymbolsandArrows	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsMiscellaneousTechnical	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsMongolian	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsMusicalSymbols	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsMyanmar	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsNumberForms	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsOgham	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsOldItalic	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsOpticalCharacterRecognition	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsOriya	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsOsmanya	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsPhoneticExtensions	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsPrivateUse	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsPrivateUseArea	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsRunic	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsShavian	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsSinhala	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsSmallFormVariants	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsSpacingModifierLetters	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsSpecials	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsSuperscriptsandSubscripts	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsSupplementalArrowsA	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsSupplementalArrowsB	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsSupplementalMathematicalOperators	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsSupplementaryPrivateUseAreaA	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsSupplementaryPrivateUseAreaB	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsSyriac	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsTagalog	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsTagbanwa	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsTags	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsTaiLe	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsTaiXuanJingSymbols	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsTamil	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsTelugu	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsThaana	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsThai	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsTibetan	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsUgaritic	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsUnifiedCanadianAboriginalSyllabics	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsVariationSelectors	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsVariationSelectorsSupplement	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsYiRadicals	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsYiSyllables	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsYijingHexagramSymbols	(code: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlUCSIsAegeanNumbers	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsAlphabeticPresentationForms	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsArabic	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsArabicPresentationFormsA	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsArabicPresentationFormsB	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsArmenian	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsArrows	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsBasicLatin	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsBengali	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsBlockElements	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsBopomofo	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsBopomofoExtended	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsBoxDrawing	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsBraillePatterns	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsBuhid	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsByzantineMusicalSymbols	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCJKCompatibility	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCJKCompatibilityForms	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCJKCompatibilityIdeographs	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCJKCompatibilityIdeographsSupplement	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCJKRadicalsSupplement	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCJKSymbolsandPunctuation	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCJKUnifiedIdeographs	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCJKUnifiedIdeographsExtensionA	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCJKUnifiedIdeographsExtensionB	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCherokee	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCombiningDiacriticalMarks	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCombiningDiacriticalMarksforSymbols	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCombiningHalfMarks	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCombiningMarksforSymbols	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsControlPictures	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCurrencySymbols	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCypriotSyllabary	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCyrillic	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCyrillicSupplement	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsDeseret	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsDevanagari	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsDingbats	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsEnclosedAlphanumerics	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsEnclosedCJKLettersandMonths	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsEthiopic	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsGeneralPunctuation	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsGeometricShapes	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsGeorgian	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsGothic	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsGreek	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsGreekExtended	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsGreekandCoptic	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsGujarati	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsGurmukhi	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsHalfwidthandFullwidthForms	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsHangulCompatibilityJamo	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsHangulJamo	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsHangulSyllables	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsHanunoo	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsHebrew	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsHighPrivateUseSurrogates	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsHighSurrogates	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsHiragana	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsIPAExtensions	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsIdeographicDescriptionCharacters	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsKanbun	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsKangxiRadicals	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsKannada	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsKatakana	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsKatakanaPhoneticExtensions	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsKhmer	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsKhmerSymbols	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsLao	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsLatin1Supplement	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsLatinExtendedA	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsLatinExtendedB	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsLatinExtendedAdditional	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsLetterlikeSymbols	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsLimbu	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsLinearBIdeograms	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsLinearBSyllabary	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsLowSurrogates	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsMalayalam	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsMathematicalAlphanumericSymbols	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsMathematicalOperators	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsMiscellaneousMathematicalSymbolsA	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsMiscellaneousMathematicalSymbolsB	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsMiscellaneousSymbols	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsMiscellaneousSymbolsandArrows	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsMiscellaneousTechnical	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsMongolian	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsMusicalSymbols	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsMyanmar	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsNumberForms	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsOgham	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsOldItalic	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsOpticalCharacterRecognition	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsOriya	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsOsmanya	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsPhoneticExtensions	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsPrivateUse	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsPrivateUseArea	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsRunic	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsShavian	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsSinhala	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsSmallFormVariants	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsSpacingModifierLetters	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsSpecials	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsSuperscriptsandSubscripts	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsSupplementalArrowsA	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsSupplementalArrowsB	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsSupplementalMathematicalOperators	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsSupplementaryPrivateUseAreaA	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsSupplementaryPrivateUseAreaB	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsSyriac	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsTagalog	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsTagbanwa	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsTags	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsTaiLe	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsTaiXuanJingSymbols	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsTamil	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsTelugu	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsThaana	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsThai	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsTibetan	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsUgaritic	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsUnifiedCanadianAboriginalSyllabics	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsVariationSelectors	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsVariationSelectorsSupplement	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsYiRadicals	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsYiSyllables	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsYijingHexagramSymbols	(code: cint): cint; EXTDECL; external xml2lib;
 
-function xmlUCSIsBlock	(code: cint; block: pchar): cint; XMLCALL; XMLPUBFUN;
+function xmlUCSIsBlock	(code: cint; block: pchar): cint; EXTDECL; external xml2lib;
 
-function xmlUCSIsCatC	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatCc	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatCf	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatCo	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatCs	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatL	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatLl	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatLm	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatLo	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatLt	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatLu	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatM	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatMc	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatMe	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatMn	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatN	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatNd	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatNl	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatNo	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatP	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatPc	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatPd	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatPe	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatPf	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatPi	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatPo	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatPs	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatS	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatSc	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatSk	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatSm	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatSo	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatZ	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatZl	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatZp	(code: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlUCSIsCatZs	(code: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlUCSIsCatC	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatCc	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatCf	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatCo	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatCs	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatL	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatLl	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatLm	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatLo	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatLt	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatLu	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatM	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatMc	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatMe	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatMn	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatN	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatNd	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatNl	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatNo	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatP	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatPc	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatPd	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatPe	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatPf	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatPi	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatPo	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatPs	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatS	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatSc	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatSk	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatSm	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatSo	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatZ	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatZl	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatZp	(code: cint): cint; EXTDECL; external xml2lib;
+function xmlUCSIsCatZs	(code: cint): cint; EXTDECL; external xml2lib;
 
-function xmlUCSIsCat  (code: cint; cat: pchar): cint; XMLCALL; XMLPUBFUN;
+function xmlUCSIsCat  (code: cint; cat: pchar): cint; EXTDECL; external xml2lib;
 {$ENDIF}
 
 {$ENDIF} (* LIBXML_UNICODE_ENABLED *)

packages/libxml/src/xmlversion.inc

@@ -12,7 +12,7 @@
  * use those to be sure nothing nasty will happen if
  * your library and includes mismatch
  *)
-procedure xmlCheckVersion(version: cint); XMLCALL; XMLPUBFUN;
+procedure xmlCheckVersion(version: cint); EXTDECL; external xml2lib;
 
 (**
  * LIBXML_DOTTED_VERSION:

packages/libxml/src/xmlwriter.inc

@@ -22,13 +22,13 @@
 (*
  * Constructors & Destructor
  *)
-function xmlNewTextWriter(_out: xmlOutputBufferPtr): xmlTextWriterPtr; XMLCALL; XMLPUBFUN;
-function xmlNewTextWriterFilename(uri: pchar; compression: cint): xmlTextWriterPtr; XMLCALL; XMLPUBFUN;
-function xmlNewTextWriterMemory(buf: xmlBufferPtr; compression: cint): xmlTextWriterPtr; XMLCALL; XMLPUBFUN;
-function xmlNewTextWriterPushParser(ctxt: xmlParserCtxtPtr; compression: cint): xmlTextWriterPtr; XMLCALL; XMLPUBFUN;
-function xmlNewTextWriterDoc(var doc: xmlDocPtr; compression: cint): xmlTextWriterPtr; XMLCALL; XMLPUBFUN;
-function xmlNewTextWriterTree(doc: xmlDocPtr; node: xmlNodePtr; compression: cint): xmlTextWriterPtr; XMLCALL; XMLPUBFUN;
-procedure xmlFreeTextWriter(writer: xmlTextWriterPtr); XMLCALL; XMLPUBFUN;
+function xmlNewTextWriter(_out: xmlOutputBufferPtr): xmlTextWriterPtr; EXTDECL; external xml2lib;
+function xmlNewTextWriterFilename(uri: pchar; compression: cint): xmlTextWriterPtr; EXTDECL; external xml2lib;
+function xmlNewTextWriterMemory(buf: xmlBufferPtr; compression: cint): xmlTextWriterPtr; EXTDECL; external xml2lib;
+function xmlNewTextWriterPushParser(ctxt: xmlParserCtxtPtr; compression: cint): xmlTextWriterPtr; EXTDECL; external xml2lib;
+function xmlNewTextWriterDoc(var doc: xmlDocPtr; compression: cint): xmlTextWriterPtr; EXTDECL; external xml2lib;
+function xmlNewTextWriterTree(doc: xmlDocPtr; node: xmlNodePtr; compression: cint): xmlTextWriterPtr; EXTDECL; external xml2lib;
+procedure xmlFreeTextWriter(writer: xmlTextWriterPtr); EXTDECL; external xml2lib;
 
 (*
  * Functions
@@ -37,111 +37,111 @@ procedure xmlFreeTextWriter(writer: xmlTextWriterPtr); XMLCALL; XMLPUBFUN;
 (*
  * Document
  *)
-function xmlTextWriterStartDocument(writer: xmlTextWriterPtr; version, encoding, standalone: pchar): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterEndDocument(writer: xmlTextWriterPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextWriterStartDocument(writer: xmlTextWriterPtr; version, encoding, standalone: pchar): cint; EXTDECL; external xml2lib;
+function xmlTextWriterEndDocument(writer: xmlTextWriterPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * Comments
  *)
-function xmlTextWriterStartComment(writer: xmlTextWriterPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterEndComment(writer: xmlTextWriterPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteFormatComment(writer: xmlTextWriterPtr; format: pchar; args: array of const): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteVFormatComment(writer: xmlTextWriterPtr; format: pchar; argptr: va_list): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteComment(writer: xmlTextWriterPtr; content: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextWriterStartComment(writer: xmlTextWriterPtr): cint; EXTDECL; external xml2lib;
+function xmlTextWriterEndComment(writer: xmlTextWriterPtr): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteFormatComment(writer: xmlTextWriterPtr; format: pchar; args: array of const): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteVFormatComment(writer: xmlTextWriterPtr; format: pchar; argptr: va_list): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteComment(writer: xmlTextWriterPtr; content: xmlCharPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * Elements
  *)
-function xmlTextWriterStartElement(writer: xmlTextWriterPtr; name: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterStartElementNS(writer: xmlTextWriterPtr; prefix, name, namespaceURI: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterEndElement(writer: xmlTextWriterPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterFullEndElement(writer: xmlTextWriterPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextWriterStartElement(writer: xmlTextWriterPtr; name: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlTextWriterStartElementNS(writer: xmlTextWriterPtr; prefix, name, namespaceURI: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlTextWriterEndElement(writer: xmlTextWriterPtr): cint; EXTDECL; external xml2lib;
+function xmlTextWriterFullEndElement(writer: xmlTextWriterPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * Elements conveniency functions
  *)
-function xmlTextWriterWriteFormatElement(writer: xmlTextWriterPtr; name: xmlCharPtr; format: pchar; args: array of const): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteVFormatElement(writer: xmlTextWriterPtr; name: xmlCharPtr; format: pchar; argptr: va_list): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteElement(writer: xmlTextWriterPtr; name, content: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteFormatElementNS(writer: xmlTextWriterPtr; prefix, name, namespaceURI: xmlCharPtr; format: pchar; args: array of const): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteVFormatElementNS(writer: xmlTextWriterPtr; prefix, name, namespaceURI: xmlCharPtr; format: pchar; argptr: va_list): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteElementNS(writer: xmlTextWriterPtr; prefix, name, namespaceURI, content: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextWriterWriteFormatElement(writer: xmlTextWriterPtr; name: xmlCharPtr; format: pchar; args: array of const): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteVFormatElement(writer: xmlTextWriterPtr; name: xmlCharPtr; format: pchar; argptr: va_list): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteElement(writer: xmlTextWriterPtr; name, content: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteFormatElementNS(writer: xmlTextWriterPtr; prefix, name, namespaceURI: xmlCharPtr; format: pchar; args: array of const): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteVFormatElementNS(writer: xmlTextWriterPtr; prefix, name, namespaceURI: xmlCharPtr; format: pchar; argptr: va_list): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteElementNS(writer: xmlTextWriterPtr; prefix, name, namespaceURI, content: xmlCharPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * Text
  *)
-function xmlTextWriterWriteFormatRaw(writer: xmlTextWriterPtr; format: pchar; args: array of const): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteVFormatRaw(writer: xmlTextWriterPtr; format: pchar; argptr: va_list): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteRawLen(writer: xmlTextWriterPtr; content: xmlCharPtr; len: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteRaw(writer: xmlTextWriterPtr; content: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteFormatString(writer: xmlTextWriterPtr; format: pchar; args: array of const): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteVFormatString(writer: xmlTextWriterPtr; format: pchar; argptr: va_list): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteString(writer: xmlTextWriterPtr; content: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteBase64(writer: xmlTextWriterPtr; data: pchar; start, len: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteBinHex(writer: xmlTextWriterPtr; data: pchar; start, len: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlTextWriterWriteFormatRaw(writer: xmlTextWriterPtr; format: pchar; args: array of const): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteVFormatRaw(writer: xmlTextWriterPtr; format: pchar; argptr: va_list): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteRawLen(writer: xmlTextWriterPtr; content: xmlCharPtr; len: cint): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteRaw(writer: xmlTextWriterPtr; content: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteFormatString(writer: xmlTextWriterPtr; format: pchar; args: array of const): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteVFormatString(writer: xmlTextWriterPtr; format: pchar; argptr: va_list): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteString(writer: xmlTextWriterPtr; content: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteBase64(writer: xmlTextWriterPtr; data: pchar; start, len: cint): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteBinHex(writer: xmlTextWriterPtr; data: pchar; start, len: cint): cint; EXTDECL; external xml2lib;
 
 (*
  * Attributes
  *)
-function xmlTextWriterStartAttribute(writer: xmlTextWriterPtr; name: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterStartAttributeNS(writer: xmlTextWriterPtr; prefix, name, namespaceURI: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterEndAttribute(writer: xmlTextWriterPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextWriterStartAttribute(writer: xmlTextWriterPtr; name: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlTextWriterStartAttributeNS(writer: xmlTextWriterPtr; prefix, name, namespaceURI: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlTextWriterEndAttribute(writer: xmlTextWriterPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * Attributes conveniency functions
  *)
-function xmlTextWriterWriteFormatAttribute(writer: xmlTextWriterPtr; name: xmlCharPtr; format: pchar; args: array of const): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteVFormatAttribute(writer: xmlTextWriterPtr; name: xmlCharPtr; format: pchar; argptr: va_list): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteAttribute(writer: xmlTextWriterPtr; name, content: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteFormatAttributeNS(writer: xmlTextWriterPtr; prefix, name, namespaceURI: xmlCharPtr; format: pchar; args: array of const): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteVFormatAttributeNS(writer: xmlTextWriterPtr; prefix, name, namespaceURI: xmlCharPtr; format: pchar; argptr: va_list): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteAttributeNS(writer: xmlTextWriterPtr; prefix, name, namespaceURI, content: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextWriterWriteFormatAttribute(writer: xmlTextWriterPtr; name: xmlCharPtr; format: pchar; args: array of const): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteVFormatAttribute(writer: xmlTextWriterPtr; name: xmlCharPtr; format: pchar; argptr: va_list): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteAttribute(writer: xmlTextWriterPtr; name, content: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteFormatAttributeNS(writer: xmlTextWriterPtr; prefix, name, namespaceURI: xmlCharPtr; format: pchar; args: array of const): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteVFormatAttributeNS(writer: xmlTextWriterPtr; prefix, name, namespaceURI: xmlCharPtr; format: pchar; argptr: va_list): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteAttributeNS(writer: xmlTextWriterPtr; prefix, name, namespaceURI, content: xmlCharPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * PI's
  *)
-function xmlTextWriterStartPI(writer: xmlTextWriterPtr; target: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterEndPI(writer: xmlTextWriterPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextWriterStartPI(writer: xmlTextWriterPtr; target: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlTextWriterEndPI(writer: xmlTextWriterPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * PI conveniency functions
  *)
-function xmlTextWriterWriteFormatPI(writer: xmlTextWriterPtr; target: xmlCharPtr; format: pchar; args: array of const): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteVFormatPI(writer: xmlTextWriterPtr; target: xmlCharPtr; format: pchar; argptr: va_list): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWritePI(writer: xmlTextWriterPtr; target, content: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextWriterWriteFormatPI(writer: xmlTextWriterPtr; target: xmlCharPtr; format: pchar; args: array of const): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteVFormatPI(writer: xmlTextWriterPtr; target: xmlCharPtr; format: pchar; argptr: va_list): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWritePI(writer: xmlTextWriterPtr; target, content: xmlCharPtr): cint; EXTDECL; external xml2lib;
 
 (**
  * xmlTextWriterWriteProcessingInstruction:
  *
  * This macro maps to xmlTextWriterWritePI
  *)
-//function xmlTextWriterWriteProcessingInstruction(writer: xmlTextWriterPtr; target, content: xmlCharPtr): cint; XMLCALL; XMLPUBFUN 'xmlTextWriterWritePI';
+//function xmlTextWriterWriteProcessingInstruction(writer: xmlTextWriterPtr; target, content: xmlCharPtr): cint; EXTDECL; external xml2lib 'xmlTextWriterWritePI';
 
 (*
  * CDATA
  *)
-function xmlTextWriterStartCDATA(writer: xmlTextWriterPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterEndCDATA(writer: xmlTextWriterPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextWriterStartCDATA(writer: xmlTextWriterPtr): cint; EXTDECL; external xml2lib;
+function xmlTextWriterEndCDATA(writer: xmlTextWriterPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * CDATA conveniency functions
  *)
-function xmlTextWriterWriteFormatCDATA(writer: xmlTextWriterPtr; format: pchar; args: array of const): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteVFormatCDATA(writer: xmlTextWriterPtr; format: pchar; argptr: va_list): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteCDATA(writer: xmlTextWriterPtr; content: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextWriterWriteFormatCDATA(writer: xmlTextWriterPtr; format: pchar; args: array of const): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteVFormatCDATA(writer: xmlTextWriterPtr; format: pchar; argptr: va_list): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteCDATA(writer: xmlTextWriterPtr; content: xmlCharPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * DTD
  *)
-function xmlTextWriterStartDTD(writer: xmlTextWriterPtr; name, pubid, sysid: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterEndDTD(writer: xmlTextWriterPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextWriterStartDTD(writer: xmlTextWriterPtr; name, pubid, sysid: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlTextWriterEndDTD(writer: xmlTextWriterPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * DTD conveniency functions
  *)
-function xmlTextWriterWriteFormatDTD(writer: xmlTextWriterPtr; name, pubid, sysid: xmlCharPtr; format: pchar; args: array of const): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteVFormatDTD(writer: xmlTextWriterPtr; name, pubid, sysid: xmlCharPtr; format: pchar; argptr: va_list): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteDTD(writer: xmlTextWriterPtr; name, pubid, sysid, subset: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextWriterWriteFormatDTD(writer: xmlTextWriterPtr; name, pubid, sysid: xmlCharPtr; format: pchar; args: array of const): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteVFormatDTD(writer: xmlTextWriterPtr; name, pubid, sysid: xmlCharPtr; format: pchar; argptr: va_list): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteDTD(writer: xmlTextWriterPtr; name, pubid, sysid, subset: xmlCharPtr): cint; EXTDECL; external xml2lib;
 
 (**
  * xmlTextWriterWriteDocType:
@@ -153,60 +153,60 @@ function xmlTextWriterWriteDTD(writer: xmlTextWriterPtr; name, pubid, sysid, sub
 (*
  * DTD element definition
  *)
-function xmlTextWriterStartDTDElement(writer: xmlTextWriterPtr; name: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterEndDTDElement(writer: xmlTextWriterPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextWriterStartDTDElement(writer: xmlTextWriterPtr; name: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlTextWriterEndDTDElement(writer: xmlTextWriterPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * DTD element definition conveniency functions
  *)
-function xmlTextWriterWriteFormatDTDElement(writer: xmlTextWriterPtr; name: xmlCharPtr; format: pchar; args: array of const): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteVFormatDTDElement(writer: xmlTextWriterPtr; name: xmlCharPtr; format: pchar; argptr: va_list): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteDTDElement(writer: xmlTextWriterPtr; name, content: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextWriterWriteFormatDTDElement(writer: xmlTextWriterPtr; name: xmlCharPtr; format: pchar; args: array of const): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteVFormatDTDElement(writer: xmlTextWriterPtr; name: xmlCharPtr; format: pchar; argptr: va_list): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteDTDElement(writer: xmlTextWriterPtr; name, content: xmlCharPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * DTD attribute list definition
  *)
-function xmlTextWriterStartDTDAttlist(writer: xmlTextWriterPtr; name: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterEndDTDAttlist(writer: xmlTextWriterPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextWriterStartDTDAttlist(writer: xmlTextWriterPtr; name: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlTextWriterEndDTDAttlist(writer: xmlTextWriterPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * DTD attribute list definition conveniency functions
  *)
-function xmlTextWriterWriteFormatDTDAttlist(writer: xmlTextWriterPtr; name: xmlCharPtr; format: pchar; args: array of const): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteVFormatDTDAttlist(writer: xmlTextWriterPtr; name: xmlCharPtr; format: pchar; argptr: va_list): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteDTDAttlist(writer: xmlTextWriterPtr; name, content: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextWriterWriteFormatDTDAttlist(writer: xmlTextWriterPtr; name: xmlCharPtr; format: pchar; args: array of const): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteVFormatDTDAttlist(writer: xmlTextWriterPtr; name: xmlCharPtr; format: pchar; argptr: va_list): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteDTDAttlist(writer: xmlTextWriterPtr; name, content: xmlCharPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * DTD entity definition
  *)
-function xmlTextWriterStartDTDEntity(writer: xmlTextWriterPtr; pe: cint; name: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterEndDTDEntity(writer: xmlTextWriterPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextWriterStartDTDEntity(writer: xmlTextWriterPtr; pe: cint; name: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlTextWriterEndDTDEntity(writer: xmlTextWriterPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * DTD entity definition conveniency functions
  *)
-function xmlTextWriterWriteFormatDTDInternalEntity(writer: xmlTextWriterPtr; pe: cint; name: xmlCharPtr; format: pchar; args: array of const): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteVFormatDTDInternalEntity(writer: xmlTextWriterPtr; pe: cint; name: xmlCharPtr; format: pchar; argptr: va_list): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteDTDInternalEntity(writer: xmlTextWriterPtr; pe: cint; name, content: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteDTDExternalEntity(writer: xmlTextWriterPtr; pe: cint; name, pubid, sysid, ndataid: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteDTDExternalEntityContents(writer: xmlTextWriterPtr; pubid, sysid, ndataid: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterWriteDTDEntity(writer: xmlTextWriterPtr; pe: cint; name, pubid, sysid, ndataid, content: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextWriterWriteFormatDTDInternalEntity(writer: xmlTextWriterPtr; pe: cint; name: xmlCharPtr; format: pchar; args: array of const): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteVFormatDTDInternalEntity(writer: xmlTextWriterPtr; pe: cint; name: xmlCharPtr; format: pchar; argptr: va_list): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteDTDInternalEntity(writer: xmlTextWriterPtr; pe: cint; name, content: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteDTDExternalEntity(writer: xmlTextWriterPtr; pe: cint; name, pubid, sysid, ndataid: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteDTDExternalEntityContents(writer: xmlTextWriterPtr; pubid, sysid, ndataid: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlTextWriterWriteDTDEntity(writer: xmlTextWriterPtr; pe: cint; name, pubid, sysid, ndataid, content: xmlCharPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * DTD notation definition
  *)
-function xmlTextWriterWriteDTDNotation(writer: xmlTextWriterPtr; name, pubid, sysid: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextWriterWriteDTDNotation(writer: xmlTextWriterPtr; name, pubid, sysid: xmlCharPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * Indentation
  *)
-function xmlTextWriterSetIndent(writer: xmlTextWriterPtr; indent: cint): cint; XMLCALL; XMLPUBFUN;
-function xmlTextWriterSetIndentString(writer: xmlTextWriterPtr; str: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextWriterSetIndent(writer: xmlTextWriterPtr; indent: cint): cint; EXTDECL; external xml2lib;
+function xmlTextWriterSetIndentString(writer: xmlTextWriterPtr; str: xmlCharPtr): cint; EXTDECL; external xml2lib;
 
 (*
  * misc
  *)
-function xmlTextWriterFlush(writer: xmlTextWriterPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlTextWriterFlush(writer: xmlTextWriterPtr): cint; EXTDECL; external xml2lib;
 
 {$ENDIF}
 {$ENDIF} (* LIBXML_WRITER_ENABLED *)

packages/libxml/src/xpath.inc

@@ -118,7 +118,7 @@
  *
  * Returns -1 in case of error, 0 otherwise
  *)
-  xmlXPathConvertFunc = function(obj: xmlXPathObjectPtr; _type: cint): cint; XMLCALL;
+  xmlXPathConvertFunc = function(obj: xmlXPathObjectPtr; _type: cint): cint; EXTDECL;
 
 (*
  * Extra type: a name and a conversion function.
@@ -144,7 +144,7 @@
  * An XPath evaluation function, the parameters are on the XPath context stack.
  *)
 
-  xmlXPathEvalFunc = procedure(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL;
+  xmlXPathEvalFunc = procedure(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL;
 
 (*
  * Extra function: a name and a evaluation function.
@@ -167,7 +167,7 @@
  * Returns the next node in that axis or NULL if at the end of the axis.
  *)
 
-  xmlXPathAxisFunc = function(ctxt: xmlXPathParserContextPtr; cur: xmlXPathObjectPtr): xmlXPathObjectPtr; XMLCALL;
+  xmlXPathAxisFunc = function(ctxt: xmlXPathParserContextPtr; cur: xmlXPathObjectPtr): xmlXPathObjectPtr; EXTDECL;
 
 (*
  * Extra axis: a name and an axis function.
@@ -186,7 +186,7 @@
  * The arguments (if any) are popped out from the context stack
  * and the result is pushed on the stack.
  *)
-  xmlXPathFunction = procedure(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL;
+  xmlXPathFunction = procedure(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL;
 
 (*
  * Function and Variable Lookup.
@@ -203,7 +203,7 @@
  *
  * Returns the XPath object value or NULL if not found.
  *)
-  xmlXPathVariableLookupFunc = function(ctxt: pointer; name, ns_uri: xmlCharPtr): xmlXPathObjectPtr; XMLCALL;
+  xmlXPathVariableLookupFunc = function(ctxt: pointer; name, ns_uri: xmlCharPtr): xmlXPathObjectPtr; EXTDECL;
 
 (**
  * xmlXPathFuncLookupFunc:
@@ -216,7 +216,7 @@
  *
  * Returns the XPath function or NULL if not found.
  *)
-  xmlXPathFuncLookupFunc = function(ctxt: pointer; name, ns_uri: xmlCharPtr): xmlXPathFunction; XMLCALL;
+  xmlXPathFuncLookupFunc = function(ctxt: pointer; name, ns_uri: xmlCharPtr): xmlXPathFunction; EXTDECL;
 {$ENDIF}
 
 {$IFDEF CONST}
@@ -367,9 +367,9 @@
 
 {$IFNDEF NO_EXTERNAL_VARS}
 var
-  xmlXPathNAN: cdouble; XMLPUBVAR;
-  xmlXPathPINF: cdouble; XMLPUBVAR;
-  xmlXPathNINF: cdouble; XMLPUBVAR;
+  xmlXPathNAN: cdouble; cvar; external;
+  xmlXPathPINF: cdouble; cvar; external;
+  xmlXPathNINF: cdouble; cvar; external;
 {$ENDIF}
 
 (* These macros may later turn into functions *)
@@ -406,67 +406,67 @@ function xmlXPathNodeSetItem(ns: xmlNodeSetPtr; index: cint): xmlNodePtr;
 function xmlXPathNodeSetIsEmpty(ns: xmlNodeSetPtr): boolean;
 
 
-procedure xmlXPathFreeObject(obj: xmlXPathObjectPtr); XMLCALL; XMLPUBFUN;
-function xmlXPathNodeSetCreate(val: xmlNodePtr): xmlNodeSetPtr; XMLCALL; XMLPUBFUN;
-procedure xmlXPathFreeNodeSetList(obj: xmlXPathObjectPtr); XMLCALL; XMLPUBFUN;
-procedure xmlXPathFreeNodeSet(obj: xmlNodeSetPtr); XMLCALL; XMLPUBFUN;
-function xmlXPathObjectCopy(val: xmlXPathObjectPtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathCmpNodes(node1, node2: xmlNodePtr): cint; XMLCALL; XMLPUBFUN;
+procedure xmlXPathFreeObject(obj: xmlXPathObjectPtr); EXTDECL; external xml2lib;
+function xmlXPathNodeSetCreate(val: xmlNodePtr): xmlNodeSetPtr; EXTDECL; external xml2lib;
+procedure xmlXPathFreeNodeSetList(obj: xmlXPathObjectPtr); EXTDECL; external xml2lib;
+procedure xmlXPathFreeNodeSet(obj: xmlNodeSetPtr); EXTDECL; external xml2lib;
+function xmlXPathObjectCopy(val: xmlXPathObjectPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+function xmlXPathCmpNodes(node1, node2: xmlNodePtr): cint; EXTDECL; external xml2lib;
 
 (**
  * Conversion functions to basic types.
  *)
-function xmlXPathCastNumberToBoolean(val: cdouble): cint; XMLCALL; XMLPUBFUN;
-function xmlXPathCastStringToBoolean(val: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlXPathCastNodeSetToBoolean(ns: xmlNodeSetPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlXPathCastToBoolean(ns: xmlXPathObjectPtr): cint; XMLCALL; XMLPUBFUN;
-
-function xmlXPathCastBooleanToNumber(val: cint): cdouble; XMLCALL; XMLPUBFUN;
-function xmlXPathCastStringToNumber(val: xmlCharPtr): cdouble; XMLCALL; XMLPUBFUN;
-function xmlXPathCastNodeToNumber(val: xmlNodePtr): cdouble; XMLCALL; XMLPUBFUN;
-function xmlXPathCastNodeSetToNumber(val: xmlNodeSetPtr): cdouble; XMLCALL; XMLPUBFUN;
-function xmlXPathCastToNumber(val: xmlXPathObjectPtr): cdouble; XMLCALL; XMLPUBFUN;
-
-function xmlXPathCastBooleanToString(val: cint): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathCastNumberToString(val: cdouble): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathCastNodeToString(val: xmlNodePtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathCastNodeSetToString(val: xmlNodeSetPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathCastToString(val: xmlXPathObjectPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-
-function xmlXPathConvertBoolean(val: xmlXPathObjectPtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathConvertNumber(val: xmlXPathObjectPtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathConvertString(val: xmlXPathObjectPtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
+function xmlXPathCastNumberToBoolean(val: cdouble): cint; EXTDECL; external xml2lib;
+function xmlXPathCastStringToBoolean(val: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlXPathCastNodeSetToBoolean(ns: xmlNodeSetPtr): cint; EXTDECL; external xml2lib;
+function xmlXPathCastToBoolean(ns: xmlXPathObjectPtr): cint; EXTDECL; external xml2lib;
+
+function xmlXPathCastBooleanToNumber(val: cint): cdouble; EXTDECL; external xml2lib;
+function xmlXPathCastStringToNumber(val: xmlCharPtr): cdouble; EXTDECL; external xml2lib;
+function xmlXPathCastNodeToNumber(val: xmlNodePtr): cdouble; EXTDECL; external xml2lib;
+function xmlXPathCastNodeSetToNumber(val: xmlNodeSetPtr): cdouble; EXTDECL; external xml2lib;
+function xmlXPathCastToNumber(val: xmlXPathObjectPtr): cdouble; EXTDECL; external xml2lib;
+
+function xmlXPathCastBooleanToString(val: cint): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlXPathCastNumberToString(val: cdouble): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlXPathCastNodeToString(val: xmlNodePtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlXPathCastNodeSetToString(val: xmlNodeSetPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlXPathCastToString(val: xmlXPathObjectPtr): xmlCharPtr; EXTDECL; external xml2lib;
+
+function xmlXPathConvertBoolean(val: xmlXPathObjectPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+function xmlXPathConvertNumber(val: xmlXPathObjectPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+function xmlXPathConvertString(val: xmlXPathObjectPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
 
 (**
  * Context handling.
  *)
-function xmlXPathNewContext(doc: xmlDocPtr): xmlXPathContextPtr; XMLCALL; XMLPUBFUN;
-procedure xmlXPathFreeContext(ctxt: xmlXPathContextPtr); XMLCALL; XMLPUBFUN;
-function xmlXPathContextSetCache(ctxt: xmlXPathContextPtr; active, value, options: cint): cint; XMLCALL; XMLPUBFUN;
+function xmlXPathNewContext(doc: xmlDocPtr): xmlXPathContextPtr; EXTDECL; external xml2lib;
+procedure xmlXPathFreeContext(ctxt: xmlXPathContextPtr); EXTDECL; external xml2lib;
+function xmlXPathContextSetCache(ctxt: xmlXPathContextPtr; active, value, options: cint): cint; EXTDECL; external xml2lib;
 
 (**
  * Evaluation functions.
  *)
-function xmlXPathOrderDocElems(doc: xmlDocPtr): clong; XMLCALL; XMLPUBFUN;
-function xmlXPathEval(str: xmlCharPtr; ctx: xmlXPathContextPtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathEvalExpression(str: xmlCharPtr; ctx: xmlXPathContextPtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathEvalPredicate(ctxt: xmlXPathContextPtr; res: xmlXPathObjectPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlXPathOrderDocElems(doc: xmlDocPtr): clong; EXTDECL; external xml2lib;
+function xmlXPathEval(str: xmlCharPtr; ctx: xmlXPathContextPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+function xmlXPathEvalExpression(str: xmlCharPtr; ctx: xmlXPathContextPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+function xmlXPathEvalPredicate(ctxt: xmlXPathContextPtr; res: xmlXPathObjectPtr): cint; EXTDECL; external xml2lib;
 
 (**
  * Separate compilation/evaluation entry points.
  *)
-function xmlXPathCompile(str: xmlCharPtr): xmlXPathCompExprPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathCtxtCompile(ctxt: xmlXPathContextPtr; str: xmlCharPtr): xmlXPathCompExprPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathCompiledEval(comp: xmlXPathCompExprPtr; ctxt: xmlXPathContextPtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathCompiledEvalToBoolean(comp: xmlXPathCompExprPtr; ctxt: xmlXPathContextPtr): cint; XMLCALL; XMLPUBFUN;
-procedure xmlXPathFreeCompExpr(comp: xmlXPathCompExprPtr); XMLCALL; XMLPUBFUN;
+function xmlXPathCompile(str: xmlCharPtr): xmlXPathCompExprPtr; EXTDECL; external xml2lib;
+function xmlXPathCtxtCompile(ctxt: xmlXPathContextPtr; str: xmlCharPtr): xmlXPathCompExprPtr; EXTDECL; external xml2lib;
+function xmlXPathCompiledEval(comp: xmlXPathCompExprPtr; ctxt: xmlXPathContextPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+function xmlXPathCompiledEvalToBoolean(comp: xmlXPathCompExprPtr; ctxt: xmlXPathContextPtr): cint; EXTDECL; external xml2lib;
+procedure xmlXPathFreeCompExpr(comp: xmlXPathCompExprPtr); EXTDECL; external xml2lib;
 {$ENDIF}
 {$ENDIF} (* LIBXML_XPATH_ENABLED *)
 
 {$if defined(LIBXML_XPATH_ENABLED) or defined(LIBXML_SCHEMAS_ENABLED)}
 {$IFDEF FUNCTION}
-procedure xmlXPathInit; XMLCALL; XMLPUBFUN;
-function xmlXPathIsNaN(val: cdouble): cint; XMLCALL; XMLPUBFUN;
-function xmlXPathIsInf(val: cdouble): cint; XMLCALL; XMLPUBFUN;
+procedure xmlXPathInit; EXTDECL; external xml2lib;
+function xmlXPathIsNaN(val: cdouble): cint; EXTDECL; external xml2lib;
+function xmlXPathIsInf(val: cdouble): cint; EXTDECL; external xml2lib;
 {$ENDIF}
 {$ENDIF} (* LIBXML_XPATH_ENABLED or LIBXML_SCHEMAS_ENABLED*)

packages/libxml/src/xpathInternals.inc

@@ -92,15 +92,15 @@
  *)
 #define xmlXPathGetContextNode(ctxt)	((ctxt)->context->node)
 
-XMLPUBFUN int XMLCALL		
+external xml2lib int EXTDECL		
 		xmlXPathPopBoolean	(xmlXPathParserContextPtr ctxt);
-XMLPUBFUN double XMLCALL		
+external xml2lib double EXTDECL		
     		xmlXPathPopNumber	(xmlXPathParserContextPtr ctxt);
-XMLPUBFUN xmlChar * XMLCALL	
+external xml2lib xmlChar * EXTDECL	
     		xmlXPathPopString	(xmlXPathParserContextPtr ctxt);
-XMLPUBFUN xmlNodeSetPtr XMLCALL	
+external xml2lib xmlNodeSetPtr EXTDECL	
     		xmlXPathPopNodeSet	(xmlXPathParserContextPtr ctxt);
-XMLPUBFUN void * XMLCALL		
+external xml2lib void * EXTDECL		
     		xmlXPathPopExternal	(xmlXPathParserContextPtr ctxt);
 
 (**
@@ -322,176 +322,176 @@ XMLPUBFUN void * XMLCALL
 (*
  * Variable Lookup forwarding.
  *)
-procedure xmlXPathRegisterVariableLookup(ctxt: xmlXPathContextPtr; f: xmlXPathVariableLookupFunc; data: pointer); XMLCALL; XMLPUBFUN;
+procedure xmlXPathRegisterVariableLookup(ctxt: xmlXPathContextPtr; f: xmlXPathVariableLookupFunc; data: pointer); EXTDECL; external xml2lib;
 
 (*
  * Function Lookup forwarding.
  *)
-procedure xmlXPathRegisterFuncLookup(ctxt: xmlXPathContextPtr; f: xmlXPathFuncLookupFunc; funcCtxt: pointer); XMLCALL; XMLPUBFUN;
+procedure xmlXPathRegisterFuncLookup(ctxt: xmlXPathContextPtr; f: xmlXPathFuncLookupFunc; funcCtxt: pointer); EXTDECL; external xml2lib;
 
 (*
  * Error reporting.
  *)
-//procedure __xmlXPatherror(ctxt: xmlXPathParserContextPtr; _file: pchar; line, no: cint); XMLCALL; XMLPUBFUN name 'xmlXPatherror';
-procedure xmlXPathErr(ctxt: xmlXPathParserContextPtr; error: cint); XMLCALL; XMLPUBFUN;
+//procedure __xmlXPatherror(ctxt: xmlXPathParserContextPtr; _file: pchar; line, no: cint); EXTDECL; external xml2lib name 'xmlXPatherror';
+procedure xmlXPathErr(ctxt: xmlXPathParserContextPtr; error: cint); EXTDECL; external xml2lib;
 
 {$IFDEF LIBXML_DEBUG_ENABLED}
-procedure xmlXPathDebugDumpObject(output: PFILE; cur: xmlXPathObjectPtr; depth: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathDebugDumpCompExpr(output: PFILE; comp: xmlXPathCompExprPtr; depth: cint); XMLCALL; XMLPUBFUN;
+procedure xmlXPathDebugDumpObject(output: PFILE; cur: xmlXPathObjectPtr; depth: cint); EXTDECL; external xml2lib;
+procedure xmlXPathDebugDumpCompExpr(output: PFILE; comp: xmlXPathCompExprPtr; depth: cint); EXTDECL; external xml2lib;
 {$ENDIF}
 
 (**
  * NodeSet handling.
  *)
-function xmlXPathNodeSetContains(cur: xmlNodeSetPtr; val: xmlNodePtr): cint; XMLCALL; XMLPUBFUN;
-function xmlXPathDifference(nodes1, nodes2: xmlNodeSetPtr): xmlNodeSetPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathIntersection(nodes1, nodes2: xmlNodeSetPtr): xmlNodeSetPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathDistinctSorted(nodes: xmlNodeSetPtr): xmlNodeSetPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathDistinct(nodes: xmlNodeSetPtr): xmlNodeSetPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathHasSameNodes(nodes1, nodes2: xmlNodeSetPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlXPathNodeLeadingSorted(nodes: xmlNodeSetPtr; node: xmlNodePtr): xmlNodeSetPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathLeadingSorted(nodes1, nodes2: xmlNodeSetPtr): xmlNodeSetPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathNodeLeading(nodes: xmlNodeSetPtr; node: xmlNodePtr): xmlNodeSetPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathLeading(nodes1, nodes2: xmlNodeSetPtr): xmlNodeSetPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathNodeTrailingSorted(nodes: xmlNodeSetPtr; node: xmlNodePtr): xmlNodeSetPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathTrailingSorted(nodes1, nodes2: xmlNodeSetPtr): xmlNodeSetPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathNodeTrailing(nodes: xmlNodeSetPtr; node: xmlNodePtr): xmlNodeSetPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathTrailing(nodes1, nodes2: xmlNodeSetPtr): xmlNodeSetPtr; XMLCALL; XMLPUBFUN;
+function xmlXPathNodeSetContains(cur: xmlNodeSetPtr; val: xmlNodePtr): cint; EXTDECL; external xml2lib;
+function xmlXPathDifference(nodes1, nodes2: xmlNodeSetPtr): xmlNodeSetPtr; EXTDECL; external xml2lib;
+function xmlXPathIntersection(nodes1, nodes2: xmlNodeSetPtr): xmlNodeSetPtr; EXTDECL; external xml2lib;
+function xmlXPathDistinctSorted(nodes: xmlNodeSetPtr): xmlNodeSetPtr; EXTDECL; external xml2lib;
+function xmlXPathDistinct(nodes: xmlNodeSetPtr): xmlNodeSetPtr; EXTDECL; external xml2lib;
+function xmlXPathHasSameNodes(nodes1, nodes2: xmlNodeSetPtr): cint; EXTDECL; external xml2lib;
+function xmlXPathNodeLeadingSorted(nodes: xmlNodeSetPtr; node: xmlNodePtr): xmlNodeSetPtr; EXTDECL; external xml2lib;
+function xmlXPathLeadingSorted(nodes1, nodes2: xmlNodeSetPtr): xmlNodeSetPtr; EXTDECL; external xml2lib;
+function xmlXPathNodeLeading(nodes: xmlNodeSetPtr; node: xmlNodePtr): xmlNodeSetPtr; EXTDECL; external xml2lib;
+function xmlXPathLeading(nodes1, nodes2: xmlNodeSetPtr): xmlNodeSetPtr; EXTDECL; external xml2lib;
+function xmlXPathNodeTrailingSorted(nodes: xmlNodeSetPtr; node: xmlNodePtr): xmlNodeSetPtr; EXTDECL; external xml2lib;
+function xmlXPathTrailingSorted(nodes1, nodes2: xmlNodeSetPtr): xmlNodeSetPtr; EXTDECL; external xml2lib;
+function xmlXPathNodeTrailing(nodes: xmlNodeSetPtr; node: xmlNodePtr): xmlNodeSetPtr; EXTDECL; external xml2lib;
+function xmlXPathTrailing(nodes1, nodes2: xmlNodeSetPtr): xmlNodeSetPtr; EXTDECL; external xml2lib;
 
 (**
  * Extending a context.
  *)
-function xmlXPathRegisterNs(ctxt: xmlXPathContextPtr; prefix, ns_uri: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlXPathNsLookup(ctxt: xmlXPathContextPtr; prefix: xmlCharPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-procedure xmlXPathDebugDumpCompExpr(ctxt: xmlXPathContextPtr); XMLCALL; XMLPUBFUN;
-function xmlXPathRegisterFunc(ctxt: xmlXPathContextPtr; name: xmlCharPtr; f: xmlXPathFunction): cint; XMLCALL; XMLPUBFUN;
-function xmlXPathRegisterFuncNS(ctxt: xmlXPathContextPtr; name, ns_uri: xmlCharPtr; f: xmlXPathFunction): cint; XMLCALL; XMLPUBFUN;
-function xmlXPathRegisterVariable(ctxt: xmlXPathContextPtr; name: xmlCharPtr; value: xmlXPathObjectPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlXPathRegisterVariableNS(ctxt: xmlXPathContextPtr; name, ns_uri: xmlCharPtr; value: xmlXPathObjectPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlXPathFunctionLookup(ctxt: xmlXPathContextPtr; name: xmlCharPtr): xmlXPathFunction; XMLCALL; XMLPUBFUN;
-function xmlXPathFunctionLookupNS(ctxt: xmlXPathContextPtr; name, ns_uri: xmlCharPtr): xmlXPathFunction; XMLCALL; XMLPUBFUN;
-procedure xmlXPathRegisteredFuncsCleanup(ctxt: xmlXPathContextPtr); XMLCALL; XMLPUBFUN;
-function xmlXPathVariableLookup(ctxt: xmlXPathContextPtr; name: xmlCharPtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathVariableLookupNS(ctxt: xmlXPathContextPtr; name, ns_uri: xmlCharPtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-procedure xmlXPathRegisteredVariablesCleanup(ctxt: xmlXPathContextPtr); XMLCALL; XMLPUBFUN;
+function xmlXPathRegisterNs(ctxt: xmlXPathContextPtr; prefix, ns_uri: xmlCharPtr): cint; EXTDECL; external xml2lib;
+function xmlXPathNsLookup(ctxt: xmlXPathContextPtr; prefix: xmlCharPtr): xmlCharPtr; EXTDECL; external xml2lib;
+procedure xmlXPathDebugDumpCompExpr(ctxt: xmlXPathContextPtr); EXTDECL; external xml2lib;
+function xmlXPathRegisterFunc(ctxt: xmlXPathContextPtr; name: xmlCharPtr; f: xmlXPathFunction): cint; EXTDECL; external xml2lib;
+function xmlXPathRegisterFuncNS(ctxt: xmlXPathContextPtr; name, ns_uri: xmlCharPtr; f: xmlXPathFunction): cint; EXTDECL; external xml2lib;
+function xmlXPathRegisterVariable(ctxt: xmlXPathContextPtr; name: xmlCharPtr; value: xmlXPathObjectPtr): cint; EXTDECL; external xml2lib;
+function xmlXPathRegisterVariableNS(ctxt: xmlXPathContextPtr; name, ns_uri: xmlCharPtr; value: xmlXPathObjectPtr): cint; EXTDECL; external xml2lib;
+function xmlXPathFunctionLookup(ctxt: xmlXPathContextPtr; name: xmlCharPtr): xmlXPathFunction; EXTDECL; external xml2lib;
+function xmlXPathFunctionLookupNS(ctxt: xmlXPathContextPtr; name, ns_uri: xmlCharPtr): xmlXPathFunction; EXTDECL; external xml2lib;
+procedure xmlXPathRegisteredFuncsCleanup(ctxt: xmlXPathContextPtr); EXTDECL; external xml2lib;
+function xmlXPathVariableLookup(ctxt: xmlXPathContextPtr; name: xmlCharPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+function xmlXPathVariableLookupNS(ctxt: xmlXPathContextPtr; name, ns_uri: xmlCharPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+procedure xmlXPathRegisteredVariablesCleanup(ctxt: xmlXPathContextPtr); EXTDECL; external xml2lib;
 
 (**
  * Utilities to extend XPath.
  *)
-function xmlXPathNewParserContext(str: xmlCharPtr; ctxt: xmlXPathContextPtr): xmlXPathParserContextPtr; XMLCALL; XMLPUBFUN;
-procedure xmlXPathFreeParserContext(ctxt: xmlXPathParserContextPtr); XMLCALL; XMLPUBFUN;
+function xmlXPathNewParserContext(str: xmlCharPtr; ctxt: xmlXPathContextPtr): xmlXPathParserContextPtr; EXTDECL; external xml2lib;
+procedure xmlXPathFreeParserContext(ctxt: xmlXPathParserContextPtr); EXTDECL; external xml2lib;
 
 (* TODO: remap to xmlXPathValuePop and Push. *)
-function valuePop(ctxt: xmlXPathParserContextPtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-function valuePush(ctxt: xmlXPathParserContextPtr): cint; XMLCALL; XMLPUBFUN;
-
-function xmlXPathNewString(val: xmlCharPtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathNewCString(val: pchar): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathWrapString(val: xmlCharPtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathWrapCString(val: pchar): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathNewFloat(val: cdouble): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathNewBoolean(val: cint): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathNewNodeSet(val: xmlNodePtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathNewValueTree(val: xmlNodePtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-procedure xmlXPathNodeSetAddUnique(cur: xmlNodeSetPtr; val: xmlNodePtr); XMLCALL; XMLPUBFUN;
-procedure xmlXPathNodeSetAdd(cur: xmlNodeSetPtr; val: xmlNodePtr); XMLCALL; XMLPUBFUN;
-procedure xmlXPathNodeSetAddNs(cur: xmlNodeSetPtr; node: xmlNodePtr; ns: xmlNsPtr); XMLCALL; XMLPUBFUN;
-procedure xmlXPathNodeSetSort(_set: xmlNodeSetPtr); XMLCALL; XMLPUBFUN;
-procedure xmlXPathRoot(ctxt: xmlXPathParserContextPtr); XMLCALL; XMLPUBFUN;
-procedure xmlXPathEvalExpr(ctxt: xmlXPathParserContextPtr); XMLCALL; XMLPUBFUN;
-function xmlXPathParseName(ctxt: xmlXPathParserContextPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
-function xmlXPathParseNCName(ctxt: xmlXPathParserContextPtr): xmlCharPtr; XMLCALL; XMLPUBFUN;
+function valuePop(ctxt: xmlXPathParserContextPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+function valuePush(ctxt: xmlXPathParserContextPtr): cint; EXTDECL; external xml2lib;
+
+function xmlXPathNewString(val: xmlCharPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+function xmlXPathNewCString(val: pchar): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+function xmlXPathWrapString(val: xmlCharPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+function xmlXPathWrapCString(val: pchar): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+function xmlXPathNewFloat(val: cdouble): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+function xmlXPathNewBoolean(val: cint): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+function xmlXPathNewNodeSet(val: xmlNodePtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+function xmlXPathNewValueTree(val: xmlNodePtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+procedure xmlXPathNodeSetAddUnique(cur: xmlNodeSetPtr; val: xmlNodePtr); EXTDECL; external xml2lib;
+procedure xmlXPathNodeSetAdd(cur: xmlNodeSetPtr; val: xmlNodePtr); EXTDECL; external xml2lib;
+procedure xmlXPathNodeSetAddNs(cur: xmlNodeSetPtr; node: xmlNodePtr; ns: xmlNsPtr); EXTDECL; external xml2lib;
+procedure xmlXPathNodeSetSort(_set: xmlNodeSetPtr); EXTDECL; external xml2lib;
+procedure xmlXPathRoot(ctxt: xmlXPathParserContextPtr); EXTDECL; external xml2lib;
+procedure xmlXPathEvalExpr(ctxt: xmlXPathParserContextPtr); EXTDECL; external xml2lib;
+function xmlXPathParseName(ctxt: xmlXPathParserContextPtr): xmlCharPtr; EXTDECL; external xml2lib;
+function xmlXPathParseNCName(ctxt: xmlXPathParserContextPtr): xmlCharPtr; EXTDECL; external xml2lib;
 
 (*
  * Existing functions.
  *)
-{XMLPUBFUN double XMLCALL 
+{external xml2lib double EXTDECL 
 		xmlXPathStringEvalNumber	(xmlChar *str);
-XMLPUBFUN int XMLCALL 
+external xml2lib int EXTDECL 
 		xmlXPathEvaluatePredicateResult (xmlXPathParserContextPtr ctxt, 
 						 xmlXPathObjectPtr res);
-XMLPUBFUN void XMLCALL 
+external xml2lib void EXTDECL 
 		xmlXPathRegisterAllFunctions	(xmlXPathContextPtr ctxt);
-XMLPUBFUN xmlNodeSetPtr XMLCALL 
+external xml2lib xmlNodeSetPtr EXTDECL 
 		xmlXPathNodeSetMerge		(xmlNodeSetPtr val1, 
 						 xmlNodeSetPtr val2);
-XMLPUBFUN void XMLCALL 
+external xml2lib void EXTDECL 
 		xmlXPathNodeSetDel		(xmlNodeSetPtr cur, 
 						 xmlNodePtr val);
-XMLPUBFUN void XMLCALL 
+external xml2lib void EXTDECL 
 		xmlXPathNodeSetRemove		(xmlNodeSetPtr cur, 
 						 int val);
-XMLPUBFUN xmlXPathObjectPtr XMLCALL 
+external xml2lib xmlXPathObjectPtr EXTDECL 
 		xmlXPathNewNodeSetList		(xmlNodeSetPtr val);
-XMLPUBFUN xmlXPathObjectPtr XMLCALL 
+external xml2lib xmlXPathObjectPtr EXTDECL 
 		xmlXPathWrapNodeSet		(xmlNodeSetPtr val);
-XMLPUBFUN xmlXPathObjectPtr XMLCALL 
+external xml2lib xmlXPathObjectPtr EXTDECL 
 		xmlXPathWrapExternal		(void *val);}
 
-function xmlXPathEqualValues(ctxt: xmlXPathParserContextPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlXPathNotEqualValues(ctxt: xmlXPathParserContextPtr): cint; XMLCALL; XMLPUBFUN;
-function xmlXPathCompareValues(ctxt: xmlXPathParserContextPtr; inf, strict: cint): cint; XMLCALL; XMLPUBFUN;
-procedure xmlXPathValueFlipSign(ctxt: xmlXPathParserContextPtr); XMLCALL; XMLPUBFUN;
-procedure xmlXPathAddValues(ctxt: xmlXPathParserContextPtr); XMLCALL; XMLPUBFUN;
-procedure xmlXPathSubValues(ctxt: xmlXPathParserContextPtr); XMLCALL; XMLPUBFUN;
-procedure xmlXPathMultValues(ctxt: xmlXPathParserContextPtr); XMLCALL; XMLPUBFUN;
-procedure xmlXPathDivValues(ctxt: xmlXPathParserContextPtr); XMLCALL; XMLPUBFUN;
-procedure xmlXPathModValues(ctxt: xmlXPathParserContextPtr); XMLCALL; XMLPUBFUN;
+function xmlXPathEqualValues(ctxt: xmlXPathParserContextPtr): cint; EXTDECL; external xml2lib;
+function xmlXPathNotEqualValues(ctxt: xmlXPathParserContextPtr): cint; EXTDECL; external xml2lib;
+function xmlXPathCompareValues(ctxt: xmlXPathParserContextPtr; inf, strict: cint): cint; EXTDECL; external xml2lib;
+procedure xmlXPathValueFlipSign(ctxt: xmlXPathParserContextPtr); EXTDECL; external xml2lib;
+procedure xmlXPathAddValues(ctxt: xmlXPathParserContextPtr); EXTDECL; external xml2lib;
+procedure xmlXPathSubValues(ctxt: xmlXPathParserContextPtr); EXTDECL; external xml2lib;
+procedure xmlXPathMultValues(ctxt: xmlXPathParserContextPtr); EXTDECL; external xml2lib;
+procedure xmlXPathDivValues(ctxt: xmlXPathParserContextPtr); EXTDECL; external xml2lib;
+procedure xmlXPathModValues(ctxt: xmlXPathParserContextPtr); EXTDECL; external xml2lib;
 
-function xmlXPathIsNodeType(name: xmlCharPtr): cint; XMLCALL; XMLPUBFUN;
+function xmlXPathIsNodeType(name: xmlCharPtr): cint; EXTDECL; external xml2lib;
 
 
 (*
  * Some of the axis navigation routines.
  *)
-function xmlXPathNextSelf(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlXPathNextChild(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlXPathNextDescendant(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlXPathNextDescendantOrSelf(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlXPathNextParent(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlXPathNextAncestorOrSelf(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlXPathNextFollowingSibling(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlXPathNextFollowing(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlXPathNextNamespace(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlXPathNextAttribute(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlXPathNextPreceding(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlXPathNextAncestor(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-function xmlXPathNextPrecedingSibling(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
+function xmlXPathNextSelf(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlXPathNextChild(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlXPathNextDescendant(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlXPathNextDescendantOrSelf(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlXPathNextParent(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlXPathNextAncestorOrSelf(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlXPathNextFollowingSibling(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlXPathNextFollowing(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlXPathNextNamespace(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlXPathNextAttribute(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlXPathNextPreceding(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlXPathNextAncestor(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
+function xmlXPathNextPrecedingSibling(ctxt: xmlXPathParserContextPtr; cur: xmlNodePtr): xmlNodePtr; EXTDECL; external xml2lib;
 
 (*
  * The official core of XPath functions.
  *)
-procedure xmlXPathLastFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathPositionFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathCountFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathIdFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathLocalNameFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathNamespaceURIFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathStringFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathStringLengthFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathConcatFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathContainsFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathStartsWithFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathSubstringFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathSubstringBeforeFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathSubstringAfterFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathNormalizeFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathTranslateFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathNotFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathTrueFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathFalseFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathLangFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathNumberFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathSumFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathFloorFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathCeilingFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathRoundFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-procedure xmlXPathBooleanFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
+procedure xmlXPathLastFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathPositionFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathCountFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathIdFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathLocalNameFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathNamespaceURIFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathStringFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathStringLengthFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathConcatFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathContainsFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathStartsWithFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathSubstringFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathSubstringBeforeFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathSubstringAfterFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathNormalizeFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathTranslateFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathNotFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathTrueFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathFalseFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathLangFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathNumberFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathSumFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathFloorFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathCeilingFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathRoundFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+procedure xmlXPathBooleanFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
 
 (**
  * Really internal functions
  *)
-procedure xmlXPathNodeSetFreeNs(ns: xmlNsPtr); XMLCALL; XMLPUBFUN;
+procedure xmlXPathNodeSetFreeNs(ns: xmlNsPtr); EXTDECL; external xml2lib;
 {$ENDIF}
 
 {$ENDIF} (* LIBXML_XPATH_ENABLED *)

packages/libxml/src/xpointer.inc

@@ -35,31 +35,31 @@
 (*
  * Handling of location sets.
  *)
-function xmlXPtrLocationSetCreate(val: xmlXPathObjectPtr): xmlLocationSetPtr; XMLCALL; XMLPUBFUN;
-procedure xmlXPtrLocationSetCreate(obj: xmlLocationSetPtr); XMLCALL; XMLPUBFUN;
-function xmlXPtrLocationSetMerge(val1, val2: xmlLocationSetPtr): xmlLocationSetPtr; XMLCALL; XMLPUBFUN;
-function xmlXPtrNewRange(start: xmlNodePtr; startindex: cint; _end: xmlNodePtr; endindex: cint): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-function xmlXPtrNewRangePoints(start, _end: xmlXPathObjectPtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-function xmlXPtrNewRangeNodePoint(start: xmlNodePtr; _end: xmlXPathObjectPtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-function xmlXPtrNewRangePointNode(start: xmlXPathObjectPtr; _end: xmlNodePtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-function xmlXPtrNewRangeNodes(start: xmlNodePtr; _end: xmlNodePtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-function xmlXPtrNewLocationSetNodes(start: xmlNodePtr; _end: xmlNodePtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-function xmlXPtrNewLocationSetNodeSet(_set: xmlNodeSetPtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-function xmlXPtrNewRangeNodeObject(start: xmlNodePtr; _end: xmlXPathObjectPtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-function xmlXPtrNewCollapsedRange(start: xmlNodePtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-procedure xmlXPtrLocationSetAdd(cur: xmlLocationSetPtr; val: xmlXPathObjectPtr); XMLCALL; XMLPUBFUN;
-function xmlXPtrWrapLocationSet(val: xmlLocationSetPtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-procedure xmlXPtrLocationSetDel(cur: xmlLocationSetPtr; val: xmlXPathObjectPtr); XMLCALL; XMLPUBFUN;
-procedure xmlXPtrLocationSetRemove(cur: xmlLocationSetPtr; val: cint); XMLCALL; XMLPUBFUN;
+function xmlXPtrLocationSetCreate(val: xmlXPathObjectPtr): xmlLocationSetPtr; EXTDECL; external xml2lib;
+procedure xmlXPtrLocationSetCreate(obj: xmlLocationSetPtr); EXTDECL; external xml2lib;
+function xmlXPtrLocationSetMerge(val1, val2: xmlLocationSetPtr): xmlLocationSetPtr; EXTDECL; external xml2lib;
+function xmlXPtrNewRange(start: xmlNodePtr; startindex: cint; _end: xmlNodePtr; endindex: cint): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+function xmlXPtrNewRangePoints(start, _end: xmlXPathObjectPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+function xmlXPtrNewRangeNodePoint(start: xmlNodePtr; _end: xmlXPathObjectPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+function xmlXPtrNewRangePointNode(start: xmlXPathObjectPtr; _end: xmlNodePtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+function xmlXPtrNewRangeNodes(start: xmlNodePtr; _end: xmlNodePtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+function xmlXPtrNewLocationSetNodes(start: xmlNodePtr; _end: xmlNodePtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+function xmlXPtrNewLocationSetNodeSet(_set: xmlNodeSetPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+function xmlXPtrNewRangeNodeObject(start: xmlNodePtr; _end: xmlXPathObjectPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+function xmlXPtrNewCollapsedRange(start: xmlNodePtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+procedure xmlXPtrLocationSetAdd(cur: xmlLocationSetPtr; val: xmlXPathObjectPtr); EXTDECL; external xml2lib;
+function xmlXPtrWrapLocationSet(val: xmlLocationSetPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+procedure xmlXPtrLocationSetDel(cur: xmlLocationSetPtr; val: xmlXPathObjectPtr); EXTDECL; external xml2lib;
+procedure xmlXPtrLocationSetRemove(cur: xmlLocationSetPtr; val: cint); EXTDECL; external xml2lib;
 
 (*
  * Functions.
  *)
-function xmlXPtrNewContext(doc: xmlDocPtr; here, origin: xmlNodePtr): xmlXPathContextPtr; XMLCALL; XMLPUBFUN;
-function xmlXPtrEval(str: xmlCharPtr; ctx: xmlXPathContextPtr): xmlXPathObjectPtr; XMLCALL; XMLPUBFUN;
-procedure xmlXPtrRangeToFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); XMLCALL; XMLPUBFUN;
-function xmlXPtrBuildNodeList(obj: xmlXPathObjectPtr): xmlNodePtr; XMLCALL; XMLPUBFUN;
-procedure xmlXPtrEvalRangePredicate(ctxt: xmlXPathParserContextPtr); XMLCALL; XMLPUBFUN;
+function xmlXPtrNewContext(doc: xmlDocPtr; here, origin: xmlNodePtr): xmlXPathContextPtr; EXTDECL; external xml2lib;
+function xmlXPtrEval(str: xmlCharPtr; ctx: xmlXPathContextPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
+procedure xmlXPtrRangeToFunction(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL; external xml2lib;
+function xmlXPtrBuildNodeList(obj: xmlXPathObjectPtr): xmlNodePtr; EXTDECL; external xml2lib;
+procedure xmlXPtrEvalRangePredicate(ctxt: xmlXPathParserContextPtr); EXTDECL; external xml2lib;
 {$ENDIF}
 
 {$ENDIF} (* LIBXML_XPTR_ENABLED *)